jtlt 0.2.0 → 0.3.0

package/src/JSONPathTransformer.js

@@ -7,25 +7,25 @@ import JSONPathTransformerContext from './JSONPathTransformerContext.js';
  * optional `mode`), sorts by priority, and invokes the winning template.
  * If no template matches, built-in default rules emulate XSLT-like behavior
  * for objects, arrays, scalars, etc.
+ * @template T
  */
 class JSONPathTransformer {
   /**
-   * @param {object} config - Configuration object
-   * @param {boolean} [config.errorOnEqualPriority] - Whether to error on
-   *   equal priority templates
-   * @param {any[]} config.templates - Array of template objects
+   * @param {import('./JSONPathTransformerContext.js').
+   *   JSONPathTransformerContextConfig<T>} config - Configuration object
    */
   constructor (config) {
     let map = /** @type {Record<string, boolean>} */ ({});
     this._config = config;
-    /** @type {any[]} */
+    /** @type {import('./index.js').JSONPathTemplateObject<T>[]} */
     this.rootTemplates = [];
-    this.templates = config.templates;
-    this.templates = this.templates.map(function (template) {
+    this.templates = config.templates.map(function (template) {
       if (Array.isArray(template)) {
         // Todo: We could allow a third argument (at beginning or
         //    end?) to represent template name
-        return {path: template[0], template: template[1]};
+        return /** @type {import('./index.js').JSONPathTemplateObject<T>} */ (
+          {path: template[0], template: template[1]}
+        );
       }
       return template;
     });
@@ -33,7 +33,8 @@ class JSONPathTransformer {
       if (template.name && map[template.name]) {
         throw new Error('Templates must all have different names.');
       }
-      map[template.name] = true;
+      map[String(template.name)] = true;
+      // Only check for root templates if path is defined
       if (template.path === '$') {
         // eslint-disable-next-line unicorn/prefer-spread -- Refactor
         this.rootTemplates = this.rootTemplates.concat(templates.splice(i, 1));
@@ -55,12 +56,12 @@ class JSONPathTransformer {
   }
 
   /**
-   * @param {string} mode - Transformation mode
-   * @returns {*} The transformation result
+   * @param {string} [mode] - Transformation mode
+   * @returns {import('./index.js').ResultType<T>} The transformation result
    */
   transform (mode) {
     const jte = new JSONPathTransformerContext(
-      /** @type {any} */ (this._config), this.templates
+      this._config, this.templates
     );
     const len = this.rootTemplates.length;
     const templateObj = len
@@ -69,13 +70,24 @@ class JSONPathTransformer {
     if (len > 1) {
       this._triggerEqualPriorityError();
     }
-    const ret = templateObj.template.call(jte, undefined, {mode});
+    const ret = /** @type {import('./index.js').JSONPathTemplateObject<T>} */ (
+      templateObj
+    ).template.call(jte, undefined, {mode});
     if (typeof ret !== 'undefined') {
       // Will vary by jte._config.outputType
-      /** @type {any} */ (jte)._getJoiningTransformer().append(ret);
+      // After the undefined check, ret is ResultType<T>
+      const joiner = jte._getJoiningTransformer();
+      if (typeof ret === 'string' ||
+          (typeof ret === 'object' && ret !== null && 'nodeType' in ret)) {
+        joiner.append(/** @type {string|Node} */ (ret));
+      } else {
+        /** @type {import('./JSONJoiningTransformer.js').default} */ (
+          joiner
+        ).append(ret);
+      }
     }
     const result = jte.getOutput();
-    return result;
+    return /** @type {import('./index.js').ResultType<T>} */ (result);
   }
 
   /**
@@ -91,21 +103,24 @@ class JSONPathTransformer {
   }
 
   // To-do: Express as JSONPath expressions?
+
   static DefaultTemplateRules = {
     transformRoot: {
       /**
-       * @param {*} value - Value
-       * @param {{mode: string}} cfg - Configuration
+       * @template U
+       * @this {JSONPathTransformerContext<U>}
+       * @param {any} value - Value
+       * @param {{mode?: string}} cfg - Configuration
        * @returns {void}
        */
       template (value, cfg) {
-        /** @type {any} */ (this).applyTemplates(null, cfg.mode);
+        this.applyTemplates(null, cfg.mode);
       }
     },
     transformPropertyNames: {
       /**
-       * @param {*} value - Current context value
-       * @returns {*}
+       * @param {any} value - Current context value
+       * @returns {any}
        */
       template (value) {
         // Emit property names for the current object context
@@ -117,36 +132,39 @@ class JSONPathTransformer {
     },
     transformObjects: {
       /**
-       * @param {*} value - Value
-       * @param {{mode: string}} cfg - Configuration
+       * @this {JSONPathTransformerContext}
+       * @param {any} value - Value
+       * @param {{mode?: string}} cfg - Configuration
        * @returns {void}
        */
       template (value, cfg) {
-        /** @type {any} */ (this).applyTemplates(null, cfg.mode);
+        this.applyTemplates(null, cfg.mode);
       }
     },
     transformArrays: {
       /**
-       * @param {*} value - Value
-       * @param {{mode: string}} cfg - Configuration
+       * @this {JSONPathTransformerContext}
+       * @param {any} value - Value
+       * @param {{mode?: string}} cfg - Configuration
        * @returns {void}
        */
       template (value, cfg) {
-        /** @type {any} */ (this).applyTemplates(null, cfg.mode);
+        this.applyTemplates(null, cfg.mode);
       }
     },
     transformScalars: {
       /**
-       * @returns {*}
+       * @this {JSONPathTransformerContext}
+       * @returns {JSONPathTransformerContext}
        */
       template () {
-        return /** @type {any} */ (this).valueOf({select: '.'});
+        return this.valueOf({select: '.'});
       }
     },
     transformFunctions: {
       /**
-       * @param {Function} value - Function at current context
-       * @returns {*}
+       * @param {( ...args: any[]) => any} value - Function at current context
+       * @returns {any}
        */
       template (value) {
         // Call the function and return its result