jtlt 0.8.0 → 0.10.0

package/src/XPathTransformerContext.js

@@ -359,6 +359,66 @@ class XPathTransformerContext {
       });
       let templateObj;
       if (!pathMatchedTemplates.length) { // default template rule branches
+        // Check mode config for no-match behavior
+        const joiner = this._getJoiningTransformer();
+        const modeConfig = joiner._modeConfig;
+        if (modeConfig) {
+          const onNoMatch = modeConfig.onNoMatch ?? 'text-only-copy';
+          if (modeConfig.warningOnNoMatch) {
+            // eslint-disable-next-line no-console -- Warning as specified
+            console.warn(
+              'Warning: No template matches. ' +
+              'Mode is configured with warningOnNoMatch=true.'
+            );
+          }
+          if (onNoMatch === 'fail') {
+            throw new Error(
+              'No template matches. Mode is configured with onNoMatch="fail".'
+            );
+          }
+          if (onNoMatch === 'deep-skip') {
+            // Skip this node entirely
+            continue;
+          }
+          if (onNoMatch === 'shallow-copy') {
+            // Output the node without processing children
+            if (node.nodeType === 1 && node.ownerDocument?.defaultView) {
+              const serializer =
+                new node.ownerDocument.defaultView.XMLSerializer();
+              // Clone node without children for shallow copy
+              const clone = node.cloneNode(false);
+              joiner.rawAppend(serializer.serializeToString(clone));
+            } else if (node.nodeType === 3 && node.nodeValue) { // Text
+              joiner.text(node.nodeValue);
+            }
+            continue;
+          }
+          if (onNoMatch === 'deep-copy') {
+            // Output the node and all descendants
+            if (node.nodeType === 1 && node.ownerDocument?.defaultView) {
+              const serializer =
+                new node.ownerDocument.defaultView.XMLSerializer();
+              joiner.rawAppend(serializer.serializeToString(node));
+            } else if (node.nodeType === 3 && node.nodeValue) { // Text
+              joiner.text(node.nodeValue);
+            }
+            continue;
+          }
+          if (onNoMatch === 'text-only-copy') {
+            // Output only text content
+            if (node.nodeType === 3 && node.nodeValue) { // Text node
+              joiner.text(node.nodeValue);
+            } else if (node.nodeType === 1) { // Element - get text content
+              const {textContent} = node;
+              if (textContent) {
+                joiner.text(textContent);
+              }
+            }
+            continue;
+          }
+          // 'apply-templates', 'shallow-skip', or other:
+          // use default template rules
+        }
         // Default template rules (simplified compared to JSON version)
         const DTR = XPathTransformerContext.DefaultTemplateRules;
         // Treat Document (9) like Element (1) so the default root rule
@@ -391,6 +451,50 @@ class XPathTransformerContext {
           }
           return aPr > bPr ? -1 : 1;
         });
+
+        // Check for multiple matches with same priority when mode is configured
+        const joiner = this._getJoiningTransformer();
+        const modeConfig = joiner._modeConfig;
+        if (modeConfig && pathMatchedTemplates.length > 1) {
+          // Check if top two templates have equal priority
+          const topPriority =
+            typeof pathMatchedTemplates[0].priority === 'number'
+              ? pathMatchedTemplates[0].priority
+              : (this._config.specificityPriorityResolver &&
+                pathMatchedTemplates[0].path
+                ? this._config.specificityPriorityResolver(
+                  pathMatchedTemplates[0].path
+                )
+                /* c8 ignore next 2 -- defensive, templates without paths
+                   are already filtered at line 334 */
+                : 0);
+          const secondPriority =
+            typeof pathMatchedTemplates[1].priority === 'number'
+              ? pathMatchedTemplates[1].priority
+              : (this._config.specificityPriorityResolver &&
+                pathMatchedTemplates[1].path
+                ? this._config.specificityPriorityResolver(
+                  pathMatchedTemplates[1].path
+                )
+                /* c8 ignore next 2 -- defensive, templates without paths
+                   are already filtered at line 334 */
+                : 0);
+          if (topPriority === secondPriority) {
+            if (modeConfig.onMultipleMatch === 'fail') {
+              throw new Error(
+                'Multiple templates match with equal priority. ' +
+                'Mode is configured with onMultipleMatch="fail".'
+              );
+            } else if (modeConfig.warningOnMultipleMatch !== false) {
+              // eslint-disable-next-line no-console -- Warning as specified
+              console.warn(
+                'Warning: Multiple templates match with equal priority. ' +
+                'Mode is configured with warningOnMultipleMatch=true.'
+              );
+            }
+          }
+        }
+
         templateObj =
           /**
            * @type {import('./index.js').XPathTemplateObject<any>}
@@ -410,7 +514,15 @@ class XPathTransformerContext {
       this._params = prevTemplateParams;
 
       if (typeof ret !== 'undefined') {
-        this._getJoiningTransformer().append(ret);
+        const joiner = this._getJoiningTransformer();
+        // Close any open tag before appending template return value
+        // @ts-expect-error -- _openTagState only on StringJoiningTransformer
+        if (joiner._openTagState) {
+          joiner.append('>');
+          // @ts-expect-error -- _openTagState only on StringJoiningTransformer
+          joiner._openTagState = false;
+        }
+        joiner.append(ret);
       }
       this._contextNode = node; // Restore (placeholder for more complex state)
     }
@@ -1438,6 +1550,22 @@ class XPathTransformerContext {
     return this;
   }
 
+  /**
+   * Configure mode behavior (similar to xsl:mode).
+   * @param {{
+   *   onMultipleMatch?: "use-last"|"fail",
+   *   warningOnMultipleMatch?: boolean,
+   *   onNoMatch?: "shallow-copy"|"deep-copy"|"fail"|"apply-templates"|
+   *     "shallow-skip"|"deep-skip"|"text-only-copy",
+   *   warningOnNoMatch?: boolean
+   * }} cfg - Mode configuration
+   * @returns {this}
+   */
+  mode (cfg) {
+    this._getJoiningTransformer().mode(cfg);
+    return this;
+  }
+
   /**
    * @param {string} name
    * @param {import('./AbstractJoiningTransformer.js').
@@ -1471,6 +1599,31 @@ class XPathTransformerContext {
     return this;
   }
 
+  /**
+   * Configure stylesheet behavior (similar to xsl:stylesheet).
+   * Unlike xsl:stylesheet, this is a directive method and does not contain
+   * nested content.
+   * @param {{
+   *   excludeResultPrefixes?: string[]
+   * }} cfg - Stylesheet configuration
+   * @returns {this}
+   */
+  stylesheet (cfg) {
+    this._getJoiningTransformer().stylesheet(cfg);
+    return this;
+  }
+
+  /**
+   * Alias for stylesheet() method (XSLT compatibility).
+   * @param {{
+   *   excludeResultPrefixes?: string[]
+   * }} cfg - Stylesheet configuration
+   * @returns {this}
+   */
+  transform (cfg) {
+    return this.stylesheet(cfg);
+  }
+
   /**
    * Append element.
    * @param {string} name Tag name
@@ -1909,7 +2062,7 @@ class XPathTransformerContext {
        * @returns {void}
        */
       template (node, cfg) {
-        this.applyTemplates('.', cfg.mode);
+        this.applyTemplates('node()', cfg.mode);
       }
     },
     transformElements: {
@@ -1920,7 +2073,7 @@ class XPathTransformerContext {
        * @returns {void}
        */
       template (node, cfg) {
-        this.applyTemplates('*', cfg.mode);
+        this.applyTemplates('node()', cfg.mode);
       }
     },
     transformTextNodes: {

package/src/index.js

@@ -34,6 +34,7 @@ export const setWindow = (win) => {
  * @template TCtx
  * @typedef {object} TemplateObject
  * @property {string} [path] - JSONPath or XPath selector for matching nodes
+ * @property {string} [match] - Alias for 'path' (XSLT compatibility)
  * @property {string} [name] - Optional name for calling via callTemplate
  * @property {string} [mode] - Optional mode for template matching
  * @property {number} [priority] - Priority for template selection