jtlt 0.5.0 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jtlt",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "type": "module",
   "author": "Brett Zamir",
   "contributors": [],

package/src/AbstractJoiningTransformer.js

@@ -72,6 +72,8 @@ class AbstractJoiningTransformer {
     this._cfg = cfg ?? /** @type {JoiningTransformerConfig<T>} */ ({});
     /** @type {Record<string, OutputCharacters>} */
     this._characterMap = {};
+    /** @type {Record<string, Record<string, string>>} */
+    this._attributeSet = {};
   }
 
   /**
@@ -105,6 +107,15 @@ class AbstractJoiningTransformer {
     this._characterMap[name] = outputCharacters;
   }
 
+  /**
+   * @param {string} name
+   * @param {Record<string, string>} attributes
+   * @returns {void}
+   */
+  attributeSet (name, attributes) {
+    this._attributeSet[name] = attributes;
+  }
+
   /**
    * @param {string} str
    * @returns {string}

package/src/DOMJoiningTransformer.js

@@ -29,6 +29,8 @@ class DOMJoiningTransformer extends AbstractJoiningTransformer {
     this._docs = [];
     /** @type {Array<{href: string, document: XMLDocument, format?: string}>} */
     this._resultDocuments = [];
+    /** @type {Record<string, unknown>} */
+    this.propertySets = {};
   }
 
   /**
@@ -67,6 +69,16 @@ class DOMJoiningTransformer extends AbstractJoiningTransformer {
     this._dom[prop] = val;
   }
 
+  /**
+   * Alias for propValue(). Set a key-value pair in the current map/object.
+   * @param {string} prop - Property name
+   * @param {any} val - Property value
+   * @returns {void}
+   */
+  mapEntry (prop, val) {
+    return this.propValue(prop, val);
+  }
+
   /**
    * @param {Record<string, unknown>} obj - Object to serialize
    * @param {(this: DOMJoiningTransformer) => void} [cb] - Callback function.
@@ -75,9 +87,20 @@ class DOMJoiningTransformer extends AbstractJoiningTransformer {
    * @returns {DOMJoiningTransformer}
    */
   object (obj, cb, usePropertySets, propSets) {
+    // eslint-disable-next-line unicorn/no-this-assignment -- Temporary
+    const that = this;
     this._requireSameChildren('dom', 'object');
-    if (this._cfg.JHTMLForJSON) {
+
+    if (usePropertySets !== undefined) {
+      obj = usePropertySets.reduce(function (o, psName) {
+        return that._usePropertySets(o, psName);
+      }, obj);
+    }
+    if (propSets !== undefined) {
       Object.assign(obj, propSets);
+    }
+
+    if (this._cfg.JHTMLForJSON) {
       this.append(JHTML.toJHTMLDOM(/** @type {any} */ (obj)));
     } else {
       // Todo: set current position and deal with children
@@ -86,6 +109,18 @@ class DOMJoiningTransformer extends AbstractJoiningTransformer {
     return this;
   }
 
+  /**
+   * Alias for object(). Build an object/map.
+   * @param {Record<string, unknown>} obj - Object to serialize
+   * @param {(this: DOMJoiningTransformer) => void} [cb] - Callback function.
+   * @param {any[]} [usePropertySets] - Property sets to use
+   * @param {Record<string, unknown>} [propSets] - Additional property sets
+   * @returns {DOMJoiningTransformer}
+   */
+  map (obj, cb, usePropertySets, propSets) {
+    return this.object(obj, cb, usePropertySets, propSets);
+  }
+
   /**
    * @param {any[]|Element} arr
    * @param {(this: DOMJoiningTransformer) => void} [cb] - Callback function
@@ -241,9 +276,10 @@ class DOMJoiningTransformer extends AbstractJoiningTransformer {
    * @param {(Node|string)[]|((this: DOMJoiningTransformer) => void)
    *   } [childNodes] - Child nodes or callback
    * @param {(this: DOMJoiningTransformer) => void} [cb] - Callback
+   * @param {string[]} [useAttributeSets] - Attribute set names to apply
    * @returns {DOMJoiningTransformer}
    */
-  element (elName, atts, childNodes, cb) {
+  element (elName, atts, childNodes, cb, useAttributeSets) {
     // Handle argument overloading like other transformers
     if (Array.isArray(atts)) {
       cb = /** @type {(this: DOMJoiningTransformer) => void} */ (
@@ -328,6 +364,21 @@ class DOMJoiningTransformer extends AbstractJoiningTransformer {
       // Use the document's root element
       const el = doc.documentElement;
 
+      // Apply attribute sets if specified
+      if (useAttributeSets && useAttributeSets.length) {
+        useAttributeSets.forEach((setName) => {
+          if (this._attributeSet[setName]) {
+            for (const att in this._attributeSet[setName]) {
+              if (Object.hasOwn(this._attributeSet[setName], att)) {
+                el.setAttribute(att, this._replaceCharacterMaps(
+                  this._attributeSet[setName][att]
+                ));
+              }
+            }
+          }
+        });
+      }
+
       for (const att in atts) {
         if (Object.hasOwn(atts, att)) {
           el.setAttribute(att, this._replaceCharacterMaps(atts[att]));
@@ -363,6 +414,21 @@ class DOMJoiningTransformer extends AbstractJoiningTransformer {
         this._cfg.document.createElement(elName)
       );
 
+    // Apply attribute sets if specified
+    if (useAttributeSets && useAttributeSets.length) {
+      useAttributeSets.forEach((setName) => {
+        if (this._attributeSet[setName]) {
+          for (const att in this._attributeSet[setName]) {
+            if (Object.hasOwn(this._attributeSet[setName], att)) {
+              el.setAttribute(att, this._replaceCharacterMaps(
+                this._attributeSet[setName][att]
+              ));
+            }
+          }
+        }
+      });
+    }
+
     for (const att in atts) {
       if (Object.hasOwn(atts, att)) {
         el.setAttribute(att, this._replaceCharacterMaps(atts[att]));
@@ -571,6 +637,23 @@ class DOMJoiningTransformer extends AbstractJoiningTransformer {
 
     return this;
   }
+
+  /**
+   * Helper method to use property sets.
+   * @param {Record<string, unknown>} obj - Object to apply property set to
+   * @param {string} psName - Property set name
+   * @returns {Record<string, unknown>}
+   */
+  _usePropertySets (obj, psName) {
+    // Merge named property set from this.propertySets into obj
+    if (this.propertySets && this.propertySets[psName]) {
+      return {
+        ...obj,
+        ...this.propertySets[psName]
+      };
+    }
+    return obj;
+  }
 }
 
 export default DOMJoiningTransformer;

package/src/JSONJoiningTransformer.js

@@ -142,6 +142,16 @@ class JSONJoiningTransformer extends AbstractJoiningTransformer {
     (/** @type {Record<string, any>} */ (this._obj))[prop] = val;
   }
 
+  /**
+   * Alias for propValue(). Set a key-value pair in the current map/object.
+   * @param {string} prop - Property name
+   * @param {any} val - Property value
+   * @returns {void}
+   */
+  mapEntry (prop, val) {
+    return this.propValue(prop, val);
+  }
+
   /* c8 ignore next 13 -- JSDoc block incorrectly counted as coverable by c8 */
   /**
    * @param {Record<string, unknown>|ObjectCallback} [objOrCb]
@@ -207,6 +217,22 @@ class JSONJoiningTransformer extends AbstractJoiningTransformer {
     return this;
   }
 
+  /**
+   * Alias for object(). Build an object/map.
+   * @param {Record<string, unknown>|ObjectCallback} [objOrCb]
+   *   Seed object or callback.
+   * @param {ObjectCallback|any[]} [cbOrUsePropertySets] Callback or sets.
+   * @param {any[]|Record<string, unknown>} [usePropertySetsOrPropSets]
+   *   Sets or prop sets.
+   * @param {Record<string, unknown>} [propSets] Key-value pairs to add.
+   * @returns {JSONJoiningTransformer}
+   */
+  map (objOrCb, cbOrUsePropertySets, usePropertySetsOrPropSets, propSets) {
+    return this.object(
+      objOrCb, cbOrUsePropertySets, usePropertySetsOrPropSets, propSets
+    );
+  }
+
   /**
    * Creates a new array and executes a callback in its context.
    * @param {any[]|ArrayCallback} [arrOrCb] Seed array or callback.
@@ -339,9 +365,10 @@ class JSONJoiningTransformer extends AbstractJoiningTransformer {
    *   Attrs, children, or cb.
    * @param {any[]|SimpleCallback} [childNodes] Children or cb.
    * @param {SimpleCallback} [cb] Builder callback.
+   * @param {string[]} [useAttributeSets] - Attribute set names to apply
    * @returns {JSONJoiningTransformer}
    */
-  element (elName, atts, childNodes, cb) {
+  element (elName, atts, childNodes, cb, useAttributeSets) {
     this._requireSameChildren('json', 'element');
     const isRoot = !this.root;
     if (isRoot) {
@@ -379,6 +406,17 @@ class JSONJoiningTransformer extends AbstractJoiningTransformer {
     /** @type {import('jamilih').JamilihChildren} */
     const jmlChildren = [];
 
+    // Apply attribute sets if specified
+    if (useAttributeSets && useAttributeSets.length) {
+      const mergedAtts = {};
+      useAttributeSets.forEach((setName) => {
+        if (this._attributeSet[setName]) {
+          Object.assign(mergedAtts, this._attributeSet[setName]);
+        }
+      });
+      attsObj = Object.assign(mergedAtts, attsObj);
+    }
+
     // Preprocess special attribute helpers present directly on attsObj
     if (attsObj.dataset && typeof attsObj.dataset === 'object' &&
       !Array.isArray(attsObj.dataset)

package/src/JSONPathTransformerContext.js

@@ -105,6 +105,10 @@ class JSONPathTransformerContext {
     this._currPath = undefined;
     /** @type {Record<string, any> | undefined} */
     this._params = undefined;
+    /** @type {string[]} */
+    this._preserveSpaceElements = [];
+    /** @type {string[]} */
+    this._stripSpaceElements = [];
   }
 
   /**
@@ -120,6 +124,24 @@ class JSONPathTransformerContext {
     }
   }
 
+  /**
+   * Check if whitespace should be stripped for a given element name.
+   * @param {string} elementName - The element name to check
+   * @returns {boolean}
+   */
+  _shouldStripSpace (elementName) {
+    // 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;
+    });
+  }
+
   /**
    * Gets the joining transformer from config.
    * @returns {T extends "json" ? import('./JSONJoiningTransformer.js').
@@ -1654,6 +1676,40 @@ class JSONPathTransformerContext {
     return this;
   }
 
+  /**
+   * Alias for propValue(). Set a key-value pair in the current map/object.
+   * @param {string} prop - Property name
+   * @param {any} val - Property value
+   * @returns {this}
+   */
+  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 {this}
+   */
+  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.
+   * @param {string|string[]} elements - Element name(s) or patterns
+   * @returns {this}
+   */
+  stripSpace (elements) {
+    const elemArray = Array.isArray(elements) ? elements : [elements];
+    this._stripSpaceElements.push(...elemArray);
+    return this;
+  }
+
   /**
    * Build an object. Mirrors the joining transformer API. All joiners now
    * support both signatures: (obj, cb, usePropertySets, propSets) with seed
@@ -1666,6 +1722,15 @@ class JSONPathTransformerContext {
     return this;
   }
 
+  /**
+   * Alias for object(). Build an object/map.
+   * @param {...any} args - Arguments to pass to joiner
+   * @returns {this}
+   */
+  map (...args) {
+    return this.object(...args);
+  }
+
   /**
    * Build an array. Mirrors the joining transformer API. All joiners now
    * support both signatures: (arr, cb) with seed array or (cb) without.
@@ -1698,6 +1763,16 @@ class JSONPathTransformerContext {
     return this;
   }
 
+  /**
+   * @param {string} name
+   * @param {Record<string, string>} attributes
+   * @returns {this}
+   */
+  attributeSet (name, attributes) {
+    this._getJoiningTransformer().attributeSet(name, attributes);
+    return this;
+  }
+
   /**
    * Create an element. Mirrors the joining transformer API so templates can
    * call `this.element()`.
@@ -1706,11 +1781,12 @@ class JSONPathTransformerContext {
    * @param {any[]} [children] - Child nodes
    * @param {import('./JSONJoiningTransformer.js').
    *   SimpleCallback<T>} [cb] - Callback function
+   * @param {string[]} [useAttributeSets] - Attribute set names to apply
    * @returns {this}
    */
-  element (name, atts, children, cb) {
+  element (name, atts, children, cb, useAttributeSets) {
     /** @type {any} */ (this._getJoiningTransformer()).element(
-      name, atts, children, cb
+      name, atts, children, cb, useAttributeSets
     );
     return this;
   }
@@ -1937,6 +2013,26 @@ class JSONPathTransformerContext {
     }
     return this;
   }
+
+  /**
+   * Assert that a test condition is true, throwing an error if it fails.
+   * Equivalent to xsl:assert. Evaluates a JSONPath expression using the
+   * same truthiness rules as if() and choose().
+   * @param {string} test - JSONPath expression to test
+   * @param {string} [message] - Optional error message to include
+   * @returns {this}
+   * @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;
+  }
 }
 
 export default JSONPathTransformerContext;

package/src/StringJoiningTransformer.js

@@ -173,6 +173,16 @@ class StringJoiningTransformer extends AbstractJoiningTransformer {
     return this;
   }
 
+  /**
+   * Alias for propValue(). Set a key-value pair in the current map/object.
+   * @param {string} prop - Property name
+   * @param {any} val - Property value
+   * @returns {StringJoiningTransformer}
+   */
+  mapEntry (prop, val) {
+    return this.propValue(prop, val);
+  }
+
   /**
    * @param {string} prop - Property name
    * @param {(this: StringJoiningTransformer) => void} cb - Callback function
@@ -258,6 +268,18 @@ class StringJoiningTransformer extends AbstractJoiningTransformer {
     return this;
   }
 
+  /**
+   * Alias for object(). Build an object/map.
+   * @param {Record<string, unknown>|Element} obj - Object to serialize
+   * @param {(this: StringJoiningTransformer) => void} cb - Callback function
+   * @param {any[]} [usePropertySets] - Property sets to use
+   * @param {Record<string, unknown>} [propSets] - Additional property sets
+   * @returns {StringJoiningTransformer}
+   */
+  map (obj, cb, usePropertySets, propSets) {
+    return this.object(obj, cb, usePropertySets, propSets);
+  }
+
   /**
    * @param {any[]|Element} [arr] - Array to serialize
    * @param {(this: StringJoiningTransformer) => void} [cb] - Callback function
@@ -440,9 +462,10 @@ class StringJoiningTransformer extends AbstractJoiningTransformer {
    * @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) {
+  element (elName, 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) {
@@ -541,6 +564,17 @@ class StringJoiningTransformer extends AbstractJoiningTransformer {
       elName = elObj.nodeName;
     }
 
+    // Apply attribute sets if specified
+    if (useAttributeSets && useAttributeSets.length) {
+      const mergedAtts = {};
+      useAttributeSets.forEach((setName) => {
+        if (this._attributeSet[setName]) {
+          Object.assign(mergedAtts, this._attributeSet[setName]);
+        }
+      });
+      atts = Object.assign(mergedAtts, atts);
+    }
+
     this.append('<' + elName);
     /** @type {any} */
     const oldTagState = this._openTagState;