jtlt 0.5.0 → 0.7.0

package/src/XPathTransformerContext.js

@@ -59,6 +59,10 @@ class XPathTransformerContext {
     this._currPath = undefined; // XPath string of current context
     /** @type {Record<string, any> | undefined} */
     this._params = undefined;
+    /** @type {string[]} */
+    this._preserveSpaceElements = [];
+    /** @type {string[]} */
+    this._stripSpaceElements = [];
   }
 
   /** @returns {import('./index.js').JoiningTransformer} */
@@ -66,6 +70,92 @@ class XPathTransformerContext {
     return this._config.joiningTransformer;
   }
 
+  /**
+   * Check if whitespace should be stripped for a given element.
+   * @param {Node} node - The node to check
+   * @returns {boolean}
+   */
+  _shouldStripSpace (node) {
+    if (node.nodeType !== 1) {
+      return false; // Only elements
+    }
+    const elementName = /** @type {Element} */ (node).localName;
+    // Check if in preserve list (takes precedence)
+    if (this._preserveSpaceElements.some((pattern) => {
+      return pattern === '*' || pattern === elementName;
+    })) {
+      return false;
+    }
+    // Check if in strip list
+    return this._stripSpaceElements.some((pattern) => {
+      return pattern === '*' || pattern === elementName;
+    });
+  }
+
+  /**
+   * Clone the DOM and strip whitespace-only text nodes from elements
+   * marked for stripping.
+   * @param {Node} node - The node to clone
+   * @returns {Node} The cloned node with whitespace stripped
+   */
+  _cloneAndStripWhitespace (node) {
+    // Deep clone the node
+    const cloned = node.cloneNode(true);
+
+    // Only process if we have strip-space declarations
+    if (this._stripSpaceElements.length === 0) {
+      return cloned;
+    }
+
+    // Recursively strip whitespace-only text nodes
+    const stripWhitespace = (/** @type {Node} */ n) => {
+      if (n.nodeType === 1) { // Element node
+        if (this._shouldStripSpace(n)) {
+          // Remove whitespace-only text node children
+          const childNodes = [...n.childNodes];
+          for (const child of childNodes) {
+            if (child.nodeType === 3) { // Text node
+              /* c8 ignore next 2  -- Branch inside loop already tested by
+                 integration tests; c8 artifact */
+              const text = child.nodeValue || '';
+              // Check if text is whitespace-only
+              if (text.trim() === '') {
+                child.remove();
+              }
+            }
+          }
+        }
+        // Recurse into child elements
+        const children = [...n.childNodes];
+        for (const child of children) {
+          stripWhitespace(child);
+        }
+      } else if (n.nodeType === 9) { // Document node
+        // Process document's children (typically documentElement)
+        const children = [...n.childNodes];
+        for (const child of children) {
+          stripWhitespace(child);
+        }
+      }
+    };
+
+    stripWhitespace(cloned);
+    return cloned;
+  }
+
+  /**
+   * Apply whitespace stripping to the context node based on strip-space
+   * declarations. This clones the DOM and updates the context.
+   * @returns {this}
+   */
+  applyWhitespaceStripping () {
+    if (this._stripSpaceElements.length > 0) {
+      const stripped = this._cloneAndStripWhitespace(this._origNode);
+      this._contextNode = stripped;
+    }
+    return this;
+  }
+
   /**
    * Evaluate an XPath expression against the current context node.
    * @param {string} expr - XPath expression
@@ -76,12 +166,16 @@ class XPathTransformerContext {
     if (!expr) {
       return this._contextNode;
     }
+
+    // Ensure we're using the stripped DOM if strip-space is declared
+    const contextNode = this._contextNode;
+
     const version = this._config.xpathVersion ?? 1;
     if (version === 1) {
       // Use native XPath (browser-like); rely on DOM doc if available.
-      const doc = this._contextNode && this._contextNode.ownerDocument
-        ? this._contextNode.ownerDocument
-        : (this._contextNode.nodeType === 9 ? this._contextNode : undefined);
+      const doc = contextNode && contextNode.ownerDocument
+        ? contextNode.ownerDocument
+        : (contextNode.nodeType === 9 ? contextNode : undefined);
       if (!doc || doc.nodeType !== 9) {
         throw new Error(
           'Native XPath unavailable for xpathVersion=1'
@@ -105,7 +199,7 @@ class XPathTransformerContext {
         );
       /* c8 ignore stop */
       const resultObj = docTyped.evaluate(
-        expr, this._contextNode, resolver, type, null
+        expr, contextNode, resolver, type, null
       );
       if (asNodes) {
         /** @type {Node[]} */
@@ -150,7 +244,7 @@ class XPathTransformerContext {
     }
     if (version === 2) {
       // Version 2: xpath2.js
-      const result = xpath2.evaluate(expr, this._contextNode);
+      const result = xpath2.evaluate(expr, contextNode);
       if (asNodes) {
         // eslint-disable-next-line @stylistic/max-len -- Long
         /* c8 ignore next -- array wrap/identity branch counted in other tests */
@@ -163,7 +257,7 @@ class XPathTransformerContext {
     // eslint-disable-next-line @stylistic/max-len -- Long
     // eslint-disable-next-line import/no-named-as-default-member -- Only as default
     const result = fontoxpath.evaluateXPath(
-      expr, this._contextNode, undefined, undefined,
+      expr, contextNode, undefined, undefined,
       // Non-deprecated, predictable all results
       14 // ReturnType.ALL_RESULTS
     );
@@ -1233,6 +1327,43 @@ class XPathTransformerContext {
     this._getJoiningTransformer().propValue(prop, val);
     return this;
   }
+  /**
+   * Alias for propValue(). Append a key-value pair to the current map/object.
+   * @param {string} prop Property name
+   * @param {any} val Value
+   * @returns {XPathTransformerContext}
+   */
+  mapEntry (prop, val) {
+    return this.propValue(prop, val);
+  }
+  /**
+   * Declare elements for which whitespace-only text nodes should be preserved.
+   * Equivalent to xsl:preserve-space.
+   * @param {string|string[]} elements - Element name(s) or patterns
+   * @returns {XPathTransformerContext}
+   */
+  preserveSpace (elements) {
+    const elemArray = Array.isArray(elements) ? elements : [elements];
+    this._preserveSpaceElements.push(...elemArray);
+    return this;
+  }
+  /**
+   * Declare elements for which whitespace-only text nodes should be stripped.
+   * Equivalent to xsl:strip-space.
+   * This automatically clones the DOM and removes whitespace-only text nodes.
+   * @param {string|string[]} elements - Element name(s) or patterns
+   * @returns {XPathTransformerContext}
+   */
+  stripSpace (elements) {
+    const elemArray = Array.isArray(elements) ? elements : [elements];
+    const wasEmpty = this._stripSpaceElements.length === 0;
+    this._stripSpaceElements.push(...elemArray);
+    // Apply stripping if this is the first strip-space declaration
+    if (wasEmpty && this._stripSpaceElements.length > 0) {
+      this.applyWhitespaceStripping();
+    }
+    return this;
+  }
   /**
    * Append object.
    * @param {Record<string, unknown>|
@@ -1253,6 +1384,23 @@ class XPathTransformerContext {
       propSets);
     return this;
   }
+  /**
+   * Alias for object(). Append an object/map.
+   * @param {Record<string, unknown>|
+   *   ((this: XPathTransformerContext) => void)} objOrCb Object or callback
+   * @param {((this: XPathTransformerContext) => void)|
+   *   any[]} [cbOrUsePropertySets] Callback or property sets
+   * @param {any[]|
+   *   Record<string, unknown>} [usePropertySetsOrPropSets]
+   *   Property sets or props
+   * @param {Record<string, unknown>} [propSets] Additional property sets
+   * @returns {XPathTransformerContext}
+   */
+  map (objOrCb, cbOrUsePropertySets, usePropertySetsOrPropSets, propSets) {
+    return this.object(
+      objOrCb, cbOrUsePropertySets, usePropertySetsOrPropSets, propSets
+    );
+  }
   /**
    * Append array.
    * @param {any[]|
@@ -1290,6 +1438,16 @@ class XPathTransformerContext {
     return this;
   }
 
+  /**
+   * @param {string} name
+   * @param {Record<string, string>} attributes
+   * @returns {this}
+   */
+  attributeSet (name, attributes) {
+    this._getJoiningTransformer().attributeSet(name, attributes);
+    return this;
+  }
+
   /**
    * Append element.
    * @param {string} name Tag name
@@ -1298,11 +1456,13 @@ class XPathTransformerContext {
    * @param {any[]|((this: XPathTransformerContext)=>void)} [children]
    *   Children
    * @param {(this: XPathTransformerContext)=>void} [cb] Callback
+   * @param {string[]} [useAttributeSets] - Attribute set names to apply
    * @returns {XPathTransformerContext}
    */
-  element (name, atts, children, cb) {
-    // @ts-expect-error - Union of transformers creates intersection types
-    this._getJoiningTransformer().element(name, atts, children, cb);
+  element (name, atts, children, cb, useAttributeSets) {
+    /** @type {any} */ (this._getJoiningTransformer()).element(
+      name, atts, children, cb, useAttributeSets
+    );
     return this;
   }
 
@@ -1556,6 +1716,26 @@ class XPathTransformerContext {
     return this;
   }
 
+  /**
+   * Assert that a test condition is true, throwing an error if it fails.
+   * Equivalent to xsl:assert. Evaluates an XPath expression using the
+   * same truthiness rules as if() and choose().
+   * @param {string} test - XPath expression to test
+   * @param {string} [message] - Optional error message to include
+   * @returns {XPathTransformerContext}
+   * @throws {Error} When the test expression evaluates to false
+   */
+  assert (test, message) {
+    const passes = this._passesIf(test);
+    if (!passes) {
+      const errorMsg = message
+        ? `Assertion failed: ${message}`
+        : `Assertion failed: ${test}`;
+      throw new Error(errorMsg);
+    }
+    return this;
+  }
+
   /**
    * Analyze a string with a regular expression, equivalent to
    * xsl:analyze-string. Processes matching and non-matching substrings