Adding Adaptive output support.

TODO.md

@@ -3,6 +3,7 @@ XSLT-processor TODO
 
 * XSLT validation, besides the version number;
 * XSL:number
-* Implement `<xsl:import>` with correct template precedence. 
+* Implement `<xsl:import>` with correct template precedence.
+* **BUG: concat() function with XPath expressions** - When using `concat()` with XPath expressions as arguments (e.g., `concat(root/first, ' ', root/second)`), the function returns malformed output like "1, first, null 1, second, null" instead of properly concatenating the string values. This appears to be an issue with how XPath NodeSetValue results are being converted to strings within the concat function.
 
 Help is much appreciated. It seems to currently work for most of our purposes, but fixes and additions are always welcome!

src/dom/xml-functions.ts

@@ -230,21 +230,31 @@
             buffer.push(finalText);
         }
     } else if (nodeType === DOM_CDATA_SECTION_NODE) {
-        if (options.cData) {
+        if (options.outputMethod === 'text') {
+            // For text output, extract the raw content without CDATA markers
+            buffer.push(nodeValue);
+        } else if (options.cData) {
             buffer.push(xmlEscapeText(nodeValue));
         } else {
             buffer.push(`<![CDATA[${nodeValue}]]>`);
         }
     } else if (nodeType == DOM_COMMENT_NODE) {
-        buffer.push(`<!-- ${nodeValue} -->`);
+        if (options.outputMethod !== 'text') {
+            buffer.push(`<!-- ${nodeValue} -->`);
+        }
     } else if (nodeType == DOM_ELEMENT_NODE) {
-        // If node didn't have a transformed name, but its children
-        // had transformations, children should be present at output.
-        // This is called here "muted logic".
-        if (node.nodeName !== null && node.nodeName !== undefined) {
-            xmlElementLogicTrivial(node, buffer, options);
+        if (options.outputMethod === 'text') {
+            // For text output, only extract text content from elements
+            xmlElementLogicTextOnly(node, buffer, options);
         } else {
-            xmlElementLogicMuted(node, buffer, options);
+            // If node didn't have a transformed name, but its children
+            // had transformations, children should be present at output.
+            // This is called here "muted logic".
+            if (node.nodeName !== null && node.nodeName !== undefined) {
+                xmlElementLogicTrivial(node, buffer, options);
+            } else {
+                xmlElementLogicMuted(node, buffer, options);
+            }
         }
     } else if (nodeType === DOM_DOCUMENT_NODE || nodeType === DOM_DOCUMENT_FRAGMENT_NODE) {
         let childNodes = node.firstChild ? [] : node.childNodes;
@@ -356,6 +366,29 @@
     }
 }
 
+/**
+ * XML element output for text mode - extracts only text content without tags.
+ * @param node The XML node.
+ * @param buffer The output buffer.
+ * @param options XML output options.
+ */
+function xmlElementLogicTextOnly(node: XNode, buffer: string[], options: XmlOutputOptions) {
+    let childNodes: XNode[] = [];
+    if (node.firstChild) {
+        let child = node.firstChild;
+        while (child) {
+            childNodes.push(child);
+            child = child.nextSibling;
+        }
+    } else {
+        childNodes = node.childNodes;
+    }
+    childNodes = childNodes.sort((a, b) => a.siblingPosition - b.siblingPosition);
+    for (let i = 0; i < childNodes.length; ++i) {
+        xmlTransformedTextRecursive(childNodes[i], buffer, options);
+    }
+}
+
 /**
  * Gets the full node name.
  * When namespace is set, the node name is `namespace:node`.
@@ -570,6 +603,59 @@
     return null;
 }
 
+/**
+ * Detects the most appropriate output format for a node based on its structure.
+ * This implements XSLT 3.1 adaptive output behavior.
+ * @param node The node to analyze.
+ * @returns The detected output method: 'text' or 'xml'.
+ */
+export function detectAdaptiveOutputFormat(node: XNode): 'text' | 'xml' {
+    if (!node) {
+        return 'xml';
+    }
+
+    const nodeType = node.nodeType;
+
+    // If it's a document or fragment, check its children
+    if (nodeType === DOM_DOCUMENT_NODE || nodeType === DOM_DOCUMENT_FRAGMENT_NODE) {
+        const children = node.childNodes || [];
+        let elementCount = 0;
+        let textCount = 0;
+        let hasSignificantText = false;
+
+        for (let i = 0; i < children.length; i++) {
+            const child = children[i];
+            if (child.nodeType === DOM_ELEMENT_NODE) {
+                elementCount++;
+            } else if (child.nodeType === DOM_TEXT_NODE) {
+                const text = child.nodeValue ? child.nodeValue.trim() : '';
+                if (text.length > 0) {
+                    textCount++;
+                    hasSignificantText = true;
+                }
+            }
+        }
+
+        // If there's only text content and no elements, use text output
+        if (elementCount === 0 && hasSignificantText) {
+            return 'text';
+        }
+        // Otherwise, use XML output
+        return 'xml';
+    }
+
+    // If it's a single text node with content, use text output
+    if (nodeType === DOM_TEXT_NODE || nodeType === DOM_CDATA_SECTION_NODE) {
+        const text = node.nodeValue ? node.nodeValue.trim() : '';
+        if (text.length > 0) {
+            return 'text';
+        }
+    }
+
+    // For elements and other node types, use XML output
+    return 'xml';
+}
+
 /**
  * Converts an XML document to a JSON string.
  * The root element becomes the top-level object.

src/xslt/xslt-options.ts

@@ -4,6 +4,6 @@ export type XsltOptions = {
     cData: boolean,
     escape: boolean,
     selfClosingTags: boolean,
-    outputMethod?: 'xml' | 'html' | 'text' | 'xhtml' | 'json',
+    outputMethod?: 'xml' | 'html' | 'text' | 'xhtml' | 'json' | 'adaptive',
     parameters?: XsltParameter[]
 }

src/xslt/xslt.ts

@@ -20,6 +20,7 @@ import {
     xmlGetAttribute,
     xmlTransformedText,
     xmlToJson,
+    detectAdaptiveOutputFormat,
     xmlValue,
     xmlValueLegacyBehavior
 } from '../dom';
@@ -77,7 +78,7 @@ export class Xslt {
     decimalFormatSettings: XsltDecimalFormatSettings;
 
     outputDocument: XDocument;
-    outputMethod: 'xml' | 'html' | 'text' | 'name' | 'xhtml' | 'json';
+    outputMethod: 'xml' | 'html' | 'text' | 'name' | 'xhtml' | 'json' | 'adaptive';
     outputOmitXmlDeclaration: string;
     version: string;
     firstTemplateRan: boolean;
@@ -143,7 +144,7 @@ export class Xslt {
      * The exported entry point of the XSL-T processor.
      * @param xmlDoc The input document root, as DOM node.
      * @param stylesheet The stylesheet document root, as DOM node.
-     * @returns the processed document, as XML text in a string, or JSON string if outputMethod is 'json'.
+     * @returns the processed document, as XML text in a string, JSON string if outputMethod is 'json', or text if outputMethod is 'text' or 'adaptive' (with text content).
      */
     async xsltProcess(xmlDoc: XDocument, stylesheet: XDocument) {
         const outputDocument = new XDocument();
@@ -163,11 +164,17 @@ export class Xslt {
             return xmlToJson(outputDocument);
         }
 
+        // Handle adaptive output format
+        let outputMethod = this.outputMethod;
+        if (this.outputMethod === 'adaptive') {
+            outputMethod = detectAdaptiveOutputFormat(outputDocument);
+        }
+
         const transformedOutputXml: string = xmlTransformedText(outputDocument, {
             cData: this.options.cData,
             escape: this.options.escape,
             selfClosingTags: this.options.selfClosingTags,
-            outputMethod: this.outputMethod
+            outputMethod: outputMethod as 'xml' | 'html' | 'text' | 'xhtml'
         });
 
         return transformedOutputXml;