jtlt 0.4.0 → 0.6.0

package/docs/TO-DO.md

@@ -84,85 +84,87 @@
 
 7. See code for other possible to-dos
 
-8. Consider implementing the following elements from <https://www.w3.org/TR/xslt-30/>
+8. Promise-based templates
+
+9. Consider implementing the following elements from <https://www.w3.org/TR/xslt-30/>
     which are not yet implemented.
 
   xsl:accept
   xsl:accumulator
   xsl:accumulator-rule
-  ~~"xsl:analyze-string",~~
   "xsl:apply-imports",
-  ~~"xsl:apply-templates",~~
-  xsl:assert
-  ~~"xsl:attribute",~~
-  "xsl:attribute-set",
   xsl:break
-  ~~"xsl:call-template",~~
   xsl:catch
-  "xsl:character-map",
-  ~~"xsl:choose",~~
-  ~~"xsl:comment",~~
   xsl:context-item
-  ~~"xsl:copy",~~
-  ~~"xsl:copy-of",~~
-  "xsl:decimal-format",
-  ~~"xsl:document",~~
-  ~~"xsl:element",~~
   xsl:evaluate
   xsl:expose
   "xsl:fallback",
-  ~~"xsl:for-each",~~
-  "xsl:for-each-group",
   xsl:fork
   "xsl:function",
   xsl:global-context-item
-  ~~"xsl:if",~~
   "xsl:import",
   "xsl:import-schema",
   "xsl:include",
   xsl:iterate
-  ~~"xsl:key",~~
-  xsl:map
-  xsl:map-entry
-  ~~"xsl:matching-substring",~~
   xsl:merge
   xsl:merge-action
   xsl:merge-key
   xsl:merge-source
-  ~~"xsl:message",~~
   xsl:mode
-  "xsl:namespace",
   "xsl:namespace-alias",
   xsl:next-iteration
   "xsl:next-match",
-  ~~"xsl:non-matching-substring",~~
-  ~~"xsl:number",~~
   xsl:on-completion
   xsl:on-empty
   xsl:on-non-empty
-  ~~"xsl:otherwise",~~
-  ~~"xsl:output",~~
-  "xsl:output-character",
   xsl:override
   xsl:package
   "xsl:param",
   "xsl:perform-sort",
   "xsl:preserve-space",
-  ~~"xsl:processing-instruction",~~
-  ~~"xsl:result-document",~~
   "xsl:sequence",
-  ~~"xsl:sort",~~
   xsl:source-document
   "xsl:strip-space",
+  xsl:try
+  xsl:use-package
+  xsl:where-populated
+
+  ~~"xsl:analyze-string",~~
+  ~~"xsl:apply-templates",~~
+  ~~xsl:assert~~
+  ~~"xsl:attribute",~~
+  ~~"xsl:attribute-set",~~
+  ~~"xsl:call-template",~~
+  ~~"xsl:character-map",~~
+  ~~"xsl:choose",~~
+  ~~"xsl:comment",~~
+  ~~"xsl:copy",~~
+  ~~"xsl:copy-of",~~
+  ~~"xsl:decimal-format",~~
+  ~~"xsl:document",~~
+  ~~"xsl:element",~~
+  ~~"xsl:for-each",~~
+  ~~"xsl:for-each-group",~~
+  ~~"xsl:if",~~
+  ~~"xsl:key",~~
+  ~~xsl:map~~
+  ~~xsl:map-entry~~
+  ~~"xsl:matching-substring",~~
+  ~~"xsl:message",~~
+  ~~"xsl:namespace",~~
+  ~~"xsl:non-matching-substring",~~
+  ~~"xsl:number",~~
+  ~~"xsl:otherwise",~~
+  ~~"xsl:output",~~
+  ~~"xsl:output-character",~~
+  ~~"xsl:processing-instruction",~~
+  ~~"xsl:result-document",~~
+  ~~"xsl:sort",~~
   ~~"xsl:stylesheet",~~
   ~~"xsl:template",~~
   ~~"xsl:text",~~
   ~~"xsl:transform",~~
-  xsl:try
-  xsl:use-package
   ~~"xsl:value-of",~~
   ~~"xsl:variable",~~
   ~~"xsl:when",~~
-  xsl:where-populated
   ~~"xsl:with-param"~~
-

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jtlt",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "type": "module",
   "author": "Brett Zamir",
   "contributors": [],
@@ -77,7 +77,11 @@
     "copy-jhtml": "cp -Rf node_modules/jhtml/src demo/vendor/jhtml",
     "copy-jamilih": "cp node_modules/jamilih/dist/jml.mjs demo/vendor/jamilih/dist/jml.mjs",
     "copy-jsonpath-plus": "cp node_modules/jsonpath-plus/dist/index-browser-esm.js demo/vendor/jsonpath-plus/dist/index-browser-esm.js",
-    "copy": "npm run copy-simple-get-json && npm run copy-jhtml && npm run copy-jamilih && npm run copy-jsonpath-plus",
+    "copy-fontoxpath": "cp node_modules/fontoxpath/dist/fontoxpath.esm.js demo/vendor/fontoxpath/dist/fontoxpath.esm.js",
+    "copy-xspattern": "cp node_modules/xspattern/dist/xspattern.esm.js demo/vendor/xspattern/dist/xspattern.esm.js",
+    "copy-prsc": "cp node_modules/prsc/dist/prsc.esm.js demo/vendor/prsc/dist/prsc.esm.js",
+    "copy-whynot": "cp node_modules/whynot/dist/whynot.esm.js demo/vendor/whynot/dist/whynot.esm.js",
+    "copy": "pnpm copy-simple-get-json && pnpm copy-jhtml && pnpm copy-jamilih && pnpm copy-jsonpath-plus && pnpm copy-fontoxpath && pnpm copy-xspattern && pnpm copy-prsc && pnpm copy-whynot",
     "lint": "eslint .",
     "mocha": "mocha",
     "test:browser": "open http://localhost:8020/test/browser/ && static -p 8020",

package/src/AbstractJoiningTransformer.js

@@ -2,6 +2,10 @@
 //    mid-transformation (e.g., building strings with
 //    string transformer but adding as text node in a DOM transformer)
 
+/**
+ * @typedef {{character: string, string: string}[]} OutputCharacters
+ */
+
 /**
  * @typedef {{
  *   requireSameChildren?: boolean,
@@ -66,6 +70,10 @@ class AbstractJoiningTransformer {
   constructor (cfg) {
     // Todo: Might set some reasonable defaults across all classes
     this._cfg = cfg ?? /** @type {JoiningTransformerConfig<T>} */ ({});
+    /** @type {Record<string, OutputCharacters>} */
+    this._characterMap = {};
+    /** @type {Record<string, Record<string, string>>} */
+    this._attributeSet = {};
   }
 
   /**
@@ -76,6 +84,51 @@ class AbstractJoiningTransformer {
     this._cfg = cfg;
   }
 
+  /**
+   * @param {import('./StringJoiningTransformer.js').OutputConfig} cfg
+   * @returns {this}
+   */
+  output (cfg) {
+    // We wait until first element is set in `element()` to add
+    //   XML declaration and DOCTYPE as latter depends on root element
+    this._outputConfig = cfg;
+
+    // Use for file extension if making downloadable?
+    this.mediaType = cfg.mediaType;
+    return this;
+  }
+
+  /**
+   * @param {string} name
+   * @param {OutputCharacters} outputCharacters
+   * @returns {void}
+   */
+  characterMap (name, outputCharacters) {
+    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}
+   */
+  _replaceCharacterMaps (str) {
+    this._outputConfig?.useCharacterMaps?.forEach((name) => {
+      this._characterMap[name].forEach(({character, string}) => {
+        str = str.replaceAll(character, string);
+      });
+    });
+    return str;
+  }
+
   /**
    * @param {string} type - Type name
    * @param {string} embedType - Embed type name

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
@@ -182,31 +217,85 @@ class DOMJoiningTransformer extends AbstractJoiningTransformer {
   }
 
   /**
-   * @param {import('./StringJoiningTransformer.js').OutputConfig} cfg
+   * @overload
+   * @param {Element|string} elName
+   * @param {Record<string, string>} atts
+   * @param {(Node|string)[]} childNodes
+   * @param {(this: DOMJoiningTransformer) => void} cb
+   * @returns {DOMJoiningTransformer}
+   */
+  /**
+   * @overload
+   * @param {Element|string} elName
+   * @param {Record<string, string>} atts
+   * @param {(Node|string)[]} childNodes
+   * @returns {DOMJoiningTransformer}
+   */
+  /**
+   * @overload
+   * @param {Element|string} elName
+   * @param {Record<string, string>} atts
+   * @param {(this: DOMJoiningTransformer) => void} cb
+   * @returns {DOMJoiningTransformer}
+   */
+  /**
+   * @overload
+   * @param {Element|string} elName
+   * @param {Record<string, string>} atts
+   * @returns {DOMJoiningTransformer}
+   */
+  /**
+   * @overload
+   * @param {Element|string} elName
+   * @param {(Node|string)[]} childNodes
+   * @param {(this: DOMJoiningTransformer) => void} cb
+   * @returns {DOMJoiningTransformer}
+   */
+  /**
+   * @overload
+   * @param {Element|string} elName
+   * @param {(Node|string)[]} childNodes
+   * @returns {DOMJoiningTransformer}
+   */
+  /**
+   * @overload
+   * @param {Element|string} elName
+   * @param {(this: DOMJoiningTransformer) => void} cb
+   * @returns {DOMJoiningTransformer}
+   */
+  /**
+   * @overload
+   * @param {Element|string} elName
    * @returns {DOMJoiningTransformer}
    */
-  output (cfg) {
-    // We wait until first element is set in `element()` to add
-    //   XML declaration and DOCTYPE as latter depends on root element
-    this._outputConfig = cfg;
-
-    // Use for file extension if making downloadable?
-    this.mediaType = cfg.mediaType;
-    return this;
-  }
-
   /**
    * @param {Element|string} elName - Element name
-   * @param {Record<string, string>} [atts] - Attributes object
-   * @param {(this: DOMJoiningTransformer) => void} [cb] - Callback function
+   * @param {Record<string, string>|(Node|string)[
+   *   ]|((this: DOMJoiningTransformer) => void)} [atts] - Attributes,
+   *   childNodes, or callback
+   * @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, cb) {
-    // Todo: allow third argument to be array following Jamilih (also let
-    //   "atts" follow Jamilih)
-    // Todo: allow for cfg to produce Jamilih DOM output or hXML
-    // Todo: allow separate XML DOM one with XML String and hXML conversions
-    //   (HTML to XHTML is inevitably safe?)
+  element (elName, atts, childNodes, cb, useAttributeSets) {
+    // Handle argument overloading like other transformers
+    if (Array.isArray(atts)) {
+      cb = /** @type {(this: DOMJoiningTransformer) => void} */ (
+        /** @type {unknown} */ (childNodes)
+      );
+      childNodes = atts;
+      atts = {};
+    } else if (typeof atts === 'function') {
+      cb = /** @type {(this: DOMJoiningTransformer) => void} */ (atts);
+      childNodes = [];
+      atts = {};
+    }
+    if (typeof childNodes === 'function') {
+      cb = /** @type {(this: DOMJoiningTransformer) => void} */ (childNodes);
+      childNodes = [];
+    }
 
     if (!this.root && this._outputConfig) {
       this.root = elName;
@@ -275,15 +364,41 @@ 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, atts[att]);
+          el.setAttribute(att, this._replaceCharacterMaps(atts[att]));
         }
       }
 
       const oldDOM = this._dom;
       this._dom = el;
 
+      // Add childNodes if provided
+      if (childNodes && childNodes.length) {
+        for (const child of childNodes) {
+          if (typeof child === 'string') {
+            el.append(this._replaceCharacterMaps(child));
+          } else {
+            el.append(child);
+          }
+        }
+      }
+
       if (cb) {
         cb.call(this);
       }
@@ -299,9 +414,24 @@ 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, atts[att]);
+        el.setAttribute(att, this._replaceCharacterMaps(atts[att]));
       }
     }
     this.append(el);
@@ -310,6 +440,17 @@ class DOMJoiningTransformer extends AbstractJoiningTransformer {
 
     this._dom = el;
 
+    // Add childNodes if provided
+    if (childNodes && childNodes.length) {
+      for (const child of childNodes) {
+        if (typeof child === 'string') {
+          el.append(this._replaceCharacterMaps(child));
+        } else {
+          el.append(child);
+        }
+      }
+    }
+
     if (cb) {
       cb.call(this);
     }
@@ -318,6 +459,21 @@ class DOMJoiningTransformer extends AbstractJoiningTransformer {
     return this;
   }
 
+  /**
+   * @param {string} prefix
+   * @param {string} namespaceURI
+   * @returns {DOMJoiningTransformer}
+   */
+  namespace (prefix, namespaceURI) {
+    /** @type {Element} */
+    (this._dom).setAttributeNS(
+      'http://www.w3.org/2000/xmlns/',
+      'xmlns:' + prefix,
+      this._replaceCharacterMaps(namespaceURI)
+    );
+    return this;
+  }
+
   /**
    * @param {string} name
    * @param {string} val
@@ -328,7 +484,9 @@ class DOMJoiningTransformer extends AbstractJoiningTransformer {
         this._dom.nodeType !== 1) {
       throw new Error('You may only set an attribute on an element');
     }
-    (/** @type {Element} */ (this._dom)).setAttribute(name, val);
+    (/** @type {Element} */ (this._dom)).setAttribute(
+      name, this._replaceCharacterMaps(val)
+    );
     return this;
   }
 
@@ -337,7 +495,7 @@ class DOMJoiningTransformer extends AbstractJoiningTransformer {
    * @returns {DOMJoiningTransformer}
    */
   text (txt) {
-    this.append(txt);
+    this.append(this._replaceCharacterMaps(txt));
     return this;
   }
 
@@ -479,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;