xslt-processor 4.2.1 → 4.3.0

package/index.mjs

@@ -2177,6 +2177,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
 import he2 from "he";
@@ -3515,9 +3631,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 = [];
@@ -3540,7 +3657,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* () {
@@ -3553,6 +3670,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,