jtlt 0.2.0 → 0.4.0

package/src/XPathTransformer.js

@@ -1,33 +1,43 @@
 import XPathTransformerContext from './XPathTransformerContext.js';
 
+/**
+ * @template T
+ * @typedef {object} XPathTransformerConfig
+ * @property {boolean} [errorOnEqualPriority] Throw on equal priority
+ * @property {import('./index.js').
+ *   XPathTemplateArray<T>} templates Template objects
+ * @property {number} [xpathVersion] XPath version (1|2|3.1)
+ */
+
 /**
  * Applies named XPath-driven templates to XML/HTML DOM data.
  *
  * Finds templates whose `path` XPath matches the current node (plus optional
  * `mode`), sorts by priority, and invokes the winning template.
  * Falls back to default rules when no template matches.
+ * @template T
  */
 class XPathTransformer {
   /**
-   * @param {object} config Configuration
-   * @param {boolean} [config.errorOnEqualPriority] Throw on equal priority
-   * @param {any[]} config.templates Template objects
-   * @param {number} [config.xpathVersion] XPath version (1|2)
+   * @param {XPathTransformerConfig<T> &
+   *   import('./XPathTransformerContext.js').
+   *   XPathTransformerContextConfig} config Configuration
    */
   constructor (config) {
     let map = /** @type {Record<string, boolean>} */ ({});
     this._config = config;
     /** @type {any[]} */
     this.rootTemplates = [];
-    this.templates = config.templates;
-    this.templates = this.templates.map(function (template) {
+
+    /** @type {import('./index.js').XPathTemplateObject<T>[]} */
+    this.templates = config.templates.map(function (template) {
       if (Array.isArray(template)) {
         return {path: template[0], template: template[1]};
       }
       return template;
     });
     this.templates.forEach((template) => {
-      if (template.name && map[template.name]) {
+      if ('name' in template && template.name && map[template.name]) {
         /* c8 ignore next 6 -- c8/Istanbul known limitation: arrow function
         * predicates within filter assignments to instance properties are not
         * instrumented. Functionality fully tested via direct assertions on
@@ -35,9 +45,12 @@ class XPathTransformer {
         * test suite. */
         throw new Error('Templates must all have different names.');
       }
-      map[template.name] = true;
+      if ('name' in template && template.name) {
+        map[template.name] = true;
+      }
     });
     // Collect root templates without mutating during iteration
+    // Only filter by path if path is defined
     this.rootTemplates = this.templates.filter((t) => t.path === '/');
     this.templates = this.templates.filter((t) => t.path !== '/');
     map = /** @type {any} */ (null);
@@ -56,8 +69,8 @@ class XPathTransformer {
   }
 
   /**
-   * @param {string} mode Transformation mode
-   * @returns {*} Result of transformation
+   * @param {string} [mode] Transformation mode
+   * @returns {import('./index.js').ResultType<T>} Result of transformation
    */
   transform (mode) {
     const xte = new XPathTransformerContext(
@@ -74,13 +87,15 @@ class XPathTransformer {
     if (typeof ret !== 'undefined') {
       /** @type {any} */ (xte)._getJoiningTransformer().append(ret);
     }
-    return xte.getOutput();
+    return /** @type {import('./index.js').ResultType<T>} */ (
+      xte.getOutput()
+    );
   }
 
   static DefaultTemplateRules = {
     transformRoot: {
       /**
-       * @param {*} node Node
+       * @param {any} node Node
        * @param {{mode:string}} cfg Config
        * @returns {void}
        */