jtlt 0.2.0 → 0.4.0

package/dist/XPathTransformerContext.d.ts

@@ -1,43 +1,64 @@
 export default XPathTransformerContext;
+export type XPathTransformerContextConfig = {
+    /**
+     * - XML/DOM root to transform
+     */
+    data?: unknown;
+    /**
+     * - 1, 2, 3.1 (default 1)
+     */
+    xpathVersion?: number | undefined;
+    /**
+     * Joiner
+     */
+    joiningTransformer: import("./index.js").JoiningTransformer;
+    errorOnEqualPriority?: boolean | undefined;
+    specificityPriorityResolver?: ((path: string) => number) | undefined;
+};
+/**
+ * @typedef {object} XPathTransformerContextConfig
+ * @property {unknown} [data] - XML/DOM root to transform
+ * @property {number} [xpathVersion] - 1, 2, 3.1 (default 1)
+ * @property {import('./index.js').
+ *   JoiningTransformer} joiningTransformer Joiner
+ * @property {boolean} [errorOnEqualPriority]
+ * @property {(path: string) => number} [specificityPriorityResolver]
+ */
 /**
  * Execution context for XPath-driven template application.
  *
  * Similar to JSONPathTransformerContext but uses XPath expressions on a
- * DOM/XML-like tree. Supports XPath 1.0 (default) or 2.0 when
- * `xpathVersion: 2`.
+ * DOM/XML-like tree. Supports XPath 1.0 (default), 2.0 when
+ * `xpathVersion: 2`, or 3.1 when `xpathVersion: 3.1`.
  *
  * Expected config:
  * - data: A Document, Element, or XML-like root node.
  * - joiningTransformer: joiner with append(), string(), object(), array(), etc.
- * - xpathVersion: 1|2 (default 1)
+ * - xpathVersion: 1|2|3.1 (default 1)
  * - errorOnEqualPriority, specificityPriorityResolver (same semantics).
  */
 declare class XPathTransformerContext {
-    /**
-     * Log a message (for debugging).
-     * @param {*} json Any value
-     * @returns {void}
-     */
-    static message(json: any): void;
     static DefaultTemplateRules: {
         transformRoot: {
             /**
-             * @param {*} node Root node
+             * @this {XPathTransformerContext}
+             * @param {unknown} node Root node
              * @param {{mode:string}} cfg Config
              * @returns {void}
              */
-            template(node: any, cfg: {
+            template(this: XPathTransformerContext, node: unknown, cfg: {
                 mode: string;
             }): void;
         };
         transformElements: {
             /**
-             * @param {*} node Element node
-             * @param {{mode:string}} cfg Config
+             * @this {XPathTransformerContext}
+             * @param {unknown} node Element node
+             * @param {{mode?:string}} cfg Config
              * @returns {void}
              */
-            template(node: any, cfg: {
-                mode: string;
+            template(this: XPathTransformerContext, node: unknown, cfg: {
+                mode?: string;
             }): void;
         };
         transformTextNodes: {
@@ -50,114 +71,117 @@ declare class XPathTransformerContext {
             }): string;
         };
         transformScalars: {
-            /** @returns {*} */
-            template(): any;
+            /**
+             * @this {XPathTransformerContext}
+             * @returns {XPathTransformerContext}
+             */
+            template(this: XPathTransformerContext): XPathTransformerContext;
         };
     };
     /**
-     * @param {object} config - Configuration object
-     * @param {Document|Element|any} config.data - XML/DOM root to transform
-     * @param {number} [config.xpathVersion] - 1 or 2 (default 1)
-    * @param {object} config.joiningTransformer Joiner
-    * @param {Function} config.joiningTransformer.append Append output
-    * @param {Function} config.joiningTransformer.get Get output
-    * @param {Function} config.joiningTransformer.string Emit string
-    * @param {Function} config.joiningTransformer.object Emit object
-    * @param {Function} config.joiningTransformer.array Emit array
-     * @param {boolean} [config.errorOnEqualPriority]
-     * @param {Function} [config.specificityPriorityResolver]
-     * @param {any[]} templates - Template objects
-     */
-    constructor(config: {
-        data: Document | Element | any;
-        xpathVersion?: number | undefined;
-        joiningTransformer: {
-            append: Function;
-            get: Function;
-            string: Function;
-            object: Function;
-            array: Function;
-        };
-        errorOnEqualPriority?: boolean | undefined;
-        specificityPriorityResolver?: Function | undefined;
-    }, templates: any[]);
-    _config: {
-        data: Document | Element | any;
-        xpathVersion?: number | undefined;
-        joiningTransformer: {
-            append: Function;
-            get: Function;
-            string: Function;
-            object: Function;
-            array: Function;
-        };
-        errorOnEqualPriority?: boolean | undefined;
-        specificityPriorityResolver?: Function | undefined;
-    };
-    _templates: any[];
-    _contextNode: any;
-    _origNode: any;
-    /** @type {Record<string, any>} */
-    vars: Record<string, any>;
-    /** @type {Record<string, any>} */
-    propertySets: Record<string, any>;
-    /** @type {Record<string, any>} */
-    keys: Record<string, any>;
+     * @param {XPathTransformerContextConfig} config
+     * @param {import('./index.js').
+     *   XPathTemplateObject<any>[]} templates - Template objects
+     */
+    constructor(config: XPathTransformerContextConfig, templates: import("./index.js").XPathTemplateObject<any>[]);
+    _config: XPathTransformerContextConfig;
+    _templates: import("./index.js").XPathTemplateObject<any>[];
+    /** @type {Document|Element|Node} */
+    _contextNode: Document | Element | Node;
+    _origNode: Document | Element | Node;
+    /** @type {Record<string, unknown>} */
+    vars: Record<string, unknown>;
+    /** @type {Record<string, Record<string, unknown>>} */
+    propertySets: Record<string, Record<string, unknown>>;
+    /** @type {Record<string, {match: string, use: string}>} */
+    keys: Record<string, {
+        match: string;
+        use: string;
+    }>;
     /** @type {boolean|undefined} */
     _initialized: boolean | undefined;
     /** @type {string|undefined} */
     _currPath: string | undefined;
-    /** @returns {any} */
-    _getJoiningTransformer(): any;
+    /** @type {Record<string, any> | undefined} */
+    _params: Record<string, any> | undefined;
+    /** @returns {import('./index.js').JoiningTransformer} */
+    _getJoiningTransformer(): import("./index.js").JoiningTransformer;
     /**
      * Evaluate an XPath expression against the current context node.
      * @param {string} expr - XPath expression
-    * @param {boolean} [asNodes] Return nodes (array) instead of scalar
-     * @returns {any}
+     * @param {boolean} [asNodes] Return nodes (array) instead of scalar
+     * @returns {unknown}
      */
-    _evalXPath(expr: string, asNodes?: boolean): any;
+    _evalXPath(expr: string, asNodes?: boolean): unknown;
     /**
      * Append raw item to output.
-     * @param {*} item
+     * @param {unknown} item
      * @returns {XPathTransformerContext}
      */
-    appendOutput(item: any): XPathTransformerContext;
-    /** @returns {*} */
-    getOutput(): any;
+    appendOutput(item: unknown): XPathTransformerContext;
+    /** @returns {unknown} */
+    getOutput(): unknown;
     /**
      * Get value(s) by XPath relative to current context.
      * @param {string} select - XPath expression
      * @param {boolean} [asNodes]
-     * @returns {*}
+     * @returns {Node[]}
      */
-    get(select: string, asNodes?: boolean): any;
+    get(select: string, asNodes?: boolean): Node[];
     /**
      * Set current context's parent property (for parity with JSONPath context).
      * Mostly placeholder for object-mirroring behavior.
-     * @param {*} v
+     * @param {Document|Element|Node} v
      * @returns {XPathTransformerContext}
      */
-    set(v: any): XPathTransformerContext;
+    set(v: Document | Element | Node): XPathTransformerContext;
     /**
      * Apply templates to nodes matched by an XPath expression.
-     * @param {string} select - XPath expression (default '.')
+     * @param {string} [select] - XPath expression (default '.')
      * @param {string} [mode]
      * @returns {XPathTransformerContext}
      */
-    applyTemplates(select: string, mode?: string): XPathTransformerContext;
+    applyTemplates(select?: string, mode?: string): XPathTransformerContext;
+    /**
+     * @param {string|
+     *   {name: string, withParam?: any[]}} name - Template name or
+     *   options object
+     * @param {any[]} [withParams] - Parameters to pass to template
+     * @returns {this}
+     */
+    callTemplate(name: string | {
+        name: string;
+        withParam?: any[];
+    }, withParams?: any[]): this;
     /**
      * Iterate over nodes selected by XPath.
      * @param {string} select - XPath expression
-     * @param {Function} cb - Callback invoked per node
+     * @param {(this: XPathTransformerContext,
+     *   node: Node
+     * )=>void} cb - Callback invoked per node
      * @returns {XPathTransformerContext}
      */
-    forEach(select: string, cb: Function): XPathTransformerContext;
+    forEach(select: string, cb: (this: XPathTransformerContext, node: Node) => void): XPathTransformerContext;
     /**
      * Append the value from an XPath expression or the context node text.
      * @param {string|object} [select]
      * @returns {XPathTransformerContext}
      */
     valueOf(select?: string | object): XPathTransformerContext;
+    /**
+     * Deep copy selection or current context when omitted.
+     * For DOM nodes uses cloneNode(true); for scalars copies the value.
+     * @param {string} [select] XPath expression selecting nodes (optional)
+     * @returns {XPathTransformerContext}
+     */
+    copyOf(select?: string): XPathTransformerContext;
+    /**
+     * Shallow copy current context node (cloneNode(false)); scalars copied
+     * directly. Provided for parity with JSONPath copy().
+     * @param {string[]} [_propertySets] Ignored in XPath variant (parity only)
+     * @returns {XPathTransformerContext}
+     */
+    copy(_propertySets?: string[]): XPathTransformerContext;
     /**
      * Define a variable by XPath selection (stores node array if nodes).
      * @param {string} name Variable name
@@ -165,19 +189,83 @@ declare class XPathTransformerContext {
      * @returns {XPathTransformerContext}
      */
     variable(name: string, select: string): XPathTransformerContext;
+    /**
+     * Log a message (for debugging).
+     * @param {unknown} json Any value
+     * @returns {void}
+     */
+    message(json: unknown): void;
     /**
      * Append string.
      * @param {string} str String to append
-     * @param {Function} [cb] Callback
+     * @param {(this: XPathTransformerContext) => void} [cb] Callback
      * @returns {XPathTransformerContext}
      */
-    string(str: string, cb?: Function): XPathTransformerContext;
+    string(str: string, cb?: (this: XPathTransformerContext) => void): XPathTransformerContext;
     /**
-     * Append number.
-     * @param {number} num Number
+     * Append number with xsl:number-like formatting.
+     * @param {number|string|{
+     *   value?: number|string,
+     *   count?: string,
+     *   level?: 'single'|'multiple'|'any',
+     *   from?: string,
+     *   format?: string,
+     *   groupingSeparator?: string,
+     *   groupingSize?: number
+     * }} num - Number value, "position()" string, or options object
      * @returns {XPathTransformerContext}
      */
-    number(num: number): XPathTransformerContext;
+    number(num: number | string | {
+        value?: number | string;
+        count?: string;
+        level?: "single" | "multiple" | "any";
+        from?: string;
+        format?: string;
+        groupingSeparator?: string;
+        groupingSize?: number;
+    }): XPathTransformerContext;
+    /**
+     * Calculate position of current node.
+     * @param {string} [count] - XPath pattern to match
+     * @param {string} [from] - XPath pattern for ancestor
+     * @returns {number}
+     * @private
+     */
+    private _calculatePosition;
+    /**
+     * Calculate position counting all ancestors (level=any).
+     * @param {string} [count] - XPath pattern to match
+     * @param {string} [from] - XPath pattern for ancestor
+     * @returns {number}
+     * @private
+     */
+    private _calculatePositionAny;
+    /**
+     * Format a number according to format string.
+     * @param {number} num - Number to format
+     * @param {string} format - Format string (1, a, A, i, I, 01, etc.)
+     * @param {string} [groupingSeparator] - Separator for grouping (e.g., ',')
+     * @param {number} [groupingSize] - Size of groups (e.g., 3 for 1,000)
+     * @param {string} [locale]
+     * @returns {string}
+     * @private
+     */
+    private _formatNumber;
+    /**
+     * Convert number to Roman numerals.
+     * @param {number} num - Number to convert (1-3999)
+     * @returns {string}
+     * @private
+     */
+    private _toRoman;
+    /**
+     * Convert number to alphabetic sequence.
+     * @param {number} num - Number to convert
+     * @param {boolean} uppercase - Use uppercase letters
+     * @returns {string}
+     * @private
+     */
+    private _toAlphabetic;
     /**
      * Append plain text (no escaping changes).
      * @param {string} str Text
@@ -187,65 +275,96 @@ declare class XPathTransformerContext {
     /**
      * Append property/value pair.
      * @param {string} prop Property name
-     * @param {*} val Value
+     * @param {any} val Value
      * @returns {XPathTransformerContext}
      */
     propValue(prop: string, val: any): XPathTransformerContext;
     /**
      * Append object.
-     * @param {...any} args Object args
+     * @param {Record<string, unknown>|
+     *   ((this: XPathTransformerContext) => void)} objOrCb Object or callback
+     * @param {((this: XPathTransformerContext) => void)|
+     *   any[]} [cbOrUsePropertySets] Callback or property sets
+     * @param {any[]|
+     *   Record<string, unknown>} [usePropertySetsOrPropSets]
+     *   Property sets or props
+     * @param {Record<string, unknown>} [propSets] Additional property sets
      * @returns {XPathTransformerContext}
      */
-    object(...args: any[]): XPathTransformerContext;
+    object(objOrCb: Record<string, unknown> | ((this: XPathTransformerContext) => void), cbOrUsePropertySets?: ((this: XPathTransformerContext) => void) | any[], usePropertySetsOrPropSets?: any[] | Record<string, unknown>, propSets?: Record<string, unknown>): XPathTransformerContext;
     /**
      * Append array.
-     * @param {...any} args Array args
+     * @param {any[]|
+     *   ((this: XPathTransformerContext) => void)} [arrOrCb]
+     *   Array or callback
+     * @param {(this: XPathTransformerContext) => void} [cb] Callback
      * @returns {XPathTransformerContext}
      */
-    array(...args: any[]): XPathTransformerContext;
+    array(arrOrCb?: any[] | ((this: XPathTransformerContext) => void), cb?: (this: XPathTransformerContext) => void): XPathTransformerContext;
+    /**
+     * Append text node content.
+     * @param {import('./StringJoiningTransformer.js').OutputConfig} cfg Text
+     * @returns {XPathTransformerContext}
+     */
+    output(cfg: import("./StringJoiningTransformer.js").OutputConfig): XPathTransformerContext;
     /**
      * Append element.
      * @param {string} name Tag name
-     * @param {object} [atts] Attributes
-     * @param {any[]} [children] Children
-     * @param {Function} [cb] Callback
+     * @param {Record<string, string>|any[]|
+     *   ((this: XPathTransformerContext)=>void)} [atts] Attributes
+     * @param {any[]|((this: XPathTransformerContext)=>void)} [children]
+     *   Children
+     * @param {(this: XPathTransformerContext)=>void} [cb] Callback
      * @returns {XPathTransformerContext}
      */
-    element(name: string, atts?: object, children?: any[], cb?: Function): XPathTransformerContext;
+    element(name: string, atts?: Record<string, string> | any[] | ((this: XPathTransformerContext) => void), children?: any[] | ((this: XPathTransformerContext) => void), cb?: (this: XPathTransformerContext) => void): XPathTransformerContext;
     /**
      * Append attribute.
      * @param {string} name Attribute name
-     * @param {string|object} val Value
+     * @param {string|Record<string, unknown>} val Value
      * @param {boolean} [avoid] Avoid duplicates
      * @returns {XPathTransformerContext}
      */
-    attribute(name: string, val: string | object, avoid?: boolean): XPathTransformerContext;
+    attribute(name: string, val: string | Record<string, unknown>, avoid?: boolean): XPathTransformerContext;
     /**
      * Append text node content.
      * @param {string} txt Text
      * @returns {XPathTransformerContext}
      */
     text(txt: string): XPathTransformerContext;
+    /**
+     * Append a comment.
+     * @param {string} text - Comment text
+     * @returns {XPathTransformerContext}
+     */
+    comment(text: string): XPathTransformerContext;
+    /**
+     * Append a processing instruction.
+     * @param {string} target - Processing instruction target
+     * @param {string} data - Processing instruction data
+     * @returns {XPathTransformerContext}
+     */
+    processingInstruction(target: string, data: string): XPathTransformerContext;
     /**
      * Define a property set (optionally composed from other sets).
      * @param {string} name Property set name
-     * @param {object} obj Base properties
+     * @param {Record<string, unknown>} obj Base properties
      * @param {string[]} [use] Property set names to merge
      * @returns {XPathTransformerContext}
      */
-    propertySet(name: string, obj: object, use?: string[]): XPathTransformerContext;
+    propertySet(name: string, obj: Record<string, unknown>, use?: string[]): XPathTransformerContext;
     /**
      * Merge properties from a named property set into obj.
-     * @param {object} obj Target object
+     * @param {Record<string, unknown>} obj Target object
      * @param {string} name Property set name
-     * @returns {object}
+     * @returns {Record<string, unknown>}
      */
-    _usePropertySets(obj: object, name: string): object;
+    _usePropertySets(obj: Record<string, unknown>, name: string): Record<string, unknown>;
     /**
      * Retrieve a key-mapped node matching a value or return context.
      * @param {string} name Key name
-     * @param {*} value Value to match
-     * @returns {*}
+     * @param {any} value Value to match
+     * @returns {any}
      */
     getKey(name: string, value: any): any;
     /**
@@ -256,5 +375,62 @@ declare class XPathTransformerContext {
      * @returns {XPathTransformerContext}
      */
     key(name: string, match: string, use: string): XPathTransformerContext;
+    /**
+     * Conditionally execute a callback when an XPath evaluates to a truthy
+     * scalar or a non-empty node set (akin to xsl:if semantics).
+     *
+     * Truthiness rules:
+     * - Node set: length > 0 passes.
+     * - Scalar: Boolean(value) must be true.
+     *
+     * @param {string} select XPath expression
+     * @param {(this: XPathTransformerContext)
+     *   => void} cb Callback invoked if condition passes
+     * @returns {XPathTransformerContext}
+     */
+    if(select: string, cb: (this: XPathTransformerContext) => void): XPathTransformerContext;
+    /**
+     * Internal helper: evaluate XPath truthiness like if().
+     * @param {string} select
+     * @returns {boolean}
+     */
+    _passesIf(select: string): boolean;
+    /**
+     * Conditional with optional fallback (like choose/otherwise).
+     * Truthiness same as `if()`.
+     * @param {string} select XPath expression
+     * @param {(this: XPathTransformerContext)
+     *   => void} whenCb Callback when condition passes
+     * @param {(this: XPathTransformerContext)
+     *   => void} [otherwiseCb] Callback when condition fails
+     * @returns {XPathTransformerContext}
+     */
+    choose(select: string, whenCb: (this: XPathTransformerContext) => void, otherwiseCb?: (this: XPathTransformerContext) => void): XPathTransformerContext;
+    /**
+     * Analyze a string with a regular expression, equivalent to
+     * xsl:analyze-string. Processes matching and non-matching substrings
+     * with separate callbacks.
+     * @param {string} str - The string to analyze
+     * @param {string|RegExp} regex - Regular expression to match against
+     * @param {{
+     *   matchingSubstring?: (
+     *     this: XPathTransformerContext,
+     *     substring: string,
+     *     groups: string[],
+     *     regexGroup: (n: number) => string
+     *   ) => void,
+     *   nonMatchingSubstring?: (
+     *     this: XPathTransformerContext,
+     *     substring: string
+     *   ) => void,
+     *   flags?: string
+     * }} options - Options object
+     * @returns {XPathTransformerContext}
+     */
+    analyzeString(str: string, regex: string | RegExp, options?: {
+        matchingSubstring?: (this: XPathTransformerContext, substring: string, groups: string[], regexGroup: (n: number) => string) => void;
+        nonMatchingSubstring?: (this: XPathTransformerContext, substring: string) => void;
+        flags?: string;
+    }): XPathTransformerContext;
 }
 //# sourceMappingURL=XPathTransformerContext.d.ts.map

package/dist/XPathTransformerContext.d.ts.map

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

package/dist/index-browser.d.ts

@@ -0,0 +1,4 @@
+export * from "./index.js";
+export default JTLT;
+import JTLT from './index.js';
+//# sourceMappingURL=index-browser.d.ts.map

package/dist/index-browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-browser.d.ts","sourceRoot":"","sources":["../src/index-browser.js"],"names":[],"mappings":";;iBAA8B,YAAY"}

package/dist/index-node.d.ts

@@ -0,0 +1,4 @@
+export * from "./index.js";
+export default JTLT;
+import JTLT from './index.js';
+//# sourceMappingURL=index-node.d.ts.map

package/dist/index-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-node.d.ts","sourceRoot":"","sources":["../src/index-node.js"],"names":[],"mappings":";;iBAC8B,YAAY"}