@jinntec/fore 1.0.0-3 → 1.0.0

package/src/xpath-evaluation.js

@@ -10,38 +10,14 @@ import {
   registerCustomXPathFunction,
   registerXQueryModule,
 } from 'fontoxpath';
+import { Fore } from './fore.js';
+
 import { XPathUtil } from './xpath-util.js';
 
 const XFORMS_NAMESPACE_URI = 'http://www.w3.org/2002/xforms';
 
 const createdNamespaceResolversByXPathQueryAndNode = new Map();
 
-function prettifyXml(source) {
-  const xmlDoc = new DOMParser().parseFromString(source, 'application/xml');
-  const xsltDoc = new DOMParser().parseFromString(
-    [
-      // describes how we want to modify the XML - indent everything
-      '<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform">',
-      '  <xsl:strip-space elements="*"/>',
-      '  <xsl:template match="para[content-style][not(text())]">', // change to just text() to strip space in text nodes
-      '    <xsl:value-of select="normalize-space(.)"/>',
-      '  </xsl:template>',
-      '  <xsl:template match="node()|@*">',
-      '    <xsl:copy><xsl:apply-templates select="node()|@*"/></xsl:copy>',
-      '  </xsl:template>',
-      '  <xsl:output indent="yes"/>',
-      '</xsl:stylesheet>',
-    ].join('\n'),
-    'application/xml',
-  );
-
-  const xsltProcessor = new XSLTProcessor();
-  xsltProcessor.importStylesheet(xsltDoc);
-  const resultDoc = xsltProcessor.transformToDocument(xmlDoc);
-  const resultXml = new XMLSerializer().serializeToString(resultDoc);
-  return resultXml;
-}
-
 function getCachedNamespaceResolver(xpath, node) {
   if (!createdNamespaceResolversByXPathQueryAndNode.has(xpath)) {
     return null;
@@ -62,6 +38,103 @@ const xhtmlNamespaceResolver = prefix => {
   return undefined;
 };
 
+export function resolveId(id, sourceObject, nodeName = null) {
+  const allMatchingTargetObjects = fxEvaluateXPathToNodes(
+      'outermost(ancestor-or-self::fx-fore[1]/(descendant::fx-fore|descendant::*[@id = $id]))[not(self::fx-fore)]',
+      sourceObject,
+      null,
+      { id },
+      { namespaceResolver: xhtmlNamespaceResolver },
+  );
+
+  if (allMatchingTargetObjects.length === 0) {
+    return null;
+  }
+
+  if (
+      allMatchingTargetObjects.length === 1 &&
+      fxEvaluateXPathToBoolean(
+          '(ancestor::fx-fore | ancestor::fx-repeat)[last()]/self::fx-fore',
+          allMatchingTargetObjects[0],
+          null,
+          null,
+          { namespaceResolver: xhtmlNamespaceResolver },
+      )
+  ) {
+    // If the target element is not repeated, then the search for the target object is trivial since
+    // there is only one associated with the target element that bears the matching ID. This is true
+    // regardless of whether or not the source object is repeated. However, if the target element is
+    // repeated, then additional information must be used to help select a target object from among
+    // those associated with the identified target element.
+    const targetObject = allMatchingTargetObjects[0];
+    if (nodeName && targetObject.localName !== nodeName) {
+      return null;
+    }
+    return targetObject;
+  }
+
+  // SPEC:
+
+  // 12.2.1 References to Elements within a repeat Element
+
+  // When the target element that is identified by the IDREF of a source object has one or more
+  // repeat elements as ancestors, then the set of ancestor repeats are partitioned into two
+  // subsets, those in common with the source element and those that are not in common. Any ancestor
+  // repeat elements of the target element not in common with the source element are descendants of
+  // the repeat elements that the source and target element have in common, if any.
+
+  // For the repeat elements that are in common, the desired target object exists in the same set of
+  // run-time objects that contains the source object. Then, for each ancestor repeat of the target
+  // element that is not in common with the source element, the current index of the repeat
+  // determines the set of run-time objects that contains the desired target object.
+  for (const ancestorRepeatItem of fxEvaluateXPathToNodes(
+      'ancestor::fx-repeatitem => reverse()',
+      sourceObject,
+      null,
+      null,
+      { namespaceResolver: xhtmlNamespaceResolver },
+  )) {
+    const foundTargetObjects = allMatchingTargetObjects.filter(to =>
+        ancestorRepeatItem.contains(to),
+    );
+    switch (foundTargetObjects.length) {
+      case 0:
+        // Nothing found: ignore
+        break;
+      case 1: {
+        // A single one is found: the target object is directly in a common repeat
+        const targetObject = foundTargetObjects[0];
+        if (nodeName && targetObject.localName !== nodeName) {
+          return null;
+        }
+        return targetObject;
+      }
+      default: {
+        // Multiple target objects are found: they are in a repeat that is not common with the source object
+        // We found a target object in a common repeat! We now need to find the one that is in the repeatitem identified at the current index
+        const targetObject = foundTargetObjects.find(to =>
+            fxEvaluateXPathToNodes(
+                'every $ancestor of ancestor::fx-repeatitem satisfies $ancestor is $ancestor/../child::fx-repeatitem[../@repeat-index]',
+                to,
+                null,
+                {},
+            ),
+        );
+        if (!targetObject) {
+          // Nothing valid found for whatever reason. This might be something dynamic?
+          return null;
+        }
+        if (nodeName && targetObject.localName !== nodeName) {
+          return null;
+        }
+        return targetObject;
+      }
+    }
+  }
+  // We found no target objects in common repeats. The id is unresolvable
+  return null;
+}
+
 /**
  * Resolve a namespace. Needs a namespace prefix and the element that is most closely related to the
  * XPath in which the namespace is being resolved. The prefix will be resolved by using the
@@ -120,7 +193,7 @@ function createNamespaceResolver(xpathQuery, formElement) {
     let instance;
     if (instanceReferences[0] === 'default') {
       const actualForeElement = fxEvaluateXPathToFirstNode(
-        'ancestor-or-self::fx-fore',
+        'ancestor-or-self::fx-fore[1]',
         formElement,
         null,
         null,
@@ -187,6 +260,10 @@ function createNamespaceResolverForNode(query, contextNode, formElement) {
   return createNamespaceResolver(query, formElement);
 }
 
+// A global registry of function names that are declared in Fore by a developer using the
+// `fx-function` element. These should be available without providing a prefix as well
+export const globallyDeclaredFunctionLocalNames = [];
+
 /**
  * Implementation of the functionNameResolver passed to FontoXPath to
  * redirect function resolving for unprefixed functions to either the fn or the xf namespace
@@ -207,7 +284,12 @@ function functionNameResolver({ prefix, localName }, _arity) {
     case 'logtree':
       return { namespaceURI: XFORMS_NAMESPACE_URI, localName };
     default:
-      if (prefix === '' || prefix === 'fn') {
+      if (prefix === '' && globallyDeclaredFunctionLocalNames.includes(localName)) {
+        // The function has been declared without a prefix and is called here without a prefix.
+        // Just make this work. It is the developer-friendly way
+        return { namespaceURI: 'http://www.w3.org/2005/xquery-local-functions', localName };
+      }
+      if (prefix === 'fn') {
         return { namespaceURI: 'http://www.w3.org/2005/xpath-functions', localName };
       }
       if (prefix === 'local') {
@@ -236,9 +318,11 @@ function getVariablesInScope(formElement) {
   }
 
   const variables = {};
-  for (const key of closestActualFormElement.inScopeVariables.keys()) {
-    const varElement = closestActualFormElement.inScopeVariables.get(key);
-    variables[key] = varElement.value;
+  if (closestActualFormElement.inScopeVariables) {
+    for (const key of closestActualFormElement.inScopeVariables.keys()) {
+      const varElement = closestActualFormElement.inScopeVariables.get(key);
+      variables[key] = varElement.value;
+    }
   }
   return variables;
 }
@@ -260,7 +344,7 @@ export function evaluateXPath(xpath, contextNode, formElement, variables = {}) {
     contextNode,
     null,
     { ...variablesInScope, ...variables },
-    'xs:anyType',
+    fxEvaluateXPath.ALL_RESULTS_TYPE,
     {
       currentContext: { formElement, variables },
       moduleImports: {
@@ -438,102 +522,6 @@ export function evaluateXPathToNumber(
 /**
  * Resolve an id in scope. Behaves like the algorithm defined on https://www.w3.org/community/xformsusers/wiki/XForms_2.0#idref-resolve
  */
-export function resolveId(id, sourceObject, nodeName = null) {
-  const allMatchingTargetObjects = fxEvaluateXPathToNodes(
-    'outermost(ancestor-or-self::fx-fore[1]/(descendant::xf-fore|descendant::*[@id = $id]))[not(self::fx-fore)]',
-    sourceObject,
-    null,
-    { id },
-    { namespaceResolver: xhtmlNamespaceResolver },
-  );
-
-  if (allMatchingTargetObjects.length === 0) {
-    return null;
-  }
-
-  if (
-    allMatchingTargetObjects.length === 1 &&
-    fxEvaluateXPathToBoolean(
-      '(ancestor::fx-fore | ancestor::fx-repeat)[last()]/self::fx-fore',
-      allMatchingTargetObjects[0],
-      null,
-      null,
-      { namespaceResolver: xhtmlNamespaceResolver },
-    )
-  ) {
-    // If the target element is not repeated, then the search for the target object is trivial since
-    // there is only one associated with the target element that bears the matching ID. This is true
-    // regardless of whether or not the source object is repeated. However, if the target element is
-    // repeated, then additional information must be used to help select a target object from among
-    // those associated with the identified target element.
-    const targetObject = allMatchingTargetObjects[0];
-    if (nodeName && targetObject.localName !== nodeName) {
-      return null;
-    }
-    return targetObject;
-  }
-
-  // SPEC:
-
-  // 12.2.1 References to Elements within a repeat Element
-
-  // When the target element that is identified by the IDREF of a source object has one or more
-  // repeat elements as ancestors, then the set of ancestor repeats are partitioned into two
-  // subsets, those in common with the source element and those that are not in common. Any ancestor
-  // repeat elements of the target element not in common with the source element are descendants of
-  // the repeat elements that the source and target element have in common, if any.
-
-  // For the repeat elements that are in common, the desired target object exists in the same set of
-  // run-time objects that contains the source object. Then, for each ancestor repeat of the target
-  // element that is not in common with the source element, the current index of the repeat
-  // determines the set of run-time objects that contains the desired target object.
-  for (const ancestorRepeatItem of fxEvaluateXPathToNodes(
-    'ancestor::fx-repeatitem => reverse()',
-    sourceObject,
-    null,
-    null,
-    { namespaceResolver: xhtmlNamespaceResolver },
-  )) {
-    const foundTargetObjects = allMatchingTargetObjects.filter(to =>
-      ancestorRepeatItem.contains(to),
-    );
-    switch (foundTargetObjects.length) {
-      case 0:
-        // Nothing found: ignore
-        break;
-      case 1: {
-        // A single one is found: the target object is directly in a common repeat
-        const targetObject = foundTargetObjects[0];
-        if (nodeName && targetObject.localName !== nodeName) {
-          return null;
-        }
-        return targetObject;
-      }
-      default: {
-        // Multiple target objects are found: they are in a repeat that is not common with the source object
-        // We found a target object in a common repeat! We now need to find the one that is in the repeatitem identified at the current index
-        const targetObject = foundTargetObjects.find(to =>
-          fxEvaluateXPathToNodes(
-            'every $ancestor of ancestor::fx-repeatitem satisfies $ancestor is $ancestor/../child::fx-repeatitem[../@repeat-index]',
-            to,
-            null,
-            {},
-          ),
-        );
-        if (!targetObject) {
-          // Nothing valid found for whatever reason. This might be something dynamic?
-          return null;
-        }
-        if (nodeName && targetObject.localName !== nodeName) {
-          return null;
-        }
-        return targetObject;
-      }
-    }
-  }
-  // We found no target objects in common repeats. The id is unresolvable
-  return null;
-}
 
 const contextFunction = (dynamicContext, string) => {
   const caller = dynamicContext.currentContext.formElement;
@@ -553,7 +541,7 @@ const contextFunction = (dynamicContext, string) => {
     }
   }
   const parent = XPathUtil.getParentBindingElement(caller);
-  const p = caller.nodeName;
+  // const p = caller.nodeName;
   // const p = dynamicContext.domFacade.getParentElement();
 
   if (parent) return parent;
@@ -599,7 +587,7 @@ registerCustomXPathFunction(
         // return JSON.stringify(instance.getDefaultContext());
       } else {
         const def = new XMLSerializer().serializeToString(instance.getDefaultContext());
-        return prettifyXml(def);
+        return Fore.prettifyXml(def);
       }
     }
     return null;
@@ -698,7 +686,7 @@ const instance = (dynamicContext, string) => {
   // TODO: handle no string passed (null will be passed instead)
 
   const formElement = fxEvaluateXPathToFirstNode(
-    'ancestor-or-self::fx-fore',
+    'ancestor-or-self::fx-fore[1]',
     dynamicContext.currentContext.formElement,
     null,
     null,
@@ -771,6 +759,8 @@ registerCustomXPathFunction(
   ['xs:string?'],
   'item()?',
   (dynamicContext, arg) => {
+    if (!dynamicContext.currentContext.variables) return [];
+    if (!arg) return [];
     const payload = dynamicContext.currentContext.variables[arg];
     if (payload.nodeType) {
       console.log('got some node as js object');

package/src/xpath-util.js

@@ -29,10 +29,6 @@ export class XPathUtil {
     return path != null && (path.startsWith('/') || path.startsWith('instance('));
   }
 
-  static isRepeated(element) {
-    return element.parentElement.closest('fx-repeatitem');
-  }
-
   static isSelfReference(ref) {
     return ref === '.' || ref === './text()' || ref === 'text()' || ref === '' || ref === null;
   }
@@ -57,21 +53,32 @@ export class XPathUtil {
     throw new Error('no Fore element present');
   }
 
-  // todo: this will need more work to look upward for instance() expr.
+  /**
+   * 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 'default';
+    return null;
   }
 
   // todo: certainly not ideal to rely on duplicating instance id on instance document - better way later ;)
   static getPath(node) {
-    const path = fx.evaluateXPath('path()', node);
+    const path = fx.evaluateXPathToString('path()', node);
     /*
     const instanceId = node.ownerDocument.firstElementChild.getAttribute('id');
     if (instanceId !== null && instanceId !== 'default') {