@jinntec/fore 2.5.0 → 2.7.0

package/src/xpath-path.js

@@ -0,0 +1,79 @@
+import * as fx from 'fontoxpath';
+import { evaluateXPathToString } from './xpath-evaluation.js';
+
+/**
+ * @param {string} path
+ * @returns string
+ */
+function shortenPath(path) {
+  const tmp = path.replaceAll(/(Q{(.*?)\})/g, '');
+  if (tmp === 'root()') return tmp;
+  // cut off leading slash
+  const tmp1 = tmp.substring(1, tmp.length);
+  // ### cut-off root node ref
+  return tmp1.substring(tmp1.indexOf('/'), tmp.length);
+}
+
+/**
+ * @param {Node} node
+ * @returns string
+ */
+export function getDocPath(node) {
+  const path = fx.evaluateXPathToString('path()', node);
+  // Path is like `$default/x[1]/y[1]`
+  const shortened = shortenPath(path);
+  return shortened.startsWith('/') ? `${shortened}` : `/${shortened}`;
+}
+
+/**
+ * @param {Node} node
+ * @param {string} instanceId
+ * @returns string
+ */
+export function getPath(node, instanceId) {
+  const path = fx.evaluateXPathToString('path()', node);
+  // Path is like `$default/x[1]/y[1]`
+  const shortened = shortenPath(path);
+  return shortened.startsWith('/') ? `$${instanceId}${shortened}` : `$${instanceId}/${shortened}`;
+}
+
+/**
+ * Checks if a template expression is dynamic, i.e. refers to data (via XPath) or functions.
+ * Used to determine whether to set up data observers or evaluate on every refresh.
+ *
+ * @param {string} expr - The raw XPath expression (from inside `{}`)
+ * @returns {boolean} - True if the expression is dynamic (data/function dependent)
+ */
+export function isDynamic(expr) {
+  try {
+    const result = evaluateXPathToString(expr, document, null);
+
+    // 1. Check for function calls with non-literal arguments
+    const functionCallPattern = /\b([\w-]+)\s*\(\s*([^)]+)\)/g;
+    let match;
+    while ((match = functionCallPattern.exec(expr)) !== null) {
+      const arg = match[2].trim();
+      if (!/^(['"]).*\1$/.test(arg) && isNaN(arg)) {
+        return true;
+      }
+    }
+
+    // 2. Check for variable references
+    if (expr.includes('$')) return true;
+
+    // 3. Check for unquoted predicates
+    let inQuote = false;
+    for (let i = 0; i < expr.length; i++) {
+      const char = expr[i];
+      if (char === '"' || char === "'") {
+        inQuote = inQuote === char ? false : char;
+      } else if (!inQuote && char === '[') {
+        return true;
+      }
+    }
+
+    return false;
+  } catch {
+    return true;
+  }
+}

package/src/xpath-util.js

@@ -1,6 +1,38 @@
 import * as fx from 'fontoxpath';
+import { createNamespaceResolver } from './xpath-evaluation';
 
 export class XPathUtil {
+  /**
+   * Recursively check AST for any dynamic expression components.
+   */
+  static containsDynamicContent(astNode) {
+    if (!astNode) return false;
+
+    // Location paths, function calls, or variable refs are dynamic
+    if (
+      astNode.type === 'pathExpression' ||
+      astNode.type === 'functionCall' ||
+      astNode.type === 'variableReference'
+    ) {
+      return true;
+    }
+
+    // Recursively check any child expressions
+    for (const key in astNode) {
+      if (astNode[key] && typeof astNode[key] === 'object') {
+        if (Array.isArray(astNode[key])) {
+          for (const item of astNode[key]) {
+            if (XPathUtil.containsDynamicContent(item)) return true;
+          }
+        } else {
+          if (XPathUtil.containsDynamicContent(astNode[key])) return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
   /**
    * creates DOM Nodes from an XPath locationpath expression. Support namespaced and un-namespaced
    * nodes.
@@ -10,48 +42,106 @@ export class XPathUtil {
    * supports multiple steps
    *
    * @param xpath
-   * @param doc
+   * @param doc {XMLDocument}
    * @param fore
-   * @return {*}
+   * @return {Node|Attr}
    */
-  static createElementFromXPath(xpath, doc, fore) {
+  static createNodesFromXPath(xpath, doc, fore) {
+    const resolveNamespace = createNamespaceResolver(xpath, fore);
+
     if (!doc) {
       doc = document.implementation.createDocument(null, null, null); // Create a new XML document if not provided
     }
 
-    const parts = xpath.split('/');
+    const parts = [];
+    let scratch = '';
+    let isInPredicate = false;
+    for (const char of xpath.split('')) {
+      if (!isInPredicate) {
+        // We are not in a predicate, the slash will terminate our step.
+        if (char === '/') {
+          parts.push(scratch);
+          scratch = '';
+          continue;
+        }
+
+        scratch += char;
+        if (char === '[') {
+          isInPredicate = true;
+        }
+        continue;
+      }
+      // We are in a predicate! So the only interesting token is ']', which means we're out of one.
+      scratch += char;
+
+      if (char === ']') {
+        isInPredicate = false;
+      }
+    }
+    // Flush the last step
+    parts.push(scratch);
+
     let rootNode = null;
     let currentNode = null;
 
     for (const part of parts) {
       if (!part) continue; // Skip empty parts (e.g., leading slashes)
+      if (part === '.') {
+        // A '.' does not introduce new elements
+        continue;
+      }
 
       // Handle attributes
       if (part.startsWith('@')) {
         const attrName = part.slice(1); // Strip '@'
         if (!currentNode) {
-          throw new Error('Cannot create an attribute without a parent element.');
+          return doc.createAttribute(attrName, '');
         }
         currentNode.setAttribute(attrName, '');
       } else {
+        // We are a predicate selector! Handle it
+        // This regex matches strings like:
+        // - listBibl
+        // - tei:listBibl
+        // - listBibl[@type="foo"]
+        // - listBibl[@type="foo"][@class="bar"]
+        // It will also match strings like
+        // - listBibl[ancestor-or-self::foo]
+        // which will be filtered out later.
+
+        const result = part.match(/^(?<name>[\w:-]+)(?<predicates>(\[[^]*\])*)$/);
+        if (!result) {
+          throw new Error(
+            `No element could be made from the XPath step ${part}. It must be of these forms: 'localName', 'prefix:name', 'name[@attr="value"]' et cetera.`,
+          );
+        }
+        const { name, predicates } = result.groups;
         // Handle namespaces if present
-        const [prefix, localName] = part.includes(':') ? part.split(':') : [null, part];
-        const namespace = prefix ? XPathUtil.lookupNamespace(fore, prefix) : null;
+        const [prefix, localName] = name.includes(':') ? name.split(':') : [null, name];
+        const namespace = resolveNamespace(prefix);
 
         const newElement = namespace
-          ? doc.createElementNS(namespace, part)
+          ? doc.createElementNS(namespace, localName)
           : doc.createElement(localName);
 
+        if (predicates) {
+          const predicateExtractionRegex =
+            /(\[@(?<name>[\w:-]*)\s?=\s?["'](?<value>[^"']*)['"]\])+/g;
+          const parsedPredicates = predicates
+            .matchAll(predicateExtractionRegex)
+            .map(match => ({ attrName: match.groups.name, value: match.groups.value }));
+          for (const { attrName, value } of parsedPredicates) {
+            newElement.setAttribute(attrName, value);
+          }
+        }
         if (!rootNode) {
           rootNode = newElement; // Set as the root node
         } else {
           currentNode.appendChild(newElement);
         }
-
         currentNode = newElement;
       }
     }
-
     if (!rootNode) {
       throw new Error('Invalid XPath; no root element could be created.');
     }
@@ -168,7 +258,10 @@ export class XPathUtil {
       (start.parentNode.nodeType !== Node.DOCUMENT_NODE ||
         start.parentNode.nodeType !== Node.DOCUMENT_FRAGMENT_NODE)
     ) {
-      return this.getClosest('[ref],fx-repeatitem', start.parentNode);
+      return this.getClosest(
+        'fx-control[ref],fx-upload[ref],fx-group[ref],fx-repeat[ref], fx-switch[ref],fx-repeatitem',
+        start.parentNode,
+      );
     }
     return null;
   }
@@ -259,12 +352,14 @@ export class XPathUtil {
    * @param {Node} node
    * @returns string
    */
+  /*
   static getDocPath(node) {
     const path = fx.evaluateXPathToString('path()', node);
     // Path is like `$default/x[1]/y[1]`
     const shortened = XPathUtil.shortenPath(path);
     return shortened.startsWith('/') ? `${shortened}` : `/${shortened}`;
   }
+*/
 
   /**
    * @param {Node} node
@@ -284,6 +379,7 @@ export class XPathUtil {
    */
   static shortenPath(path) {
     const tmp = path.replaceAll(/(Q{(.*?)\})/g, '');
+    if (tmp === 'root()') return tmp;
     // cut off leading slash
     const tmp1 = tmp.substring(1, tmp.length);
     // ### cut-off root node ref