@jinntec/fore 2.9.0 → 3.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jinntec/fore",
-  "version": "2.9.0",
+  "version": "3.0.1",
   "description": "Fore - declarative user interfaces in plain HTML",
   "module": "./index.js",
   "publishConfig": {
@@ -37,6 +37,8 @@
   },
   "devDependencies": {
     "@babel/plugin-proposal-class-properties": "^7.17.12",
+    "@babel/plugin-proposal-private-methods": "^7.18.6",
+    "@babel/plugin-transform-private-methods": "^7.28.6",
     "@jinntec/jinn-codemirror": "^1.17.6",
     "@open-wc/building-rollup": "^2.0.1",
     "@open-wc/eslint-config": "^7.0.0",

package/src/DependentXPathQueries.js

@@ -21,7 +21,7 @@ export default class DependentXPathQueries {
       }
     }
 
-    // We can also depend on the index function if it was used in our ancestry
+    // We can also depend on the index functioxn if it was used in our ancestry
     return !!this._parentDependencies?.isInvalidatedByIndexFunction();
   }
 
@@ -57,13 +57,48 @@ export default class DependentXPathQueries {
     return !!this._parentDependencies?.isInvalidatedByChildlistChanges(affectedLocalNames);
   }
 
+  /**
+   * Add an XPath to the dependencies
+   *
+   * @param {string} xpath the XPath to add
+   */
   /**
    * Add an XPath to the dependencies
    *
    * @param {string} xpath the XPath to add
    */
   addXPath(xpath) {
-    this._xpaths.add(xpath);
+    const expr = String(xpath ?? '');
+    if (!expr) return;
+
+    // Always keep the original expression
+    this._xpaths.add(expr);
+
+    // --- NEW: extract implicit JSON lookup deps hidden behind variables ---
+    //
+    // Examples:
+    //   contains(., $default?ui?query)  -> adds ?ui?query
+    //   $foo.?ui?query                 -> adds ?ui?query
+    //
+    // We only add lookup tails that start with ? or .? and then a key.
+    // This is intentionally conservative and string-based.
+    const varLookupRe =
+      /\$[A-Za-z_][\w.-]*\s*(\.\?)?(\?[\w$.-]+(?:\[[^\]]+\])?)(\?[\w$.-]+(?:\[[^\]]+\])?)*(\?\*)?/g;
+
+    // We want the full tail beginning at the first '?' (ignore optional '.')
+    // so: ".?ui?query" => "?ui?query"
+    let m;
+    while ((m = varLookupRe.exec(expr)) !== null) {
+      const fullMatch = m[0] || '';
+      const qpos = fullMatch.indexOf('?');
+      if (qpos === -1) continue;
+
+      const tail = fullMatch.slice(qpos); // e.g. "?ui?query"
+      // Only record meaningful deps (ignore just "?*")
+      if (tail === '?*') continue;
+
+      this._xpaths.add(tail);
+    }
   }
 
   /**

package/src/ForeElementMixin.js

@@ -184,7 +184,7 @@ export default class ForeElementMixin extends HTMLElement {
         // console.log('match ', match);
         const naked = match.substring(1, match.length - 1);
         const inscope = getInScopeContext(node, naked);
-        const result = evaluateXPathToString(naked, inscope, this);
+        const result = evaluateXPathToString(naked, inscope, this.getOwnerForm());
         const replaced = expr.replaceAll(match, result);
         // console.log('replacing ', expr, ' with ', replaced);
         expr = replaced;
@@ -239,63 +239,89 @@ export default class ForeElementMixin extends HTMLElement {
     return null;
   }
 
+  /**
+   * @returns {import('./modelitem.js').ModelItem}
+   */
   /**
    * @returns {import('./modelitem.js').ModelItem}
    */
   getModelItem() {
-    if (!this.getModel()) return;
+    if (!this.getModel()) return null;
 
-    // First try to find by node reference
-    const mi = this.getModel().getModelItem(this.nodeset);
-    if (mi) {
-      this.modelItem = mi;
-    }
+    const model = this.getModel();
 
+    // Resolve the effective bound node for repeated contexts
     const repeated = XPathUtil.getClosest('fx-repeatitem', this);
-    let existed;
+    let effectiveNode = this.nodeset;
+
     if (repeated) {
       const { index } = repeated;
-      if (Array.isArray(this.nodeset)) {
-        existed = this.getModel().getModelItem(this.nodeset[index - 1]);
-      } else {
-        existed = this.getModel().getModelItem(this.nodeset);
+      if (Array.isArray(effectiveNode)) {
+        effectiveNode = effectiveNode[index - 1];
       }
-    } else {
-      existed = this.nodeset ? this.getModel().getModelItem(this.nodeset) : null;
     }
 
-    // If we couldn't find by node reference, try to find by path
-    if (!existed && this.nodeset) {
-      // Get the path for the current nodeset
-      const instanceId = XPathUtil.resolveInstance(this, this.ref);
-      let targetNode =
-        this.nodeset.nodeType === Node.TEXT_NODE ? this.nodeset.parentNode : this.nodeset;
+    // 1) Try exact lookup by node OR lens object (model.getModelItem was updated earlier)
+    let existed = effectiveNode ? model.getModelItem(effectiveNode) : null;
+    if (existed) {
+      this.modelItem = existed;
+      return existed;
+    }
+
+    // 2) Try lookup by canonical path (XML + JSON)
+    const instanceId = XPathUtil.resolveInstance(this, this.ref);
 
-      if (targetNode?.nodeType) {
-        const path = getPath(targetNode, instanceId);
+    // Normalize XML text node -> parent
+    let targetNode = effectiveNode;
+    if (targetNode?.nodeType === Node.TEXT_NODE) targetNode = targetNode.parentNode;
 
-        // Try to find a ModelItem with this path
-        existed = this.getModel().modelItems.find(item => item.path === path);
+    let path = null;
 
-        if (existed) {
-          // Update the node reference in the existing ModelItem
+    // XML node path
+    if (targetNode?.nodeType) {
+      path = getPath(targetNode, instanceId);
+    }
+    // JSON lens node path (preferred)
+    else if (targetNode?.__jsonlens__ && typeof targetNode.getPath === 'function') {
+      // JSONNode.getPath() already returns the canonical path you want
+      path = targetNode.getPath();
+    }
+    // As a last resort: try getPath() util for JSON lens nodes if it supports them
+    else if (targetNode?.__jsonlens__) {
+      try {
+        path = getPath(targetNode, instanceId);
+      } catch (_e) {
+        // ignore
+      }
+    }
+
+    if (path) {
+      existed = model.modelItems.find(item => item.path === path) || null;
+      if (existed) {
+        // CRITICAL: retarget existing ModelItem to the current backing object
+        const isLensObject =
+            targetNode &&
+            typeof targetNode === 'object' &&
+            typeof targetNode.get === 'function' &&
+            typeof targetNode.set === 'function';
+
+        if (isLensObject) {
+          existed.lens = targetNode;
+          existed.node = null;
+        } else {
           existed.node = targetNode;
+          existed.lens = null;
         }
-      }
-      if (!existed) {
-        const lazyCreatedModelItem = FxModel.lazyCreateModelItem(
-          this.getModel(),
-          this.ref,
-          this.nodeset,
-          this,
-        );
-        this.modelItem = lazyCreatedModelItem;
-        return lazyCreatedModelItem;
+
+        this.modelItem = existed;
+        return existed;
       }
     }
-    this.modelItem = existed;
 
-    return existed;
+    // 3) Not found: lazily create (lazyCreateModelItem now dedupes/retargets by path)
+    const lazyCreatedModelItem = FxModel.lazyCreateModelItem(model, this.ref, effectiveNode, this);
+    this.modelItem = lazyCreatedModelItem;
+    return lazyCreatedModelItem;
   }
   /**
    * Returns the effective value for the element.