@jinntec/fore 1.10.0 → 1.10.1

package/src/xpath-evaluation.js

@@ -418,6 +418,7 @@ function getVariablesInScope(formElement) {
  * @param  {Node} contextNode The start of the XPath
  * @param  {{parentNode}|ForeElementMixin} formElement  The form element associated to the XPath
  */
+/*
 export function evaluateXPath(xpath, contextNode, formElement, variables = {}, options={}, domFacade = null) {
     const namespaceResolver = createNamespaceResolverForNode(xpath, contextNode, formElement);
     const variablesInScope = getVariablesInScope(formElement);
@@ -440,7 +441,59 @@ export function evaluateXPath(xpath, contextNode, formElement, variables = {}, o
         },
     );
 }
+*/
+export function evaluateXPath(xpath, contextNode, formElement, variables = {}, options={}) {
+    try{
+        console.log('evaluateXPath',xpath);
+        const namespaceResolver = createNamespaceResolverForNode(xpath, contextNode, formElement);
+        const variablesInScope = getVariablesInScope(formElement);
+
+        return fxEvaluateXPath(
+            xpath,
+            contextNode,
+            null,
+            {...variablesInScope, ...variables},
+            fxEvaluateXPath.ALL_RESULTS_TYPE,
+            {
+                debug: true,
+                currentContext: {formElement, variables},
+                moduleImports: {
+                    xf: XFORMS_NAMESPACE_URI,
+                },
+                functionNameResolver,
+                namespaceResolver,
+                language: options.language || evaluateXPath.XPATH_3_1
+            },
+        );
+    }catch (e){
+        formElement.dispatchEvent(new CustomEvent('error', {
+            composed: false,
+            bubbles: true,
+            detail: {
+                origin: formElement,
+                message: `Expression '${xpath}' failed`,
+                expr:xpath,
+                level:'Error'
+            },
+        }));
 
+/*
+        formElement.dispatchEvent(
+            new CustomEvent('error', {
+                composed: false,
+                bubbles: true,
+                cancelable:true,
+                detail: {
+                    origin: formElement,
+                    message: `Expression '${xpath}' failed`,
+                    expr:xpath,
+                    level:'Error'},
+            }),
+        );
+*/
+        return false;
+    }
+}
 /**
  * Evaluate an XPath to the first Node
  *
@@ -450,17 +503,30 @@ export function evaluateXPath(xpath, contextNode, formElement, variables = {}, o
  * @return {Node}  The first node found by the XPath
  */
 export function evaluateXPathToFirstNode(xpath, contextNode, formElement) {
-    const namespaceResolver = createNamespaceResolverForNode(xpath, contextNode, formElement);
-    const variablesInScope = getVariablesInScope(formElement);
-    return fxEvaluateXPathToFirstNode(xpath, contextNode, null, variablesInScope, {
-        defaultFunctionNamespaceURI: XFORMS_NAMESPACE_URI,
-        moduleImports: {
-            xf: XFORMS_NAMESPACE_URI,
-        },
-        currentContext: {formElement},
-        functionNameResolver,
-        namespaceResolver,
-    });
+    try{
+        const namespaceResolver = createNamespaceResolverForNode(xpath, contextNode, formElement);
+        const variablesInScope = getVariablesInScope(formElement);
+        return fxEvaluateXPathToFirstNode(xpath, contextNode, null, variablesInScope, {
+            defaultFunctionNamespaceURI: XFORMS_NAMESPACE_URI,
+            moduleImports: {
+                xf: XFORMS_NAMESPACE_URI,
+            },
+            currentContext: {formElement},
+            functionNameResolver,
+            namespaceResolver,
+        });
+    } catch (e){
+        formElement.dispatchEvent(new CustomEvent('error', {
+            composed: false,
+            bubbles: true,
+            detail: {
+                origin: formElement,
+                message: `Expression '${xpath}' failed`,
+                expr:xpath,
+                level:'Error'
+            },
+        }));
+    }
 }
 
 /**
@@ -472,17 +538,30 @@ export function evaluateXPathToFirstNode(xpath, contextNode, formElement) {
  * @return {Node[]}  All nodes
  */
 export function evaluateXPathToNodes(xpath, contextNode, formElement) {
-    const namespaceResolver = createNamespaceResolverForNode(xpath, contextNode, formElement);
-    const variablesInScope = getVariablesInScope(formElement);
+    try{
+        const namespaceResolver = createNamespaceResolverForNode(xpath, contextNode, formElement);
+        const variablesInScope = getVariablesInScope(formElement);
 
-    return fxEvaluateXPathToNodes(xpath, contextNode, null, variablesInScope, {
-        currentContext: {formElement},
-        functionNameResolver,
-        moduleImports: {
-            xf: XFORMS_NAMESPACE_URI,
-        },
-        namespaceResolver,
-    });
+        return fxEvaluateXPathToNodes(xpath, contextNode, null, variablesInScope, {
+            currentContext: {formElement},
+            functionNameResolver,
+            moduleImports: {
+                xf: XFORMS_NAMESPACE_URI,
+            },
+            namespaceResolver,
+        });
+    }catch (e){
+        formElement.dispatchEvent(new CustomEvent('error', {
+            composed: false,
+            bubbles: true,
+            detail: {
+                origin: formElement,
+                message: `Expression '${xpath}' failed`,
+                expr:xpath,
+                level:'Error'
+            },
+        }));
+    }
 }
 
 /**
@@ -494,17 +573,30 @@ export function evaluateXPathToNodes(xpath, contextNode, formElement) {
  * @return {boolean}
  */
 export function evaluateXPathToBoolean(xpath, contextNode, formElement) {
-    const namespaceResolver = createNamespaceResolverForNode(xpath, contextNode, formElement);
-    const variablesInScope = getVariablesInScope(formElement);
+    try{
+        const namespaceResolver = createNamespaceResolverForNode(xpath, contextNode, formElement);
+        const variablesInScope = getVariablesInScope(formElement);
 
-    return fxEvaluateXPathToBoolean(xpath, contextNode, null, variablesInScope, {
-        currentContext: {formElement},
-        functionNameResolver,
-        moduleImports: {
-            xf: XFORMS_NAMESPACE_URI,
-        },
-        namespaceResolver,
-    });
+        return fxEvaluateXPathToBoolean(xpath, contextNode, null, variablesInScope, {
+            currentContext: {formElement},
+            functionNameResolver,
+            moduleImports: {
+                xf: XFORMS_NAMESPACE_URI,
+            },
+            namespaceResolver,
+        });
+    }catch (e){
+        formElement.dispatchEvent(new CustomEvent('error', {
+            composed: false,
+            bubbles: true,
+            detail: {
+                origin: formElement,
+                message: `Expression '${xpath}' failed`,
+                expr:xpath,
+                level:'Error'
+            },
+        }));
+    }
 }
 
 /**
@@ -525,17 +617,30 @@ export function evaluateXPathToString(
     domFacade = null,
     namespaceReferenceNode = formElement,
 ) {
-    const namespaceResolver = createNamespaceResolverForNode(xpath, contextNode, formElement);
-    const variablesInScope = getVariablesInScope(formElement);
+    try{
+        const namespaceResolver = createNamespaceResolverForNode(xpath, contextNode, formElement);
+        const variablesInScope = getVariablesInScope(formElement);
 
-    return fxEvaluateXPathToString(xpath, contextNode, domFacade, variablesInScope, {
-        currentContext: {formElement},
-        functionNameResolver,
-        moduleImports: {
-            xf: XFORMS_NAMESPACE_URI,
-        },
-        namespaceResolver,
-    });
+        return fxEvaluateXPathToString(xpath, contextNode, domFacade, variablesInScope, {
+            currentContext: {formElement},
+            functionNameResolver,
+            moduleImports: {
+                xf: XFORMS_NAMESPACE_URI,
+            },
+            namespaceResolver,
+        });
+    }catch (e) {
+        formElement.dispatchEvent(new CustomEvent('error', {
+            composed: false,
+            bubbles: true,
+            detail: {
+                origin: formElement,
+                message: `Expression '${xpath}' failed`,
+                expr:xpath,
+                level:'Error'
+            },
+        }));
+    }
 }
 
 /**
@@ -556,22 +661,31 @@ export function evaluateXPathToStrings(
     domFacade = null,
     namespaceReferenceNode = formElement,
 ) {
-    const namespaceResolver = createNamespaceResolverForNode(xpath, contextNode, formElement);
-    return fxEvaluateXPathToStrings(
-        xpath,
-        contextNode,
-        domFacade,
-        {},
-
-        {
-            currentContext: {formElement},
-            functionNameResolver,
-            moduleImports: {
-                xf: XFORMS_NAMESPACE_URI,
+    try{
+        const namespaceResolver = createNamespaceResolverForNode(xpath, contextNode, formElement);
+        return fxEvaluateXPathToStrings( xpath, contextNode, domFacade,
+            {},
+            {
+                currentContext: {formElement},
+                functionNameResolver,
+                moduleImports: {
+                    xf: XFORMS_NAMESPACE_URI,
+                },
+                namespaceResolver,
             },
-            namespaceResolver,
-        },
-    );
+        );
+    } catch (e){
+        formElement.dispatchEvent(new CustomEvent('error', {
+            composed: false,
+            bubbles: true,
+            detail: {
+                origin: formElement,
+                message: `Expression '${xpath}' failed`,
+                expr:xpath,
+                level:'Error'
+            },
+        }));
+    }
 }
 
 /**
@@ -592,17 +706,30 @@ export function evaluateXPathToNumber(
     domFacade = null,
     namespaceReferenceNode = formElement,
 ) {
-    const namespaceResolver = createNamespaceResolverForNode(xpath, contextNode, formElement);
-    const variablesInScope = getVariablesInScope(formElement);
+    try{
+        const namespaceResolver = createNamespaceResolverForNode(xpath, contextNode, formElement);
+        const variablesInScope = getVariablesInScope(formElement);
 
-    return fxEvaluateXPathToNumber(xpath, contextNode, domFacade, variablesInScope, {
-        currentContext: {formElement},
-        functionNameResolver,
-        moduleImports: {
-            xf: XFORMS_NAMESPACE_URI,
-        },
-        namespaceResolver,
-    });
+        return fxEvaluateXPathToNumber(xpath, contextNode, domFacade, variablesInScope, {
+            currentContext: {formElement},
+            functionNameResolver,
+            moduleImports: {
+                xf: XFORMS_NAMESPACE_URI,
+            },
+            namespaceResolver,
+        });
+    }catch (e) {
+        formElement.dispatchEvent(new CustomEvent('error', {
+            composed: false,
+            bubbles: true,
+            detail: {
+                origin: formElement,
+                message: `Expression '${xpath}' failed`,
+                expr:xpath,
+                level:'Error'
+            },
+        }));
+    }
 }
 
 const contextFunction = (dynamicContext, string) => {
@@ -844,18 +971,44 @@ const instance = (dynamicContext, string) => {
         {namespaceResolver: xhtmlNamespaceResolver},
     );
 
+    let lookup = null;
+    if(string === null || string === 'default'){
+        lookup = formElement.getModel().getDefaultInstance();
+    }else{
+        lookup = formElement.getModel().getInstance(string);
+        if(!lookup){
+            document.querySelector('fx-fore').dispatchEvent(new CustomEvent('error', {
+                composed: true,
+                bubbles: true,
+                detail: {
+                    origin: 'functions',
+                    message: `Function not found '${localName}'`,
+                    level:'Error'
+                },
+            }));
+        }
+    }
+
+    const context = lookup.getDefaultContext();
+    if (!context) {
+        debugger;
+        return null;
+    }
+    return context;
+
+/*
     const inst = string
           ? formElement.getModel().getInstance(string)
           : formElement.getModel().getDefaultInstance();
+*/
 
 /*
     const inst = string
         ? resolveId(string, formElement, 'fx-instance')
         : formElement.querySelector(`fx-instance`);
-*/
 
-    if (inst) {
-        const context = inst.getDefaultContext();
+    if (lookup) {
+        const context = lookup.getDefaultContext();
 		if (!context) {
 			debugger;
 			return null;
@@ -863,6 +1016,7 @@ const instance = (dynamicContext, string) => {
 		return context;
     }
     return null;
+*/
 };
 
 registerCustomXPathFunction(

package/src/xpath-util.js

@@ -2,151 +2,159 @@ import * as fx from 'fontoxpath';
 
 export class XPathUtil {
 
-	/**
-	 * Alternative to `contains` that respects shadowroots
-	 */
-	static contains(ancestor, descendant) {
-		while (descendant) {
-			if (descendant === ancestor) {
-				return true;
-			}
+    /**
+     * Alternative to `contains` that respects shadowroots
+     */
+    static contains(ancestor, descendant) {
+        while (descendant) {
+            if (descendant === ancestor) {
+                return true;
+            }
 
-			if (descendant.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
-				// We are passing a shadow root boundary
-				descendant = descendant.host;
-			} else {
-				descendant = descendant.parentNode;
-			}
-		}
-		return false;
-	}
-
-  /**
-   * Alternative to `closest` that respects subcontrol boundaries
-   */
-  static getClosest(querySelector, start) {
-    while (start && !start.matches || !start.matches(querySelector)) {
-      if (start.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
-        // We are passing a shadow root boundary
-        start = start.host;
-        continue;
-      }
-      if (start.nodeType === Node.ATTRIBUTE_NODE) {
-        // We are passing an attribute
-        start = start.ownerElement;
-        continue;
-      }
-      if (start.nodeType === Node.TEXT_NODE) {
-        start = start.parentNode;
-      }
-      if (start.matches('fx-fore')) {
-        // Subform reached. Bail out
-        return null;
-      }
-      start = start.parentNode;
-      if (!start) {
-        return null;
-      }
+            if (descendant.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
+                // We are passing a shadow root boundary
+                descendant = descendant.host;
+            } else {
+                descendant = descendant.parentNode;
+            }
+        }
+        return false;
     }
-    return start;
-  }
-
-  /**
-   * returns next bound element upwards in tree
-   * @param start where to start the search
-   * @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) ) {
-/*
-      if (start.parentNode.hasAttribute('ref')) {
-        return start.parentNode;
-      }
-      return XPathUtil.getParentBindingElement(start.parentNode);
-*/
 
-      return start.parentNode.closest('[ref]');
+    /**
+     * Alternative to `closest` that respects subcontrol boundaries
+     */
+    static getClosest(querySelector, start) {
+        while (start && !start.matches || !start.matches(querySelector)) {
+            if (start.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
+                // We are passing a shadow root boundary
+                start = start.host;
+                continue;
+            }
+            if (start.nodeType === Node.ATTRIBUTE_NODE) {
+                // We are passing an attribute
+                start = start.ownerElement;
+                continue;
+            }
+            if (start.nodeType === Node.TEXT_NODE) {
+                start = start.parentNode;
+            }
+            if (start.matches('fx-fore')) {
+                // Subform reached. Bail out
+                return null;
+            }
+            start = start.parentNode;
+            if (!start) {
+                return null;
+            }
+        }
+        return start;
     }
-    return null;
-  }
 
-  /**
-   * Checks whether the specified path expression is an absolute path.
-   *
-   * @param path the path expression.
-   * @return <code>true</code> if specified path expression is an absolute
-   * path, otherwise <code>false</code>.
-   */
-  static isAbsolutePath(path) {
-    return path != null && (path.startsWith('/') || path.startsWith('instance('));
-  }
+    /**
+     * returns next bound element upwards in tree
+     * @param start where to start the search
+     * @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)) {
+            /*
+                  if (start.parentNode.hasAttribute('ref')) {
+                    return start.parentNode;
+                  }
+                  return XPathUtil.getParentBindingElement(start.parentNode);
+            */
 
-  static isSelfReference(ref) {
-    return ref === '.' || ref === './text()' || ref === 'text()' || ref === '' || ref === null;
-  }
+            return start.parentNode.closest('[ref]');
+        }
+        return null;
+    }
 
-  /**
-   * returns the instance id from a complete XPath using `instance()` function.
-   *
-   * Will return 'default' in case no ref is given at all or the `instance()` function is called without arg.
-   *
-   * Otherwise instance id is extracted from function and returned. If all fails null is returned.
-   * @param ref
-   * @returns {string}
-   */
-  static getInstanceId(ref) {
-    if (!ref) {
-      return 'default';
+    /**
+     * Checks whether the specified path expression is an absolute path.
+     *
+     * @param path the path expression.
+     * @return <code>true</code> if specified path expression is an absolute
+     * path, otherwise <code>false</code>.
+     */
+    static isAbsolutePath(path) {
+        return path != null && (path.startsWith('/') || path.startsWith('instance('));
     }
-    if (ref.startsWith('instance()')) {
-      return 'default';
+
+    static isSelfReference(ref) {
+        return ref === '.' || ref === './text()' || ref === 'text()' || ref === '' || ref === null;
     }
-    if (ref.startsWith('instance(')) {
-      const result = ref.substring(ref.indexOf('(') + 1);
-      return result.substring(1, result.indexOf(')') - 1);
+
+    /**
+     * returns the instance id from a complete XPath using `instance()` function.
+     *
+     * Will return 'default' in case no ref is given at all or the `instance()` function is called without arg.
+     *
+     * Otherwise instance id is extracted from function and returned. If all fails null is returned.
+     * @param ref
+     * @returns {string}
+     */
+    static getInstanceId(ref) {
+        if (!ref) {
+            return 'default';
+        }
+        if (ref.startsWith('instance()')) {
+            return 'default';
+        }
+        if (ref.startsWith('instance(')) {
+            const result = ref.substring(ref.indexOf('(') + 1);
+            return result.substring(1, result.indexOf(')') - 1);
+        }
+        return null;
     }
-    return null;
-  }
 
-	static resolveInstance(boundElement, path){
-		let instanceId = XPathUtil.getInstanceId(path);
-		if (!instanceId) {
-			instanceId = XPathUtil.getInstanceId(boundElement.getAttribute('ref'));
-		}
-    if(instanceId !== null){
-      return instanceId;
+    static resolveInstance(boundElement, path) {
+        let instanceId = XPathUtil.getInstanceId(path);
+        if (!instanceId) {
+            instanceId = XPathUtil.getInstanceId(boundElement.getAttribute('ref'));
+        }
+        if (instanceId !== null) {
+            return instanceId;
+        }
+
+        const parentBinding = XPathUtil.getParentBindingElement(boundElement);
+        if (parentBinding) {
+            return this.resolveInstance(parentBinding, path);
+        }
+        return 'default';
     }
 
-    const parentBinding = XPathUtil.getParentBindingElement(boundElement);
-    if(parentBinding){
-		return this.resolveInstance(parentBinding, path);
+    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}`;
     }
-    return 'default';
-  }
 
-  static getPath(node, instanceId) {
-    const path = fx.evaluateXPathToString('path()', node);
-	// Path is like `$default/x/y`
-	return `$${instanceId}${XPathUtil.shortenPath(path)}`;
-  }
+    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}`;
+    }
 
-  static shortenPath(path) {
-    const tmp = path.replaceAll(/(Q{(.*?)\})/g, '');
-    // cut off leading slash
-    const tmp1 = tmp.substring(1, tmp.length);
-    // ### cut-off root node ref
-    return tmp1.substring(tmp1.indexOf('/'), tmp.length);
-  }
+    static shortenPath(path) {
+        const tmp = path.replaceAll(/(Q{(.*?)\})/g, '');
+        // cut off leading slash
+        const tmp1 = tmp.substring(1, tmp.length);
+        // ### cut-off root node ref
+        return tmp1.substring(tmp1.indexOf('/'), tmp.length);
+    }
 
-  static getBasePath(dep) {
-    const split = dep.split(':');
-    return split[0];
-  }
+    static getBasePath(dep) {
+        const split = dep.split(':');
+        return split[0];
+    }
 }