jtlt 0.2.0 → 0.3.0

package/dist/StringJoiningTransformer.d.ts

@@ -1,4 +1,33 @@
 export default StringJoiningTransformer;
+export type OutputConfig = {
+    encoding?: string;
+    indent?: boolean;
+    omitXmlDeclaration?: boolean;
+    doctypePublic?: string;
+    doctypeSystem?: string;
+    cdataSectionElements?: string[];
+    mediaType?: string;
+    version?: string;
+    standalone?: boolean;
+    method?: "xml" | "html" | "text" | "json" | "xhtml";
+};
+export type SimpleCallback = (this: StringJoiningTransformer) => void;
+/**
+ * Attributes object for element() allowing standard string attributes
+ * plus special helpers: dataset (object) and $a (ordered attribute array).
+ */
+export type ElementAttributes = Record<string, unknown> & {
+    dataset?: Record<string, string>;
+    $a?: Array<[string, string]>;
+};
+/**
+ * Attributes object for element() allowing standard string attributes
+ * plus special helpers: dataset (object) and $a (ordered attribute array).
+ * @typedef {Record<string, unknown> & {
+ *   dataset?: Record<string, string>,
+ *   $a?: Array<[string, string]>
+ * }} ElementAttributes
+ */
 /**
  *
  */
@@ -28,13 +57,15 @@ export default StringJoiningTransformer;
  *   name mapping rules differ, etc.).
  * - cfg.preEscapedAttributes: skip escaping attribute values.
  * - cfg.JHTMLForJSON / cfg.mode: affect how object()/array() serialize.
+ * @extends {AbstractJoiningTransformer<"string">}
  */
-declare class StringJoiningTransformer extends AbstractJoiningTransformer {
+declare class StringJoiningTransformer extends AbstractJoiningTransformer<"string"> {
     /**
      * @param {string} s - Initial string
-     * @param {object} cfg - Configuration object
+     * @param {import('./AbstractJoiningTransformer.js').
+     *   StringJoiningTransformerConfig} [cfg] - Configuration object
      */
-    constructor(s: string, cfg: object);
+    constructor(s: string, cfg?: import("./AbstractJoiningTransformer.js").StringJoiningTransformerConfig);
     _str: string;
     /** @type {any} */
     _objPropTemp: any;
@@ -50,59 +81,72 @@ declare class StringJoiningTransformer extends AbstractJoiningTransformer {
     _arr: any[];
     /** @type {string | undefined} */
     _strTemp: string | undefined;
-    /** @type {Record<string, any>} */
-    propertySets: Record<string, any>;
+    /** @type {Record<string, unknown>} */
+    propertySets: Record<string, unknown>;
+    /** @type {string[]} */
+    _docs: string[];
+    /** @type {boolean} */
+    _insideDocument: boolean;
+    /** @type {Array<{href: string, document: string, format?: string}>} */
+    _resultDocuments: Array<{
+        href: string;
+        document: string;
+        format?: string;
+    }>;
     /**
-     * @param {string|*} s - String or value to append
+     * @param {string|any} s - String or value to append
      * @returns {StringJoiningTransformer}
      */
     append(s: string | any): StringJoiningTransformer;
     /**
-     * @returns {string}
+     * @returns {string|string[]}
      */
-    get(): string;
+    get(): string | string[];
     /**
      * @param {string} prop - Property name
-     * @param {*} val - Property value
+     * @param {any} val - Property value
      * @returns {StringJoiningTransformer}
      */
     propValue(prop: string, val: any): StringJoiningTransformer;
     /**
      * @param {string} prop - Property name
-     * @param {Function} cb - Callback function
+     * @param {(this: StringJoiningTransformer) => void} cb - Callback function
      * @returns {StringJoiningTransformer}
      */
-    propOnly(prop: string, cb: Function): StringJoiningTransformer;
+    propOnly(prop: string, cb: (this: StringJoiningTransformer) => void): StringJoiningTransformer;
     /**
-     * @param {object|Element} obj - Object to serialize
-     * @param {Function} cb - Callback function
+     * @param {Record<string, unknown>|Element} obj - Object to serialize
+     * @param {(this: StringJoiningTransformer) => 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 {StringJoiningTransformer}
      */
-    object(obj: object | Element, cb: Function, usePropertySets?: any[], propSets?: object): StringJoiningTransformer;
+    object(obj: Record<string, unknown> | Element, cb: (this: StringJoiningTransformer) => void, usePropertySets?: any[], propSets?: Record<string, unknown>): StringJoiningTransformer;
     /**
      * @param {any[]|Element} [arr] - Array to serialize
-     * @param {Function} [cb] - Callback function
+     * @param {(this: StringJoiningTransformer) => void} [cb] - Callback function
      * @returns {StringJoiningTransformer}
      */
-    array(arr?: any[] | Element, cb?: Function): StringJoiningTransformer;
+    array(arr?: any[] | Element, cb?: (this: StringJoiningTransformer) => void): StringJoiningTransformer;
     /**
-     * @param {string|Element|object} str - String value or element
-     * @param {Function} [cb] - Callback function
+     * @param {string|Element|Record<string, unknown>} str
+     *   String value or element
+     * @param {(this: StringJoiningTransformer) => void} [cb] - Callback function
      * @returns {StringJoiningTransformer}
      */
-    string(str: string | Element | object, cb?: Function): StringJoiningTransformer;
+    string(str: string | Element | Record<string, unknown>, cb?: (this: StringJoiningTransformer) => void): StringJoiningTransformer;
     /**
-     * @param {number|Element|object} num - Number value or element
+     * @param {number|Element|Record<string, unknown>} num
+     *   Number value or element
      * @returns {StringJoiningTransformer}
      */
-    number(num: number | Element | object): StringJoiningTransformer;
+    number(num: number | Element | Record<string, unknown>): StringJoiningTransformer;
     /**
-     * @param {boolean|Element|object} bool - Boolean value or element
+     * @param {boolean|Element|Record<string, unknown>} bool
+     *   Boolean value or element
      * @returns {StringJoiningTransformer}
      */
-    boolean(bool: boolean | Element | object): StringJoiningTransformer;
+    boolean(bool: boolean | Element | Record<string, unknown>): StringJoiningTransformer;
     /**
      * @returns {StringJoiningTransformer}
      */
@@ -117,52 +161,99 @@ declare class StringJoiningTransformer extends AbstractJoiningTransformer {
      */
     nonfiniteNumber(num: number | Element): StringJoiningTransformer;
     /**
-     * @param {Function|Element} func - Function to stringify
+     * @param {((...args: any[]) => any)|Element} func - Function to stringify
+     * @returns {StringJoiningTransformer}
+     */
+    function(func: ((...args: any[]) => any) | Element): StringJoiningTransformer;
+    /**
+     * @param {OutputConfig} cfg
      * @returns {StringJoiningTransformer}
      */
-    function(func: Function | Element): StringJoiningTransformer;
+    output(cfg: OutputConfig): StringJoiningTransformer;
+    _outputConfig: any;
+    mediaType: string | undefined;
     /**
-     * @param {string|object} elName - Element name or element object
-     * @param {object} [atts] - Element attributes
+     * @param {string|Element} elName - Element name or element object
+     * @param {ElementAttributes} [atts] - Element attributes
      * @param {any[]} [childNodes] - Child nodes
-     * @param {Function} [cb] - Callback function
+     * @param {(this: StringJoiningTransformer) => void} [cb] - Callback function
      * @returns {StringJoiningTransformer}
      */
-    element(elName: string | object, atts?: object, childNodes?: any[], cb?: Function): StringJoiningTransformer;
+    element(elName: string | Element, atts?: ElementAttributes, childNodes?: any[], cb?: (this: StringJoiningTransformer) => void): StringJoiningTransformer;
     _openTagState: any;
+    root: any;
     /**
      * @param {string} name - Attribute name
-     * @param {string|object} val - Attribute value
+     * @param {string|Record<string, unknown>|
+     *   string[][]} val - Attribute value
      * @param {boolean} [avoidAttEscape] - Whether to avoid escaping the
      *   attribute value
      * @returns {StringJoiningTransformer}
      */
-    attribute(name: string, val: string | object, avoidAttEscape?: boolean): StringJoiningTransformer;
+    attribute(name: string, val: string | Record<string, unknown> | string[][], avoidAttEscape?: boolean): StringJoiningTransformer;
     /**
      * @param {string} txt - Text content to escape and append
      * @returns {StringJoiningTransformer}
      */
     text(txt: string): StringJoiningTransformer;
     /**
-    * Unlike text(), does not escape for HTML; unlike string(), does not perform
-    *   JSON stringification; unlike append(), does not do other checks (but still
-    *   varies in its role across transformers).
-    * @param {string} str
-    * @returns {StringJoiningTransformer}
-    */
+     * @param {string} text
+     * @returns {StringJoiningTransformer}}
+     */
+    comment(text: string): StringJoiningTransformer;
+    /**
+     * @param {string} target
+     * @param {string} data
+     * @returns {StringJoiningTransformer}}
+     */
+    processingInstruction(target: string, data: string): StringJoiningTransformer;
+    /**
+     * Unlike text(), does not escape for HTML; unlike string(), does not perform
+     *   JSON stringification; unlike append(), does not do other checks (but
+     *   still varies in its role across transformers).
+     * @param {string} str
+     * @returns {StringJoiningTransformer}
+     */
     rawAppend(str: string): StringJoiningTransformer;
     /**
      * @param {string} str - Plain text to append without escaping
      * @returns {StringJoiningTransformer}
      */
     plainText(str: string): StringJoiningTransformer;
+    /**
+     * Creates a new string 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: StringJoiningTransformer) => void} cb
+     *   Callback that builds the document content
+     * @param {OutputConfig} [cfg]
+     *   Output configuration for the document (encoding, doctype, etc.)
+     * @returns {StringJoiningTransformer}
+     */
+    document(cb: (this: StringJoiningTransformer) => void, cfg?: OutputConfig): StringJoiningTransformer;
+    /**
+     * 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: StringJoiningTransformer) => void} cb
+     *   Callback that builds the document content
+     * @param {OutputConfig} [cfg]
+     *   Output configuration for the document (encoding, doctype, format, etc.)
+     * @returns {StringJoiningTransformer}
+     */
+    resultDocument(href: string, cb: (this: StringJoiningTransformer) => void, cfg?: OutputConfig): StringJoiningTransformer;
     /**
      * Helper method to use property sets.
-     * @param {object} obj - Object to apply property set to
+     * @param {Record<string, unknown>} obj - Object to apply property set to
      * @param {string} psName - Property set name
-     * @returns {object}
+     * @returns {Record<string, unknown>}
      */
-    _usePropertySets(obj: object, psName: string): object;
+    _usePropertySets(obj: Record<string, unknown>, psName: string): Record<string, unknown>;
 }
 import AbstractJoiningTransformer from './AbstractJoiningTransformer.js';
 //# sourceMappingURL=StringJoiningTransformer.d.ts.map

package/dist/StringJoiningTransformer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StringJoiningTransformer.d.ts","sourceRoot":"","sources":["../src/StringJoiningTransformer.js"],"names":[],"mappings":";AAuBA;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IACE;;;OAGG;IACH,eAHW,MAAM,OACN,MAAM,EAsBhB;IAjBC,aAAmB;IACnB,kBAAkB;IAClB,cADW,GAAG,CACe;IAC7B,kCAAkC;IAClC,eADW,OAAO,GAAG,SAAS,CACA;IAC9B,kCAAkC;IAClC,eADW,OAAO,GAAG,SAAS,CACA;IAC9B,kCAAkC;IAClC,eADW,OAAO,GAAG,SAAS,CACA;IAC9B,kBAAkB;IAClB,MADW,GAAG,CACO;IACrB,oBAAoB;IACpB,MADW,GAAG,EAAE,CACF;IACd,iCAAiC;IACjC,UADW,MAAM,GAAG,SAAS,CACJ;IACzB,kCAAkC;IAClC,cADW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CACR;IAGxB;;;OAGG;IACH,UAHW,MAAM,GAAC,GAAC,GACN,wBAAwB,CAqBpC;IAED;;OAEG;IACH,OAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,gBAJW,MAAM,OACN,GAAC,GACC,wBAAwB,CAUpC;IAED;;;;OAIG;IACH,eAJW,MAAM,iBAEJ,wBAAwB,CAuBpC;IAED;;;;;;OAMG;IACH,YANW,MAAM,GAAC,OAAO,kCAEd,GAAG,EAAE,aACL,MAAM,GACJ,wBAAwB,CAkDpC;IAED;;;;OAIG;IACH,YAJW,GAAG,EAAE,GAAC,OAAO,kBAEX,wBAAwB,CA2CpC;IAED;;;;OAIG;IACH,YAJW,MAAM,GAAC,OAAO,GAAC,MAAM,kBAEnB,wBAAwB,CA4BpC;IAED;;;OAGG;IACH,YAHW,MAAM,GAAC,OAAO,GAAC,MAAM,GACnB,wBAAwB,CAWpC;IAED;;;OAGG;IACH,cAHW,OAAO,GAAC,OAAO,GAAC,MAAM,GACpB,wBAAwB,CAWpC;IAED;;OAEG;IACH,QAFa,wBAAwB,CAMpC;IAED;;OAEG;IACH,aAFa,wBAAwB,CAWpC;IAED;;;OAGG;IACH,qBAHW,MAAM,GAAC,OAAO,GACZ,wBAAwB,CAgBpC;IAED;;;OAGG;IACH,eAHW,WAAS,OAAO,GACd,wBAAwB,CAgBpC;IAED;;;;;;OAMG;IACH,gBANW,MAAM,GAAC,MAAM,SACb,MAAM,eACN,GAAG,EAAE,kBAEH,wBAAwB,CA2EpC;IAtBC,mBAAyB;IAwB3B;;;;;;OAMG;IACH,gBANW,MAAM,OACN,MAAM,GAAC,MAAM,mBACb,OAAO,GAEL,wBAAwB,CAqDpC;IAED;;;OAGG;IACH,UAHW,MAAM,GACJ,wBAAwB,CAWpC;IAED;;;;;;MAME;IACF,eAHU,MAAM,GACJ,wBAAwB,CAMnC;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,wBAAwB,CAQpC;IAED;;;;;OAKG;IACH,sBAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAWlB;CACF;uCAtkBsC,iCAAiC"}
+{"version":3,"file":"StringJoiningTransformer.d.ts","sourceRoot":"","sources":["../src/StringJoiningTransformer.js"],"names":[],"mappings":"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"}

package/dist/XPathTransformer.d.ts

@@ -1,16 +1,39 @@
 export default XPathTransformer;
+export type XPathTransformerConfig<T> = {
+    /**
+     * Throw on equal priority
+     */
+    errorOnEqualPriority?: boolean | undefined;
+    /**
+     * Template objects
+     */
+    templates: import("./index.js").XPathTemplateArray<T>;
+    /**
+     * XPath version (1|2)
+     */
+    xpathVersion?: number | undefined;
+};
+/**
+ * @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)
+ */
 /**
  * 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
  */
-declare class XPathTransformer {
+declare class XPathTransformer<T> {
     static DefaultTemplateRules: {
         transformRoot: {
             /**
-             * @param {*} node Node
+             * @param {any} node Node
              * @param {{mode:string}} cfg Config
              * @returns {void}
              */
@@ -20,32 +43,24 @@ declare 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: {
-        errorOnEqualPriority?: boolean | undefined;
-        templates: any[];
-        xpathVersion?: number | undefined;
-    });
-    _config: {
-        errorOnEqualPriority?: boolean | undefined;
-        templates: any[];
-        xpathVersion?: number | undefined;
-    };
+    constructor(config: XPathTransformerConfig<T> & import("./XPathTransformerContext.js").XPathTransformerContextConfig);
+    _config: XPathTransformerConfig<T> & import("./XPathTransformerContext.js").XPathTransformerContextConfig;
     /** @type {any[]} */
     rootTemplates: any[];
-    templates: any[];
+    /** @type {import('./index.js').XPathTemplateObject<T>[]} */
+    templates: import("./index.js").XPathTemplateObject<T>[];
     /**
      * @returns {void}
      */
     _triggerEqualPriorityError(): void;
     /**
-     * @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: string): any;
+    transform(mode?: string): import("./index.js").ResultType<T>;
 }
 //# sourceMappingURL=XPathTransformer.d.ts.map

package/dist/XPathTransformer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"XPathTransformer.d.ts","sourceRoot":"","sources":["../src/XPathTransformer.js"],"names":[],"mappings":";AAEA;;;;;;GAMG;AACH;IAsEE;;YAEI;;;;eAIG;2BAHQ,GAAC,OACD;gBAAC,IAAI,EAAC,MAAM,CAAA;aAAC,GACX,IAAI;;MAMnB;IAhFF;;;;;OAKG;IACH,oBAJG;QAAyB,oBAAoB;QACvB,SAAS,EAAvB,GAAG,EAAE;QACW,YAAY;KACtC,EA4BA;IAzBC;;mBALS,GAAG,EAAE;;MAKO;IACrB,oBAAoB;IACpB,eADW,GAAG,EAAE,CACO;IACvB,iBAAiC;IAwBnC;;OAEG;IACH,8BAFa,IAAI,CAShB;IAED;;;OAGG;IACH,gBAHW,MAAM,GACJ,GAAC,CAkBb;CAcF"}
+{"version":3,"file":"XPathTransformer.d.ts","sourceRoot":"","sources":["../src/XPathTransformer.js"],"names":[],"mappings":";mCAGa,CAAC;;;;;;;;eAGA,OAAO,YAAY,EAC5B,kBAAkB,CAAC,CAAC,CAAC;;;;;;AAL1B;;;;;;;GAOG;AAEH;;;;;;;GAOG;AACH,+BAFa,CAAC;IA6EZ;;YAEI;;;;eAIG;2BAHQ,GAAG,OACH;gBAAC,IAAI,EAAC,MAAM,CAAA;aAAC,GACX,IAAI;;MAMnB;IArFF;;;;OAIG;IACH,oBAJW,sBAAsB,CAAC,CAAC,CAAC,GACnC,OAAW,8BAA8B,EACrC,6BAA6B,EAiCjC;IA7BC,0GAAqB;IACrB,oBAAoB;IACpB,eADW,GAAG,EAAE,CACO;IAEvB,4DAA4D;IAC5D,WADW,OAAO,YAAY,EAAE,mBAAmB,CAAC,CAAC,CAAC,EAAE,CAMtD;IAqBJ;;OAEG;IACH,8BAFa,IAAI,CAShB;IAED;;;OAGG;IACH,iBAHW,MAAM,GACJ,OAAO,YAAY,EAAE,UAAU,CAAC,CAAC,CAAC,CAoB9C;CAcF"}