jtlt 0.3.0 → 0.4.0

package/src/XPathTransformerContext.js

@@ -1,10 +1,12 @@
 import xpath2 from 'xpath2.js'; // Runtime JS import; ambient types declared
-// xpathVersion: 1 => browser/native XPathEvaluator API; 2 => xpath2.js
+// eslint-disable-next-line @stylistic/max-len -- Long
+// xpathVersion: 1 => browser/native XPathEvaluator API; 2 => xpath2.js, 3 => fontoxpath
+import fontoxpath from 'fontoxpath';
 
 /**
  * @typedef {object} XPathTransformerContextConfig
  * @property {unknown} [data] - XML/DOM root to transform
- * @property {number} [xpathVersion] - 1 or 2 (default 1)
+ * @property {number} [xpathVersion] - 1, 2, 3.1 (default 1)
  * @property {import('./index.js').
  *   JoiningTransformer} joiningTransformer Joiner
  * @property {boolean} [errorOnEqualPriority]
@@ -15,13 +17,13 @@ import xpath2 from 'xpath2.js'; // Runtime JS import; ambient types declared
  * 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).
  */
 class XPathTransformerContext {
@@ -69,7 +71,7 @@ class XPathTransformerContext {
     if (!expr) {
       return this._contextNode;
     }
-    const version = this._config.xpathVersion === 2 ? 2 : 1;
+    const version = this._config.xpathVersion ?? 1;
     if (version === 1) {
       // Use native XPath (browser-like); rely on DOM doc if available.
       const doc = this._contextNode && this._contextNode.ownerDocument
@@ -141,8 +143,25 @@ class XPathTransformerContext {
       /* c8 ignore stop */
       }
     }
-    // Version 2: xpath2.js
-    const result = xpath2.evaluate(expr, this._contextNode);
+    if (version === 2) {
+      // Version 2: xpath2.js
+      const result = xpath2.evaluate(expr, this._contextNode);
+      if (asNodes) {
+        // eslint-disable-next-line @stylistic/max-len -- Long
+        /* c8 ignore next -- array wrap/identity branch counted in other tests */
+        return Array.isArray(result) ? result : [result];
+      }
+      /* c8 ignore next -- scalar return trivial; wrap behavior tested */
+      return result;
+    }
+
+    // eslint-disable-next-line @stylistic/max-len -- Long
+    // eslint-disable-next-line import/no-named-as-default-member -- Only as default
+    const result = fontoxpath.evaluateXPath(
+      expr, this._contextNode, undefined, undefined,
+      // Non-deprecated, predictable all results
+      14 // ReturnType.ALL_RESULTS
+    );
     if (asNodes) {
       /* c8 ignore next -- array wrap/identity branch counted in other tests */
       return Array.isArray(result) ? result : [result];
@@ -523,14 +542,309 @@ class XPathTransformerContext {
     return this;
   }
   /**
-   * 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) {
-    this._getJoiningTransformer().number(num);
+    // Handle xsl:number-like functionality
+    if (typeof num === 'object' && num !== null) {
+      const opts = num;
+      let {value} = opts;
+
+      // Handle position() calculation
+      if (value === 'position()' || value === undefined) {
+        const {count} = opts;
+        const level = opts.level || 'single';
+        const {from} = opts;
+
+        switch (level) {
+        case 'single': {
+          value = this._calculatePosition(count, from);
+
+          break;
+        }
+        case 'multiple': {
+          // Hierarchical numbering: get position for each ancestor up to root
+          const positions = [];
+          let node = /** @type {any} */ (this._config).currentNode;
+          while (node) {
+            positions.unshift(this._calculatePosition(count, undefined));
+            node = node.parentNode;
+            if (from) {
+              const fromResult = /** @type {any} */ (
+                this._evalXPath(from, node)
+              );
+              if (fromResult && fromResult.length > 0) {
+                break;
+              }
+            }
+          }
+          value = positions.join('.');
+
+          break;
+        }
+        case 'any': {
+          value = this._calculatePositionAny(count, from);
+
+          break;
+        }
+        // No default
+        }
+      }
+
+      // Determine format string and locale
+      let format = opts.format || '1';
+      // @ts-expect-error: dynamic property access
+      const locale = opts.lang || 'en';
+      // @ts-expect-error: dynamic property access
+      const {letterValue} = opts;
+
+      // If letterValue is 'alphabetic', force alphabetic format
+      if (letterValue === 'alphabetic') {
+        format = (opts.format && (/^[aA]$/v).test(opts.format)) ? opts.format : 'a';
+      }
+
+      const numValue = typeof value === 'string' ? Number(value) : (value || 1);
+      const formatted = this._formatNumber(
+        numValue,
+        format,
+        opts.groupingSeparator,
+        opts.groupingSize,
+        locale
+      );
+      this._getJoiningTransformer().plainText(formatted);
+    } else if (num === 'position()') {
+      // Simple position() call
+      const pos = this._calculatePosition();
+      this._getJoiningTransformer().number(pos);
+    } else {
+      // Simple number
+      this._getJoiningTransformer().number(
+        typeof num === 'string' ? Number(num) : num
+      );
+    }
     return this;
   }
+
+  /**
+   * Calculate position of current node.
+   * @param {string} [count] - XPath pattern to match
+   * @param {string} [from] - XPath pattern for ancestor
+   * @returns {number}
+   * @private
+   */
+  _calculatePosition (count, from) {
+    // eslint-disable-next-line prefer-destructuring -- TS
+    const currentNode = /** @type {any} */ (this._config).currentNode;
+    if (!currentNode) {
+      return 1;
+    }
+
+    // Get parent node
+    const parent = currentNode.parentNode;
+    if (!parent) {
+      return 1;
+    }
+
+    // If from pattern specified, find that ancestor
+    let startNode = parent;
+    if (from) {
+      const fromResult = /** @type {any} */ (
+        this._evalXPath(from, currentNode)
+      );
+      if (fromResult && fromResult.length > 0) {
+        startNode = fromResult[0];
+      }
+    }
+
+    // Count preceding siblings
+    let position = 1;
+    let sibling = currentNode.previousSibling;
+
+    while (sibling) {
+      if (count) {
+        // Check if sibling matches count pattern
+        const matches = /** @type {any} */ (this._evalXPath(count, sibling));
+        if (matches && matches.length > 0) {
+          position++;
+        }
+      } else if (sibling.nodeType === currentNode.nodeType &&
+        (!currentNode.nodeName || sibling.nodeName === currentNode.nodeName)) {
+        position++;
+      }
+      sibling = sibling.previousSibling;
+    }
+
+    return position;
+  }
+
+  /**
+   * Calculate position counting all ancestors (level=any).
+   * @param {string} [count] - XPath pattern to match
+   * @param {string} [from] - XPath pattern for ancestor
+   * @returns {number}
+   * @private
+   */
+  _calculatePositionAny (count, from) {
+    // eslint-disable-next-line prefer-destructuring -- TS
+    const currentNode = /** @type {any} */ (this._config).currentNode;
+    if (!currentNode) {
+      return 1;
+    }
+
+    // Find root or 'from' node
+    let root = currentNode.ownerDocument || currentNode;
+    if (from) {
+      const fromResult = /** @type {any} */ (
+        this._evalXPath(from, currentNode)
+      );
+      if (fromResult && fromResult.length > 0) {
+        root = fromResult[0];
+      }
+    }
+
+    // Count all matching nodes in document order up to current
+    const pattern = count || 'node()';
+    const allNodes = /** @type {any[]} */ (
+      this._evalXPath('//' + pattern, root)
+    );
+
+    for (const [i, allNode] of allNodes.entries()) {
+      if (allNode === currentNode) {
+        return i + 1;
+      }
+    }
+
+    return 1;
+  }
+
+  /**
+   * 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
+   */
+  _formatNumber (num, format, groupingSeparator, groupingSize, locale = 'en') {
+    if (Number.isNaN(num)) {
+      return String(num);
+    }
+
+    let result;
+    const formatChar = format.charAt(0);
+
+    switch (formatChar) {
+    case 'i': {
+      result = this._toRoman(num).toLowerCase();
+
+      break;
+    }
+    case 'I': {
+      result = this._toRoman(num);
+
+      break;
+    }
+    case 'a': {
+      result = this._toAlphabetic(num, false);
+
+      break;
+    }
+    case 'A': {
+      result = this._toAlphabetic(num, true);
+
+      break;
+    }
+    case '0': {
+      const width = format.length;
+      result = String(num).padStart(width, '0');
+
+      break;
+    }
+    default: {
+      // Use Intl.NumberFormat for decimal formatting if grouping/locale
+      //   options are provided
+      let options = {};
+      if (groupingSeparator || groupingSize) {
+        options = {
+          useGrouping: true
+        };
+      }
+      try {
+        result = new Intl.NumberFormat(locale, options).format(num);
+        if (groupingSeparator) {
+          result = result.replaceAll(',', groupingSeparator);
+        }
+      } catch (e) {
+        result = String(num);
+      }
+    }
+    }
+    return result;
+  }
+
+  /**
+   * Convert number to Roman numerals.
+   * @param {number} num - Number to convert (1-3999)
+   * @returns {string}
+   * @private
+   */
+  // eslint-disable-next-line class-methods-use-this -- Avoid for now
+  _toRoman (num) {
+    if (num < 1 || num > 3999) {
+      return String(num);
+    }
+
+    const vals = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1];
+    const syms = [
+      'M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', 'I'
+    ];
+
+    let result = '';
+    for (const [i, val] of vals.entries()) {
+      while (num >= val) {
+        result += syms[i];
+        num -= val;
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Convert number to alphabetic sequence.
+   * @param {number} num - Number to convert
+   * @param {boolean} uppercase - Use uppercase letters
+   * @returns {string}
+   * @private
+   */
+  // eslint-disable-next-line class-methods-use-this -- Avoid for now
+  _toAlphabetic (num, uppercase) {
+    if (num < 1) {
+      return String(num);
+    }
+
+    let result = '';
+    const base = uppercase ? 65 : 97; // 'A' or 'a'
+
+    while (num > 0) {
+      num--; // Make 0-indexed
+      result = String.fromCodePoint(base + (num % 26)) + result;
+      num = Math.floor(num / 26);
+    }
+
+    return result;
+  }
   /**
    * Append plain text (no escaping changes).
    * @param {string} str Text
@@ -824,6 +1138,143 @@ class XPathTransformerContext {
     return this;
   }
 
+  /**
+   * 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, regex, options = {}) {
+    // Ensure we have a string
+    const inputString = String(str || '');
+
+    // If empty string, do nothing
+    if (inputString.length === 0) {
+      return this;
+    }
+
+    const {
+      matchingSubstring,
+      nonMatchingSubstring,
+      flags = ''
+    } = options;
+
+    // Convert regex to RegExp if it's a string
+    let regexObj;
+    if (typeof regex === 'string') {
+      // Ensure 'g' flag is present for global matching
+      const actualFlags = flags.includes('g') ? flags : flags + 'g';
+      regexObj = new RegExp(regex, actualFlags);
+    } else {
+      regexObj = regex;
+      // Ensure global flag is set
+      if (!regexObj.global) {
+        regexObj = new RegExp(
+          regexObj.source,
+          regexObj.flags + 'g'
+        );
+      }
+    }
+
+    // Check for zero-length matches (error condition in XSLT)
+    if (regexObj.test('')) {
+      throw new Error(
+        'Regular expression matches zero-length string'
+      );
+    }
+
+    // Store captured groups for access during callback
+    /** @type {string[] | undefined} */
+    let currentCapturedGroups;
+
+    /**
+     * Get captured group by index.
+     * @param {number} groupNumber - Group index
+     * @returns {string} - Captured group or empty string
+     */
+    const getRegexGroup = (groupNumber) => {
+      if (!currentCapturedGroups ||
+          groupNumber < 0 ||
+          groupNumber >= currentCapturedGroups.length) {
+        return '';
+      }
+      return currentCapturedGroups[groupNumber] || '';
+    };
+
+    // Save previous context to restore later
+    const prevContext = this._contextNode;
+
+    let lastIndex = 0;
+    let match;
+
+    // Bind callbacks to this context
+    const boundMatchingSubstring = matchingSubstring
+      ? matchingSubstring.bind(this)
+      : undefined;
+    const boundNonMatchingSubstring = nonMatchingSubstring
+      ? nonMatchingSubstring.bind(this)
+      : undefined;
+
+    // Find all matches
+    while ((match = regexObj.exec(inputString)) !== null) {
+      // Process non-matching substring before this match
+      if (match.index > lastIndex) {
+        const nonMatchingStr = inputString.slice(lastIndex, match.index);
+        if (boundNonMatchingSubstring) {
+          boundNonMatchingSubstring(nonMatchingStr);
+        }
+      }
+
+      // Process matching substring
+      if (boundMatchingSubstring) {
+        const matchingStr = match[0];
+        // Store captured groups: [full match, group1, group2, ...]
+        currentCapturedGroups = [...match];
+        boundMatchingSubstring(
+          matchingStr, currentCapturedGroups, getRegexGroup
+        );
+        currentCapturedGroups = undefined;
+      }
+
+      const {lastIndex: newLastIndex} = regexObj;
+      lastIndex = newLastIndex;
+
+      // Prevent infinite loop on zero-length matches (shouldn't happen
+      // due to earlier check, but defensive)
+      if (match.index === regexObj.lastIndex) {
+        regexObj.lastIndex++;
+      }
+    }
+
+    // Process final non-matching substring
+    if (lastIndex < inputString.length) {
+      const nonMatchingStr = inputString.slice(lastIndex);
+      if (boundNonMatchingSubstring) {
+        boundNonMatchingSubstring(nonMatchingStr);
+      }
+    }
+
+    // Restore previous context
+    this._contextNode = prevContext;
+
+    return this;
+  }
+
   /* c8 ignore start -- static default rules object has spotty function
    * attribution under coverage; behavior is exercised via applyTemplates */
   static DefaultTemplateRules = {

package/src/index.js

@@ -175,8 +175,8 @@ export const setWindow = (win) => {
  *     import('./JSONPathTransformerContext.js').default
  *   >],
  *   engineType: 'xpath',
- *   xpathVersion?: 1|2,
- *   outputType?: 'string'|'dom'|'json'
+ *   xpathVersion?: 1|2|3.1,
+ *   outputType?: T
  * }} XPathJTLTOptions
  */
 
@@ -390,10 +390,13 @@ class JTLT {
             : null
       );
     this.config.templates = query
-      // eslint-disable-next-line @stylistic/max-len -- Long
-      ? /** @type {JSONPathTemplateObject<joiningTypes>[]|XPathTemplateObject<joiningTypes>[]} */ ([
-        {name: 'root', path: '$', template: query}
-      ])
+      ? this.config.engineType === 'xpath'
+        ? /** @type {XPathTemplateObject<joiningTypes>[]} */ ([
+          {name: 'root', path: '//*', template: query}
+        ])
+        : /** @type {JSONPathTemplateObject<joiningTypes>[]} */ ([
+          {name: 'root', path: '$', template: query}
+        ])
       // eslint-disable-next-line @stylistic/max-len -- Long
       : /** @type {JSONPathTemplateObject<joiningTypes>[]|XPathTemplateObject<joiningTypes>[]} */ (
         cfg.templates || [cfg.template]

package/tsconfig.json

@@ -9,6 +9,9 @@
     "noEmit": true,
     "strict": true
   },
-  "include": ["*.js", "*.d.ts", "src/**/*.js", "test/*.js", "typings/xpath2-js.d.ts"],
-  "exclude": ["node_modules", "./dist/**/*.js"]
+  "include": [
+    "*.js", "*.d.ts", "src/**/*.js", "demo/**/*.js", "test/**/*.js",
+    "typings/xpath2-js.d.ts"
+  ],
+  "exclude": ["node_modules", "./dist/**/*.js", "demo/codemirror.esm.js", "demo/vendor"]
 }