jtlt 0.7.3 → 0.9.0

package/src/AbstractJoiningTransformer.js

@@ -74,6 +74,20 @@ class AbstractJoiningTransformer {
     this._characterMap = {};
     /** @type {Record<string, Record<string, string>>} */
     this._attributeSet = {};
+
+    /** @type {Map<string, string>} */
+    this._namespaceAliases = new Map();
+
+    /**
+     * @type {{
+     *   onMultipleMatch?: "use-last"|"fail",
+     *   warningOnMultipleMatch?: boolean,
+     *   onNoMatch?: "shallow-copy"|"deep-copy"|"fail"|"apply-templates"|
+     *     "shallow-skip"|"deep-skip"|"text-only-copy",
+     *   warningOnNoMatch?: boolean
+     * }|undefined}
+     */
+    this._modeConfig = undefined;
   }
 
   /**
@@ -98,6 +112,22 @@ class AbstractJoiningTransformer {
     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._modeConfig = cfg;
+    return this;
+  }
+
   /**
    * @param {string} name
    * @param {OutputCharacters} outputCharacters
@@ -116,6 +146,71 @@ class AbstractJoiningTransformer {
     this._attributeSet[name] = attributes;
   }
 
+  /**
+   * @param {string} stylesheetPrefix
+   * @param {string} resultPrefix
+   * @returns {void}
+   */
+  namespaceAlias (stylesheetPrefix, resultPrefix) {
+    // Convert empty string to '#default' to match _getNamespaceAlias behavior
+    const key = stylesheetPrefix || '#default';
+    this._namespaceAliases.set(key, resultPrefix);
+  }
+
+  /**
+   * @param {string} prefix
+   * @returns {string}
+   */
+  _getNamespaceAlias (prefix) {
+    // eslint-disable-next-line @stylistic/max-len -- Long
+    // eslint-disable-next-line unicorn/prefer-default-parameters -- Empty string fallback
+    const lookupPrefix = prefix || '#default';
+    return this._namespaceAliases.get(lookupPrefix) ?? (
+      lookupPrefix
+    );
+  }
+
+  /**
+   * @param {string} attName
+   * @returns {string}
+   */
+  _replaceNamespaceAliasInNamespaceDeclaration (attName) {
+    if (!attName.startsWith('xmlns')) {
+      return attName;
+    }
+    const namespacedAtt = attName.startsWith('xmlns:');
+
+    const prefix = namespacedAtt ? attName.slice(0, 6) : '#default';
+    const alias = this._getNamespaceAlias(prefix);
+
+    return alias === '#default'
+      ? 'xmlns'
+      : 'xmlns:' + alias;
+  }
+
+  /**
+   * @param {string} elemName
+   * @returns {string}
+   */
+  _replaceNamespaceAliasInElement (elemName) {
+    const colonIdx = elemName.indexOf(':');
+
+    const prefix = colonIdx === -1 ? '#default' : elemName.slice(0, colonIdx);
+    const alias = this._getNamespaceAlias(prefix);
+
+    if (colonIdx === -1) {
+      if (alias === '#default') {
+        return elemName;
+      }
+      return alias + ':' + elemName;
+    }
+
+    return (alias === '#default'
+      ? ''
+      : alias + ':'
+    ) + elemName.slice(colonIdx + 1);
+  }
+
   /**
    * @param {string} str
    * @returns {string}

package/src/DOMJoiningTransformer.js

@@ -281,7 +281,7 @@ class DOMJoiningTransformer extends AbstractJoiningTransformer {
    * @returns {DOMJoiningTransformer}
    */
   /**
-   * @param {Element|string} elName - Element name
+   * @param {Element|string} elem - Element name
    * @param {Record<string, string>|(Node|string)[
    *   ]|((this: DOMJoiningTransformer) => void)} [atts] - Attributes,
    *   childNodes, or callback
@@ -291,7 +291,7 @@ class DOMJoiningTransformer extends AbstractJoiningTransformer {
    * @param {string[]} [useAttributeSets] - Attribute set names to apply
    * @returns {DOMJoiningTransformer}
    */
-  element (elName, atts, childNodes, cb, useAttributeSets) {
+  element (elem, atts, childNodes, cb, useAttributeSets) {
     // Handle argument overloading like other transformers
     if (Array.isArray(atts)) {
       cb = /** @type {(this: DOMJoiningTransformer) => void} */ (
@@ -309,12 +309,14 @@ class DOMJoiningTransformer extends AbstractJoiningTransformer {
       childNodes = [];
     }
 
-    if (!this.root && this._outputConfig) {
-      this.root = elName;
+    const elementName = this._replaceNamespaceAliasInElement(
+      typeof elem === 'string'
+        ? elem
+        : elem.localName
+    );
 
-      const elementName = typeof elName === 'string'
-        ? elName
-        : elName.localName;
+    if (!this.root && this._outputConfig) {
+      this.root = elementName;
 
       const {
         omitXmlDeclaration, doctypePublic, doctypeSystem, method
@@ -420,10 +422,10 @@ class DOMJoiningTransformer extends AbstractJoiningTransformer {
     }
 
     // Non-root elements
-    const el = elName && typeof elName === 'object'
-      ? elName
+    const el = elem && typeof elem === 'object'
+      ? elem
       : /** @type {Element} */ (
-        this._cfg.document.createElement(elName)
+        this._cfg.document.createElement(elem)
       );
 
     // Apply attribute sets if specified
@@ -477,10 +479,11 @@ class DOMJoiningTransformer extends AbstractJoiningTransformer {
    * @returns {DOMJoiningTransformer}
    */
   namespace (prefix, namespaceURI) {
+    const alias = this._getNamespaceAlias(prefix);
     /** @type {Element} */
     (this._dom).setAttributeNS(
       'http://www.w3.org/2000/xmlns/',
-      'xmlns:' + prefix,
+      alias === '#default' ? 'xmlns' : 'xmlns:' + alias,
       this._replaceCharacterMaps(namespaceURI)
     );
     return this;
@@ -497,7 +500,8 @@ class DOMJoiningTransformer extends AbstractJoiningTransformer {
       throw new Error('You may only set an attribute on an element');
     }
     (/** @type {Element} */ (this._dom)).setAttribute(
-      name, this._replaceCharacterMaps(val)
+      this._replaceNamespaceAliasInNamespaceDeclaration(name),
+      this._replaceCharacterMaps(val)
     );
     return this;
   }

package/src/JSONJoiningTransformer.js

@@ -372,7 +372,7 @@ class JSONJoiningTransformer extends AbstractJoiningTransformer {
    * Result form: ['tag', {attr: 'val'}, child1, child2, ...]
    * Helpers: dataset -> data-*; $a -> ordered attributes.
    * Supported signatures mirror StringJoiningTransformer.element.
-   * @param {string|Element} elName Element name or Element-like.
+   * @param {string|Element} elem Element name or Element-like.
    * @param {ElementAttributes|any[]|SimpleCallback} [atts]
    *   Attrs, children, or cb.
    * @param {any[]|SimpleCallback} [childNodes] Children or cb.
@@ -380,11 +380,16 @@ class JSONJoiningTransformer extends AbstractJoiningTransformer {
    * @param {string[]} [useAttributeSets] - Attribute set names to apply
    * @returns {JSONJoiningTransformer}
    */
-  element (elName, atts, childNodes, cb, useAttributeSets) {
+  element (elem, atts, childNodes, cb, useAttributeSets) {
     this._requireSameChildren('json', 'element');
+    const elementName = this._replaceNamespaceAliasInElement(
+      typeof elem === 'string'
+        ? elem
+        : elem.localName
+    );
     const isRoot = !this.root;
     if (isRoot) {
-      this.root = elName;
+      this.root = elementName;
     }
     // Normalize arguments similarly to StringJoiningTransformer.element
     if (Array.isArray(atts)) {
@@ -401,14 +406,11 @@ class JSONJoiningTransformer extends AbstractJoiningTransformer {
       childNodes = [];
     }
 
-    const elementName = typeof elName === 'string'
-      ? elName
-      : elName.localName;
     // Element-like object (DOM Element) -> extract attributes
-    if (typeof elName === 'object' && elName && 'attributes' in elName) {
+    if (typeof elem === 'object' && elem && 'attributes' in elem) {
       /** @type {Record<string, string>} */
       const objAtts = {};
-      [...elName.attributes].forEach((att) => {
+      [...elem.attributes].forEach((att) => {
         objAtts[att.name] = att.value;
       });
       atts = Object.assign(objAtts, atts);
@@ -556,8 +558,10 @@ class JSONJoiningTransformer extends AbstractJoiningTransformer {
       attsObj.xmlns = {};
     }
 
+    const alias = this._getNamespaceAlias(prefix);
     /** @type {Record<string, string>} */
-    (attsObj.xmlns)[prefix] = this._replaceCharacterMaps(namespaceURI);
+    (attsObj.xmlns)[alias === '#default' ? '' : alias] =
+      this._replaceCharacterMaps(namespaceURI);
 
     return this;
   }
@@ -600,7 +604,8 @@ class JSONJoiningTransformer extends AbstractJoiningTransformer {
       });
       return this;
     }
-    attsObj[name] = this._replaceCharacterMaps(/** @type {string} */ (val));
+    attsObj[this._replaceNamespaceAliasInNamespaceDeclaration(name)] =
+      this._replaceCharacterMaps(/** @type {string} */ (val));
     return this;
   }
 

package/src/JSONPathTransformer.js

@@ -19,6 +19,9 @@ class JSONPathTransformer {
     this._config = config;
     /** @type {import('./index.js').JSONPathTemplateObject<T>[]} */
     this.rootTemplates = [];
+    if (!config.templates) {
+      throw new TypeError('config.templates is required');
+    }
     this.templates = config.templates.map(function (template) {
       if (Array.isArray(template)) {
         // Todo: We could allow a third argument (at beginning or
@@ -27,6 +30,10 @@ class JSONPathTransformer {
           {path: template[0], template: template[1]}
         );
       }
+      // Normalize 'match' to 'path' for XSLT compatibility
+      if (template.match && !template.path) {
+        return {...template, path: template.match};
+      }
       return template;
     });
     this.templates.forEach((template, i, templates) => {

package/src/JSONPathTransformerContext.js

@@ -62,7 +62,7 @@ import JSONPathTransformer from './JSONPathTransformer.js';
  *   JSONPath
  * @property {(path: string) => number} [specificityPriorityResolver]
  *   Priority resolver function
- * @property {import('./index.js').JSONPathTemplateObject<T>[]} templates
+ * @property {import('./index.js').JSONPathTemplateObject<T>[]} [templates]
  */
 
 /**
@@ -408,6 +408,48 @@ class JSONPathTransformerContext {
 
       let templateObj;
       if (!pathMatchedTemplates.length) {
+        // Check mode config for no-match behavior
+        const joiner = that._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 and its descendants entirely
+            continue;
+          }
+          if (onNoMatch === 'shallow-copy') {
+            // Output the value as-is without processing children
+            joiner.append(value);
+            continue;
+          }
+          if (onNoMatch === 'deep-copy') {
+            // Output the value and all descendants as-is
+            joiner.append(JSON.stringify(value));
+            continue;
+          }
+          if (onNoMatch === 'text-only-copy') {
+            // Output only text content (primitives)
+            if (typeof value === 'string' || typeof value === 'number' ||
+                typeof value === 'boolean') {
+              joiner.append(String(value));
+            }
+            continue;
+          }
+          // 'apply-templates', 'shallow-skip', or other:
+          // use default template rules
+        }
         const dtr = JSONPathTransformer.DefaultTemplateRules;
         if (propertyNamesMode) {
           templateObj = dtr.transformPropertyNames;
@@ -446,6 +488,49 @@ class JSONPathTransformerContext {
           return (aPriority > bPriority) ? -1 : 1;
         });
 
+        // Check for multiple matches with same priority when mode is configured
+        const joiner = that._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
+              : (that._config.specificityPriorityResolver &&
+                pathMatchedTemplates[0].path
+                ? that._config.specificityPriorityResolver(
+                  pathMatchedTemplates[0].path
+                )
+                /* c8 ignore next 2 -- defensive, templates without paths
+                   are already filtered at line 388 */
+                : 0);
+          const secondPriority =
+            typeof pathMatchedTemplates[1].priority === 'number'
+              ? pathMatchedTemplates[1].priority
+              : (that._config.specificityPriorityResolver &&
+                pathMatchedTemplates[1].path
+                ? that._config.specificityPriorityResolver(
+                  pathMatchedTemplates[1].path
+                )
+                /* c8 ignore next 2 -- defensive, templates without paths
+                   are already filtered at line 388 */
+                : 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').JSONPathTemplateObject<T>} */ (
             pathMatchedTemplates.shift()
@@ -471,7 +556,18 @@ class JSONPathTransformerContext {
       that._params = prevTemplateParams;
       if (typeof ret !== 'undefined') {
         // After the undefined check, ret is ResultType<T>
-        that._getJoiningTransformer().append(
+        const joiner = that._getJoiningTransformer();
+        // Close any open tag before appending template return value
+        /* c8 ignore start -- _openTagState only on StringJoiningTransformer,
+           defensive check for string output mode */
+        // @ts-expect-error -- _openTagState only on StringJoiningTransformer
+        if (joiner._openTagState) {
+          joiner.append('>');
+          // @ts-expect-error -- _openTagState only on StringJoiningTransformer
+          joiner._openTagState = false;
+        }
+        /* c8 ignore stop */
+        joiner.append(
           /** @type {string|Node|*} */ (ret)
         );
       }
@@ -1757,6 +1853,22 @@ class JSONPathTransformerContext {
     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').
@@ -1778,14 +1890,30 @@ class JSONPathTransformerContext {
     return this;
   }
 
+  /**
+   * @param {string} stylesheetPrefix
+   * @param {string} resultPrefix
+   * @returns {this}
+   */
+  namespaceAlias (stylesheetPrefix, resultPrefix) {
+    this._getJoiningTransformer().namespaceAlias(
+      stylesheetPrefix, resultPrefix
+    );
+    return this;
+  }
+
   /**
    * Create an element. Mirrors the joining transformer API so templates can
    * call `this.element()`.
    * @param {string} name - Element name
-   * @param {Record<string, string>} [atts] - Attributes object
-   * @param {any[]} [children] - Child nodes
-   * @param {import('./JSONJoiningTransformer.js').
-   *   SimpleCallback<T>} [cb] - Callback function
+   * @param {Record<string, string>|any[]|
+   *   ((this: JSONPathTransformerContext<T>) => void)} [atts] -
+   *   Attributes object or children or callback
+   * @param {any[]|
+   *   ((this: JSONPathTransformerContext<T>) => void)} [children] -
+   *   Child nodes or callback
+   * @param {(this: JSONPathTransformerContext<T>) => void} [cb] -
+   *   Callback function
    * @param {string[]} [useAttributeSets] - Attribute set names to apply
    * @returns {this}
    */

package/src/StringJoiningTransformer.js

@@ -471,14 +471,14 @@ class StringJoiningTransformer extends AbstractJoiningTransformer {
   }
 
   /**
-   * @param {string|Element} elName - Element name or element object
+   * @param {string|Element} elem - Element name or element object
    * @param {ElementAttributes} [atts] - Element attributes
    * @param {any[]} [childNodes] - Child nodes
    * @param {(this: StringJoiningTransformer) => void} [cb] - Callback function
    * @param {string[]} [useAttributeSets] - Attribute set names to apply
    * @returns {StringJoiningTransformer}
    */
-  element (elName, atts, childNodes, cb, useAttributeSets) {
+  element (elem, atts, childNodes, cb, useAttributeSets) {
     // If a parent element's start tag is still open, close it before
     // starting a new element to ensure valid nesting.
     if (this._openTagState) {
@@ -486,6 +486,24 @@ class StringJoiningTransformer extends AbstractJoiningTransformer {
       this._openTagState = false;
     }
 
+    /** @type {string} */
+    let elName;
+    if (typeof elem === 'object') {
+      /** @type {Record<string, string>} */
+      const objAtts = {};
+      /** @type {any} */
+      const elObj = elem;
+      [...elObj.attributes].forEach(function (att, i) {
+        objAtts[att.name] = att.value;
+      });
+      atts = Object.assign(objAtts, atts);
+      elName = elObj.nodeName;
+    } else {
+      elName = elem;
+    }
+
+    elName = this._replaceNamespaceAliasInElement(elName);
+
     if (!this.root) {
       this.root = elName;
 
@@ -565,18 +583,6 @@ class StringJoiningTransformer extends AbstractJoiningTransformer {
       return this;
     }
 
-    if (typeof elName === 'object') {
-      /** @type {Record<string, string>} */
-      const objAtts = {};
-      /** @type {any} */
-      const elObj = elName;
-      [...elObj.attributes].forEach(function (att, i) {
-        objAtts[att.name] = att.value;
-      });
-      atts = Object.assign(objAtts, atts);
-      elName = elObj.nodeName;
-    }
-
     // Apply attribute sets if specified
     if (useAttributeSets && useAttributeSets.length) {
       const mergedAtts = {};
@@ -627,7 +633,10 @@ class StringJoiningTransformer extends AbstractJoiningTransformer {
    * @returns {StringJoiningTransformer}
    */
   namespace (prefix, namespaceURI) {
-    this.append(' xmlns:' + prefix + '="' +
+    const alias = this._getNamespaceAlias(prefix);
+    this.append(' ' + (
+      alias === '#default' ? 'xmlns' : 'xmlns:' + alias
+    ) + '="' +
         this._replaceCharacterMaps(namespaceURI) + '"');
     return this;
   }
@@ -644,8 +653,7 @@ class StringJoiningTransformer extends AbstractJoiningTransformer {
     // Adds an attribute to the most recently opened start tag. Supports
     // special objects for dataset and ordered attributes ($a). Escapes '&'
     // and '"' unless cfg.preEscapedAttributes or avoidAttEscape are set.
-    // eslint-disable-next-line unicorn/no-this-assignment -- Temporary
-    const that = this;
+
     if (!this._openTagState) {
       throw new Error(
         'An attribute cannot be added after an opening tag has been closed ' +
@@ -659,8 +667,8 @@ class StringJoiningTransformer extends AbstractJoiningTransformer {
         const valObj = /** @type {any} */ (val);
         switch (name) {
         case 'dataset': {
-          Object.keys(valObj).forEach(function (att) {
-            that.attribute(
+          Object.keys(valObj).forEach((att) => {
+            this.attribute(
               'data-' + att.replaceAll(
                 camelCase, _makeDatasetAttribute
               ),
@@ -673,8 +681,8 @@ class StringJoiningTransformer extends AbstractJoiningTransformer {
         case '$a': { // Ordered attributes
           /** @type {unknown[][]} */
           const valArr = /** @type {any} */ (val);
-          valArr.forEach(function (attArr) {
-            that.attribute(
+          valArr.forEach((attArr) => {
+            this.attribute(
               String(attArr[0]),
               /** @type {string|Record<string, unknown>} */ (attArr[1]),
               false
@@ -695,7 +703,10 @@ class StringJoiningTransformer extends AbstractJoiningTransformer {
     val = (this._cfg.preEscapedAttributes || avoidAttEscape)
       ? valStr
       : valStr.replaceAll('&', '&amp;').replaceAll('"', '&quot;');
-    this.append(' ' + name + '="' + this._replaceCharacterMaps(val) + '"');
+    this.append(
+      ' ' + this._replaceNamespaceAliasInNamespaceDeclaration(name) + '="' +
+      this._replaceCharacterMaps(val) + '"'
+    );
     return this;
   }
 

package/src/XPathTransformer.js

@@ -34,6 +34,10 @@ class XPathTransformer {
       if (Array.isArray(template)) {
         return {path: template[0], template: template[1]};
       }
+      // Normalize 'match' to 'path' for XSLT compatibility
+      if (template.match && !template.path) {
+        return {...template, path: template.match};
+      }
       return template;
     });
     this.templates.forEach((template) => {