@jinntec/fore 2.8.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/fx-functionlib.js

@@ -1,10 +1,45 @@
 import ForeElementMixin from '../ForeElementMixin.js';
 import registerFunction from './registerFunction.js';
 
-/**
- * Allows to extend a form with remote custom functions.
- *
- */
+const LOCAL_FUNCTIONS_NS = 'http://www.w3.org/2005/xquery-local-functions';
+
+// Global per-page cache to prevent registering the same library multiple times.
+// Keyed by resolved URL + prefix + mode.
+const _functionLibLoadCache = new Map();
+
+function looksLikeModuleSrc(src) {
+  return /\.m?js($|\?)/i.test(src);
+}
+
+function applyPrefixToSignature(signature, prefix) {
+  if (!signature || !prefix) return signature;
+
+  const s = signature.trim();
+  const paren = s.indexOf('(');
+  if (paren < 0) return s;
+
+  const namePart = s.slice(0, paren).trim();
+  const rest = s.slice(paren);
+
+  const localName = namePart.includes(':') ? namePart.split(':').pop().trim() : namePart;
+  if (!localName) return s;
+
+  return `${prefix}:${localName}${rest}`;
+}
+
+function normalizeModuleExportToList(mod, src) {
+  const lib = mod.functions ?? mod.fxFunctions;
+  if (!lib) {
+    console.error(
+      `fx-functionlib: Module ${src} must export a named \`functions\` (or \`fxFunctions\`).`,
+    );
+    return [];
+  }
+  if (Array.isArray(lib)) return lib;
+  if (typeof lib === 'object') return Object.values(lib);
+  return [];
+}
+
 export class FxFunctionlib extends ForeElementMixin {
   constructor() {
     super();
@@ -24,20 +59,112 @@ export class FxFunctionlib extends ForeElementMixin {
     this.style.display = 'none';
 
     const src = this.getAttribute('src');
+    if (!src) {
+      console.error('fx-functionlib: Missing required @src.');
+      this._resolveLoading(undefined);
+      return;
+    }
+
+    const prefix = (this.getAttribute('prefix') || '').trim();
+
+    const typeAttr = (this.getAttribute('type') || '').trim().toLowerCase();
+    const isModule = typeAttr === 'module' || (!typeAttr && looksLikeModuleSrc(src));
+
+    const resolvedUrl = new URL(src, this.baseURI).href;
+
+    if (prefix) this._ensurePrefixDeclared(prefix);
+
+    const mode = isModule ? 'module' : 'html';
+    const cacheKey = `${mode}|${resolvedUrl}|${prefix}`;
+
+    const existing = _functionLibLoadCache.get(cacheKey);
+    if (existing) {
+      try {
+        await existing;
+      } finally {
+        this._resolveLoading(undefined);
+      }
+      return;
+    }
+
+    const loadPromise = (async () => {
+      if (isModule) {
+        await this._loadModuleLibrary(resolvedUrl, src, prefix);
+      } else {
+        await this._loadHtmlLibrary(resolvedUrl, src, prefix);
+      }
+    })();
 
-    const result = await fetch(src);
+    _functionLibLoadCache.set(cacheKey, loadPromise);
+
+    try {
+      await loadPromise;
+    } catch (e) {
+      _functionLibLoadCache.delete(cacheKey);
+      console.error(`fx-functionlib: Loading function library at ${src} failed.`, e);
+    } finally {
+      this._resolveLoading(undefined);
+    }
+  }
+
+  _ensurePrefixDeclared(prefix) {
+    const ownerForm =
+        (typeof this.getOwnerForm === 'function' && this.getOwnerForm()) || this.closest('fx-fore');
+
+    if (!ownerForm) return;
+
+    const attrName = `xmlns:${prefix}`;
+    if (!ownerForm.getAttribute(attrName)) {
+      ownerForm.setAttribute(attrName, LOCAL_FUNCTIONS_NS);
+    }
+  }
+
+  _register(functionObject, prefix) {
+    if (!functionObject || typeof functionObject.signature !== 'string') return;
+
+    // If prefix is given: register ONLY the prefixed signature (no unprefixed alias).
+    const sig = prefix
+        ? applyPrefixToSignature(functionObject.signature, prefix)
+        : functionObject.signature;
+
+    registerFunction({ ...functionObject, signature: sig }, this);
+  }
+
+  async _loadModuleLibrary(resolvedUrl, src, prefix) {
+    const mod = await import(/* @vite-ignore */ resolvedUrl);
+
+    const items = normalizeModuleExportToList(mod, src);
+
+    for (const item of items) {
+      if (typeof item === 'function') {
+        const { signature } = item;
+        if (typeof signature !== 'string' || !signature.trim()) continue;
+
+        this._register(
+            {
+              type: 'text/javascript',
+              signature: signature.trim(),
+              implementation: item,
+            },
+            prefix,
+        );
+      } else if (item && typeof item === 'object' && typeof item.signature === 'string') {
+        this._register(item, prefix);
+      }
+    }
+  }
+
+  async _loadHtmlLibrary(resolvedUrl, src, prefix) {
+    const result = await fetch(resolvedUrl);
     if (!result.ok) {
       console.error(`Loading function library at ${src} failed.`);
+      return;
     }
 
     const body = await result.text();
     const document = new DOMParser().parseFromString(body, 'text/html');
 
-    /**
-     * @type {HTMLElement[]}
-     */
     const functions = Array.from(document.querySelectorAll('fx-function'));
-    // TODO: also recurse into new function libraries here?
     for (const func of functions) {
       const functionObject = {
         type: func.getAttribute('type'),
@@ -45,12 +172,11 @@ export class FxFunctionlib extends ForeElementMixin {
         functionBody: func.innerText,
       };
 
-      registerFunction(functionObject, this);
+      this._register(functionObject, prefix);
     }
-    this._resolveLoading(undefined);
   }
 }
 
 if (!customElements.get('fx-functionlib')) {
   customElements.define('fx-functionlib', FxFunctionlib);
-}
+}

package/src/functions/mylib.js

@@ -0,0 +1,13 @@
+export function myfunc(node) {
+  // simple: true if node is present
+  return !!node;
+}
+myfunc.signature = 'myfunc($node as item()?) as xs:boolean';
+
+export function hasText(s) {
+  return s != null && String(s).trim() !== '';
+}
+hasText.signature = 'hasText($s as xs:string?) as xs:boolean';
+
+// Named export is the default convention for fx-functionlib
+export const functions = [myfunc, hasText];

package/src/functions/registerFunction.js

@@ -1,8 +1,27 @@
 import { createTypedValueFactory, registerCustomXPathFunction } from 'fontoxpath';
-import { evaluateXPath, globallyDeclaredFunctionLocalNames } from '../xpath-evaluation';
+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,28 +50,64 @@ 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': {
+      // If a real JS function is provided (module libs), register it directly.
+      if (typeof functionObject.implementation === 'function') {
+        const impl = functionObject.implementation;
+        registerCustomXPathFunction(
+          functionIdentifier,
+          paramParts.map(paramPart => paramPart.variableType),
+          returnType || 'item()*',
+          (domFacade, ...values) =>
+            impl.apply(formElement.getInScopeContext(), [...values, formElement.getOwnerForm()]),
+        );
+        break;
+      }
+
+      // Existing behavior: compile from functionBody
       // eslint-disable-next-line no-new-func
       const fun = new Function(
         '_domFacade',
@@ -60,6 +115,7 @@ export default function registerFunction(functionObject, formElement) {
         'form',
         functionObject.functionBody,
       );
+
       registerCustomXPathFunction(
         functionIdentifier,
         paramParts.map(paramPart => paramPart.variableType),
@@ -76,19 +132,20 @@ export default function registerFunction(functionObject, formElement) {
       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,
@@ -97,6 +154,7 @@ export default function registerFunction(functionObject, formElement) {
           }, {}),
           { language },
         );
+
       registerCustomXPathFunction(
         functionIdentifier,
         paramParts.map(paramPart => paramPart.variableType),