@getodk/xforms-engine 0.12.0 → 0.13.0

package/dist/client/TextRange.d.ts

@@ -47,15 +47,6 @@ import { ActiveLanguage } from './FormLanguage.ts';
  *   - `h:body//hint/@ref[not(is-translation-expr())]`
  *
  *   (See notes above for clarification of `is-translation-expr()`.)
- *
- * @todo It's unclear whether this will all become simpler or more compelex when
- * we add support for outputs in translations. In theory, the actual translation
- * `<text>` nodes map quite well to the `TextRange` concept (i.e. they are a
- * range of static and output chunks, just like labels and hints). The potential
- * for complications arise from XPath implementation details being largely
- * opaque (as in, the `jr:itext` implementation is encapsulated in the `xpath`
- * package, and the engine doesn't really deal with itext translations at the
- * node level at all).
  */
 export type TextChunkSource = 'literal' | 'output' | 'reference' | 'translation';
 /**

package/dist/index.js

@@ -11576,7 +11576,45 @@ const nodeSet = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
   itext
 }, Symbol.toStringTag, { value: 'Module' }));
 
-const jr$2 = new FunctionLibrary(JAVAROSA_NAMESPACE_URI, [...Object.values(nodeSet)]);
+const choiceName = new StringFunction(
+  "choice-name",
+  [
+    { arityType: "required", typeHint: "string" },
+    { arityType: "required", typeHint: "string" }
+  ],
+  (context, [nodeExpression, valueExpression]) => {
+    const node = nodeExpression.evaluate(context).toString();
+    const value = valueExpression.evaluate(context).toString();
+    const [contextNode] = context.contextNodes;
+    const { domProvider } = context;
+    let nodes;
+    if (contextNode && domProvider.isElement(contextNode)) {
+      nodes = context.evaluator.evaluateNodes(value, { contextNode });
+    } else {
+      nodes = context.evaluator.evaluateNodes(value);
+    }
+    const firstNode = nodes?.[0];
+    if (!firstNode) {
+      return "";
+    }
+    if (!("getChoiceName" in firstNode)) {
+      throw new Error(
+        `Evaluating 'jr:choice-name' on element '${value}' which has no possible choices.`
+      );
+    }
+    return firstNode.getChoiceName(node) ?? "";
+  }
+);
+
+const select$1 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+  __proto__: null,
+  choiceName
+}, Symbol.toStringTag, { value: 'Module' }));
+
+const jr$2 = new FunctionLibrary(JAVAROSA_NAMESPACE_URI, [
+  ...Object.values(nodeSet),
+  ...Object.values(select$1)
+]);
 
 const booleanFromString = new BooleanFunction(
   "boolean-from-string",
@@ -19007,6 +19045,10 @@ const hex = /*#__PURE__*/_mergeNamespaces({
   default: encHex
 }, [encHexExports]);
 
+const base64Decode$1 = (base64Input) => {
+  return new TextDecoder().decode(Uint8Array.from(atob(base64Input), (m) => m.charCodeAt(0)));
+};
+
 const toStrings = (context, expressions) => {
   return expressions.flatMap((arg) => {
     const result = arg.evaluate(context);
@@ -19018,6 +19060,17 @@ const toStrings = (context, expressions) => {
   });
 };
 
+const base64Decode = new StringFunction(
+  "base64-decode",
+  [{ arityType: "required", typeHint: "string" }],
+  (context, [base64Expression]) => {
+    try {
+      return base64Decode$1(base64Expression.evaluate(context).toString());
+    } catch {
+      return "";
+    }
+  }
+);
 const coalesce = new StringFunction(
   "coalesce",
   [
@@ -19107,6 +19160,23 @@ const join = new StringFunction(
     return strings.join(glue);
   }
 );
+const pulldata = new StringFunction(
+  "pulldata",
+  [
+    { arityType: "required", typeHint: "string" },
+    { arityType: "required", typeHint: "string" },
+    { arityType: "required", typeHint: "string" },
+    { arityType: "required", typeHint: "string" }
+  ],
+  (context, [instanceExpression, desiredElementExpression, queryElementExpression, queryExpression]) => {
+    const instanceId = instanceExpression.evaluate(context).toString();
+    const desiredElement = desiredElementExpression.evaluate(context).toString();
+    const queryElement = queryElementExpression.evaluate(context).toString();
+    const query = queryExpression.evaluate(context).toString();
+    const expr = `instance('${instanceId}')/root/item[${queryElement}='${query}']/${desiredElement}`;
+    return context.evaluator.evaluateString(expr);
+  }
+);
 const regex = new BooleanFunction(
   "regex",
   [
@@ -19185,11 +19255,13 @@ const uuid = new StringFunction(
 
 const string = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
   __proto__: null,
+  base64Decode,
   coalesce,
   concat,
   digest,
   endsWith,
   join,
+  pulldata,
   regex,
   substr,
   uuid
@@ -19903,18 +19975,32 @@ const isTranslationFunctionCall = (syntaxNode) => {
     ANY_ARGUMENT_TYPE
   ]);
 };
-const isTranslationExpression = (expression) => {
+const findFunctionPrincipalExpressionNode = (expression) => {
   let result;
   try {
     result = expressionParser.parse(expression);
   } catch {
-    return false;
+    return null;
   }
   const functionCallNode = findTypedPrincipalExpressionNode(["function_call"], result.rootNode);
   if (functionCallNode == null) {
-    return false;
+    return null;
   }
-  return isTranslationFunctionCall(functionCallNode);
+  return functionCallNode;
+};
+const getTranslationExpression = (expression) => {
+  const functionCallNode = findFunctionPrincipalExpressionNode(expression);
+  if (!functionCallNode) {
+    return null;
+  }
+  if (!isTranslationFunctionCall(functionCallNode)) {
+    return null;
+  }
+  const arg = functionCallNode.children.find((child) => child.type === "argument");
+  if (!arg) {
+    return null;
+  }
+  return arg.text;
 };
 const isCurrentFunctionCall = (syntaxNode) => {
   return isCallToLocalNamedFunction(syntaxNode, "current") && hasCallSignature(syntaxNode, []);
@@ -20034,7 +20120,7 @@ const evaluatorMethodsByResultType = {
   string: "evaluateString"
 };
 class DependentExpression {
-  constructor(context, resultType, expression, options = {}) {
+  constructor(resultType, expression) {
     this.resultType = resultType;
     this.expression = expression;
     if (resultType === "boolean" && isConstantTruthyExpression(expression)) {
@@ -20048,16 +20134,6 @@ class DependentExpression {
       this.constantExpression = null;
     }
     this.evaluatorMethod = evaluatorMethodsByResultType[resultType];
-    const {
-      semanticDependencies = {
-        translations: false
-      }
-    } = options;
-    const isTranslated = semanticDependencies.translations && isTranslationExpression(expression);
-    if (isTranslated) {
-      this.isTranslated = true;
-      context.isTranslated = true;
-    }
   }
   isTranslated = false;
   evaluatorMethod;
@@ -20081,33 +20157,32 @@ class TextChunkExpression extends DependentExpression {
   source;
   // Set for the literal source, blank otherwise
   stringValue;
-  constructor(context, resultType, expression, source, options = {}, literalValue = "") {
-    super(context, resultType, expression, {
-      semanticDependencies: {
-        translations: options.isTranslated
-      },
-      ignoreContextReference: true
-    });
+  resourceType;
+  constructor(resultType, expression, source, literalValue = "", options = {}) {
+    super(resultType, expression);
+    this.resourceType = options.type ?? null;
     this.source = source;
     this.stringValue = literalValue;
   }
-  static fromLiteral(context, stringValue) {
-    return new TextChunkExpression(context, "string", "null", "literal", {}, stringValue);
+  static fromLiteral(stringValue) {
+    return new TextChunkExpression("string", "null", "literal", stringValue);
   }
-  static fromReference(context, ref) {
-    return new TextChunkExpression(context, "string", ref, "reference");
+  static fromReference(ref) {
+    return new TextChunkExpression("string", ref, "reference");
   }
-  static fromOutput(context, element) {
+  static fromOutput(element) {
     if (!isOutputElement(element)) {
       return null;
     }
-    return new TextChunkExpression(context, "string", element.getAttribute("value"), "output");
+    return new TextChunkExpression("string", element.getAttribute("value"), "output");
   }
-  static fromTranslation(context, maybeExpression) {
-    if (isTranslationExpression(maybeExpression)) {
-      return new TextChunkExpression(context, "nodes", maybeExpression, "translation", {
-        isTranslated: true
-      });
+  static fromResource(url, type) {
+    return new TextChunkExpression("string", "null", "literal", url, { type });
+  }
+  static fromTranslation(maybeExpression) {
+    const translationExpression = getTranslationExpression(maybeExpression);
+    if (translationExpression) {
+      return new TextChunkExpression("nodes", translationExpression, "translation");
     }
     return null;
   }
@@ -20354,24 +20429,23 @@ class TextElementDefinition extends TextRangeDefinition {
   chunks;
   constructor(form, owner, sourceNode) {
     super(form, owner, sourceNode);
-    const context = this;
     const refExpression = parseNodesetReference(owner, sourceNode, "ref");
     if (refExpression == null) {
       this.chunks = Array.from(sourceNode.childNodes).flatMap((childNode) => {
         if (isElementNode(childNode)) {
-          return TextChunkExpression.fromOutput(context, childNode) ?? [];
+          return TextChunkExpression.fromOutput(childNode) ?? [];
         }
         if (isTextNode(childNode)) {
-          return TextChunkExpression.fromLiteral(context, childNode.data);
+          return TextChunkExpression.fromLiteral(childNode.data);
         }
         return [];
       });
     } else {
-      const expression = TextChunkExpression.fromTranslation(context, refExpression);
-      if (expression != null) {
-        this.chunks = [expression];
+      const translationChunk = TextChunkExpression.fromTranslation(refExpression);
+      if (translationChunk) {
+        this.chunks = [translationChunk];
       } else {
-        this.chunks = [TextChunkExpression.fromReference(context, refExpression)];
+        this.chunks = [TextChunkExpression.fromReference(refExpression)];
       }
     }
   }
@@ -20596,14 +20670,14 @@ class RangeControlDefinition extends ControlDefinition {
 }
 
 class ItemsetNodesetExpression extends DependentExpression {
-  constructor(itemset, nodesetExpression) {
-    super(itemset.parent, "nodes", nodesetExpression);
+  constructor(nodesetExpression) {
+    super("nodes", nodesetExpression);
   }
 }
 
 class ItemsetValueExpression extends DependentExpression {
   constructor(itemset, expression) {
-    super(itemset, "string", expression);
+    super("string", expression);
     this.itemset = itemset;
   }
 }
@@ -20624,11 +20698,11 @@ class ItemsetLabelDefinition extends TextRangeDefinition {
     if (refExpression == null) {
       throw new Error("<itemset><label> missing ref attribute");
     }
-    const expression = TextChunkExpression.fromTranslation(this, refExpression);
-    if (expression != null) {
-      this.chunks = [expression];
+    const translationChunk = TextChunkExpression.fromTranslation(refExpression);
+    if (translationChunk) {
+      this.chunks = [translationChunk];
     } else {
-      this.chunks = [TextChunkExpression.fromReference(this, refExpression)];
+      this.chunks = [TextChunkExpression.fromReference(refExpression)];
     }
   }
 }
@@ -20638,7 +20712,7 @@ class ItemsetDefinition extends BodyElementDefinition {
     super(form, parent, element);
     this.parent = parent;
     const nodesetExpression = parseNodesetReference(parent, element, "nodeset");
-    this.nodes = new ItemsetNodesetExpression(this, nodesetExpression);
+    this.nodes = new ItemsetNodesetExpression(nodesetExpression);
     this.reference = nodesetExpression;
     const valueElement = getValueElement(element);
     if (valueElement == null) {
@@ -21457,6 +21531,64 @@ const parseStaticDocumentFromDOMSubtree = (subtreeRootElement, options = {}) =>
   });
 };
 
+const JR_RESOURCE_URL_PROTOCOL = "jr:";
+const ALL_RESOURCE_TYPES = ["image", "audio", "video"];
+const isResourceType = (string) => {
+  return ALL_RESOURCE_TYPES.includes(string);
+};
+class JRResourceURL extends URL {
+  static create(category, fileName) {
+    return new this(`jr://${category}/${fileName}`);
+  }
+  static from(url) {
+    return new this(url);
+  }
+  static isJRResourceReference(reference) {
+    return reference?.startsWith(JR_RESOURCE_URL_PROTOCOL) ?? false;
+  }
+  constructor(url) {
+    super(url);
+  }
+}
+
+const generateChunk = (node) => {
+  if (isElementNode(node)) {
+    return TextChunkExpression.fromOutput(node);
+  }
+  if (isTextNode(node)) {
+    const formAttribute = node.parentElement.getAttribute("form");
+    if (isResourceType(formAttribute)) {
+      return TextChunkExpression.fromResource(node.data, formAttribute);
+    }
+    return TextChunkExpression.fromLiteral(node.data);
+  }
+  return null;
+};
+const generateChunksForValues = (valueElement) => {
+  return Array.from(valueElement.childNodes).map((node) => generateChunk(node)).filter((chunk) => chunk !== null);
+};
+const generateChunksForTranslation = (textElement) => {
+  return Array.from(textElement.childNodes).flatMap(
+    (valueElement) => generateChunksForValues(valueElement)
+  );
+};
+const generateChunksForLanguage = (translationElement) => {
+  return new Map(
+    Array.from(translationElement.children).map((textElement) => {
+      const itextId = textElement.getAttribute("id");
+      return [itextId, generateChunksForTranslation(textElement)];
+    })
+  );
+};
+const generateItextChunks = (translationElements) => {
+  return new Map(
+    translationElements.map((translationElement) => {
+      const lang = translationElement.getAttribute("lang");
+      return [lang, generateChunksForLanguage(translationElement)];
+    })
+  );
+};
+
 const assertItextTranslationsDefinitionEntry = ([
   key,
   root
@@ -21503,8 +21635,7 @@ const bindComputationResultTypes = {
   saveIncomplete: "boolean"
 };
 class BindComputationExpression extends DependentExpression {
-  constructor(bind, computation, expression) {
-    const ignoreContextReference = computation === "constraint";
+  constructor(computation, expression) {
     let isDefaultExpression;
     let resolvedExpression;
     if (expression == null) {
@@ -21517,9 +21648,7 @@ class BindComputationExpression extends DependentExpression {
       isDefaultExpression = false;
       resolvedExpression = expression;
     }
-    super(bind, bindComputationResultTypes[computation], resolvedExpression, {
-      ignoreContextReference
-    });
+    super(bindComputationResultTypes[computation], resolvedExpression);
     this.computation = computation;
     this.isDefaultExpression = isDefaultExpression;
   }
@@ -21528,7 +21657,7 @@ class BindComputationExpression extends DependentExpression {
     if (expression == null) {
       return null;
     }
-    return new this(bind, computation, expression);
+    return new this(computation, expression);
   }
   isDefaultExpression;
 }
@@ -21537,11 +21666,11 @@ class MessageDefinition extends TextRangeDefinition {
   constructor(bind, role, message) {
     super(bind.form, bind, null);
     this.role = role;
-    const expression = TextChunkExpression.fromTranslation(this, message);
-    if (expression != null) {
-      this.chunks = [expression];
+    const translationChunk = TextChunkExpression.fromTranslation(message);
+    if (translationChunk) {
+      this.chunks = [translationChunk];
     } else {
-      this.chunks = [TextChunkExpression.fromLiteral(this, message)];
+      this.chunks = [TextChunkExpression.fromLiteral(message)];
     }
   }
   static from(bind, type) {
@@ -26409,16 +26538,16 @@ class RepeatCountControlExpression extends DependentExpression {
   static from(bodyElement, initialCount) {
     const { countExpression, noAddRemoveExpression } = bodyElement;
     if (countExpression != null) {
-      return new this(bodyElement, countExpression);
+      return new this(countExpression);
     }
     if (noAddRemoveExpression != null && isConstantTruthyExpression(noAddRemoveExpression)) {
       const fixedCountExpression = String(Math.max(initialCount, 1));
-      return new this(bodyElement, fixedCountExpression);
+      return new this(fixedCountExpression);
     }
     return null;
   }
-  constructor(context, expression) {
-    super(context, "number", expression);
+  constructor(expression) {
+    super("number", expression);
   }
 }
 
@@ -26685,12 +26814,14 @@ class ModelDefinition {
     this.root = new RootDefinition(form, this, submission, form.body.classes);
     this.nodes = nodeDefinitionMap(this.root);
     this.itextTranslations = ItextTranslationsDefinition.from(form.xformDOM);
+    this.itextChunks = generateItextChunks(form.xformDOM.itextTranslationElements);
   }
   binds;
   root;
   nodes;
   instance;
   itextTranslations;
+  itextChunks;
   getNodeDefinition(nodeset) {
     const definition = this.nodes.get(nodeset);
     if (definition == null) {
@@ -26709,6 +26840,10 @@ class ModelDefinition {
     const { form, ...rest } = this;
     return rest;
   }
+  getTranslationChunks(itextId, activeLanguage) {
+    const languageMap = this.itextChunks.get(activeLanguage.language);
+    return languageMap?.get(itextId) ?? [];
+  }
 }
 
 class XFormDefinition {
@@ -26734,22 +26869,6 @@ class XFormDefinition {
   model;
 }
 
-const JR_RESOURCE_URL_PROTOCOL = "jr:";
-class JRResourceURL extends URL {
-  static create(category, fileName) {
-    return new this(`jr://${category}/${fileName}`);
-  }
-  static from(url) {
-    return new this(url);
-  }
-  static isJRResourceReference(reference) {
-    return reference?.startsWith(JR_RESOURCE_URL_PROTOCOL) ?? false;
-  }
-  constructor(url) {
-    super(url);
-  }
-}
-
 const assertSecondaryInstanceDefinition = ({ root }) => {
   const id = root.getAttributeValue("id");
   if (id == null) {
@@ -29454,42 +29573,42 @@ class TextRange {
   }
 }
 
-const createTextChunks = (context, chunkExpressions) => {
+const createTextChunks = (context, definition) => {
   return createMemo(() => {
     const chunks = [];
     const mediaSources = {};
+    let chunkExpressions;
+    if (definition.chunks[0]?.source === "translation") {
+      const itextId = context.evaluator.evaluateString(definition.chunks[0].toString(), {
+        contextNode: context.contextNode
+      });
+      chunkExpressions = definition.form.model.getTranslationChunks(
+        itextId,
+        context.getActiveLanguage()
+      );
+    } else {
+      chunkExpressions = definition.chunks;
+    }
     chunkExpressions.forEach((chunkExpression) => {
+      if (chunkExpression.resourceType) {
+        mediaSources[chunkExpression.resourceType] = JRResourceURL.from(
+          chunkExpression.stringValue
+        );
+        return;
+      }
       if (chunkExpression.source === "literal") {
         chunks.push(new TextChunk(context, chunkExpression.source, chunkExpression.stringValue));
         return;
       }
       const computed = createComputedExpression(context, chunkExpression)();
-      if (typeof computed === "string") {
-        chunks.push(new TextChunk(context, chunkExpression.source, computed));
-        return;
-      } else {
-        computed.forEach((itextForm) => {
-          if (isEngineXPathElement(itextForm) && itextForm instanceof StaticElement) {
-            const formAttribute = itextForm.getAttributeValue("form");
-            if (!formAttribute) {
-              const defaultFormValue = itextForm.getXPathValue();
-              chunks.push(new TextChunk(context, chunkExpression.source, defaultFormValue));
-            } else if (["image", "video", "audio"].includes(formAttribute)) {
-              const formValue = itextForm.getXPathValue();
-              if (JRResourceURL.isJRResourceReference(formValue)) {
-                mediaSources[formAttribute] = JRResourceURL.from(formValue);
-              }
-            }
-          }
-        });
-      }
+      chunks.push(new TextChunk(context, chunkExpression.source, computed));
     });
     return { chunks, mediaSources };
   });
 };
 const createTextRange = (context, role, definition) => {
   return context.scope.runTask(() => {
-    const textChunks = createTextChunks(context, definition.chunks);
+    const textChunks = createTextChunks(context, definition);
     return createMemo(() => {
       const chunks = textChunks();
       return new TextRange("form", role, chunks.chunks, chunks.mediaSources);
@@ -30368,6 +30487,10 @@ class RankControl extends ValueNode {
     this.setValueState(valuesInOrder);
     return this.root;
   }
+  getChoiceName(value) {
+    const option = this.mapOptionsByValue().get(value);
+    return option?.label?.asString ?? null;
+  }
 }
 
 const insertAtIndex = (currentValues, insertionIndex, newValues) => {
@@ -30932,6 +31055,10 @@ class SelectControl extends ValueNode {
     this.setValueState(effectiveValues);
     return this.root;
   }
+  getChoiceName(value) {
+    const option = this.mapOptionsByValue().get(value);
+    return option?.label?.asString ?? null;
+  }
 }
 
 class Subtree extends DescendantNode {