jtlt 0.1.0

package/dist/DOMJoiningTransformer.d.ts

@@ -0,0 +1,113 @@
+export default DOMJoiningTransformer;
+/**
+ * Joining transformer that accumulates into a DOM tree.
+ *
+ * This transformer appends strings and nodes to a DocumentFragment/Element.
+ * 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.
+ */
+declare class DOMJoiningTransformer extends AbstractJoiningTransformer {
+    /**
+     * @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 {Node} item
+     * @returns {void}
+     */
+    rawAppend(item: Node): void;
+    /**
+     * @param {string|Node} item - Item to append
+     * @returns {void}
+     */
+    append(item: string | Node): void;
+    /**
+     * @returns {DocumentFragment|Element}
+     */
+    get(): DocumentFragment | Element;
+    /**
+     * @param {string} prop - Property name
+     * @param {*} val - Property value
+     * @returns {void}
+     */
+    propValue(prop: string, val: any): void;
+    /**
+     * @param {object} obj - Object to serialize
+     * @param {Function} [cb] - Callback function.
+     * @param {any[]} [usePropertySets] - Property sets to use
+     * @param {object} [propSets] - Additional property sets
+     * @returns {DOMJoiningTransformer}
+     */
+    object(obj: object, cb?: Function, usePropertySets?: any[], propSets?: object): DOMJoiningTransformer;
+    /**
+     * @param {any[]|Element} arr
+     * @param {Function} [cb] - Callback function
+     * @returns {DOMJoiningTransformer}
+     */
+    array(arr: any[] | Element, cb?: Function): DOMJoiningTransformer;
+    /**
+     * @param {string} str - String value
+     * @param {Function} cb - Callback function (unused)
+     * @returns {DOMJoiningTransformer}
+     */
+    string(str: string, cb: Function): DOMJoiningTransformer;
+    /**
+     * @param {number} num - Number value
+     * @returns {DOMJoiningTransformer}
+     */
+    number(num: number): DOMJoiningTransformer;
+    /**
+     * @param {boolean} bool
+     * @returns {DOMJoiningTransformer}
+     */
+    boolean(bool: boolean): DOMJoiningTransformer;
+    /**
+     * @returns {DOMJoiningTransformer}
+     */
+    null(): DOMJoiningTransformer;
+    /**
+     * @returns {DOMJoiningTransformer}
+     */
+    undefined(): DOMJoiningTransformer;
+    /**
+     * @param {number} num - Non-finite number (NaN, Infinity, -Infinity)
+     * @returns {DOMJoiningTransformer}
+     */
+    nonfiniteNumber(num: number): DOMJoiningTransformer;
+    /**
+     * @param {Function} func - Function to stringify
+     * @returns {DOMJoiningTransformer}
+     */
+    function(func: Function): DOMJoiningTransformer;
+    /**
+     * @param {string} elName - Element name
+     * @param {object} [atts] - Attributes object
+     * @param {Function} [cb] - Callback function
+     * @returns {DOMJoiningTransformer}
+     */
+    element(elName: string, atts?: object, cb?: Function): DOMJoiningTransformer;
+    /**
+     * @param {string} name
+     * @param {string} val
+     * @returns {DOMJoiningTransformer}
+     */
+    attribute(name: string, val: string): DOMJoiningTransformer;
+    /**
+     * @param {string} txt - Text content
+     * @returns {DOMJoiningTransformer}
+     */
+    text(txt: string): DOMJoiningTransformer;
+    /**
+     * @param {string} str
+     * @returns {DOMJoiningTransformer}
+     */
+    plainText(str: string): DOMJoiningTransformer;
+}
+import AbstractJoiningTransformer from './AbstractJoiningTransformer.js';
+//# sourceMappingURL=DOMJoiningTransformer.d.ts.map

package/dist/DOMJoiningTransformer.d.ts.map

@@ -0,0 +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"}

package/dist/JSONJoiningTransformer.d.ts

@@ -0,0 +1,160 @@
+export default JSONJoiningTransformer;
+/**
+ * JSON-based joining transformer for building JSON/JavaScript objects.
+ *
+ * This joiner accumulates into an in-memory JSON value (object or array).
+ * append() will push to arrays or shallow-merge into objects; string/number/
+ * boolean/null add primitives accordingly. It does not perform HTML escaping
+ * or string serialization; it builds real JS values.
+ */
+declare class JSONJoiningTransformer extends AbstractJoiningTransformer {
+    /**
+     * @param {any[]|object} [o] - Initial object or array
+     * @param {object} [cfg] - Configuration object
+     */
+    constructor(o?: any[] | object, cfg?: object);
+    /** @type {any[]|object} */
+    _obj: any[] | object;
+    /** @type {boolean | undefined} */
+    _objPropState: boolean | undefined;
+    /** @type {boolean | undefined} */
+    _arrItemState: boolean | undefined;
+    /** @type {{attsObj: Record<string, any>, jmlChildren: any[]}[]} */
+    _elementStack: {
+        attsObj: Record<string, any>;
+        jmlChildren: any[];
+    }[];
+    /**
+     * Directly appends an item to the internal array without checks.
+     * @param {*} item - Item to append
+     * @returns {void}
+     */
+    rawAppend(item: any): void;
+    /**
+     * Appends an item to the current object or array.
+     * @param {*} item - Item to append
+     * @returns {JSONJoiningTransformer}
+     */
+    append(item: any): JSONJoiningTransformer;
+    /**
+     * Gets the current object or array. If unwrapSingleResult config option is
+     * enabled and the root array contains exactly one element, returns that
+     * element directly (unwrapped).
+     * @returns {any[]|object|any}
+     */
+    get(): any[] | object | any;
+    /**
+     * Sets a property value on the current object.
+     * @param {string} prop - Property name
+     * @param {*} val - Property value
+     * @returns {void}
+     */
+    propValue(prop: string, val: any): void;
+    /**
+     * @param {object|Function} [objOrCb] - Seed object to start with, or
+     *   callback if no seed provided
+     * @param {Function|any[]} [cbOrUsePropertySets] - Callback to be executed
+     *   on this transformer but with a context nested within the newly created
+     *   object, or array of property set names if first arg was an object
+     * @param {any[]|object} [usePropertySetsOrPropSets] - Array of string
+     *   property set names to copy onto the new object, or propSets if second
+     *   arg was a callback
+     * @param {object} [propSets] - An object of key-value pairs to copy onto
+     *   the new object
+     * @returns {JSONJoiningTransformer}
+     */
+    object(objOrCb?: object | Function, cbOrUsePropertySets?: Function | any[], usePropertySetsOrPropSets?: any[] | object, propSets?: object): JSONJoiningTransformer;
+    /**
+     * Creates a new array and executes a callback in its context.
+     * @param {any[]|Function} [arrOrCb] - Seed array to start with, or callback
+     *   if no seed provided
+     * @param {Function} [cb] - Callback function (if first arg was a seed array)
+     * @returns {JSONJoiningTransformer}
+     */
+    array(arrOrCb?: any[] | Function, cb?: Function): JSONJoiningTransformer;
+    /**
+     * Appends a string value.
+     * @param {string} str - String value
+    * @param {Function} [cb] - Callback function (unused)
+     * @returns {JSONJoiningTransformer}
+     */
+    string(str: string, cb?: Function): JSONJoiningTransformer;
+    /**
+     * Appends a number value.
+     * @param {number} num - Number value
+     * @returns {JSONJoiningTransformer}
+     */
+    number(num: number): JSONJoiningTransformer;
+    /**
+     * Appends a boolean value.
+     * @param {boolean} bool - Boolean value
+     * @returns {JSONJoiningTransformer}
+     */
+    boolean(bool: boolean): JSONJoiningTransformer;
+    /**
+     * Appends a null value.
+     * @returns {JSONJoiningTransformer}
+     */
+    null(): JSONJoiningTransformer;
+    /**
+     * Appends an undefined value (JavaScript mode only).
+     * @returns {JSONJoiningTransformer}
+     */
+    undefined(): JSONJoiningTransformer;
+    /**
+     * Appends a non-finite number (JavaScript mode only).
+     * @param {number} num - Non-finite number (NaN, Infinity, -Infinity)
+     * @returns {JSONJoiningTransformer}
+     */
+    nonfiniteNumber(num: number): JSONJoiningTransformer;
+    /**
+     * Appends a function value (JavaScript mode only).
+     * @param {Function} func - Function to append
+     * @returns {JSONJoiningTransformer}
+     */
+    function(func: Function): JSONJoiningTransformer;
+    /**
+    * Build a Jamilih-style element JSON array and append to current container.
+    * Result form: ['tag', {attr: 'val'}, child1, child2, ...]
+    * Helpers: dataset -> data-*; $a -> ordered attributes.
+    * Supported signatures mirror StringJoiningTransformer.element.
+     * @param {string|Element|object} elName - Element name or Element-like
+     * @param {object|any[]|Function} [atts] - Attributes object or children or cb
+     * @param {any[]|Function} [childNodes] - Child nodes array or callback
+     * @param {Function} [cb] - Callback for building children/attributes
+     * @returns {JSONJoiningTransformer}
+     */
+    element(elName: string | Element | object, atts?: object | any[] | Function, childNodes?: any[] | Function, cb?: Function): JSONJoiningTransformer;
+    /**
+     * Adds/updates an attribute for the most recently open element built via
+     * a callback-driven element(). When not in an element callback context,
+     * throws. Supports the same dataset/$a helpers as string joiner.
+     * @param {string} name - Attribute name (or helper: dataset, $a)
+     * @param {string|object|any[]} val - Attribute value or helper object
+     * @returns {JSONJoiningTransformer}
+     */
+    attribute(name: string, val: string | object | any[]): JSONJoiningTransformer;
+    /**
+     * Adds a text node (string) as a child within the current element() callback
+     * context. Outside of an element callback, simply appends the text to the
+     * current array/object like string().
+     * @param {string} txt - Text content
+     * @returns {JSONJoiningTransformer}
+     */
+    text(txt: string): JSONJoiningTransformer;
+    /**
+     * Appends plain text as a string.
+     * @param {string} str - Plain text string
+     * @returns {JSONJoiningTransformer}
+     */
+    plainText(str: string): JSONJoiningTransformer;
+    /**
+     * Helper method to use property sets (to be implemented).
+     * @param {object} obj - Object to apply property set to
+     * @param {string} psName - Property set name
+     * @returns {object}
+     */
+    _usePropertySets(obj: object, psName: string): object;
+}
+import AbstractJoiningTransformer from './AbstractJoiningTransformer.js';
+//# sourceMappingURL=JSONJoiningTransformer.d.ts.map

package/dist/JSONJoiningTransformer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JSONJoiningTransformer.d.ts","sourceRoot":"","sources":["../src/JSONJoiningTransformer.js"],"names":[],"mappings":";AAYA;;;;;;;GAOG;AACH;IACE;;;OAGG;IACH,gBAHW,GAAG,EAAE,GAAC,MAAM,QACZ,MAAM,EAYhB;IARC,2BAA2B;IAC3B,MADW,GAAG,EAAE,GAAC,MAAM,CACJ;IACnB,kCAAkC;IAClC,eADW,OAAO,GAAG,SAAS,CACA;IAC9B,kCAAkC;IAClC,eADW,OAAO,GAAG,SAAS,CACA;IAC9B,mEAAmE;IACnE,eADW;QAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAAC,WAAW,EAAE,GAAG,EAAE,CAAA;KAAC,EAAE,CACxC;IAGzB;;;;OAIG;IACH,gBAHW,GAAC,GACC,IAAI,CAIhB;IAED;;;;OAIG;IACH,aAHW,GAAC,GACC,sBAAsB,CAalC;IAED;;;;;OAKG;IACH,OAFa,GAAG,EAAE,GAAC,MAAM,GAAC,GAAG,CAS5B;IAED;;;;;OAKG;IACH,gBAJW,MAAM,OACN,GAAC,GACC,IAAI,CAShB;IAGD;;;;;;;;;;;;OAYG;IACH,iBAZW,MAAM,WAAS,wBAEf,WAAS,GAAG,EAAE,8BAGd,GAAG,EAAE,GAAC,MAAM,aAGZ,MAAM,GAEJ,sBAAsB,CAsDlC;IAED;;;;;;OAMG;IACH,gBALW,GAAG,EAAE,WAAS,kBAGZ,sBAAsB,CA+BlC;IAED;;;;;OAKG;IACH,YAJW,MAAM,kBAEJ,sBAAsB,CAMlC;IAED;;;;OAIG;IACH,YAHW,MAAM,GACJ,sBAAsB,CAKlC;IAED;;;;OAIG;IACH,cAHW,OAAO,GACL,sBAAsB,CAKlC;IAED;;;OAGG;IACH,QAFa,sBAAsB,CAKlC;IAED;;;OAGG;IACH,aAFa,sBAAsB,CAUlC;IAED;;;;OAIG;IACH,qBAHW,MAAM,GACJ,sBAAsB,CAUlC;IAED;;;;OAIG;IACH,0BAFa,sBAAsB,CAUlC;IAED;;;;;;;;;;OAUG;IACH,gBANW,MAAM,GAAC,OAAO,GAAC,MAAM,SACrB,MAAM,GAAC,GAAG,EAAE,WAAS,eACrB,GAAG,EAAE,WAAS,kBAEZ,sBAAsB,CA2FlC;IAED;;;;;;;OAOG;IACH,gBAJW,MAAM,OACN,MAAM,GAAC,MAAM,GAAC,GAAG,EAAE,GACjB,sBAAsB,CA8BlC;IAED;;;;;;OAMG;IACH,UAHW,MAAM,GACJ,sBAAsB,CAWlC;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,sBAAsB,CAKlC;IAED;;;;;OAKG;IACH,sBAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAUlB;CACF;uCApdsC,iCAAiC"}

package/dist/JSONPathTransformer.d.ts

@@ -0,0 +1,95 @@
+export default JSONPathTransformer;
+/**
+ * Applies named JSONPath-driven templates to JSON data.
+ *
+ * This engine finds templates whose `path` match the current node (plus an
+ * 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.
+ */
+declare class JSONPathTransformer {
+    /**
+     * @param {string} select - JSONPath selector
+     * @returns {string} Absolute JSONPath
+     */
+    static makeJSONPathAbsolute(select: string): string;
+    static DefaultTemplateRules: {
+        transformRoot: {
+            /**
+             * @param {*} value - Value
+             * @param {{mode: string}} cfg - Configuration
+             * @returns {void}
+             */
+            template(value: any, cfg: {
+                mode: string;
+            }): void;
+        };
+        transformPropertyNames: {
+            /**
+             * @param {*} value - Current context value
+             * @returns {*}
+             */
+            template(value: any): any;
+        };
+        transformObjects: {
+            /**
+             * @param {*} value - Value
+             * @param {{mode: string}} cfg - Configuration
+             * @returns {void}
+             */
+            template(value: any, cfg: {
+                mode: string;
+            }): void;
+        };
+        transformArrays: {
+            /**
+             * @param {*} value - Value
+             * @param {{mode: string}} cfg - Configuration
+             * @returns {void}
+             */
+            template(value: any, cfg: {
+                mode: string;
+            }): void;
+        };
+        transformScalars: {
+            /**
+             * @returns {*}
+             */
+            template(): any;
+        };
+        transformFunctions: {
+            /**
+             * @param {Function} value - Function at current context
+             * @returns {*}
+             */
+            template(value: Function): any;
+        };
+    };
+    /**
+     * @param {object} config - Configuration object
+     * @param {boolean} [config.errorOnEqualPriority] - Whether to error on
+     *   equal priority templates
+     * @param {any[]} config.templates - Array of template objects
+     */
+    constructor(config: {
+        errorOnEqualPriority?: boolean | undefined;
+        templates: any[];
+    });
+    _config: {
+        errorOnEqualPriority?: boolean | undefined;
+        templates: any[];
+    };
+    /** @type {any[]} */
+    rootTemplates: any[];
+    templates: any[];
+    /**
+     * @returns {void}
+     */
+    _triggerEqualPriorityError(): void;
+    /**
+     * @param {string} mode - Transformation mode
+     * @returns {*} The transformation result
+     */
+    transform(mode: string): any;
+}
+//# sourceMappingURL=JSONPathTransformer.d.ts.map

package/dist/JSONPathTransformer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JSONPathTransformer.d.ts","sourceRoot":"","sources":["../src/JSONPathTransformer.js"],"names":[],"mappings":";AAEA;;;;;;;GAOG;AACH;IAsEE;;;OAGG;IACH,oCAHW,MAAM,GACJ,MAAM,CAQlB;IAGD;;YAEI;;;;eAIG;4BAHQ,GAAC,OACD;gBAAC,IAAI,EAAE,MAAM,CAAA;aAAC,GACZ,IAAI;;;YAOjB;;;eAGG;4BAFQ,GAAC,GACC,GAAC;;;YAWd;;;;eAIG;4BAHQ,GAAC,OACD;gBAAC,IAAI,EAAE,MAAM,CAAA;aAAC,GACZ,IAAI;;;YAOjB;;;;eAIG;4BAHQ,GAAC,OACD;gBAAC,IAAI,EAAE,MAAM,CAAA;aAAC,GACZ,IAAI;;;YAOjB;;eAEG;wBADU,GAAC;;;YAOd;;;eAGG;uCADU,GAAC;;MAOhB;IAhJF;;;;;OAKG;IACH,oBAJG;QAAyB,oBAAoB;QAEvB,SAAS,EAAvB,GAAG,EAAE;KACf,EA0BA;IAvBC;;mBAJS,GAAG,EAAE;MAIO;IACrB,oBAAoB;IACpB,eADW,GAAG,EAAE,CACO;IACvB,iBAAiC;IAsBnC;;OAEG;IACH,8BAFa,IAAI,CAShB;IAED;;;OAGG;IACH,gBAHW,MAAM,GACJ,GAAC,CAoBb;CA8EF"}

package/dist/JSONPathTransformerContext.d.ts

@@ -0,0 +1,263 @@
+export default JSONPathTransformerContext;
+/**
+ * Execution context for JSONPath-driven template application.
+ *
+ * Holds the current node, parent, path, variables, and property sets while
+ * running templates. Exposes helper methods that mirror the underlying
+ * joining transformer (e.g., string(), object(), array()) so templates can
+ * emit results without referencing the joiner directly.
+ */
+declare class JSONPathTransformerContext {
+    /**
+     * @param {object} config - Configuration object
+     * @param {object} config.data - Data to transform
+     * @param {object} [config.parent] - Parent object
+     * @param {string} [config.parentProperty] - Parent property name
+     * @param {boolean} [config.errorOnEqualPriority] - Whether to error on
+     *   equal priority
+     * @param {{append: Function, get: Function, string: Function,
+     *   object: Function, array: Function}} config.joiningTransformer -
+     *   Joining transformer
+     * @param {boolean} [config.preventEval] - Whether to prevent eval in
+     *   JSONPath
+     * @param {Function} [config.specificityPriorityResolver] - Function to
+     *   resolve priority
+     * @param {any[]} templates - Array of template objects
+     */
+    constructor(config: {
+        data: object;
+        parent?: object | undefined;
+        parentProperty?: string | undefined;
+        errorOnEqualPriority?: boolean | undefined;
+        joiningTransformer: {
+            append: Function;
+            get: Function;
+            string: Function;
+            object: Function;
+            array: Function;
+        };
+        preventEval?: boolean | undefined;
+        specificityPriorityResolver?: Function | undefined;
+    }, templates: any[]);
+    _config: {
+        data: object;
+        parent?: object | undefined;
+        parentProperty?: string | undefined;
+        errorOnEqualPriority?: boolean | undefined;
+        joiningTransformer: {
+            append: Function;
+            get: Function;
+            string: Function;
+            object: Function;
+            array: Function;
+        };
+        preventEval?: boolean | undefined;
+        specificityPriorityResolver?: Function | undefined;
+    };
+    _templates: any[];
+    _contextObj: object;
+    _origObj: object;
+    _parent: object;
+    _parentProperty: string;
+    /** @type {Record<string, any>} */
+    vars: Record<string, any>;
+    /** @type {Record<string, any>} */
+    propertySets: Record<string, any>;
+    /** @type {Record<string, any>} */
+    keys: Record<string, any>;
+    /** @type {boolean | undefined} */
+    _initialized: boolean | undefined;
+    /** @type {string | undefined} */
+    _currPath: string | undefined;
+    /**
+     * Triggers an error if equal priority templates are found.
+     * @returns {void}
+     */
+    _triggerEqualPriorityError(): void;
+    /**
+     * Gets the joining transformer from config.
+     * @returns {any} The joining transformer
+     */
+    _getJoiningTransformer(): any;
+    /**
+     * @param {*} item - Item to append to output
+     * @returns {JSONPathTransformerContext}
+     */
+    appendOutput(item: any): JSONPathTransformerContext;
+    /**
+     * Gets the current output.
+     * @returns {*} The output from the joining transformer
+     */
+    getOutput(): any;
+    /**
+     * Get() and set() are provided as a convenience method for templates, but
+     *   it should typically not be used (use valueOf or the copy methods to add
+     *   to the result tree instead).
+     * @param {string} select - JSONPath selector
+     * @param {boolean} wrap - Whether to wrap results
+     * @returns {*} The selected value(s)
+     */
+    get(select: string, wrap: boolean): any;
+    /**
+     * @param {*} v - Value to set
+     * @returns {JSONPathTransformerContext}
+     */
+    set(v: any): JSONPathTransformerContext;
+    /**
+     * Apply matching templates to nodes selected by JSONPath, optionally sorted.
+     *
+     * Sort parameter forms:
+     * - string: JSONPath relative to each match (e.g., '$.name' or '@')
+     * - function: comparator (aValue, bValue, ctx) => number
+     * - object: { select, order='ascending'|'descending', type='text'|'number',
+     *            locale, localeOptions }
+     * - array: multiple key objects/strings in priority order.
+     *
+     * @param {string|object} select - JSONPath selector or options object
+     * @param {string} [mode] - Mode to apply
+     * @param {string|Function|object|Array<string|object>} [sort] - Sort spec
+     * @returns {JSONPathTransformerContext}
+     */
+    applyTemplates(select: string | object, mode?: string, sort?: string | Function | object | Array<string | object>): JSONPathTransformerContext;
+    /**
+     * @param {string|object} name - Template name or options object
+     * @param {any[]} [withParams] - Parameters to pass to template
+     * @returns {JSONPathTransformerContext}
+     */
+    callTemplate(name: string | object, withParams?: any[]): JSONPathTransformerContext;
+    /**
+     * Iterate over values selected by JSONPath, optionally sorted.
+     *
+     * Sort parameter forms are the same as applyTemplates().
+     * @param {string} select - JSONPath selector
+     * @param {Function} cb - Callback function
+     * @param {string|Function|object|Array<string|object>} [sort] - Sort spec
+     * @returns {JSONPathTransformerContext}
+     */
+    forEach(select: string, cb: Function, sort?: string | Function | object | Array<string | object>): JSONPathTransformerContext;
+    /**
+     * @param {string|object} [select] - JSONPath selector
+     * @returns {JSONPathTransformerContext}
+     */
+    valueOf(select?: string | object): JSONPathTransformerContext;
+    /**
+     * Deep copy selection or current context when omitted.
+     * @param {string} [select] - JSONPath selector
+     * @returns {JSONPathTransformerContext}
+     */
+    copyOf(select?: string): JSONPathTransformerContext;
+    /**
+     * Shallow copy current context; optionally merge property set names.
+     * @param {string[]} [propertySets] - Property sets to merge
+     * @returns {JSONPathTransformerContext}
+     */
+    copy(propertySets?: string[]): JSONPathTransformerContext;
+    /**
+     * @param {string} name - Variable name
+     * @param {string} select - JSONPath selector
+     * @returns {JSONPathTransformerContext}
+     */
+    variable(name: string, select: string): JSONPathTransformerContext;
+    /**
+     * @param {*} json - JSON data to log
+     * @returns {void}
+     */
+    message(json: any): void;
+    /**
+     * @param {string} str - String value
+     * @param {Function} cb - Callback function
+     * @returns {JSONPathTransformerContext}
+     */
+    string(str: string, cb: Function): JSONPathTransformerContext;
+    /**
+     * Append a number to JSON output. Mirrors the joining transformer API so
+     *   templates can call `this.number()`.
+     * @param {number} num - Number value to append
+     * @returns {JSONPathTransformerContext}
+     */
+    number(num: number): JSONPathTransformerContext;
+    /**
+     * Append plain text directly to the output without escaping or JSON
+     *   stringification. Mirrors the joining transformer API so templates can
+     *   call `this.plainText()`.
+     * @param {string} str - Plain text to append
+     * @returns {JSONPathTransformerContext}
+     */
+    plainText(str: string): JSONPathTransformerContext;
+    /**
+     * Set a property value on the current object (JSON joiner). Mirrors the
+     *   joining transformer API so templates can call `this.propValue()`.
+     * @param {string} prop - Property name
+     * @param {*} val - Property value
+     * @returns {JSONPathTransformerContext}
+     */
+    propValue(prop: string, val: any): JSONPathTransformerContext;
+    /**
+     * Build an object. Mirrors the joining transformer API. All joiners now
+     * support both signatures: (obj, cb, usePropertySets, propSets) with seed
+     * object or (cb, usePropertySets, propSets) without.
+     * @param {...any} args - Arguments to pass to joiner
+     * @returns {JSONPathTransformerContext}
+     */
+    object(...args: any[]): JSONPathTransformerContext;
+    /**
+     * Build an array. Mirrors the joining transformer API. All joiners now
+     * support both signatures: (arr, cb) with seed array or (cb) without.
+     * @param {...any} args - Arguments to pass to joiner
+     * @returns {JSONPathTransformerContext}
+     */
+    array(...args: any[]): JSONPathTransformerContext;
+    /**
+     * Create an element. Mirrors the joining transformer API so templates can
+     * call `this.element()`.
+     * @param {string} name - Element name
+     * @param {object} [atts] - Attributes object
+     * @param {any[]} [children] - Child nodes
+     * @param {Function} [cb] - Callback function
+     * @returns {JSONPathTransformerContext}
+     */
+    element(name: string, atts?: object, children?: any[], cb?: Function): JSONPathTransformerContext;
+    /**
+     * Add an attribute to the most recently opened element. Mirrors the joining
+     * transformer API so templates can call `this.attribute()`.
+     * @param {string} name - Attribute name
+     * @param {string|object} val - Attribute value
+     * @param {boolean} [avoidAttEscape] - Whether to avoid escaping
+     * @returns {JSONPathTransformerContext}
+     */
+    attribute(name: string, val: string | object, avoidAttEscape?: boolean): JSONPathTransformerContext;
+    /**
+     * Append text content. Mirrors the joining transformer API so templates can
+     * call `this.text()`.
+     * @param {string} txt - Text content
+     * @returns {JSONPathTransformerContext}
+     */
+    text(txt: string): JSONPathTransformerContext;
+    /**
+     * @param {string} name - Property set name
+     * @param {object} propertySetObj - Property set object
+     * @param {any[]} [usePropertySets] - Property sets to use
+     * @returns {JSONPathTransformerContext}
+     */
+    propertySet(name: string, propertySetObj: object, usePropertySets?: any[]): JSONPathTransformerContext;
+    /**
+     * @param {object} obj - Object to assign properties to
+     * @param {string} name - Property set name
+     * @returns {object}
+     */
+    _usePropertySets(obj: object, name: string): object;
+    /**
+     * @param {string} name - Key name
+     * @param {*} value - Value to match
+     * @returns {*}
+     */
+    getKey(name: string, value: any): any;
+    /**
+     * @param {string} name - Key name
+     * @param {string} match - Match expression
+     * @param {string} use - Use expression
+     * @returns {JSONPathTransformerContext}
+     */
+    key(name: string, match: string, use: string): JSONPathTransformerContext;
+}
+//# sourceMappingURL=JSONPathTransformerContext.d.ts.map

package/dist/JSONPathTransformerContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JSONPathTransformerContext.d.ts","sourceRoot":"","sources":["../src/JSONPathTransformerContext.js"],"names":[],"mappings":"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"}