jtlt 0.23.0 → 0.24.1

package/src/AbstractJoiningTransformer.js

@@ -230,7 +230,7 @@ class AbstractJoiningTransformer {
         `Function "${name}" must have either 'body' or 'sequence' attribute`
       );
     }
-    /* c8 ignore stop */
+    /* c8 ignore stop -- See above */
 
     // Create function key with arity
     const arity = params.length;
@@ -280,7 +280,7 @@ class AbstractJoiningTransformer {
         `supported in this context)`
       );
     }
-    /* c8 ignore stop */
+    /* c8 ignore stop -- See above */
     return functionDef.body(...args);
   }
 
@@ -361,10 +361,7 @@ class AbstractJoiningTransformer {
     this._flushPendingNamespace(alias);
 
     if (colonIdx === -1) {
-      if (alias === '#default') {
-        return elemName;
-      }
-      return alias + ':' + elemName;
+      return alias === '#default' ? elemName : alias + ':' + elemName;
     }
 
     return (alias === '#default'
@@ -392,13 +389,14 @@ class AbstractJoiningTransformer {
    */
   _trackAttributePrefix (attrName) {
     const colonIdx = attrName.indexOf(':');
-    if (colonIdx !== -1 && !attrName.startsWith('xmlns')) {
-      const prefix = attrName.slice(0, colonIdx);
-      this._usedNamespacePrefixes.add(prefix);
-
-      // If this prefix was buffered, output it now
-      this._flushPendingNamespace(prefix);
+    if (colonIdx === -1 || attrName.startsWith('xmlns')) {
+      return;
     }
+    const prefix = attrName.slice(0, colonIdx);
+    this._usedNamespacePrefixes.add(prefix);
+
+    // If this prefix was buffered, output it now
+    this._flushPendingNamespace(prefix);
   }
 
   /**
@@ -445,10 +443,12 @@ class AbstractJoiningTransformer {
     const cfg = /** @type {Record<string, unknown>} */ (this._cfg);
     const oldCfgProp = cfg[prop];
     cfg[prop] = val;
-    if (cb) {
-      cb.call(this);
-      cfg[prop] = oldCfgProp;
+    if (!cb) {
+      return;
     }
+
+    cb.call(this);
+    cfg[prop] = oldCfgProp;
   }
 }
 

package/src/DOMJoiningTransformer.js

@@ -357,7 +357,7 @@ class DOMJoiningTransformer extends AbstractJoiningTransformer {
         omitXmlDeclaration, doctypePublic, doctypeSystem, method
       /* c8 ignore start -- outputConfig ?? attribution issue */
       } = this._outputConfig ?? {};
-      /* c8 ignore stop */
+      /* c8 ignore stop -- See above */
 
       /* c8 ignore start -- namespace/prefix detection branches */
       const dtd = this._cfg.document.implementation.createDocumentType(
@@ -379,7 +379,7 @@ class DOMJoiningTransformer extends AbstractJoiningTransformer {
         elementName,
         dtd
       );
-      /* c8 ignore stop */
+      /* c8 ignore stop -- See above */
 
       /* c8 ignore start -- third OR condition short-circuits */
       if (!omitXmlDeclaration && (
@@ -403,7 +403,7 @@ class DOMJoiningTransformer extends AbstractJoiningTransformer {
           doc.firstChild
         );
       }
-      /* c8 ignore stop */
+      /* c8 ignore stop -- See above */
 
       // Push the document to _docs
       this._docs.push(doc);
@@ -587,15 +587,17 @@ class DOMJoiningTransformer extends AbstractJoiningTransformer {
    */
   _flushPendingNamespace (prefix) {
     const pending = this._pendingNamespaceMap.get(prefix);
-    if (pending) {
-      /** @type {Element} */
-      (this._dom).setAttributeNS(
-        'http://www.w3.org/2000/xmlns/',
-        pending.prefix === '#default' ? 'xmlns' : 'xmlns:' + pending.prefix,
-        this._replaceCharacterMaps(pending.namespaceURI)
-      );
-      this._pendingNamespaceMap.delete(prefix);
+    if (!pending) {
+      return;
     }
+
+    /** @type {Element} */
+    (this._dom).setAttributeNS(
+      'http://www.w3.org/2000/xmlns/',
+      pending.prefix === '#default' ? 'xmlns' : 'xmlns:' + pending.prefix,
+      this._replaceCharacterMaps(pending.namespaceURI)
+    );
+    this._pendingNamespaceMap.delete(prefix);
   }
   /**
    * @param {string} name

package/src/JSONJoiningTransformer.js

@@ -488,10 +488,9 @@ class JSONJoiningTransformer extends AbstractJoiningTransformer {
     // If children provided as array, copy (may be primitives or nested JML)
     if (Array.isArray(childNodes) && childNodes.length) {
       jmlChildren.push(...childNodes.map((childNode) => {
-        if (typeof childNode === 'string') {
-          return this._replaceCharacterMaps(childNode);
-        }
-        return childNode;
+        return typeof childNode === 'string'
+          ? this._replaceCharacterMaps(childNode)
+          : childNode;
       }));
     }
 
@@ -537,7 +536,7 @@ class JSONJoiningTransformer extends AbstractJoiningTransformer {
             standalone
           };
         }
-        /* c8 ignore stop */
+        /* c8 ignore stop -- See above */
 
         const doc = {$document: {
           ...(xmlDeclaration ? {xmlDeclaration} : {}),
@@ -641,20 +640,22 @@ class JSONJoiningTransformer extends AbstractJoiningTransformer {
     }
 
     const pending = this._pendingNamespaceMap.get(prefix);
-    if (pending) {
-      const top = /** @type {ElementInfo} */ (this._elementStack.at(-1));
-      const {attsObj} = top;
-
-      if (!attsObj.xmlns) {
-        attsObj.xmlns = {};
-      }
+    if (!pending) {
+      return;
+    }
 
-      /** @type {Record<string, string>} */
-      (attsObj.xmlns)[pending.prefix === '#default' ? '' : pending.prefix] =
-        this._replaceCharacterMaps(pending.namespaceURI);
+    const top = /** @type {ElementInfo} */ (this._elementStack.at(-1));
+    const {attsObj} = top;
 
-      this._pendingNamespaceMap.delete(prefix);
+    if (!attsObj.xmlns) {
+      attsObj.xmlns = {};
     }
+
+    /** @type {Record<string, string>} */
+    (attsObj.xmlns)[pending.prefix === '#default' ? '' : pending.prefix] =
+      this._replaceCharacterMaps(pending.namespaceURI);
+
+    this._pendingNamespaceMap.delete(prefix);
   }
   /**
    * Adds/updates an attribute for the most recently open element built via
@@ -882,7 +883,7 @@ class JSONJoiningTransformer extends AbstractJoiningTransformer {
           standalone
         };
       }
-      /* c8 ignore stop */
+      /* c8 ignore stop -- See above */
 
       resultDoc = {$document: {
         ...(xmlDeclaration ? {xmlDeclaration} : {}),
@@ -921,10 +922,9 @@ class JSONJoiningTransformer extends AbstractJoiningTransformer {
    */
   _usePropertySets (obj, psName) {
     // Merge the named property set (if present) into the provided object
-    if (Object.hasOwn(this.propertySets, psName)) {
-      return Object.assign(obj, this.propertySets[psName]);
-    }
-    return obj;
+    return Object.hasOwn(this.propertySets, psName)
+      ? Object.assign(obj, this.propertySets[psName])
+      : obj;
   }
 }
 

package/src/JSONPathTransformer.js

@@ -34,10 +34,9 @@ class JSONPathTransformer {
        */
       template (value) {
         // Emit property names for the current object context
-        if (value && typeof value === 'object' && !Array.isArray(value)) {
-          return Object.keys(value).join('');
-        }
-        return '';
+        return value && typeof value === 'object' && !Array.isArray(value)
+          ? Object.keys(value).join('')
+          : '';
       }
     },
     transformObjects: {

package/src/JSONPathTransformerContext.js

@@ -319,10 +319,8 @@ class JSONPathTransformerContext {
     /* const results = */ this._getJoiningTransformer();
     const modeMatchedTemplates = this._templates.filter((templateObj) => {
       // Exclude named-only templates (those with name but no path)
-      if (templateObj.name && !templateObj.path) {
-        return false;
-      }
-      return ((mode && mode === templateObj.mode) ||
+      return (!templateObj.name || templateObj.path) &&
+        ((mode && mode === templateObj.mode) ||
         (!mode && !templateObj.mode));
     });
 
@@ -382,10 +380,7 @@ class JSONPathTransformerContext {
         if (Number.isNaN(an)) {
           return Number(order);
         }
-        if (Number.isNaN(bn)) {
-          return -order;
-        }
-        return (an - bn) * order;
+        return Number.isNaN(bn) ? -order : (an - bn) * order;
       }
       // text
       /* c8 ignore next 2 -- all null/undefined tested; OR short-circuit */
@@ -460,7 +455,7 @@ class JSONPathTransformerContext {
           if (!templateObj.path) {
             return false;
           }
-          /* c8 ignore stop */
+          /* c8 ignore stop -- See above */
           const queryResult = /** @type {any[]} */ (
             (/** @type {any} */ (jsonpath))({
               path: JSONPathTransformer.makeJSONPathAbsolute(
@@ -554,7 +549,7 @@ class JSONPathTransformerContext {
             : (that._config.specificityPriorityResolver && b.path
               ? that._config.specificityPriorityResolver(b.path)
               : 0);
-          /* c8 ignore stop */
+          /* c8 ignore stop -- See above */
 
           if (aPriority === bPriority) {
             that._triggerEqualPriorityError();
@@ -676,13 +671,13 @@ class JSONPathTransformerContext {
               // @ts-expect-error -- _openTagState: StringJoiningTransformer
               joiner._openTagState = false;
             }
-            /* c8 ignore stop */
+            /* c8 ignore stop -- See above */
             joiner.append(resolvedRet);
           }
           that._parent = parent;
           // Matches reached here always carry a parentProperty; the sync
           // path covers the root-node fallback.
-          /* c8 ignore next */
+          /* c8 ignore next -- See comment just above */
           that._parentProperty = (parentProperty ?? that._parentProperty);
           that._currPath = _oldPath;
           return undefined;
@@ -700,7 +695,7 @@ class JSONPathTransformerContext {
           // @ts-expect-error -- _openTagState only on StringJoiningTransformer
           joiner._openTagState = false;
         }
-        /* c8 ignore stop */
+        /* c8 ignore stop -- See above */
         joiner.append(
           /** @type {string|Node|*} */ (ret)
         );
@@ -825,9 +820,22 @@ class JSONPathTransformerContext {
    *   `void`, not `void|Promise<void>` — see the note on `SimpleCallback`
    *   in JSONJoiningTransformer.js.)
    * @param {SortSpec<V>} [sort] - Sort spec
+   * @param {string} [keyVar] - When given, binds each iteration's key —
+   *   the array index, or the object property name when `select` is an
+   *   object-wildcard path like `$.*` (jsonpath-plus's own `parentProperty`
+   *   on a `resultType: 'all'` match) — to this name for the duration of
+   *   that iteration, readable back via a bare `$name` reference (same
+   *   convention as `variable()`), same as `_params[0]`/`this.vars` are
+   *   already scoped fresh per iteration. Lets a template render
+   *   "property: value" pairs, or skip one property by name via `$if`,
+   *   while iterating an object's own properties — jsonpath-plus's match
+   *   data already carries this; `select`s naming a bound variable (the
+   *   bare-`$name` convention, below) carry the array index too, but never
+   *   a meaningful key for a non-array bound value (treated as a single,
+   *   length-1-sequence item — there's no "property name" for that case).
    * @returns {this|Promise<this>}
    */
-  forEach (select, cb, sort) {
+  forEach (select, cb, sort, keyVar) {
     // eslint-disable-next-line unicorn/no-this-assignment -- Temporary
     const that = this;
     // A bare `$name` (matching `if()`/`valueOf()`/comparisons' own
@@ -840,10 +848,13 @@ class JSONPathTransformerContext {
     const param = paramRef && paramRef.groups
       ? this._lookupParam(paramRef.groups.name)
       : {has: false, value: undefined};
-    /** @type {{value: any}[]} */
+    /** @type {{value: any, parentProperty?: string|number}[]} */
     const matches = param.has
-      ? (Array.isArray(param.value) ? param.value : [param.value]).
-        map((value) => ({value}))
+      ? (Array.isArray(param.value)
+        // An array's own index is a meaningful key (see `keyVar`, above);
+        // a non-array value wrapped as a length-1 sequence has none.
+        ? param.value.map((value, index) => ({value, parentProperty: index}))
+        : [{value: param.value}])
       : /** @type {any} */ (jsonpath)({
         path: select,
         json: this._contextObj,
@@ -894,10 +905,7 @@ class JSONPathTransformerContext {
         if (Number.isNaN(an)) {
           return Number(order);
         }
-        if (Number.isNaN(bn)) {
-          return -order;
-        }
-        return (an - bn) * order;
+        return Number.isNaN(bn) ? -order : (an - bn) * order;
       }
       /* c8 ignore next 2 -- all null/undefined tested; OR short-circuit */
       const aStr = aVal === null || aVal === undefined ? '' : String(aVal);
@@ -960,7 +968,7 @@ class JSONPathTransformerContext {
       const prevVars = that.vars;
       that._params = {0: m.value};
       that._contextObj = m.value;
-      that.vars = {};
+      that.vars = keyVar ? {[keyVar]: m.parentProperty} : {};
       // `cb`'s declared return type is plain `void` (see the parameter's
       // JSDoc) — cast here to duck-type the real value; see the note on
       // `SimpleCallback` in JSONJoiningTransformer.js.
@@ -991,7 +999,7 @@ class JSONPathTransformerContext {
             const pv = that.vars;
             that._params = {0: next.value};
             that._contextObj = next.value;
-            that.vars = {};
+            that.vars = keyVar ? {[keyVar]: next.parentProperty} : {};
             try {
               // eslint-disable-next-line no-await-in-loop -- Sequential order
               await cb.call(that, next.value);
@@ -1241,23 +1249,25 @@ class JSONPathTransformerContext {
         currentGroup.push(m.value);
         const endMatch = evalInContext(groupEndingWith, m.value);
 
-        if (endMatch) {
-          const prevContext = this._contextObj;
-          const prevParams = this._params;
-          const prevVars = this.vars;
-          this.vars = {};
-          try {
-            this._contextObj = currentGroup;
-            /** @type {any} */ (this)._currentGroup = currentGroup;
-            cb.call(this, null, currentGroup, this);
-          } finally {
-            this._contextObj = prevContext;
-            this._params = prevParams;
-            this.vars = prevVars;
-            delete /** @type {any} */ (this)._currentGroup;
-          }
-          currentGroup = [];
+        if (!endMatch) {
+          continue;
         }
+
+        const prevContext = this._contextObj;
+        const prevParams = this._params;
+        const prevVars = this.vars;
+        this.vars = {};
+        try {
+          this._contextObj = currentGroup;
+          /** @type {any} */ (this)._currentGroup = currentGroup;
+          cb.call(this, null, currentGroup, this);
+        } finally {
+          this._contextObj = prevContext;
+          this._params = prevParams;
+          this.vars = prevVars;
+          delete /** @type {any} */ (this)._currentGroup;
+        }
+        currentGroup = [];
       }
 
       // Process last group if not ended
@@ -1325,10 +1335,7 @@ class JSONPathTransformerContext {
         if (Number.isNaN(an)) {
           return order;
         }
-        if (Number.isNaN(bn)) {
-          return -order;
-        }
-        return (an - bn) * order;
+        return Number.isNaN(bn) ? -order : (an - bn) * order;
       }
       /* c8 ignore next 2 -- all null/undefined tested; OR short-circuit */
       const aStr = aVal === null || aVal === undefined ? '' : String(aVal);
@@ -1626,12 +1633,11 @@ class JSONPathTransformerContext {
      * @returns {string} - Captured group or empty string
      */
     const getRegexGroup = (groupNumber) => {
-      if (!currentCapturedGroups ||
+      return !currentCapturedGroups ||
           groupNumber < 0 ||
-          groupNumber >= currentCapturedGroups.length) {
-        return '';
-      }
-      return currentCapturedGroups[groupNumber] || '';
+          groupNumber >= currentCapturedGroups.length
+        ? ''
+        : currentCapturedGroups[groupNumber] || '';
     };
 
     // Save previous context to restore later
@@ -1734,7 +1740,7 @@ class JSONPathTransformerContext {
         // For non-functions, attempting structuredClone again would rethrow;
         // use shallow clone to retain non-serializable props like Symbols.
         clone = Array.isArray(val) ? [...val] : {...val};
-        /* c8 ignore stop */
+        /* c8 ignore stop -- See above */
       }
     } else {
       // Primitives/functions copied by value/reference semantics naturally.
@@ -1766,7 +1772,7 @@ class JSONPathTransformerContext {
       }
     } else { /* c8 ignore start -- primitive branch attribution variance */
       clone = src; // Primitive/function - nothing to shallow clone
-    } /* c8 ignore stop */
+    } /* c8 ignore stop -- See above */
     this._getJoiningTransformer().append(clone);
     return this;
   }
@@ -1825,10 +1831,9 @@ class JSONPathTransformerContext {
     if (Object.hasOwn(this.vars, name)) {
       return {has: true, value: this.vars[name]};
     }
-    if (Object.hasOwn(this._runtimeParams, name)) {
-      return {has: true, value: this._runtimeParams[name]};
-    }
-    return {has: false, value: undefined};
+    return Object.hasOwn(this._runtimeParams, name)
+      ? {has: true, value: this._runtimeParams[name]}
+      : {has: false, value: undefined};
   }
 
   /**
@@ -2762,15 +2767,9 @@ class JSONPathTransformerContext {
       }
       // Single item; apply scalar truthiness
       const single = val[0];
-      if (single && typeof single === 'object') {
-        return true;
-      }
-      return Boolean(single);
+      return single && typeof single === 'object' ? true : Boolean(single);
     }
-    if (val && typeof val === 'object') {
-      return true;
-    }
-    return Boolean(val);
+    return val && typeof val === 'object' ? true : Boolean(val);
   }
 
   /**
@@ -2821,10 +2820,9 @@ class JSONPathTransformerContext {
       return null;
     }
     const right = this._parseLiteral(m.groups.right.trim());
-    if (!right) {
-      return null;
-    }
-    return {left: m.groups.left, op: m.groups.op, right: right.value};
+    return !right
+      ? null
+      : {left: m.groups.left, op: m.groups.op, right: right.value};
   }
 
   /**
@@ -2855,10 +2853,7 @@ class JSONPathTransformerContext {
     if (str === 'null') {
       return {value: null};
     }
-    if (str === 'undefined') {
-      return {value: undefined};
-    }
-    return null;
+    return str === 'undefined' ? {value: undefined} : null;
   }
 
   /**

package/src/StringJoiningTransformer.js

@@ -562,7 +562,7 @@ class StringJoiningTransformer extends AbstractJoiningTransformer {
           standalone ? ` standalone="yes"` : ''
         }?>\n`;
       }
-      /* c8 ignore stop */
+      /* c8 ignore stop -- See above */
 
       const doctype = bareDoctype ||
         doctypePublic !== undefined || doctypeSystem !== undefined
@@ -733,13 +733,15 @@ class StringJoiningTransformer extends AbstractJoiningTransformer {
    */
   _flushPendingNamespace (prefix) {
     const pending = this._pendingNamespaceMap.get(prefix);
-    if (pending) {
-      this.append(' ' + (
-        pending.prefix === '#default' ? 'xmlns' : 'xmlns:' + pending.prefix
-      ) + '="' +
-          this._replaceCharacterMaps(pending.namespaceURI) + '"');
-      this._pendingNamespaceMap.delete(prefix);
+    if (!pending) {
+      return;
     }
+
+    this.append(' ' + (
+      pending.prefix === '#default' ? 'xmlns' : 'xmlns:' + pending.prefix
+    ) + '="' +
+        this._replaceCharacterMaps(pending.namespaceURI) + '"');
+    this._pendingNamespaceMap.delete(prefix);
   }
 
   /**

package/src/XPathTransformer.js

@@ -50,10 +50,9 @@ class XPathTransformer {
         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;
+      return template.match && !template.path
+        ? {...template, path: template.match}
+        : template;
     });
     this.templates.forEach((template) => {
       if ('name' in template && template.name &&