jtlt 0.2.0 → 0.3.0

package/src/index.js

@@ -1,10 +1,4 @@
 import {getJSON} from 'simple-get-json';
-// import JHTML from 'jhtml';
-// import jsonpath from 'jsonpath-plus';
-// import {jml} from 'jamilih';
-import {JSDOM} from 'jsdom';
-
-// import Stringifier from 'jhtml/SAJJ/SAJJ.Stringifier.js';
 
 import DOMJoiningTransformer from './DOMJoiningTransformer.js';
 import JSONJoiningTransformer from './JSONJoiningTransformer.js';
@@ -13,18 +7,105 @@ import XPathTransformer from './XPathTransformer.js';
 import StringJoiningTransformer from './StringJoiningTransformer.js';
 import XSLTStyleJSONPathResolver from './XSLTStyleJSONPathResolver.js';
 
+/** @type {import('jsdom').DOMWindow | typeof globalThis} */
+let _win;
+/**
+ * @param {import('jsdom').DOMWindow | typeof globalThis} win
+ */
+export const setWindow = (win) => {
+  _win = win;
+};
+
+/**
+ * Internal options extension adding private runtime state flags.
+ * Not part of the public API surface but used for narrowing casts.
+ * @typedef {JTLTOptions & {
+ *   _customJoiningTransformer?: boolean
+ * }} InternalJTLTOptions
+ */
+
+/**
+ * A template declaration whose `template` executes with `this` bound
+ * to the engine-specific context type `TCtx`.
+ * Either `path` must be provided (for pattern matching), or `name` must be
+ * provided (for named templates callable via callTemplate), or both.
+ * @template T
+ * @template U
+ * @template TCtx
+ * @typedef {object} TemplateObject
+ * @property {string} [path] - JSONPath or XPath selector for matching nodes
+ * @property {string} [name] - Optional name for calling via callTemplate
+ * @property {string} [mode] - Optional mode for template matching
+ * @property {number} [priority] - Priority for template selection
+ * @property {TemplateFunction<T, U, TCtx>} template - Template function
+ */
+
+/**
+ * A callable template function with an engine-specific `this`.
+ * @template T
+ * @template U
+ * @template TCtx
+ * @typedef {(this: TCtx,
+ *   value: ResultType<U>,
+ *   cfg?: {mode?: string}
+ * ) => ResultType<T>|void} TemplateFunction
+ */
+
+/**
+ * @template T
+ * @typedef {TemplateObject<T, "json",
+ *   import('./JSONPathTransformerContext.js').default<T>
+ * >} JSONPathTemplateObject
+ */
+/**
+ * @template T
+ * @typedef {TemplateObject<T, "dom",
+ *   import('./XPathTransformerContext.js').default
+ * >} XPathTemplateObject
+ */
+/**
+ * @template T
+ * @typedef {(XPathTemplateObject<T> | [string, TemplateFunction<T, "dom",
+ *   import('./XPathTransformerContext.js').default
+ * >])[]} XPathTemplateArray
+ */
+/**
+ * @template T
+ * @typedef {JSONPathTemplateObject<T> | [string, TemplateFunction<T, "json",
+ *   import('./JSONPathTransformerContext.js').default
+ * >]} JSONPathTemplateArray
+ */
+
+/**
+ * @typedef {(
+ *   StringJoiningTransformer|
+ *   DOMJoiningTransformer|
+ *   JSONJoiningTransformer
+ * )} JoiningTransformer
+ */
+
+/**
+ * @typedef {"json"|"string"|"dom"} joiningTypes
+ */
+
 /**
- * @typedef {object} JTLTOptions
- * @property {Function} success A callback supplied with a single
- * argument that is the result of this instance's transform() method.
- * @property {any[]} [templates] An array of template objects
- * @property {object|Function} [template] A function assumed to be a
- * root template or a single, complete template object
- * @property {Function} [query] A function assumed to be a root template
- * @property {any[]} [forQuery] An array with arguments to be supplied
- * to a single call to `forEach` (and which will serve as the root
- * template)
- * @property {any} [data] A JSON object
+ * @template T
+ * @typedef {T extends "json" ? unknown : T extends "string" ? string :
+ *   DocumentFragment|Element} ResultType
+ */
+
+/**
+ * Options common to both engines.
+ * @template T
+ * @typedef {object} BaseJTLTOptions
+ * @property {(
+ *   result: ResultType<T>
+ * ) => void} success A callback supplied
+ *   with a single argument that is the result of this instance's
+ *   transform() method. When used in TypeScript, this can be made
+ *   generic as `success<T>(result: T): void`.
+ * @property {null|boolean|number|string|object} [data] A JSON
+ *   object or DOM document (XPath)
  * @property {string} [ajaxData] URL of a JSON file to retrieve for
  * evaluation
  * @property {boolean} [errorOnEqualPriority] Whether or not to
@@ -36,30 +117,77 @@ import XSLTStyleJSONPathResolver from './XSLTStyleJSONPathResolver.js';
  * input, but reduces capabilities of JSONPath.
  * @property {boolean} [unwrapSingleResult] For JSON output, whether to
  * unwrap single-element root arrays to return just the element
+ * @property {boolean} [exposeDocuments] When true, joiners return an array
+ * of complete documents: XMLDocument[] for DOM, document wrapper objects[]
+ * for JSON, and string[] for string joiners. Each array element corresponds
+ * to a root element built during transformation.
  * @property {string} [mode] The mode in which to begin the transform.
- * @property {string} [outputType] Output type: 'string', 'dom', or 'json'
- * @property {Function} [engine] Will be based the
+ * @property {(opts: JTLTOptions &
+ *   Required<Pick<JTLTOptions, "joiningTransformer">>
+ * ) => ResultType<T>} [engine] Will be based on the
  * same config as passed to this instance. Defaults to a transforming
  * function based on JSONPath and with its own set of priorities for
  * processing templates.
- * @property {'jsonpath'|'xpath'} [engineType] Choose built-in engine.
- * Defaults to 'jsonpath'. When 'xpath', `xpathVersion` may be used.
- * @property {1|2} [xpathVersion] XPath engine version: 1 (native) or 2
- * (xpath2.js) when `engineType` is 'xpath'.
- * @property {Function} [specificityPriorityResolver]
+ * @property {(path: string) => 0 | 0.5 | -0.5} [specificityPriorityResolver]
  * Callback for getting the priority by specificity
- * @property {{get: Function, append: Function, string?: Function,
- *   object?: Function, array?: Function}} [joiningTransformer] Can
- * be a singleton or class instance. Defaults to string joining for output
- * transformation.
- * @property {object} [joiningConfig] Config to pass on to the joining
- *   transformer
- * @property {any} [parent] Parent object for context
+ * @property {JoiningTransformer} [joiningTransformer]
+ * A concrete joining transformer instance (or custom subclass) responsible
+ * for accumulating output. When omitted, one is created automatically based
+ * on `outputType`.
+ * @property {import('./AbstractJoiningTransformer.js').
+ *   JoiningTransformerConfig<T>} [joiningConfig] Config for the joining
+ *   transformer.
+ * @property {object} [parent] Parent object for context
  * @property {string} [parentProperty] Parent property name for context
  */
 
-const {window} = new JSDOM();
-const {document} = window;
+/**
+ * JSONPath engine options with context-aware template typing.
+ * @template [T = "json"]
+ * @typedef {BaseJTLTOptions<T> & {
+ *   templates?: JSONPathTemplateArray<T>[],
+ *   template?: JSONPathTemplateObject<T> | TemplateFunction<T, "json",
+ *     import('./JSONPathTransformerContext.js').default
+ *   >,
+ *   query?: TemplateFunction<T, "json",
+ *     import('./JSONPathTransformerContext.js').default
+ *   >,
+ *   forQuery?: [string, TemplateFunction<T, "json",
+ *     import('./XPathTransformerContext.js').default
+ *   >],
+ *   engineType?: 'jsonpath',
+ *   outputType?: T
+ * }} JSONPathJTLTOptions
+ */
+
+/**
+ * XPath engine options with context-aware template typing.
+ * @template T
+ * @typedef {BaseJTLTOptions<T> & {
+ *   templates?: XPathTemplateArray<T>,
+ *   template?: XPathTemplateObject<T> | TemplateFunction<T, "dom",
+ *     import('./XPathTransformerContext.js').default
+ *   >,
+ *   query?: TemplateFunction<T, "dom",
+ *     import('./XPathTransformerContext.js').default
+ *   >,
+ *   forQuery?: [string, TemplateFunction<T, "dom",
+ *     import('./JSONPathTransformerContext.js').default
+ *   >],
+ *   engineType: 'xpath',
+ *   xpathVersion?: 1|2,
+ *   outputType?: 'string'|'dom'|'json'
+ * }} XPathJTLTOptions
+ */
+
+/**
+ * @typedef {JSONPathJTLTOptions |
+ *   JSONPathJTLTOptions<"string"> |
+ *   JSONPathJTLTOptions<"dom"> |
+ *   XPathJTLTOptions<"json">|
+ *   XPathJTLTOptions<"string">|
+ *   XPathJTLTOptions<"dom">} JTLTOptions
+ */
 
 /**
  * High-level façade for running a JTLT transform.
@@ -75,6 +203,30 @@ class JTLT {
    * config.template, or config.templates, but one must be
    * present and of valid type. For the source json, one must use
    * either a valid config.ajaxData or config.data parameter.
+   * @overload
+   * @param {JSONPathJTLTOptions} config Options for JSONPath engine
+   */
+  /**
+   * @overload
+   * @param {JSONPathJTLTOptions<"string">} config Options for JSONPath engine
+   */
+  /**
+   * @overload
+   * @param {JSONPathJTLTOptions<"dom">} config Options for JSONPath engine
+   */
+  /**
+   * @overload
+   * @param {XPathJTLTOptions<"json">} config Options for XPath engine
+   */
+  /**
+   * @overload
+   * @param {XPathJTLTOptions<"string">} config Options for XPath engine
+   */
+  /**
+   * @overload
+   * @param {XPathJTLTOptions<"dom">} config Options for XPath engine
+   */
+  /**
    * @param {JTLTOptions} config Options
    * @todo Remove JSONPath dependency in query use of '$'?
    */
@@ -83,7 +235,10 @@ class JTLT {
     this.config = config || {};
 
     // Track if a custom joiner was provided
-    /** @type {any} */ (this.config)._customJoiningTransformer =
+    /**
+     * @type {InternalJTLTOptions}
+     */
+    (this.config)._customJoiningTransformer =
       Boolean(this.config.joiningTransformer);
 
     this.setDefaults(config);
@@ -94,7 +249,7 @@ class JTLT {
       getJSON(this.config.ajaxData, (function (cfg) {
         return function (json) {
           that.config.data = json;
-          that._autoStart(/** @type {any} */ (cfg).mode);
+          that._autoStart(cfg.mode);
         };
       }(config)));
       return;
@@ -102,7 +257,7 @@ class JTLT {
     if (this.config.data === undefined) {
       throw new Error('You must supply either config.ajaxData or config.data');
     }
-    this._autoStart(/** @type {any} */ (config).mode);
+    this._autoStart(config.mode);
   }
 
   /**
@@ -110,62 +265,78 @@ class JTLT {
    *   StringJoiningTransformer}
    */
   _createJoiningTransformer () {
-    let JT;
-    switch (this.config.outputType) {
-    case 'dom':
-      JT = DOMJoiningTransformer;
-      break;
-    case 'json':
-      JT = JSONJoiningTransformer;
-      break;
-    case 'string': default:
-      JT = StringJoiningTransformer;
-      break;
-    }
-
-    /** @type {any} */
-    let initial;
-
     // Derive a document to use for joiners when running XPath engine
     /** @type {Document|undefined} */
     let docForJoiner;
-    if ((/** @type {any} */ (this.config)).engineType === 'xpath') {
-      const {data} = /** @type {any} */ (this.config);
+    if (this.config.engineType === 'xpath') {
+      const {data} = this.config;
       if (data && typeof data === 'object') {
+        const dataNode = /** @type {Document|Element} */ (data);
         // Document
-        if (data.nodeType === 9) {
-          docForJoiner = data;
+        if ((/** @type {Document} */ (dataNode)).nodeType === 9) {
+          docForJoiner = /** @type {Document} */ (dataNode);
         // Element or Node with ownerDocument
-        } else if (data.ownerDocument) {
-          docForJoiner = data.ownerDocument;
+        } else if ((/** @type {Element} */ (dataNode)).ownerDocument) {
+          docForJoiner = (/** @type {Element} */ (dataNode)).ownerDocument;
         }
       }
     }
-    if (JT === StringJoiningTransformer) {
-      initial = '';
-    } else if (JT === DOMJoiningTransformer) {
-      initial = (docForJoiner || document).createDocumentFragment();
-    } else {
-      initial = [];
-    }
 
-    // Build config for joining transformer
-    const joiningConfig = this.config.joiningConfig || {
-      string: {}, json: {}, dom: {}, jamilih: {},
-      document: docForJoiner || document
-    };
+    // Build config, supporting both direct config or nested structure
+    const baseConfig = this.config.joiningConfig || {};
 
-    // Pass unwrapSingleResult to JSON joiner if configured
-    if (JT === JSONJoiningTransformer &&
-    /** @type {any} */ (this.config).unwrapSingleResult) {
-      /** @type {any} */ (joiningConfig).unwrapSingleResult = true;
+    switch (this.config.outputType) {
+    case 'dom': {
+      /**
+       * @type {import('./AbstractJoiningTransformer.js').
+       *   DOMJoiningTransformerConfig}
+       */
+      const domConfig = /** @type {typeof domConfig} */ ({
+        ...baseConfig,
+        document: docForJoiner || _win.document
+      });
+      if (this.config.exposeDocuments) {
+        domConfig.exposeDocuments = true;
+      }
+      const initial = (docForJoiner || _win.document).createDocumentFragment();
+      return new DOMJoiningTransformer(initial, domConfig);
+    }
+    case 'json': {
+      /**
+       * @type {import('./AbstractJoiningTransformer.js').
+       *   JSONJoiningTransformerConfig}
+       */
+      const jsonConfig = /** @type {typeof jsonConfig} */ ({
+        ...baseConfig
+      });
+      // Pass unwrapSingleResult to JSON joiner if configured
+      if (this.config.unwrapSingleResult) {
+        jsonConfig.unwrapSingleResult = true;
+      }
+      // Pass exposeDocuments to JSON joiner if configured
+      if (this.config.exposeDocuments) {
+        jsonConfig.exposeDocuments = true;
+      }
+      return new JSONJoiningTransformer([], jsonConfig);
+    }
+    case 'string': default: {
+      /**
+       * @type {import('./AbstractJoiningTransformer.js').
+       *   StringJoiningTransformerConfig}
+       */
+      const stringConfig = /** @type {typeof stringConfig} */ ({
+        ...baseConfig
+      });
+      if (this.config.exposeDocuments) {
+        stringConfig.exposeDocuments = true;
+      }
+      return new StringJoiningTransformer('', stringConfig);
+    }
     }
-
-    return new JT(initial, joiningConfig);
   }
 
   /**
-   * @param {string} mode
+   * @param {string|undefined} mode
    * @returns {void}
    */
   _autoStart (mode) {
@@ -177,7 +348,7 @@ class JTLT {
       return;
     }
 
-    this.transform(mode);
+    this.transform(/** @type {string} */ (mode));
   }
 
   /**
@@ -191,11 +362,25 @@ class JTLT {
     const query = cfg.forQuery
       // eslint-disable-next-line @stylistic/operator-linebreak -- TS
       ? /**
-       * @this {any}
-       * @returns {void}
-       */
+         * @this {import('./JSONPathTransformerContext.js').default |
+         *   import('./XPathTransformerContext.js').default}
+         * @returns {void}
+         */
       function () {
-        this.forEach([].slice.call(cfg.forQuery));
+        const [path, fn] =
+          /**
+           * @type {[string, TemplateFunction<
+           *   joiningTypes,
+           *   "dom"|"json",
+           *   import('./JSONPathTransformerContext.js').default |
+           *   import('./XPathTransformerContext.js').default
+           * >]}
+           */ (
+            cfg.forQuery
+          );
+        // eslint-disable-next-line @stylistic/max-len -- Long
+        // eslint-disable-next-line unicorn/no-array-method-this-argument -- Not array
+        this.forEach(path, fn);
       }
       : cfg.query || (
         typeof cfg.templates === 'function'
@@ -205,23 +390,102 @@ class JTLT {
             : null
       );
     this.config.templates = query
-      ? [
+      // eslint-disable-next-line @stylistic/max-len -- Long
+      ? /** @type {JSONPathTemplateObject<joiningTypes>[]|XPathTemplateObject<joiningTypes>[]} */ ([
         {name: 'root', path: '$', template: query}
-      ]
-      : cfg.templates || [cfg.template];
+      ])
+      // eslint-disable-next-line @stylistic/max-len -- Long
+      : /** @type {JSONPathTemplateObject<joiningTypes>[]|XPathTemplateObject<joiningTypes>[]} */ (
+        cfg.templates || [cfg.template]
+      );
     this.config.errorOnEqualPriority = cfg.errorOnEqualPriority || false;
     this.config.engine = this.config.engine ||
       /**
-       * @param {JTLTOptions} configParam
-       * @returns {any}
+       * @param {JTLTOptions &
+       *   Required<Pick<JTLTOptions, "joiningTransformer">>} configParam
+       * @returns {ResultType<joiningTypes>}
        */
       function (configParam) {
-        if ((/** @type {any} */ (configParam)).engineType === 'xpath') {
-          const xt = new XPathTransformer(/** @type {any} */ (configParam));
-          return xt.transform(/** @type {any} */ (configParam).mode);
+        if (configParam.engineType === 'xpath') {
+          let xt;
+          /* c8 ignore next -- Defensive: outputType set in setDefaults */
+          const outputType = cfg.outputType || 'json';
+          // eslint-disable-next-line sonarjs/no-all-duplicated-branches -- TS
+          if (outputType === 'string') {
+            xt = new (/** @type {typeof XPathTransformer<"string">} */ (
+              XPathTransformer
+            ))(
+              /**
+               * @type {import('./XPathTransformer.js').
+               *   XPathTransformerConfig<"string"> &
+               *   import('./XPathTransformerContext.js').
+               *   XPathTransformerContextConfig}
+               */
+              (configParam)
+            );
+          // eslint-disable-next-line sonarjs/no-duplicated-branches -- TS
+          } else if (outputType === 'json') {
+            xt = new (/** @type {typeof XPathTransformer<"json">} */ (
+              XPathTransformer
+            ))(
+              /**
+               * @type {import('./XPathTransformer.js').
+               *   XPathTransformerConfig<"json"> &
+               *   import('./XPathTransformerContext.js').
+               *   XPathTransformerContextConfig}
+               */
+              (configParam)
+            );
+          // eslint-disable-next-line sonarjs/no-duplicated-branches -- TS
+          } else {
+            xt = new (/** @type {typeof XPathTransformer<"dom">} */ (
+              XPathTransformer
+            ))(
+              /**
+               * @type {import('./XPathTransformer.js').
+               *   XPathTransformerConfig<"dom"> &
+               *   import('./XPathTransformerContext.js').
+               *   XPathTransformerContextConfig}
+               */
+              (configParam)
+            );
+          }
+          return xt.transform(configParam.mode);
+        }
+
+        // Type assertion is safe here because _createJoiningTransformer
+        // ensures the joiningTransformer type matches outputType
+        const outputType = configParam.outputType || 'json';
+
+        // Branch based on outputType to help TypeScript narrow the type
+        if (outputType === 'string') {
+          const jpt = new JSONPathTransformer(
+            /**
+             * @type {import('./JSONPathTransformerContext.js').
+             *   JSONPathTransformerContextConfig<"string">}
+             */
+            (configParam)
+          );
+          return jpt.transform(configParam.mode);
         }
-        const jpt = new JSONPathTransformer(/** @type {any} */ (configParam));
-        return jpt.transform(/** @type {any} */ (configParam).mode);
+        if (outputType === 'dom') {
+          const jpt = new JSONPathTransformer(
+            /**
+             * @type {import('./JSONPathTransformerContext.js').
+             *   JSONPathTransformerContextConfig<"dom">}
+             */
+            (configParam)
+          );
+          return jpt.transform(configParam.mode);
+        }
+        const jpt = new JSONPathTransformer(
+          /**
+           * @type {import('./JSONPathTransformerContext.js').
+           *   JSONPathTransformerContextConfig<"json">}
+           */
+          (configParam)
+        );
+        return jpt.transform(configParam.mode);
       };
     // Todo: Let's also, unlike XSLT and the following, give options for
     //   higher priority to absolute fixed paths over recursive descent
@@ -237,8 +501,8 @@ class JTLT {
   }
 
   /**
-   * @param {string} mode The mode of the transformation
-   * @returns {any} Result of transformation
+   * @param {string} [mode] The mode of the transformation
+   * @returns {void}
    * @todo Allow for a success callback in case the jsonpath code is modified
    *     to work asynchronously (as with queries to access remote JSON
    *     stores)
@@ -256,18 +520,155 @@ class JTLT {
 
     // Create a fresh joining transformer for each transform to avoid
     // accumulation, but only if a custom one wasn't provided
-    if (!(/** @type {any} */ (this.config))._customJoiningTransformer) {
+    if (!(
+      /**
+       * @type {InternalJTLTOptions}
+       */
+      (this.config)
+    )._customJoiningTransformer) {
       this.config.joiningTransformer = this._createJoiningTransformer();
     }
 
     this.config.mode = mode;
-    const ret = /** @type {Function} */ (this.config.success)(
-      (/** @type {any} */ (this.config.engine))(this.config)
+    const {engine} = this.config;
+    /* c8 ignore next 3 -- Defensive: always configured by setDefaults */
+    if (!engine) {
+      throw new Error('Engine is not configured');
+    }
+    const result = engine(
+      // eslint-disable-next-line @stylistic/max-len -- Long type
+      /** @type {JTLTOptions & Required<Pick<JTLTOptions, "joiningTransformer">>} */ (
+        this.config
+      )
+    );
+    // The engine returns ResultType<T>. We cast through never to bypass
+    // the impossible intersection type that TypeScript infers for the union.
+    const ret = this.config.success(
+      /** @type {never} */ (result)
     );
     return ret;
   }
 }
 
+/**
+ * Create and run a JTLT instance with the appropriate engine typing.
+ *
+ * Overloads help TypeScript select the correct constructor signature.
+ * @overload
+ * @param {Omit<JSONPathJTLTOptions<"json">, "success">} cfg
+ * @returns {Promise<ResultType<"json">>}
+ */
+/**
+ * @overload
+ * @param {Omit<JSONPathJTLTOptions<"string">, "success">} cfg
+ * @returns {Promise<ResultType<"string">>}
+ */
+/**
+ * @overload
+ * @param {Omit<JSONPathJTLTOptions<"dom">, "success">} cfg
+ * @returns {Promise<ResultType<"dom">>}
+ */
+/**
+ * @overload
+ * @param {Omit<XPathJTLTOptions<"json">, "success">} cfg
+ * @returns {Promise<ResultType<"json">>}
+ */
+/**
+ * @overload
+ * @param {Omit<XPathJTLTOptions<"dom">, "success">} cfg
+ * @returns {Promise<ResultType<"dom">>}
+ */
+/**
+ * @overload
+ * @param {Omit<XPathJTLTOptions<"string">, "success">} cfg
+ * @returns {Promise<ResultType<"string">>}
+ */
+/**
+ * @param {Omit<JTLTOptions, "success">} cfg Options
+ */
+export function jtlt (cfg) {
+  // eslint-disable-next-line promise/avoid-new -- Own API
+  return new Promise((resolve) => {
+    // Narrow the constructor overload based on engineType
+    if (cfg && cfg.engineType === 'xpath') {
+      const outputType = cfg.outputType || 'string';
+
+      if (outputType === 'json') {
+        // eslint-disable-next-line no-new -- API
+        new JTLT(
+          /** @type {XPathJTLTOptions<"json">} */ ({
+            ...cfg,
+            outputType: 'json',
+            success (val) {
+              resolve(val);
+            }
+          })
+        );
+      } else if (outputType === 'dom') {
+        // eslint-disable-next-line no-new -- API
+        new JTLT(
+          /** @type {XPathJTLTOptions<"dom">} */ ({
+            ...cfg,
+            outputType: 'dom',
+            success (val) {
+              resolve(val);
+            }
+          })
+        );
+      } else {
+        // eslint-disable-next-line no-new -- API
+        new JTLT(
+          /** @type {XPathJTLTOptions<"string">} */ ({
+            ...cfg,
+            outputType: 'string',
+            success (val) {
+              resolve(val);
+            }
+          })
+        );
+      }
+      return;
+    }
+
+    const outputType = cfg.outputType || 'json';
+
+    if (outputType === 'string') {
+      // eslint-disable-next-line no-new -- API
+      new JTLT(
+        /** @type {JSONPathJTLTOptions<"string">} */ ({
+          ...cfg,
+          outputType: 'string',
+          success (val) {
+            resolve(val);
+          }
+        })
+      );
+    } else if (outputType === 'dom') {
+      // eslint-disable-next-line no-new -- API
+      new JTLT(
+        /** @type {JSONPathJTLTOptions<"dom">} */ ({
+          ...cfg,
+          outputType: 'dom',
+          success (val) {
+            resolve(val);
+          }
+        })
+      );
+    } else {
+      // eslint-disable-next-line no-new -- API
+      new JTLT(
+        /** @type {JSONPathJTLTOptions<"json">} */ ({
+          ...cfg,
+          outputType: 'json',
+          success (val) {
+            resolve(val);
+          }
+        })
+      );
+    }
+  });
+}
+
 export {
   default as AbstractJoiningTransformer
 } from './AbstractJoiningTransformer.js';