@jinntec/fore 2.9.0 → 3.0.1

package/src/actions/fx-setvalue.js

@@ -82,17 +82,20 @@ export default class FxSetvalue extends AbstractAction {
    */
   dispatchExecute() {}
 
+  // Adjustment in setValue logic to ensure we work with JSONNode, not just raw values
   setValue(modelItem, newVal) {
     console.log('setValue', modelItem, newVal);
     const item = modelItem;
     if (!item) return;
 
-    if (item.value !== newVal) {
-      // const path = XPathUtil.getPath(modelItem.node);
-      const path = Fore.getDomNodeIndexString(modelItem.node);
+    // Check if current node is a JSONNode
+    const node = Array.isArray(item.node) ? item.node[0] : item.node;
 
+    if (item.value !== newVal) {
+      const path = Fore.getDomNodeIndexString(node);
       const ev = this.event;
       const targetElem = this;
+
       this.dispatchEvent(
         new CustomEvent('execute-action', {
           composed: true,
@@ -107,20 +110,19 @@ export default class FxSetvalue extends AbstractAction {
         }),
       );
 
+      // Use ModelItem's value setter which handles both DOM nodes and JSON lenses
       if (newVal?.nodeType) {
         if (newVal.nodeType === Node.ELEMENT_NODE) {
           item.value = newVal;
-        }
-        if (newVal.nodeType === Node.ATTRIBUTE_NODE) {
-          item.value = newVal.getValue();
-        }
-        if (newVal.nodeType === Node.TEXT_NODE) {
+        } else if (newVal.nodeType === Node.ATTRIBUTE_NODE) {
+          item.value = newVal.nodeValue;
+        } else if (newVal.nodeType === Node.TEXT_NODE) {
           item.value = newVal.textContent;
         }
       } else {
         item.value = newVal;
-        item.node.textContent = newVal;
       }
+
       this.getModel().changed.push(modelItem);
       this.needsUpdate = true;
       modelItem.notify();

package/src/fore.js

@@ -293,82 +293,39 @@ export class Fore {
    * @returns {Promise<void>}
    */
   static async refreshChildren(startElement, force) {
-    const refreshed = new Promise(resolve => {
-      /*
-      if there's an 'refresh-on-view' attribute the element wants to be handled by
-      handleIntersect function that calls the refresh of the respective element and
-      not the global one.
-       */
-      // if(!force && startElement.hasAttribute('refresh-on-view')) return;
-
-      /*  ### attempt with querySelectorAll is even slower than iterating recursively
-
-      const children = startElement.querySelectorAll('[ref]');
-      Array.from(children).forEach(uiElement => {
-        if (Fore.isUiElement(uiElement.nodeName) && typeof uiElement.refresh === 'function') {
-          uiElement.refresh();
-        }
-      });
-*/
-      const { children } = startElement;
-      if (children) {
-        for (const element of Array.from(children)) {
-          if (element.nodeName.toUpperCase() === 'FX-FORE') {
-            break;
-          }
-          if (Fore.isUiElement(element.nodeName) && typeof element.refresh === 'function') {
-            /**
-             * @type {import('./ForeElementMixin.js').default}
-             */
-            const bound = element;
-            if (!force) {
-              continue;
-            }
-/*
-            if(element.nodeName === 'FX-CASE') {
-              console.log('hey - got a case', element);
-            }
-*/
-            if (force === true) {
-              // console.log('🔄 refreshing ', element);
-              // Unconditional force refresh
-              bound.refresh(force);
-              continue;
-            }
-            if (typeof force !== 'object') {
-              continue;
-            }
-            /*
-            if (
-              force.reason === 'index-function' &&
-              bound.dependencies.isInvalidatedByIndexFunction()
-            ) {
-              console.log('🔄 refreshing ', element);
-
-              bound.refresh(force);
-              continue;
-            }
-
-            if (
-              bound.dependencies.isInvalidatedByChildlistChanges(force.elementLocalnamesWithChanges)
-            ) {
-              console.log('🔄 refreshing ', element);
-
-              bound.refresh(force);
-              continue;
-            }
-*/
+    const children = startElement?.children ? Array.from(startElement.children) : [];
+    for (const element of children) {
+      // Do not cross into nested fore roots
+      if (element.nodeName.toUpperCase() === 'FX-FORE') {
+        break;
+      }
+
+      if (Fore.isUiElement(element.nodeName) && typeof element.refresh === 'function') {
+        /** @type {import('./ForeElementMixin.js').default} */
+        const bound = element;
+
+        // Keep old behavior: only refresh UI elements during full/forced refresh
+        if (!force) {
+          // still recurse below
+        } else if (force === true) {
+          const maybePromise = bound.refresh(force);
+          if (maybePromise && typeof maybePromise.then === 'function') {
+            await maybePromise;
           }
-          if (!(element.inert === true)) {
-            // testing for inert catches model and action elements and should just leave updateable html elements
-            Fore.refreshChildren(element, force);
+        } else if (typeof force === 'object') {
+          // future selective refresh logic can live here if you re-enable it
+          const maybePromise = bound.refresh(force);
+          if (maybePromise && typeof maybePromise.then === 'function') {
+            await maybePromise;
           }
         }
       }
-      resolve('done');
-    });
 
-    return refreshed;
+      // Traverse DOM unless inert
+      if (!(element.inert === true)) {
+        await Fore.refreshChildren(element, force);
+      }
+    }
   }
 
   static copyDom(inputElement) {

package/src/functions/registerFunction.js

@@ -1,8 +1,27 @@
 import { createTypedValueFactory, registerCustomXPathFunction } from 'fontoxpath';
 import { evaluateXPath, globallyDeclaredFunctionLocalNames } from '../xpath-evaluation.js';
 
+// FontoXPath custom functions are registered globally. If multiple <fx-functionlib> (or multiple
+// <fx-fore> instances) register the same function name+arity, later registrations would overwrite
+// earlier ones across the whole page. We enforce "first wins".
+const _registeredFunctionKeys = new Set();
+
+function _makeFunctionKey(functionIdentifier, arity) {
+  if (typeof functionIdentifier === 'string') {
+    return `str:${functionIdentifier}#${arity}`;
+  }
+  return `{${functionIdentifier.namespaceURI}}${functionIdentifier.localName}#${arity}`;
+}
+
+function _ensureGlobalUnprefixedName(localName) {
+  // Keep this list unique to avoid unbounded growth across tests
+  if (!globallyDeclaredFunctionLocalNames.includes(localName)) {
+    globallyDeclaredFunctionLocalNames.push(localName);
+  }
+}
+
 /**
- * @param functionObject {{signature: string, type: string|null, functionBody: string}}
+ * @param functionObject {{signature: string, type: string|null, functionBody: string, implementation?: Function}}
  * @param formElement {HTMLElement} The form element connected to this function. Used to determine inscope context
  * @returns {undefined}
  */
@@ -31,29 +50,51 @@ export default function registerFunction(functionObject, formElement) {
       ? { namespaceURI: 'http://www.w3.org/2005/xquery-local-functions', localName }
       : `${prefix}:${localName}`;
 
-  // Make the function available globally w/o a prefix. See the functionNameResolver for for how
-  // functionObject is picked up
-  if (!prefix) {
-    globallyDeclaredFunctionLocalNames.push(localName);
-  }
-
   const paramParts = params
-    ? params.split(',').map(param => {
-        const match = param.match(/(?<variableName>\$[^\s]+)(?:\sas\s(?<varType>[^\s]+))/);
-        if (!match) {
-          throw new Error(`Param ${param} could not be parsed`);
-        }
-        const { variableName, varType } = match.groups;
-        return {
-          variableName,
-          variableType: varType || 'item()*',
-        };
-      })
+    ? params
+        .split(',')
+        .map(param => param.trim())
+        .filter(Boolean)
+        .map(param => {
+          const match = param.match(/(?<variableName>\$[^\s]+)(?:\sas\s(?<varType>[^\s]+))/);
+          if (!match) {
+            throw new Error(`Param ${param} could not be parsed`);
+          }
+          const { variableName, varType } = match.groups;
+          return {
+            variableName,
+            variableType: varType || 'item()*',
+          };
+        })
     : [];
 
+  const arity = paramParts.length;
+
+  // -------------------------------------------------
+  // FIRST-WINS GUARD (name + arity) WITH NAME EXPORT
+  // -------------------------------------------------
+  const key = _makeFunctionKey(functionIdentifier, arity);
+
+  if (_registeredFunctionKeys.has(key)) {
+    // If this registration is unprefixed, we must still make it callable without prefix.
+    // This fixes the unit test case where local:hello-world() was registered earlier and
+    // hello-world() should resolve to that implementation.
+    if (!prefix) {
+      _ensureGlobalUnprefixedName(localName);
+    }
+    return;
+  }
+
+  _registeredFunctionKeys.add(key);
+
+  // Make the function available globally w/o a prefix.
+  if (!prefix) {
+    _ensureGlobalUnprefixedName(localName);
+  }
+
   switch (type) {
     case 'text/javascript': {
-      // NEW: if a real JS function is provided (module libs), register it directly.
+      // If a real JS function is provided (module libs), register it directly.
       if (typeof functionObject.implementation === 'function') {
         const impl = functionObject.implementation;
         registerCustomXPathFunction(
@@ -74,6 +115,7 @@ export default function registerFunction(functionObject, formElement) {
         'form',
         functionObject.functionBody,
       );
+
       registerCustomXPathFunction(
         functionIdentifier,
         paramParts.map(paramPart => paramPart.variableType),
@@ -83,25 +125,27 @@ export default function registerFunction(functionObject, formElement) {
       );
       break;
     }
+
     case 'text/xquf':
     case 'text/xquery':
     case 'text/xpath': {
       const typedValueFactories = paramParts.map(param =>
         createTypedValueFactory(param.variableType),
       );
+
       const language =
         type === 'text/xpath'
           ? 'XPath3.1'
           : type === 'text/xquery'
             ? 'XQuery3.1'
             : 'XQueryUpdate3.1';
+
       const fun = (domFacade, ...args) =>
         evaluateXPath(
           functionObject.functionBody,
           formElement.getInScopeContext(),
           formElement.getOwnerForm(),
           paramParts.reduce((variablesByName, paramPart, i) => {
-            // Because we know the XPath type here (from the function declaration) we do not have to depend on the implicit typings
             variablesByName[paramPart.variableName.replace('$', '')] = typedValueFactories[i](
               args[i],
               domFacade,
@@ -110,6 +154,7 @@ export default function registerFunction(functionObject, formElement) {
           }, {}),
           { language },
         );
+
       registerCustomXPathFunction(
         functionIdentifier,
         paramParts.map(paramPart => paramPart.variableType),

package/src/fx-bind.js

@@ -9,7 +9,6 @@ import {
 import { XPathUtil } from './xpath-util.js';
 import getInScopeContext from './getInScopeContext.js';
 import { getPath } from './xpath-path.js';
-import { evaluateXPathToFirstNode } from 'fontoxpath';
 
 /**
  * FxBind declaratively attaches constraints to nodes in the data (instances).
@@ -157,86 +156,75 @@ export class FxBind extends ForeElementMixin {
    */
   init(model) {
     this.model = model;
-    // console.log('init binding ', this);
     this._getInstanceId();
     this.bindType = this.getModel().getInstance(this.instanceId).type;
-    // console.log('binding type ', this.bindType);
 
+    // ✅ Always evaluate nodeset first (XML + JSON)
+    this._evalInContext();
+
+    // ✅ Build dependency graph for both types
+    this._buildBindGraph();
+
+    // ✅ Create modelitems for both types
     if (this.bindType === 'xml') {
-      this._evalInContext();
-      this._buildBindGraph();
       this._createModelItems();
+    } else if (this.bindType === 'json') {
+      this._createModelItemsForJSON();
     }
-    // todo: support json
 
-    // ### process child bindings
     this._processChildren(model);
   }
 
   _buildBindGraph() {
-    if (this.bindType === 'xml') {
-      this.nodeset.forEach(node => {
-        const instance = XPathUtil.resolveInstance(this, this.ref);
-
-        const path = getPath(node, instance);
-        this.model.mainGraph.addNode(path, node);
-
-        /* ### catching references in the 'ref' itself...
-        todo: investigate cases where 'ref' attributes use predicates pointing to other nodes. These would not be handled
-        in current implementation.
-
-        General question: are there valid use-cases for using a 'filter' expression to narrow the nodeset
-          where to apply constraints? Guess yes and if it's 'just' for reducing the amount of necessary modelItem objects.
+    // ✅ Works for XML and JSON (JSON nodes have getPath()/getPath() handles __jsonlens__)
+    this.nodeset.forEach(node => {
+      const instanceId = XPathUtil.resolveInstance(this, this.ref);
+      const path = getPath(node, instanceId);
 
-        */
-        // const foreignRefs = this.getReferences(this.ref);
+      this.model.mainGraph.addNode(path, node);
 
-        if (this.calculate) {
-          this.model.mainGraph.addNode(`${path}:calculate`, node);
-          // Calculated values are a dependency of the model item.
-          this.model.mainGraph.addDependency(path, `${path}:calculate`);
-        }
+      if (this.calculate) {
+        this.model.mainGraph.addNode(`${path}:calculate`, node);
+        this.model.mainGraph.addDependency(path, `${path}:calculate`);
+      }
 
-        const calculateRefs = this._getReferencesForProperty(this.calculate, node);
-        if (calculateRefs.length !== 0) {
-          this._addDependencies(calculateRefs, node, path, 'calculate');
-        }
+      const calculateRefs = this._getReferencesForProperty(this.calculate, node);
+      if (calculateRefs.length !== 0) {
+        this._addDependencies(calculateRefs, node, path, 'calculate', instanceId);
+      }
 
-        if (!this.calculate) {
-          const readonlyRefs = this._getReferencesForProperty(this.readonly, node);
-          if (readonlyRefs.length !== 0) {
-            this._addDependencies(readonlyRefs, node, path, 'readonly');
-          } else if (this.readonly) {
-            this.model.mainGraph.addNode(`${path}:readonly`, node);
-          }
+      if (!this.calculate) {
+        const readonlyRefs = this._getReferencesForProperty(this.readonly, node);
+        if (readonlyRefs.length !== 0) {
+          this._addDependencies(readonlyRefs, node, path, 'readonly', instanceId);
+        } else if (this.readonly) {
+          this.model.mainGraph.addNode(`${path}:readonly`, node);
         }
+      }
 
-        // const requiredRefs = this.requiredReferences;
-        const requiredRefs = this._getReferencesForProperty(this.required, node);
-        if (requiredRefs.length !== 0) {
-          this._addDependencies(requiredRefs, node, path, 'required');
-        } else if (this.required) {
-          this.model.mainGraph.addNode(`${path}:required`, node);
-        }
+      const requiredRefs = this._getReferencesForProperty(this.required, node);
+      if (requiredRefs.length !== 0) {
+        this._addDependencies(requiredRefs, node, path, 'required', instanceId);
+      } else if (this.required) {
+        this.model.mainGraph.addNode(`${path}:required`, node);
+      }
 
-        const relevantRefs = this._getReferencesForProperty(this.relevant, node);
-        if (relevantRefs.length !== 0) {
-          this._addDependencies(relevantRefs, node, path, 'relevant');
-        } else if (this.relevant) {
-          this.model.mainGraph.addNode(`${path}:relevant`, node);
-        }
+      const relevantRefs = this._getReferencesForProperty(this.relevant, node);
+      if (relevantRefs.length !== 0) {
+        this._addDependencies(relevantRefs, node, path, 'relevant', instanceId);
+      } else if (this.relevant) {
+        this.model.mainGraph.addNode(`${path}:relevant`, node);
+      }
 
-        const constraintRefs = this._getReferencesForProperty(this.constraint, node);
-        if (constraintRefs.length !== 0) {
-          this._addDependencies(constraintRefs, node, path, 'constraint');
-        } else if (this.constraint) {
-          this.model.mainGraph.addNode(`${path}:constraint`, node);
-          this.model.mainGraph.addDependency(path, `${path}:constraint`);
-        }
-      });
-    }
+      const constraintRefs = this._getReferencesForProperty(this.constraint, node);
+      if (constraintRefs.length !== 0) {
+        this._addDependencies(constraintRefs, node, path, 'constraint', instanceId);
+      } else if (this.constraint) {
+        this.model.mainGraph.addNode(`${path}:constraint`, node);
+        this.model.mainGraph.addDependency(path, `${path}:constraint`);
+      }
+    });
   }
-
   /**
    * Resolves a referenced ModelItem using the model's graph and node registry.
    * @param {string} refName
@@ -266,26 +254,25 @@ export class FxBind extends ForeElementMixin {
    * @param  {string}  path The path to the start of the reference
    * @param  {string}  property The property with this dependency
    */
-  _addDependencies(refs, node, path, property) {
-    // console.log('_addDependencies',path);
+  _addDependencies(refs, node, path, property, instanceId) {
     const nodeHash = `${path}:${property}`;
+
     if (refs.length !== 0) {
       if (!this.model.mainGraph.hasNode(nodeHash)) {
         this.model.mainGraph.addNode(nodeHash, node);
       }
+
       refs.forEach(ref => {
-        const instance = XPathUtil.resolveInstance(this, path);
+        const otherPath = getPath(ref, instanceId);
 
-        const otherPath = getPath(ref, instance);
-        // console.log('otherPath', otherPath)
+        // keep old XML-only hack
+        if (this.bindType === 'xml' && otherPath.endsWith('text()[1]')) return;
 
-        // todo: nasty hack to prevent duplicate pathes like 'a[1]' and 'a[1]/text()[1]' to end up as separate nodes in the graph
-        if (!otherPath.endsWith('text()[1]')) {
-          if (!this.model.mainGraph.hasNode(otherPath)) {
-            this.model.mainGraph.addNode(otherPath, ref);
-          }
-          this.model.mainGraph.addDependency(nodeHash, otherPath);
+        if (!this.model.mainGraph.hasNode(otherPath)) {
+          this.model.mainGraph.addNode(otherPath, ref);
         }
+
+        this.model.mainGraph.addDependency(nodeHash, otherPath);
       });
     } else {
       this.model.mainGraph.addNode(nodeHash, node);
@@ -311,6 +298,23 @@ export class FxBind extends ForeElementMixin {
     return null;
   }
 
+  _createModelItemsForJSON() {
+    const fore = this.closest('fx-fore');
+    const instanceId = this.instanceId;
+
+    this.nodeset.forEach(jsonNode => {
+      const path = getPath(jsonNode, instanceId);
+
+      // ✅ ModelItem node should be the JSONNode itself (lens), NOT JSONLens
+      const newItem = new ModelItem(path, this.getBindingExpr(), jsonNode, this, instanceId, fore);
+
+      const alert = this.getAlert();
+      if (alert) newItem.addAlert(alert);
+
+      this.getModel().registerModelItem(newItem);
+    });
+  }
+
   /**
    * overwrites
    */
@@ -346,8 +350,11 @@ export class FxBind extends ForeElementMixin {
       const inst = this.getModel().getInstance(this.instanceId);
       if (inst.type === 'xml') {
         this.nodeset = evaluateXPathToNodes(this.ref, inscopeContext, this);
+      } else if (inst.type === 'json') {
+        // ✅ JSON must also resolve the nodeset via XPath evaluation
+        this.nodeset = evaluateXPathToNodes(this.ref, inscopeContext, this);
       } else {
-        this.nodeset = this.ref;
+        this.nodeset = [];
       }
     }
   }
@@ -458,6 +465,33 @@ export class FxBind extends ForeElementMixin {
   }
 
   getReferences(propertyExpr) {
+    // For XML, DependencyNotifyingDomFacade reliably reports the nodes touched during evaluation.
+    // For JSON lens nodes, the domFacade hook does not fire (evaluation goes through our lens resolver),
+    // so we must extract lookup tokens and resolve them explicitly.
+
+    if (!propertyExpr) return [];
+
+    // JSON path: resolve dependencies by parsing lens lookups in the expression.
+    if (this.bindType === 'json') {
+      const touchedNodes = new Set();
+      const tokens = this._extractJsonLookupTokens(propertyExpr);
+
+      // Evaluate each token in the *current* context node (each item in nodeset)
+      this.nodeset.forEach(node => {
+        tokens.forEach(token => {
+          try {
+            const refs = evaluateXPathToNodes(token, node, this);
+            refs.forEach(r => touchedNodes.add(r));
+          } catch (_e) {
+            // ignore: dependency extraction must never break bind initialization
+          }
+        });
+      });
+
+      return Array.from(touchedNodes.values());
+    }
+
+    // XML path: use dom facade for accurate dependency tracking
     const touchedNodes = new Set();
     const domFacade = new DependencyNotifyingDomFacade(otherNode => touchedNodes.add(otherNode));
     this.nodeset.forEach(node => {
@@ -465,6 +499,27 @@ export class FxBind extends ForeElementMixin {
     });
     return Array.from(touchedNodes.values());
   }
+  _extractJsonLookupTokens(expr) {
+    if (!expr) return [];
+
+    const src = String(expr);
+    const tokens = new Set();
+
+    // instance('id')?a?b?c  or instance('id')?*
+    const instRe = /instance\s*\([^)]*\)\s*(?:\?\s*\*|\?\s*[a-zA-Z_][\w-]*)+/g;
+    let m;
+    while ((m = instRe.exec(src)) !== null) {
+      if (m[0]) tokens.add(m[0].replace(/\s+/g, ''));
+    }
+
+    // relative lookups like ?title, ?year, ?ui, ?query (ignore ?*)
+    const relRe = /\?[a-zA-Z_][\w-]*/g;
+    while ((m = relRe.exec(src)) !== null) {
+      if (m[0] && m[0] !== '?*') tokens.add(m[0]);
+    }
+
+    return Array.from(tokens);
+  }
 
   /*
     static getReferencesForRef(ref,nodeset){