@jinntec/fore 2.8.0 → 3.0.1

package/src/xpath-path.js

@@ -30,13 +30,147 @@ export function getDocPath(node) {
  * @param {string} instanceId
  * @returns string
  */
-export function getPath(node, instanceId) {
+/**
+ * @param {Node} node
+ * @param {string} instanceId
+ * @returns string
+ */
+/**
+ * Compute a stable Fore path for a node.
+ *
+ * NOTE:
+ * During bind graph build we often deal with XML nodes that live in a separate XML Document
+ * (instance document). Those nodes are not in the HTML DOM and therefore cannot "see" <fx-instance>
+ * via ancestor traversal, shadow root, or document.querySelector.
+ *
+ * For that reason, getPath MUST be able to compute $default/... without requiring that an
+ * <fx-instance id="default"> element exists in the HTML DOM.
+ *
+ * @param {Node|any} node
+ * @param {string} instanceId
+ * @returns {string}
+ */
+export function getPath(node, instanceId = 'default') {
+  const wantedId = (instanceId ?? 'default').trim() || 'default';
+
+  // JSON lens nodes carry their own path – no need to resolve <fx-instance>
+  if (node && node.__jsonlens__ === true) {
+    return getJsonPath(node);
+  }
+
+  // Try to find the corresponding fx-instance in the current HTML document.
+  // This is useful for sanity checks / detecting JSON instances, but MUST NOT be required
+  // for computing an XML path (especially for the default instance).
+  let instanceEl = null;
+  try {
+    instanceEl = document.querySelector(`fx-instance[id='${wantedId}']`);
+
+    // Many Fore documents use an id-less first instance as the default instance.
+    if (!instanceEl && (wantedId === 'default' || wantedId === '')) {
+      instanceEl =
+        document.querySelector('fx-instance:not([id])') ||
+        document.querySelector("fx-instance[id='default']");
+    }
+  } catch (_e) {
+    // ignore
+  }
+
+  // If we *did* find an instance element and it is JSON, then the caller is using the wrong node type.
+  // (JSON instances are addressed via JSON lens nodes.)
+  if (instanceEl) {
+    const isJson = instanceEl.getAttribute('type') === 'json' || instanceEl.type === 'json';
+    if (isJson) {
+      throw new Error(`getPath: Instance '${wantedId}' is JSON but node is not a JSON lens node.`);
+    }
+  } else {
+    // IMPORTANT BEHAVIOR CHANGE:
+    // - If default instance element can't be found (common for detached XML documents),
+    //   we still compute an XML path. Do NOT throw.
+    // - For non-default ids, keep the old strict behavior.
+    if (wantedId !== 'default') {
+      throw new Error(`Instance with id '${wantedId}' not found.`);
+    }
+  }
+
+  // XML nodes: compute path purely from the XML tree
+  if (node && node.nodeType !== undefined) {
+    return getXmlPath(node, wantedId);
+  }
+
+  throw new Error('Unsupported node type for getPath');
+}
+
+function getXmlPath(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}`;
 }
 
+export function getJsonPath(node) {
+  if (!node || !node.__jsonlens__) {
+    throw new Error('getJsonPath called on non-JSONLens node');
+  }
+
+  const pathSegments = [];
+  let current = node;
+  const instanceId = node.instanceId || 'default';
+
+  while (current && current.parent) {
+    const { keyOrIndex, parent } = current;
+    if (typeof keyOrIndex === 'number') {
+      pathSegments.unshift(`[${keyOrIndex + 1}]`); // XPath is 1-based
+    } else {
+      pathSegments.unshift(`/${keyOrIndex}`);
+    }
+    current = parent;
+  }
+
+  return pathSegments.length > 0 ? `$${instanceId}${pathSegments.join('')}` : `$${instanceId}/`;
+}
+
+/**
+ * Parses a JSON-style binding expression like `?automobiles?1?maker`
+ * into a list of steps: ['automobiles', 0, 'maker']
+ *
+ * @param {string} ref
+ * @returns {Array<string|number>}
+ */
+// returns null if it's not a JSON-lens style ref
+// otherwise returns { instanceId: string, steps: Array<string|number> }
+export function parseJsonRef(ref, defaultInstanceId = 'default') {
+  if (!ref) return null;
+
+  const s = String(ref).trim();
+
+  // Optional leading instance('id') / instance("id")
+  const instMatch = s.match(/^instance\s*\(\s*(['"])(.*?)\1\s*\)\s*(\?.*)?$/);
+
+  let instanceId;
+  let lensPart;
+
+  if (instMatch) {
+    instanceId = instMatch[2];
+    lensPart = instMatch[3] || '';
+  } else {
+    // No instance(...): must be a lens ref starting with '?'
+    if (!s.startsWith('?')) return null;
+    instanceId = defaultInstanceId;
+    lensPart = s;
+  }
+
+  const steps = lensPart
+    .split('?')
+    .filter(Boolean)
+    .map(part => {
+      if (part === '*') return '*';
+      if (/^\d+$/.test(part)) return Number(part) - 1; // 1-based -> 0-based
+      return part;
+    });
+
+  return { instanceId, steps };
+}
+
 /**
  * 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.
@@ -45,35 +179,151 @@ export function getPath(node, instanceId) {
  * @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;
+  const s = String(expr ?? '').trim();
+  if (s === '') return false;
+
+  const isLiteral = token => {
+    const t = token.trim();
+    // string literal or number literal
+    return /^(['"]).*\1$/.test(t) || /^-?\d+(\.\d+)?$/.test(t);
+  };
+
+  const splitArgsTopLevel = argsStr => {
+    const args = [];
+    let cur = '';
+    let depth = 0;
+    let quote = null;
+
+    for (let i = 0; i < argsStr.length; i++) {
+      const ch = argsStr[i];
+
+      if (quote) {
+        cur += ch;
+        if (ch === quote) quote = null;
+        continue;
+      }
+
+      if (ch === '"' || ch === "'") {
+        quote = ch;
+        cur += ch;
+        continue;
+      }
+
+      if (ch === '(') {
+        depth++;
+        cur += ch;
+        continue;
+      }
+      if (ch === ')') {
+        depth = Math.max(0, depth - 1);
+        cur += ch;
+        continue;
+      }
+
+      if (ch === ',' && depth === 0) {
+        args.push(cur.trim());
+        cur = '';
+        continue;
+      }
+
+      cur += ch;
+    }
+
+    if (cur.trim() !== '') args.push(cur.trim());
+    return args;
+  };
+
+  // 1) variables and predicates => dynamic
+  {
+    let quote = null;
+    for (let i = 0; i < s.length; i++) {
+      const ch = s[i];
+      if (quote) {
+        if (ch === quote) quote = null;
+        continue;
       }
+      if (ch === '"' || ch === "'") {
+        quote = ch;
+        continue;
+      }
+      if (ch === '$') return true;
+      if (ch === '[') return true;
+    }
+  }
+
+  // 2) function calls
+  // Only treat a small set of known pure string functions as static when all args are literals.
+  const staticIfLiteral = new Set(['concat', 'string-length']);
+
+  let quote = null;
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+
+    if (quote) {
+      if (ch === quote) quote = null;
+      continue;
     }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+
+    if (ch !== '(') continue;
+
+    // find function name just before '('
+    let j = i - 1;
+    while (j >= 0 && /\s/.test(s[j])) j--;
+
+    const end = j;
+    while (j >= 0 && /[\w:-]/.test(s[j])) j--;
+
+    const fnName = s.slice(j + 1, end + 1);
+    if (!fnName) continue;
 
-    // 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;
+    // parse argument substring until matching ')'
+    let k = i + 1;
+    let depth = 1;
+    let q2 = null;
+
+    while (k < s.length && depth > 0) {
+      const c = s[k];
+      if (q2) {
+        if (c === q2) q2 = null;
+        k++;
+        continue;
+      }
+      if (c === '"' || c === "'") {
+        q2 = c;
+        k++;
+        continue;
       }
+      if (c === '(') depth++;
+      else if (c === ')') depth--;
+      k++;
+    }
+
+    const argsStr = s.slice(i + 1, k - 1);
+    const fnLower = fnName.toLowerCase();
+
+    // Anything not explicitly “static-if-literal” is dynamic (matches your tests for myfunc(), instance(), index(), etc.)
+    if (!staticIfLiteral.has(fnLower)) return true;
+
+    const args = splitArgsTopLevel(argsStr);
+
+    // concat("a","b") is static; concat(foo,"b") is dynamic
+    if (fnLower === 'concat') {
+      return !args.every(isLiteral);
     }
 
-    return false;
-  } catch {
+    // string-length("x") is static; string-length(foo) is dynamic
+    if (fnLower === 'string-length') {
+      return !(args.length === 1 && isLiteral(args[0]));
+    }
+
+    // fallback: be safe
     return true;
   }
+
+  // If none of the dynamic markers matched, it's static
+  return false;
 }

package/src/xpath-util.js

@@ -23,9 +23,7 @@ export class XPathUtil {
           for (const item of astNode[key]) {
             if (XPathUtil.containsDynamicContent(item)) return true;
           }
-        } else {
-          if (XPathUtil.containsDynamicContent(astNode[key])) return true;
-        }
+        } else if (XPathUtil.containsDynamicContent(astNode[key])) return true;
       }
     }
 
@@ -247,22 +245,30 @@ export class XPathUtil {
    * @returns {*|null}
    */
   static getParentBindingElement(start) {
-    /*    if (start.parentNode.host) {
-          const { host } = start.parentNode;
-          if (host.hasAttribute('ref')) {
-            return host;
-          }
-        } else */
-    if (
-      start.parentNode &&
-      (start.parentNode.nodeType !== Node.DOCUMENT_NODE ||
-        start.parentNode.nodeType !== Node.DOCUMENT_FRAGMENT_NODE)
+    // JSON lens case
+    if (start && start.__jsonlens__ === true) {
+      let current = start.parent;
+      while (current) {
+        if (current.bindingElement) return current.bindingElement;
+        current = current.parent;
+      }
+      return null;
+    }
+
+    // DOM case
+    let node = start?.parentNode;
+
+    while (
+      node &&
+      node.nodeType !== Node.DOCUMENT_NODE &&
+      node.nodeType !== Node.DOCUMENT_FRAGMENT_NODE
     ) {
-      return this.getClosest(
-        'fx-control[ref],fx-upload[ref],fx-group[ref],fx-repeat[ref], fx-switch[ref],fx-repeatitem',
-        start.parentNode,
-      );
+      if (node.matches?.('[ref],fx-repeatitem')) {
+        return node;
+      }
+      node = node.parentNode;
     }
+
     return null;
   }
 
@@ -275,7 +281,7 @@ export class XPathUtil {
    */
   static isAbsolutePath(path) {
     return (
-      path != null && (path.startsWith('/') || path.startsWith('instance(') || path.startsWith('$'))
+      path != null && (path.startsWith('/') || path.startsWith('instance(') || path.startsWith('$') || path.startsWith('?'))
     );
   }
 
@@ -297,34 +303,86 @@ export class XPathUtil {
    * @returns {string}
    */
   static getInstanceId(ref, boundElement) {
-    if (!ref) {
-      return 'default';
+    const refStr = typeof ref === 'string' ? ref.trim() : '';
+
+    // Variant A: instance-vars ($default, $foo) must count as instance references
+    // for dependency tracking, otherwise repeats won't refresh when they change.
+    try {
+      const host =
+          boundElement?.nodeType === Node.ATTRIBUTE_NODE ? boundElement.ownerElement : boundElement;
+      const fore = host?.closest?.('fx-fore');
+      const bindings = fore?._instanceVarBindings;
+
+      if (bindings) {
+        // $default => default instance
+        if (/\$default(?![\w.-])/.test(refStr)) return 'default';
+
+        // $<id> => instance <id> (only if it's a known binding key)
+        for (const k of Object.keys(bindings)) {
+          if (k === 'default') continue;
+          const re = new RegExp(
+              `\\$${k.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')}(?![\\w.-])`,
+          );
+          if (re.test(refStr)) return k;
+        }
+      }
+    } catch (_e) {
+      // ignore
     }
-    if (ref.startsWith('instance()')) {
+
+    // Explicit "default instance" selector
+    if (refStr.startsWith('instance()')) {
       return 'default';
     }
-    if (ref.startsWith('instance(')) {
-      const result = ref.substring(ref.indexOf('(') + 1);
-      return result.substring(1, result.indexOf(')') - 1);
+
+    // Explicit instance('id') selector at the START of the expression only
+    // (Do NOT use refStr.includes('instance(') because predicates may reference other instances.)
+    {
+      const m = refStr.match(/^instance\(\s*(['"])(?<id>.*?)\1\s*\)/);
+      if (m?.groups?.id != null) {
+        return m.groups.id;
+      }
     }
-    if (ref.startsWith('$')) {
-      // this variable might actually point to an instance
-      const variableName = ref.match(/\$(?<variableName>[a-zA-Z0-9\-\_]+).*/)?.groups?.variableName;
+
+    // Variable indirection (may ultimately point to instance(...))
+    if (refStr.startsWith('$')) {
+      const variableName = refStr.match(/^\$(?<variableName>[a-zA-Z0-9\-_]+)/)?.groups
+          ?.variableName;
+
       let closestActualFormElement = boundElement;
       while (closestActualFormElement && !('inScopeVariables' in closestActualFormElement)) {
         closestActualFormElement =
-          closestActualFormElement.nodeType === Node.ATTRIBUTE_NODE
-            ? closestActualFormElement.ownerElement
-            : closestActualFormElement.parentNode;
+            closestActualFormElement.nodeType === Node.ATTRIBUTE_NODE
+                ? closestActualFormElement.ownerElement
+                : closestActualFormElement.parentNode;
       }
 
       const correspondingVariable = closestActualFormElement?.inScopeVariables?.get(variableName);
-      if (!correspondingVariable) {
-        return null;
-      }
+      if (!correspondingVariable) return null;
+
       return this.getInstanceId(correspondingVariable.valueQuery, correspondingVariable);
     }
-    return null;
+
+    // If we can't decide from the ref itself (relative paths, '/', '.', missing ref, fx-repeatitem),
+    // inherit from the nearest ancestor that *does* have a ref or explicit instance().
+    const parentBinding = XPathUtil.getParentBindingElement(boundElement);
+    if (parentBinding) {
+      // If this is a repeatitem boundary with no ref, keep climbing
+      if (parentBinding.matches?.('fx-repeatitem') && !parentBinding.getAttribute?.('ref')) {
+        return this.getInstanceId(null, parentBinding);
+      }
+
+      const parentRef = parentBinding.getAttribute?.('ref');
+      if (parentRef) {
+        return this.getInstanceId(parentRef, parentBinding);
+      }
+
+      // Parent binding exists but has no ref (rare, but safe): keep climbing
+      return this.getInstanceId(null, parentBinding);
+    }
+
+    // No parent binding => top of scope. If ref wasn't explicit, default.
+    return 'default';
   }
 
   /**
@@ -361,18 +419,6 @@ export class XPathUtil {
   }
 */
 
-  /**
-   * @param {Node} node
-   * @param {string} instanceId
-   * @returns string
-   */
-  static getPath(node, instanceId) {
-    const path = fx.evaluateXPathToString('path()', node);
-    // Path is like `$default/x[1]/y[1]`
-    const shortened = XPathUtil.shortenPath(path);
-    return shortened.startsWith('/') ? `$${instanceId}${shortened}` : `$${instanceId}/${shortened}`;
-  }
-
   /**
    * @param {string} path
    * @returns string