xslt-processor 4.2.0 → 4.3.0

package/README.md

@@ -89,12 +89,57 @@ const xslt = new Xslt(options);
 - `cData` (`boolean`, default `true`): resolves CDATA elements in the output. Content under CDATA is resolved as text. This overrides `escape` for CDATA content.
 - `escape` (`boolean`, default `true`): replaces symbols like `<`, `>`, `&` and `"` by the corresponding [HTML/XML entities](https://www.tutorialspoint.com/xml/xml_character_entities.htm). Can be overridden by `disable-output-escaping`, that also does the opposite, unescaping `&gt;` and `&lt;` by `<` and `>`, respectively.
 - `selfClosingTags` (`boolean`, default `true`): Self-closes tags that don't have inner elements, if `true`. For instance, `<test></test>` becomes `<test />`.
-- `outputMethod` (`string`, default `xml`): Specifies the default output method. if `<xsl:output>` is declared in your XSLT file, this will be overridden. Valid values: `xml`, `html`, `text`, `name`, `xhtml`.
+- `outputMethod` (`string`, default `xml`): Specifies the default output method. if `<xsl:output>` is declared in your XSLT file, this will be overridden. Valid values: `xml`, `html`, `text`, `name`, `xhtml`, `json`.
 - `parameters` (`array`, default `[]`): external parameters that you want to use.
     - `name`: the parameter name;
     - `namespaceUri` (optional): the namespace;
     - `value`: the value.
 
+#### JSON Output Format
+
+When using `outputMethod: 'json'`, the XSLT processor will convert the resulting XML document to JSON format. This is useful for APIs and modern JavaScript applications.
+
+**Example:**
+
+```js
+const xslt = new Xslt({ outputMethod: 'json' });
+const xmlParser = new XmlParser();
+
+const xmlString = `<root>
+  <users>
+    <user>Alice</user>
+    <user>Bob</user>
+  </users>
+</root>`;
+
+const xsltString = `<?xml version="1.0"?>
+  <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+    <xsl:template match="/">
+      <xsl:copy-of select="root"/>
+    </xsl:template>
+  </xsl:stylesheet>`;
+
+const result = await xslt.xsltProcess(
+  xmlParser.xmlParse(xmlString),
+  xmlParser.xmlParse(xsltString)
+);
+
+// result will be a JSON string:
+// {"root":{"users":{"user":["Alice","Bob"]}}}
+
+const parsed = JSON.parse(result);
+console.log(parsed.root.users.user); // ["Alice", "Bob"]
+```
+
+**JSON Structure Rules:**
+
+- Each element becomes a property in a JSON object
+- Text-only elements become string values
+- Elements with multiple children of the same name become arrays
+- Empty elements are omitted from the output
+- Attributes are prefixed with `@` (when present in the output)
+- Mixed text and element content uses the `#text` property for text nodes
+
 ### Direct use in browsers
 
 You can simply add a tag like this:

package/index.d.mts

@@ -532,6 +532,7 @@ type XsltOptions = {
     cData: boolean;
     escape: boolean;
     selfClosingTags: boolean;
+    outputMethod?: 'xml' | 'html' | 'text' | 'xhtml' | 'json';
     parameters?: XsltParameter[];
 };
 
@@ -566,7 +567,7 @@ declare class Xslt {
     options: XsltOptions;
     decimalFormatSettings: XsltDecimalFormatSettings;
     outputDocument: XDocument;
-    outputMethod: 'xml' | 'html' | 'text' | 'name' | 'xhtml';
+    outputMethod: 'xml' | 'html' | 'text' | 'name' | 'xhtml' | 'json';
     outputOmitXmlDeclaration: string;
     version: string;
     firstTemplateRan: boolean;
@@ -591,7 +592,7 @@ declare 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.
+     * @returns the processed document, as XML text in a string, or JSON string if outputMethod is 'json'.
      */
     xsltProcess(xmlDoc: XDocument, stylesheet: XDocument): Promise<string>;
     /**

package/index.d.ts

@@ -532,6 +532,7 @@ type XsltOptions = {
     cData: boolean;
     escape: boolean;
     selfClosingTags: boolean;
+    outputMethod?: 'xml' | 'html' | 'text' | 'xhtml' | 'json';
     parameters?: XsltParameter[];
 };
 
@@ -566,7 +567,7 @@ declare class Xslt {
     options: XsltOptions;
     decimalFormatSettings: XsltDecimalFormatSettings;
     outputDocument: XDocument;
-    outputMethod: 'xml' | 'html' | 'text' | 'name' | 'xhtml';
+    outputMethod: 'xml' | 'html' | 'text' | 'name' | 'xhtml' | 'json';
     outputOmitXmlDeclaration: string;
     version: string;
     firstTemplateRan: boolean;
@@ -591,7 +592,7 @@ declare 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.
+     * @returns the processed document, as XML text in a string, or JSON string if outputMethod is 'json'.
      */
     xsltProcess(xmlDoc: XDocument, stylesheet: XDocument): Promise<string>;
     /**

package/index.js

@@ -2213,6 +2213,122 @@ function xmlGetAttribute(node, name) {
   }
   return value;
 }
+function nodeToJsonObject(node) {
+  if (!node) {
+    return null;
+  }
+  const nodeType = node.nodeType;
+  if (nodeType === DOM_TEXT_NODE || nodeType === DOM_CDATA_SECTION_NODE) {
+    const text = node.nodeValue ? node.nodeValue.trim() : "";
+    return text.length > 0 ? text : null;
+  }
+  if (nodeType === DOM_COMMENT_NODE) {
+    return null;
+  }
+  if (nodeType === DOM_DOCUMENT_NODE || nodeType === DOM_DOCUMENT_FRAGMENT_NODE) {
+    const children = node.childNodes || [];
+    const childObjects = [];
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
+      const childObj = nodeToJsonObject(child);
+      if (childObj !== null) {
+        childObjects.push(childObj);
+      }
+    }
+    if (childObjects.length === 0) {
+      return null;
+    } else if (childObjects.length === 1) {
+      return childObjects[0];
+    } else {
+      return childObjects;
+    }
+  }
+  if (nodeType === DOM_ELEMENT_NODE) {
+    const obj = {};
+    const element = node;
+    const hasAttributes = element.attributes && element.attributes.length > 0;
+    if (hasAttributes) {
+      for (let i = 0; i < element.attributes.length; i++) {
+        const attr = element.attributes[i];
+        obj["@" + attr.nodeName] = attr.nodeValue;
+      }
+    }
+    const children = element.childNodes || [];
+    let textContent = "";
+    let hasElementChildren = false;
+    const childElements = {};
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
+      const childType = child.nodeType;
+      if (childType === DOM_TEXT_NODE || childType === DOM_CDATA_SECTION_NODE) {
+        const text = child.nodeValue ? child.nodeValue.trim() : "";
+        if (text.length > 0) {
+          textContent += text;
+        }
+      } else if (childType === DOM_ELEMENT_NODE) {
+        hasElementChildren = true;
+        const childElement = child;
+        const childName = childElement.localName || childElement.nodeName;
+        const childObj = nodeToJsonObject(child);
+        if (childObj !== null) {
+          if (childElements[childName]) {
+            if (!Array.isArray(childElements[childName])) {
+              childElements[childName] = [childElements[childName]];
+            }
+            childElements[childName].push(childObj);
+          } else {
+            childElements[childName] = childObj;
+          }
+        }
+      }
+    }
+    Object.assign(obj, childElements);
+    if (!hasElementChildren && textContent.length > 0) {
+      if (!hasAttributes && Object.keys(childElements).length === 0) {
+        return textContent;
+      } else {
+        obj["#text"] = textContent;
+      }
+    }
+    if (Object.keys(obj).length === 0) {
+      return null;
+    }
+    return obj;
+  }
+  return null;
+}
+function xmlToJson(node) {
+  if (!node) {
+    return "{}";
+  }
+  let rootElement = node;
+  if (node.nodeType === DOM_DOCUMENT_NODE || node.nodeType === DOM_DOCUMENT_FRAGMENT_NODE) {
+    const children = node.childNodes || [];
+    for (let i = 0; i < children.length; i++) {
+      if (children[i].nodeType === DOM_ELEMENT_NODE) {
+        rootElement = children[i];
+        break;
+      }
+    }
+  }
+  const element = rootElement;
+  const rootName = element.localName || element.nodeName;
+  const jsonObj = {};
+  const elementContent = nodeToJsonObject(rootElement);
+  if (elementContent === null) {
+    jsonObj[rootName] = {};
+  } else if (typeof elementContent === "object" && !Array.isArray(elementContent)) {
+    jsonObj[rootName] = elementContent;
+  } else {
+    jsonObj[rootName] = elementContent;
+  }
+  try {
+    const cleaned = JSON.parse(JSON.stringify(jsonObj));
+    return JSON.stringify(cleaned);
+  } catch (error) {
+    return JSON.stringify(jsonObj);
+  }
+}
 
 // src/dom/xml-parser.ts
 var import_he2 = __toESM(require("he"));
@@ -3446,24 +3562,31 @@ function nodeMatchesSinglePattern(node, pattern, context, matchResolver, xPath)
     const patternLocalName = attrPattern.includes(":") ? attrPattern.substring(attrPattern.indexOf(":") + 1) : attrPattern;
     return attrName === patternLocalName || node.nodeName === attrPattern;
   }
-  const nodeContext = context.clone([node], 0);
-  try {
-    const expr = xPath.xPathParse(pattern, "self-and-siblings");
-    const nodes = matchResolver.expressionMatch(expr, nodeContext);
-    if (nodes.some((n) => n.id === node.id)) {
-      return true;
-    }
-  } catch (e) {
-  }
   if (pattern === "*" && node.nodeType === DOM_ELEMENT_NODE) {
     return true;
   }
-  if (pattern.includes("[") || pattern.includes("/")) {
+  if (!pattern.includes("/") && !pattern.includes("[") && !pattern.startsWith("@")) {
+    if (pattern === node.nodeName || pattern === node.localName) {
+      return true;
+    }
+  }
+  if (pattern.includes("/") || pattern.includes("[")) {
     try {
+      const evaluationPattern = pattern.startsWith("/") ? pattern : "//" + pattern;
       const rootContext = context.clone([context.root], 0);
-      const descendantPattern = pattern.startsWith("/") ? pattern : "//" + pattern;
-      const expr = xPath.xPathParse(descendantPattern);
-      const nodes = matchResolver.expressionMatch(expr, rootContext);
+      const evalResult = xPath.xPathEval(evaluationPattern, rootContext);
+      const nodes = evalResult.nodeSetValue();
+      if (nodes.some((n) => n.id === node.id)) {
+        return true;
+      }
+    } catch (e) {
+    }
+  }
+  if (!pattern.includes("/") && !pattern.includes("[") && !pattern.startsWith("@")) {
+    try {
+      const nodeContext = context.clone([node], 0);
+      const expr = xPath.xPathParse(pattern, "self-and-siblings");
+      const nodes = matchResolver.expressionMatch(expr, nodeContext);
       if (nodes.some((n) => n.id === node.id)) {
         return true;
       }
@@ -3544,9 +3667,10 @@ var Xslt = class {
       cData: options.cData === true,
       escape: options.escape === true,
       selfClosingTags: options.selfClosingTags === true,
+      outputMethod: options.outputMethod,
       parameters: options.parameters || []
     };
-    this.outputMethod = "xml";
+    this.outputMethod = options.outputMethod || "xml";
     this.outputOmitXmlDeclaration = "no";
     this.stripSpacePatterns = [];
     this.preserveSpacePatterns = [];
@@ -3569,7 +3693,7 @@ var Xslt = class {
    * 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.
+   * @returns the processed document, as XML text in a string, or JSON string if outputMethod is 'json'.
    */
   xsltProcess(xmlDoc, stylesheet) {
     return __async(this, null, function* () {
@@ -3582,6 +3706,9 @@ var Xslt = class {
         }
       }
       yield this.xsltProcessContext(expressionContext, stylesheet, this.outputDocument);
+      if (this.outputMethod === "json") {
+        return xmlToJson(outputDocument);
+      }
       const transformedOutputXml = xmlTransformedText(outputDocument, {
         cData: this.options.cData,
         escape: this.options.escape,
@@ -3741,7 +3868,9 @@ var Xslt = class {
       const mode = xmlGetAttribute(template, "mode");
       const top = template.ownerDocument.documentElement;
       const expandedTemplates = collectAndExpandTemplates(top, mode, this.xPath);
-      const modifiedContext = context.clone(nodes);
+      const paramContext = context.clone();
+      yield this.xsltWithParam(paramContext, template);
+      const modifiedContext = paramContext.clone(nodes);
       for (let j = 0; j < modifiedContext.contextSize(); ++j) {
         const currentNode = modifiedContext.nodeList[j];
         if (currentNode.nodeType === DOM_TEXT_NODE) {
@@ -4612,13 +4741,76 @@ var Xslt = class {
           contextClone.baseTemplateMatched = true;
           const templateContext = contextClone.clone(winner.matchedNodes, 0);
           yield this.xsltChildNodes(templateContext, winner.priority.template, output);
+        } else {
+          const rootNode = context.nodeList[context.position];
+          if (rootNode && rootNode.childNodes && rootNode.childNodes.length > 0) {
+            const childNodes = rootNode.childNodes.filter((n) => n.nodeName !== "#dtd-section");
+            if (childNodes.length > 0) {
+              const childContext = context.clone(childNodes);
+              for (let j = 0; j < childContext.contextSize(); ++j) {
+                const currentNode = childContext.nodeList[j];
+                if (currentNode.nodeType === DOM_TEXT_NODE) {
+                  const textNodeContext = context.clone([currentNode], 0);
+                  this.commonLogicTextNode(textNodeContext, currentNode, output);
+                } else {
+                  const clonedContext = childContext.clone([currentNode], 0);
+                  const selection = selectBestTemplate(
+                    expandedTemplates,
+                    clonedContext,
+                    this.matchResolver,
+                    this.xPath
+                  );
+                  if (selection.selectedTemplate) {
+                    const templateContext = clonedContext.clone([currentNode], 0);
+                    templateContext.inApplyTemplates = true;
+                    yield this.xsltChildNodes(templateContext, selection.selectedTemplate, output);
+                  } else {
+                    if (currentNode.childNodes && currentNode.childNodes.length > 0) {
+                      const grandchildNodes = currentNode.childNodes.filter((n) => n.nodeName !== "#dtd-section");
+                      if (grandchildNodes.length > 0) {
+                        const grandchildContext = context.clone(grandchildNodes);
+                        for (let k = 0; k < grandchildContext.contextSize(); ++k) {
+                          const grandchildNode = grandchildContext.nodeList[k];
+                          if (grandchildNode.nodeType === DOM_TEXT_NODE) {
+                            const textNodeContext = context.clone([grandchildNode], 0);
+                            this.commonLogicTextNode(textNodeContext, grandchildNode, output);
+                          } else {
+                            const grandchildClonedContext = grandchildContext.clone([grandchildNode], 0);
+                            const grandchildSelection = selectBestTemplate(
+                              expandedTemplates,
+                              grandchildClonedContext,
+                              this.matchResolver,
+                              this.xPath
+                            );
+                            if (grandchildSelection.selectedTemplate) {
+                              const grandchildTemplateContext = grandchildClonedContext.clone([grandchildNode], 0);
+                              grandchildTemplateContext.inApplyTemplates = true;
+                              yield this.xsltChildNodes(grandchildTemplateContext, grandchildSelection.selectedTemplate, output);
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
         }
       }
     });
   }
   xsltValueOf(context, template, output) {
     const select = xmlGetAttribute(template, "select");
-    const attribute = this.xPath.xPathEval(select, context);
+    const current = context.nodeList[context.position];
+    let attribute = this.xPath.xPathEval(select, context);
+    if (current && current.nodeName === "#document" && (attribute.stringValue() === "" || attribute instanceof NodeSetValue && attribute.nodeSetValue().length === 0)) {
+      const docChild = current.childNodes.find((c) => c.nodeName !== "#dtd-section");
+      if (docChild) {
+        const fallbackContext = context.clone([docChild], 0);
+        attribute = this.xPath.xPathEval(select, fallbackContext);
+      }
+    }
     const value = attribute.stringValue();
     const node = domCreateTextNode(this.outputDocument, value);
     const targetOutput = output || this.outputDocument;