jtlt 0.2.0 → 0.3.0

package/CHANGES.md

@@ -1,5 +1,23 @@
 # jtlt CHANGES
 
+## 0.3.0
+
+- feat: `if()`
+- feat: `choose()`
+- feat: propSets for DOM
+- feat: add `comment()` and `processingInstruction()`
+- feat: optional `path` may be omitted when `name` present (named-only templates)
+- feat: XPath `copy()` (shallow) and `copyOf(select?)` (deep cloning / scalar append)
+- feat: JSONPath cloning docs expanded (existing `copy`/`copyOf` clarified)
+- fix: avoid appending `undefined` from `callTemplate` when template returns nothing
+- fix: parameter fallback in `valueOf` for JSONPath param access
+- fix: scalar XPath `copyOf()` prevents DOM hierarchy errors when expression returns Document
+ - feat: add `exposeDocuments` option
+ - feat: callTemplate in XPath
+ - feat: add `document()` (XSLT `xsl:document`-like) and `resultDocument()` (XSLT `xsl:result-document`-like) to all joiners
+ - feat: support `output({method})` values `json` and `xhtml` across joiners
+ - change: JSON joiner `$document` wrapper includes DOCTYPE only when `method` is `xml` or `xhtml`; XML declaration emitted for `xml`/`xhtml` unless `omitXmlDeclaration`
+
 ## 0.2.0
 
 - fix: point to `types` and add `exports`

package/README.md

@@ -56,6 +56,15 @@ JTLT has two layers:
     - DOMJoiningTransformer: Builds a DocumentFragment/Element tree. element()/attribute()/text() add real nodes; primitives append as text nodes.
     - JSONJoiningTransformer: Builds real JS values (objects/arrays/primitives) without serialization.
 
+### Output formats and multi-document
+
+- Output formats supported via `output({method})`: `xml`, `html`, `text`, `xhtml`, and `json`.
+  - `xml`/`xhtml` behave like XML: XML declaration (unless omitted) and optional DOCTYPE.
+  - `html` is HTML‑centric; `text` is raw text; `json` is JSON‑centric (no XML declaration/DOCTYPE).
+- Multi-document APIs:
+  - `document(cb, cfg?)`: Create additional documents; when a joiner is configured with `{exposeDocuments: true}`, `get()` returns an array of documents.
+  - `resultDocument(href, cb, cfg?)`: Create additional documents with metadata (`href`, `format`, and `document`) accessible on `joiner._resultDocuments`.
+
 ### Common joiner methods
 
 - append(value): Central sink. Based on context, concatenates to string, pushes to array, or assigns to an object property.
@@ -109,7 +118,7 @@ const doc = parser.parseFromString(
   '<root><item>a</item><item>b</item></root>', 'text/xml'
 );
 
-const joiner = new StringJoiningTransformer('', {document: doc});
+const joiner = new StringJoiningTransformer('');
 const templates = [
   {name: 'root', path: '/', template () {
     this.applyTemplates('//item');
@@ -427,7 +436,11 @@ Advantages (strong parallels with XSLT):
 
 Differences / current limitations:
 
-- Expression language: XPath 2.0 implementation is not fully feature complete.
+- Expression language: XPath 2.0 implementation is not fully feature complete and the XPath 1.0 implementation from `jsdom` may not be either.
+- As the syntax is JavaScript, it is not feasible to recursively transform
+  JTLT syntax with itself (at least not easily) as one can do with XSLT.
+  However, one can use arbitrary JavaScript, or using such as `jsep`,
+  allow a particuluar subset of JavaScript.
 - Stylesheet composition/precedence: no `xsl:import`/`xsl:include` equivalents; only basic priority and modes.
 - Schema awareness: no type-aware processing (a major XSLT/XQuery feature).
 - Multi-output (`xsl:result-document`): not built-in; pick one output type per transform.
@@ -447,88 +460,4 @@ from XSLT):
 
 ## To-dos
 
-1.  Document and add test cases to cover current features! (Could adapt an XSLT/XQuery test suite)
-
-    1.  Implement and demo equivalent to applying and calling templates, and
-        root template
-
-    2.  Demo chaining of methods, including [equivalents](https://www.saxonica.com/papers/XTech2005/mhkpaper.html#S4.)
-        to XQuery's FLWOR expressions (see also Promises to-do), perhaps
-        even making aliases so that XQuery's friendlier terms can be used
-        instead of XSLT's.
-
-2.  Support processing of JSON documents with `$jtlt-stylesheet` to let
-    documents define their own targeted stylesheets.
-
-3.  When sufficiently documented, add as example library/tool to
-    JSONPath wiki.
-
-4.  Allow alternative to `element()`, `array()`, etc. methods by just
-    detecting those types from return values (and generic of each
-    type like `dom()` and `json()`).
-
-5.  Allow, depending on mode, containers to contain containers of other
-    types (e.g., a JS container containing DOM objects, or temporary use
-    of a string container, etc.).
-
-    1.  Support XML and add [hXML](https://github.com/brettz9/hxml) methods.
-
-    2.  Support [JHTML](https://github.com/brettz9/jhtml).
-
-    3.  Support `appendJSON()`/`appendDOM()` and
-        `appendType('json', ...)` (allowing type extensions).
-
-6.  Add `appendResult(function () {return result})`.
-
-7.  Add JSON update functions (equivalent to Xquery Update Facility for
-    XML ([overview](http://www.xmlplease.com/xquery-update))) and create
-    JSON serialization (as with XSLT expressed itself in declarative XML)
-    so one can submit and evaluate
-    through [HTTPQuery](https://github.com/brettz9/httpquery) (and also
-    supply to JSONEditor, etc.). Utilize updating by reference.
-
-8. Demo narrowing to subset of JavaScript (as with `jspe`) to make
-    JTLT truly "declarative" as far as freedom from scripting
-
-## Possible to-dos
-
-1.  Make schema-aware so that templates could target types. Most reusable
-    application may be having a type-driven view of a JSON Schema instance
-    (e.g., dates could be shown inside a calendar widget). Perhaps this
-    schema-awareness could also drive a JSON editor (as with other existing
-    projects) (even using same API as JSONEditor?) (or type-aware filtered
-    search/raw queries). This would help not only for editors which edit a
-    JSON file in full, but also for providing schema paths or other identifiers
-    so that a transformed/queried subset of a file (or joining of multiple
-    files) could point the way for edited contents to be saved back to the
-    correct JSON file and position in the JSON file.
-
-2.  Add a [non-eval PR for JSONPath](https://github.com/s3u/JSONPath/pull/4).
-    The OR condition (outside of filters) is another important feature as
-    would be schema-aware path results.
-
-3.  Allow hybrid JSON/[Jamilih](https://github.com/brettz9/jamilih) or
-    JSON/(X)HTML/XML so that one can add
-    XPath or query into HTML in a relevant manner
-
-4.  Support pull parsing/streaming? Pass `done()` function to templates to
-    signal completion?
-
-5.  Support Promise API in addition to callbacks (reconcile with
-    current chaining; see also XQuery FLWOR to-do)
-
-6.  Add [XQuery Functions](https://code.google.com/p/jsxqueryparser/source/browse/trunk/jsxqueryparser/XQueryParser.js#1768)
-    (also supporting DOM and JSON where possible) as plug-in (also any
-    missing from XSLT/XQuery 3.0). Also add, if not present among these
-    functions (or in XQuery), add equivalents to XSLT's
-    `document()` and `unparsed-text()` for allowing non-JSON file
-    retrieval (as well as variables/parameters) and also methods for
-    iterating or retrieving IndexedDB, `localStorage`, and cookies
-    (names, keys and values).
-
-7.  Add `outputType` which uses a DOM joiner but allows specialized
-    serialized output (e.g., pretty-printed HTML) so the users
-    don't need to build it themselves (likewise with stringified
-    JSON output).
-
-8.  See code for other possible to-dos
+See [TO-DO](./docs/TO.DO.md).

package/demo/calltemplate-params-demo.js

@@ -0,0 +1,138 @@
+/**
+ * Demo: Using valueOf() to access parameters in callTemplate
+ *
+ * This demonstrates the new feature where parameters passed via callTemplate
+ * can be accessed within the template using valueOf({select: '$paramName'})
+ * instead of having to receive them as function parameters.
+ */
+
+/* eslint-disable no-console, no-new -- Demo file */
+
+import JTLT from '../src/index-node.js';
+
+console.log('=== Demo 1: Named parameters ===');
+new JTLT({
+  data: {
+    users: [
+      {name: 'Alice', role: 'Admin'},
+      {name: 'Bob', role: 'User'}
+    ]
+  },
+  outputType: 'string',
+  templates: [
+    {
+      path: '$',
+      template () {
+        this.forEach('$.users[*]', function (user) {
+          this.callTemplate({
+            name: 'formatUser',
+            withParam: [
+              {name: 'userName', value: user.name},
+              {name: 'userRole', value: user.role},
+              {name: 'prefix', value: '> '}
+            ]
+          });
+        });
+      }
+    },
+    {
+      name: 'formatUser',
+      template () {
+        // Access parameters using valueOf with $paramName
+        this.valueOf({select: '$prefix'});
+        this.valueOf({select: '$userName'});
+        this.string(' (');
+        this.valueOf({select: '$userRole'});
+        this.string(')\n');
+      }
+    }
+  ],
+  success (result) {
+    console.log(result);
+    console.log('\n');
+  }
+});
+
+console.log('=== Demo 2: Indexed parameters (no names) ===');
+new JTLT({
+  data: {value: 'Test'},
+  outputType: 'string',
+  templates: [
+    {
+      path: '$',
+      template () {
+        this.callTemplate({
+          name: 'format',
+          withParam: [
+            {value: 'First param'},
+            {value: 'Second param'},
+            {select: '$.value'}
+          ]
+        });
+      }
+    },
+    {
+      name: 'format',
+      template () {
+        // Access by index when name not provided
+        this.string('Param 0: ');
+        this.valueOf({select: '$0'});
+        this.string('\nParam 1: ');
+        this.valueOf({select: '$1'});
+        this.string('\nParam 2: ');
+        this.valueOf({select: '$2'});
+        this.string('\n');
+      }
+    }
+  ],
+  success (result) {
+    console.log(result);
+    console.log('\n');
+  }
+});
+
+console.log('=== Demo 3: Nested callTemplate ===');
+new JTLT({
+  data: {company: 'ACME Corp'},
+  outputType: 'string',
+  templates: [
+    {
+      path: '$',
+      template () {
+        this.callTemplate({
+          name: 'outer',
+          withParam: [
+            {name: 'company', select: '$.company'}
+          ]
+        });
+      }
+    },
+    {
+      name: 'outer',
+      template () {
+        this.string('Company: ');
+        this.valueOf({select: '$company'});
+        this.string('\n');
+
+        // Call another template from within
+        /** @type {any} */ (this).callTemplate({
+          name: 'inner',
+          withParam: [
+            {name: 'message', value: 'Nested template call'}
+          ]
+        });
+      }
+    },
+    {
+      name: 'inner',
+      template () {
+        this.string('  Message: ');
+        this.valueOf({select: '$message'});
+        this.string('\n');
+      }
+    }
+  ],
+  success (result) {
+    console.log(result);
+  }
+});

package/demo/index.html

@@ -0,0 +1,31 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title>JTLT Demo</title>
+    <link rel="icon" href="data:image/png;base64,iVBORw0KGgo=" />
+    <link rel="stylesheet" href="../node_modules/mocha/mocha.css" />
+    <script type="importmap">
+      {
+        "imports": {
+          "mocha": "../node_modules/mocha/mocha.js",
+          "chai": "../node_modules/chai/index.js",
+          "simple-get-json": "../node_modules/simple-get-json/dist/index-es.js",
+          "jhtml": "../node_modules/jhtml/src/jhtml-browser.js",
+          "jamilih": "../node_modules/jamilih/dist/jml.mjs",
+          "jsonpath-plus" :"../node_modules/jsonpath-plus/dist/index-browser-esm.js",
+          "xpath2.js": "./xpath2-placeholder.js"
+        }
+      }
+    </script>
+    <script src="../node_modules/mocha/mocha.js"></script>
+    <script>
+      /* globals mocha -- Needs ESM */
+      mocha.setup('bdd');
+    </script>
+    <script type="module" src="index.js"></script>
+  </head>
+  <body>
+    <div id="mocha"></div>
+  </body>
+</html>

package/demo/index.js

@@ -0,0 +1,30 @@
+/* globals mocha, describe, it -- Should be ESM */
+import {expect} from 'chai';
+
+import {jtlt} from '../src/index-browser.js';
+
+describe('jtlt', () => {
+  it('performs a string transformation', async () => {
+    const result = await jtlt({
+      data: new DOMParser().parseFromString(
+        `<div type="questions-answers">
+          <p n="1">Some text</p>
+          <p n="2">More text</p>
+        </div>`,
+        'text/xml'
+      ),
+      engineType: 'xpath',
+      outputType: 'string',
+      templates: [{
+        path: '//*[@type="questions-answers"]/p',
+        template (p) {
+          this.valueOf('@n');
+          this.valueOf('./text()');
+        }
+      }]
+    });
+    expect(result).to.equal('1Some text2More text');
+  });
+});
+
+mocha.run();

package/demo/xpath2-placeholder.js

@@ -0,0 +1 @@
+export default {};

package/dist/AbstractJoiningTransformer.d.ts

@@ -1,4 +1,76 @@
 export default AbstractJoiningTransformer;
+export type BaseTransformerConfig = {
+    requireSameChildren?: boolean;
+    JHTMLForJSON?: boolean;
+    mode?: "JSON" | "JavaScript";
+};
+/**
+ * When exposeDocuments is true, get() returns an array of XMLDocument
+ * objects (one per root element) instead of a DocumentFragment.
+ */
+export type DOMJoiningTransformerConfig = BaseTransformerConfig & {
+    document: Document;
+    exposeDocuments?: boolean;
+};
+export type JSONJoiningTransformerConfig = {
+    requireSameChildren?: boolean | undefined;
+    unwrapSingleResult?: boolean | undefined;
+    /**
+     * - When true, get() returns an array
+     * of document wrapper objects (one per root element) instead of the raw array.
+     */
+    exposeDocuments?: boolean | undefined;
+    mode?: "JSON" | "JavaScript" | undefined;
+};
+/**
+ * When exposeDocuments is true, get() returns an array of document
+ * strings (one per root element) instead of a single concatenated string.
+ */
+export type StringJoiningTransformerConfig = BaseTransformerConfig & {
+    xmlElements?: boolean;
+    preEscapedAttributes?: boolean;
+    exposeDocuments?: boolean;
+};
+export type JoiningTransformerConfig<T> = T extends "string" ? StringJoiningTransformerConfig : T extends "dom" ? DOMJoiningTransformerConfig : T extends "json" ? JSONJoiningTransformerConfig : never;
+/**
+ * @typedef {{
+ *   requireSameChildren?: boolean,
+ *   JHTMLForJSON?: boolean,
+ *   mode?: "JSON"|"JavaScript"
+ * }} BaseTransformerConfig
+ */
+/**
+ * @typedef {BaseTransformerConfig & {
+ *   document: Document,
+ *   exposeDocuments?: boolean
+ * }} DOMJoiningTransformerConfig
+ * When exposeDocuments is true, get() returns an array of XMLDocument
+ * objects (one per root element) instead of a DocumentFragment.
+ */
+/**
+ * @typedef {object} JSONJoiningTransformerConfig
+ * @property {boolean} [requireSameChildren]
+ * @property {boolean} [unwrapSingleResult]
+ * @property {boolean} [exposeDocuments] - When true, get() returns an array
+ * of document wrapper objects (one per root element) instead of the raw array.
+ * @property {"JSON"|"JavaScript"} [mode]
+ */
+/**
+ * @typedef {BaseTransformerConfig & {
+ *   xmlElements?: boolean,
+ *   preEscapedAttributes?: boolean,
+ *   exposeDocuments?: boolean
+ * }} StringJoiningTransformerConfig
+ * When exposeDocuments is true, get() returns an array of document
+ * strings (one per root element) instead of a single concatenated string.
+ */
+/**
+ * @template T
+ * @typedef {T extends "string" ? StringJoiningTransformerConfig :
+ *   T extends "dom" ? DOMJoiningTransformerConfig :
+ *   T extends "json" ? JSONJoiningTransformerConfig : never
+ * } JoiningTransformerConfig
+ */
 /**
  * Base class for joining transformers.
  *
@@ -13,18 +85,19 @@ export default AbstractJoiningTransformer;
  *   based on the current state.
  * - get(): returns the accumulated result.
  * - config(): temporarily tweak a config flag for the duration of a callback.
+ * @template T
  */
-declare class AbstractJoiningTransformer {
+declare class AbstractJoiningTransformer<T> {
     /**
-     * @param {object} [cfg] - Configuration object
+     * @param {JoiningTransformerConfig<T>} [cfg] - Configuration object
      */
-    constructor(cfg?: object);
+    constructor(cfg?: JoiningTransformerConfig<T>);
+    _cfg: JoiningTransformerConfig<T>;
     /**
-     * @param {any} [cfg] - Configuration object
+     * @param {JoiningTransformerConfig<T>} cfg - Configuration object
      * @returns {void}
      */
-    setConfig(cfg?: any): void;
-    _cfg: any;
+    setConfig(cfg: JoiningTransformerConfig<T>): void;
     /**
      * @param {string} type - Type name
      * @param {string} embedType - Embed type name
@@ -33,10 +106,11 @@ declare class AbstractJoiningTransformer {
     _requireSameChildren(type: string, embedType: string): void;
     /**
      * @param {string} prop - Configuration property name
-     * @param {*} val - Configuration property value
-     * @param {Function} [cb] - Callback function
+     * @param {any} val - Configuration property value
+     * @param {(this: AbstractJoiningTransformer<T>) => void} [cb]
+     *   Optional callback invoked with this instance
      * @returns {void}
      */
-    config(prop: string, val: any, cb?: Function): void;
+    config(prop: string, val: any, cb?: (this: AbstractJoiningTransformer<T>) => void): void;
 }
 //# sourceMappingURL=AbstractJoiningTransformer.d.ts.map

package/dist/AbstractJoiningTransformer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AbstractJoiningTransformer.d.ts","sourceRoot":"","sources":["../src/AbstractJoiningTransformer.js"],"names":[],"mappings":";AAIA;;;;;;;;;;;;;;GAcG;AACH;IACE;;OAEG;IACH,kBAFW,MAAM,EAKhB;IAED;;;OAGG;IACH,gBAHW,GAAG,GACD,IAAI,CAIhB;IADC,UAAe;IAGjB;;;;OAIG;IACH,2BAJW,MAAM,aACN,MAAM,GACJ,IAAI,CAUhB;IAED;;;;;OAKG;IACH,aALW,MAAM,OACN,GAAC,kBAEC,IAAI,CAchB;CACF"}
+{"version":3,"file":"AbstractJoiningTransformer.d.ts","sourceRoot":"","sources":["../src/AbstractJoiningTransformer.js"],"names":[],"mappings":";oCAKa;IACR,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,IAAI,CAAC,EAAE,MAAM,GAAC,YAAY,CAAA;CAC3B;;;;;0CAIS,qBAAqB,GAAG;IAChC,QAAQ,EAAE,QAAQ,CAAC;IACnB,eAAe,CAAC,EAAE,OAAO,CAAA;CAC1B;;;;;;;;;;;;;;;6CAaS,qBAAqB,GAAG;IAChC,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,eAAe,CAAC,EAAE,OAAO,CAAA;CAC1B;qCAKS,CAAC,IACD,CAAC,SAAS,QAAQ,GAAG,8BAA8B,GAC3D,CAAC,SAAS,KAAK,GAAG,2BAA2B,GAC7C,CAAC,SAAS,MAAM,GAAG,4BAA4B,GAAG,KAAK;AArC5D;;;;;;GAMG;AAEH;;;;;;;GAOG;AACH;;;;;;;GAOG;AACH;;;;;;;;GAQG;AACH;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,yCAFa,CAAC;IAGZ;;OAEG;IACH,kBAFW,wBAAwB,CAAC,CAAC,CAAC,EAKrC;IADC,kCAAkE;IAGpE;;;OAGG;IACH,eAHW,wBAAwB,CAAC,CAAC,CAAC,GACzB,IAAI,CAIhB;IAED;;;;OAIG;IACH,2BAJW,MAAM,aACN,MAAM,GACJ,IAAI,CAUhB;IAED;;;;;;OAMG;IACH,aANW,MAAM,OACN,GAAG,OACH,CAAC,IAAI,EAAE,0BAA0B,CAAC,CAAC,CAAC,KAAK,IAAI,GAE3C,IAAI,CAUhB;CACF"}

package/dist/DOMJoiningTransformer.d.ts

@@ -1,4 +1,10 @@
 export default DOMJoiningTransformer;
+export type SimpleCallback = (this: DOMJoiningTransformer) => void;
+/**
+ * @callback SimpleCallback
+ * @this {DOMJoiningTransformer}
+ * @returns {void}
+ */
 /**
  * Joining transformer that accumulates into a DOM tree.
  *
@@ -6,17 +12,24 @@ export default DOMJoiningTransformer;
  * It expects templates to build DOM nodes explicitly (e.g., via element(),
  * attribute(), and text()), though string/number/boolean will append text
  * nodes for convenience.
+ * @extends {AbstractJoiningTransformer<"dom">}
  */
-declare class DOMJoiningTransformer extends AbstractJoiningTransformer {
+declare class DOMJoiningTransformer extends AbstractJoiningTransformer<"dom"> {
     /**
      * @param {DocumentFragment|Element} o - Initial DOM node
-     * @param {object} cfg - Configuration object
-     * @param {object} [cfg.document] - Document object
-     */
-    constructor(o: DocumentFragment | Element, cfg: {
-        document?: object | undefined;
-    });
-    _dom: DocumentFragment | Element;
+     * @param {import('./AbstractJoiningTransformer.js').
+     *   DOMJoiningTransformerConfig} cfg - Configuration object
+     */
+    constructor(o: DocumentFragment | Element, cfg: import("./AbstractJoiningTransformer.js").DOMJoiningTransformerConfig);
+    _dom: Element | DocumentFragment;
+    /** @type {XMLDocument[]} */
+    _docs: XMLDocument[];
+    /** @type {Array<{href: string, document: XMLDocument, format?: string}>} */
+    _resultDocuments: Array<{
+        href: string;
+        document: XMLDocument;
+        format?: string;
+    }>;
     /**
      * @param {Node} item
      * @returns {void}
@@ -28,35 +41,36 @@ declare class DOMJoiningTransformer extends AbstractJoiningTransformer {
      */
     append(item: string | Node): void;
     /**
-     * @returns {DocumentFragment|Element}
+     * @returns {DocumentFragment|Element|XMLDocument[]}
      */
-    get(): DocumentFragment | Element;
+    get(): DocumentFragment | Element | XMLDocument[];
     /**
      * @param {string} prop - Property name
-     * @param {*} val - Property value
+     * @param {any} val - Property value
      * @returns {void}
      */
     propValue(prop: string, val: any): void;
     /**
-     * @param {object} obj - Object to serialize
-     * @param {Function} [cb] - Callback function.
+     * @param {Record<string, unknown>} obj - Object to serialize
+     * @param {(this: DOMJoiningTransformer) => void} [cb] - Callback function.
      * @param {any[]} [usePropertySets] - Property sets to use
-     * @param {object} [propSets] - Additional property sets
+     * @param {Record<string, unknown>} [propSets] - Additional property sets
      * @returns {DOMJoiningTransformer}
      */
-    object(obj: object, cb?: Function, usePropertySets?: any[], propSets?: object): DOMJoiningTransformer;
+    object(obj: Record<string, unknown>, cb?: (this: DOMJoiningTransformer) => void, usePropertySets?: any[], propSets?: Record<string, unknown>): DOMJoiningTransformer;
     /**
      * @param {any[]|Element} arr
-     * @param {Function} [cb] - Callback function
+     * @param {(this: DOMJoiningTransformer) => void} [cb] - Callback function
      * @returns {DOMJoiningTransformer}
      */
-    array(arr: any[] | Element, cb?: Function): DOMJoiningTransformer;
+    array(arr: any[] | Element, cb?: (this: DOMJoiningTransformer) => void): DOMJoiningTransformer;
     /**
      * @param {string} str - String value
-     * @param {Function} cb - Callback function (unused)
+     * @param {(this: DOMJoiningTransformer) => void} [cb] - Callback
+     *   function (unused)
      * @returns {DOMJoiningTransformer}
      */
-    string(str: string, cb: Function): DOMJoiningTransformer;
+    string(str: string, cb?: (this: DOMJoiningTransformer) => void): DOMJoiningTransformer;
     /**
      * @param {number} num - Number value
      * @returns {DOMJoiningTransformer}
@@ -81,17 +95,25 @@ declare class DOMJoiningTransformer extends AbstractJoiningTransformer {
      */
     nonfiniteNumber(num: number): DOMJoiningTransformer;
     /**
-     * @param {Function} func - Function to stringify
+     * @param {(...args: any[]) => any} func - Function to stringify
+     * @returns {DOMJoiningTransformer}
+     */
+    function(func: (...args: any[]) => any): DOMJoiningTransformer;
+    /**
+     * @param {import('./StringJoiningTransformer.js').OutputConfig} cfg
      * @returns {DOMJoiningTransformer}
      */
-    function(func: Function): DOMJoiningTransformer;
+    output(cfg: import("./StringJoiningTransformer.js").OutputConfig): DOMJoiningTransformer;
+    _outputConfig: any;
+    mediaType: string | undefined;
     /**
-     * @param {string} elName - Element name
-     * @param {object} [atts] - Attributes object
-     * @param {Function} [cb] - Callback function
+     * @param {Element|string} elName - Element name
+     * @param {Record<string, string>} [atts] - Attributes object
+     * @param {(this: DOMJoiningTransformer) => void} [cb] - Callback function
      * @returns {DOMJoiningTransformer}
      */
-    element(elName: string, atts?: object, cb?: Function): DOMJoiningTransformer;
+    element(elName: Element | string, atts?: Record<string, string>, cb?: (this: DOMJoiningTransformer) => void): DOMJoiningTransformer;
+    root: any;
     /**
      * @param {string} name
      * @param {string} val
@@ -103,11 +125,49 @@ declare class DOMJoiningTransformer extends AbstractJoiningTransformer {
      * @returns {DOMJoiningTransformer}
      */
     text(txt: string): DOMJoiningTransformer;
+    /**
+     * @param {string} text
+     * @returns {DOMJoiningTransformer}}
+     */
+    comment(text: string): DOMJoiningTransformer;
+    /**
+     * @param {string} target
+     * @param {string} data
+     * @returns {DOMJoiningTransformer}}
+     */
+    processingInstruction(target: string, data: string): DOMJoiningTransformer;
     /**
      * @param {string} str
      * @returns {DOMJoiningTransformer}
      */
     plainText(str: string): DOMJoiningTransformer;
+    /**
+     * Creates a new XML document and executes a callback in its context.
+     * Similar to XSLT's xsl:document, this allows templates to generate
+     * multiple output documents. The created document is pushed to this._docs
+     * and will be included in the result when exposeDocuments is true.
+     *
+     * @param {(this: DOMJoiningTransformer) => void} cb
+     *   Callback that builds the document content
+     * @param {import('./StringJoiningTransformer.js').OutputConfig} [cfg]
+     *   Output configuration for the document (encoding, doctype, etc.)
+     * @returns {DOMJoiningTransformer}
+     */
+    document(cb: (this: DOMJoiningTransformer) => void, cfg?: import("./StringJoiningTransformer.js").OutputConfig): DOMJoiningTransformer;
+    /**
+     * Creates a new result document with metadata (href, format).
+     * Similar to XSLT's xsl:result-document, this allows templates to generate
+     * multiple output documents with associated metadata like URIs. The created
+     * document is stored in this._resultDocuments with the provided href.
+     *
+     * @param {string} href - URI/path for the result document
+     * @param {(this: DOMJoiningTransformer) => void} cb
+     *   Callback that builds the document content
+     * @param {import('./StringJoiningTransformer.js').OutputConfig} [cfg]
+     *   Output configuration for the document (encoding, doctype, format, etc.)
+     * @returns {DOMJoiningTransformer}
+     */
+    resultDocument(href: string, cb: (this: DOMJoiningTransformer) => void, cfg?: import("./StringJoiningTransformer.js").OutputConfig): DOMJoiningTransformer;
 }
 import AbstractJoiningTransformer from './AbstractJoiningTransformer.js';
 //# sourceMappingURL=DOMJoiningTransformer.d.ts.map

package/dist/DOMJoiningTransformer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DOMJoiningTransformer.d.ts","sourceRoot":"","sources":["../src/DOMJoiningTransformer.js"],"names":[],"mappings":";AAGA;;;;;;;GAOG;AACH;IACE;;;;OAIG;IACH,eAJW,gBAAgB,GAAC,OAAO,OAEhC;QAAqB,QAAQ;KAC/B,EAKA;IAFC,iCAC0D;IAG5D;;;OAGG;IACH,gBAHW,IAAI,GACF,IAAI,CAIhB;IAED;;;OAGG;IACH,aAHW,MAAM,GAAC,IAAI,GACT,IAAI,CAIhB;IAED;;OAEG;IACH,OAFa,gBAAgB,GAAC,OAAO,CAIpC;IAED;;;;OAIG;IAEH,gBALW,MAAM,OACN,GAAC,GACC,IAAI,CAKhB;IAED;;;;;;OAMG;IACH,YANW,MAAM,mCAEN,GAAG,EAAE,aACL,MAAM,GACJ,qBAAqB,CAWjC;IAED;;;;OAIG;IACH,WAJW,GAAG,EAAE,GAAC,OAAO,kBAEX,qBAAqB,CAWjC;IAED;;;;OAIG;IACH,YAJW,MAAM,iBAEJ,qBAAqB,CAMjC;IAED;;;OAGG;IACH,YAHW,MAAM,GACJ,qBAAqB,CAKjC;IAED;;;OAGG;IACH,cAHW,OAAO,GACL,qBAAqB,CAKjC;IAED;;OAEG;IACH,QAFa,qBAAqB,CAKjC;IAED;;OAEG;IACH,aAFa,qBAAqB,CAUjC;IAED;;;OAGG;IACH,qBAHW,MAAM,GACJ,qBAAqB,CAUjC;IAED;;;OAGG;IACH,0BAFa,qBAAqB,CAUjC;IAED;;;;;OAKG;IACH,gBALW,MAAM,SACN,MAAM,kBAEJ,qBAAqB,CA6BjC;IAED;;;;OAIG;IACH,gBAJW,MAAM,OACN,MAAM,GACJ,qBAAqB,CASjC;IAED;;;OAGG;IACH,UAHW,MAAM,GACJ,qBAAqB,CAKjC;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,qBAAqB,CAKjC;CACF;uCAzOsC,iCAAiC"}
+{"version":3,"file":"DOMJoiningTransformer.d.ts","sourceRoot":"","sources":["../src/DOMJoiningTransformer.js"],"names":[],"mappings":";8DAMa,IAAI;AAHjB;;;;GAIG;AAEH;;;;;;;;GAQG;AACH;IACE;;;;OAIG;IACH,eAJW,gBAAgB,GAAC,OAAO,OACxB,OAAO,iCAAiC,EAC9C,2BAA2B,EAS/B;IALC,iCAAsD;IACtD,4BAA4B;IAC5B,OADW,WAAW,EAAE,CACT;IACf,4EAA4E;IAC5E,kBADW,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,WAAW,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAC,CAAC,CAC9C;IAG5B;;;OAGG;IACH,gBAHW,IAAI,GACF,IAAI,CAIhB;IAED;;;OAGG;IACH,aAHW,MAAM,GAAC,IAAI,GACT,IAAI,CAIhB;IAED;;OAEG;IACH,OAFa,gBAAgB,GAAC,OAAO,GAAC,WAAW,EAAE,CAOlD;IAED;;;;OAIG;IACH,gBAJW,MAAM,OACN,GAAG,GACD,IAAI,CAKhB;IAED;;;;;;OAMG;IACH,YANW,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,OACvB,CAAC,IAAI,EAAE,qBAAqB,KAAK,IAAI,oBACrC,GAAG,EAAE,aACL,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACrB,qBAAqB,CAYjC;IAED;;;;OAIG;IACH,WAJW,GAAG,EAAE,GAAC,OAAO,OACb,CAAC,IAAI,EAAE,qBAAqB,KAAK,IAAI,GACnC,qBAAqB,CAWjC;IAED;;;;;OAKG;IACH,YALW,MAAM,OACN,CAAC,IAAI,EAAE,qBAAqB,KAAK,IAAI,GAEnC,qBAAqB,CAMjC;IAED;;;OAGG;IACH,YAHW,MAAM,GACJ,qBAAqB,CAKjC;IAED;;;OAGG;IACH,cAHW,OAAO,GACL,qBAAqB,CAKjC;IAED;;OAEG;IACH,QAFa,qBAAqB,CAKjC;IAED;;OAEG;IACH,aAFa,qBAAqB,CAUjC;IAED;;;OAGG;IACH,qBAHW,MAAM,GACJ,qBAAqB,CAUjC;IAED;;;OAGG;IACH,eAHW,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,GACrB,qBAAqB,CAUjC;IAED;;;OAGG;IACH,YAHW,OAAO,+BAA+B,EAAE,YAAY,GAClD,qBAAqB,CAUjC;IALC,mBAAwB;IAGxB,8BAA8B;IAIhC;;;;;OAKG;IACH,gBALW,OAAO,GAAC,MAAM,SACd,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,OACtB,CAAC,IAAI,EAAE,qBAAqB,KAAK,IAAI,GACnC,qBAAqB,CAqHjC;IA3GG,UAAkB;IA6GtB;;;;OAIG;IACH,gBAJW,MAAM,OACN,MAAM,GACJ,qBAAqB,CASjC;IAED;;;OAGG;IACH,UAHW,MAAM,GACJ,qBAAqB,CAKjC;IAED;;;OAGG;IACH,cAHW,MAAM,GACJ,qBAAqB,CAWjC;IAED;;;;OAIG;IACH,8BAJW,MAAM,QACN,MAAM,GACJ,qBAAqB,CAcjC;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,qBAAqB,CAKjC;IAED;;;;;;;;;;;OAWG;IACH,aANW,CAAC,IAAI,EAAE,qBAAqB,KAAK,IAAI,QAErC,OAAO,+BAA+B,EAAE,YAAY,GAElD,qBAAqB,CA4BjC;IAED;;;;;;;;;;;;OAYG;IACH,qBAPW,MAAM,MACN,CAAC,IAAI,EAAE,qBAAqB,KAAK,IAAI,QAErC,OAAO,+BAA+B,EAAE,YAAY,GAElD,qBAAqB,CA2CjC;CACF;uCAhesC,iCAAiC"}