@getodk/xforms-engine 0.9.0 → 0.10.0

package/dist/client/SelectNode.d.ts

@@ -13,6 +13,7 @@ export interface SelectItem {
 }
 export type SelectValueOptions = readonly SelectItem[];
 export interface SelectNodeState extends BaseValueNodeState<readonly string[]> {
+    get isSelectWithImages(): boolean;
     get children(): null;
     get valueOptions(): readonly SelectItem[];
     /**

package/dist/client/TextRange.d.ts

@@ -1,3 +1,4 @@
+import { JRResourceURL } from '../../../common/src/jr-resources/JRResourceURL.ts';
 import { ActiveLanguage } from './FormLanguage.ts';
 /**
  * **COMMENTARY**
@@ -135,4 +136,7 @@ export interface TextRange<Role extends TextRole, Origin extends TextOrigin = Te
     [Symbol.iterator](): Iterable<TextChunk>;
     get asString(): string;
     get formatted(): unknown;
+    get imageSource(): JRResourceURL | undefined;
+    get audioSource(): JRResourceURL | undefined;
+    get videoSource(): JRResourceURL | undefined;
 }

package/dist/index.js

@@ -9759,7 +9759,7 @@ const substring = new StringFunction(
     return string2.substring(start, end);
   }
 );
-const string$2 = new StringFunction(
+const string$1 = new StringFunction(
   "string",
   [{ arityType: "optional" }],
   (context, [expression]) => (expression?.evaluate(context) ?? context).toString()
@@ -9792,13 +9792,13 @@ const translate = new StringFunction(
   }
 );
 
-const string$3 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+const string$2 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
   __proto__: null,
   concat: concat$1,
   contains,
   normalizeSpace,
   startsWith,
-  string: string$2,
+  string: string$1,
   stringLength,
   substring,
   substringAfter,
@@ -9810,7 +9810,7 @@ const fn$2 = new FunctionLibrary(FN_NAMESPACE_URI, [
   ...Object.values(boolean$2),
   ...Object.values(nodeset$1),
   ...Object.values(number$3),
-  ...Object.values(string$3)
+  ...Object.values(string$2)
 ]);
 
 class BaseStep {
@@ -11590,21 +11590,21 @@ const enk = new FunctionLibrary(ENKETO_NAMESPACE_URI, [
   new FunctionAlias("format-date", formatDateTime)
 ]);
 
-const itext = new StringFunction(
+const itext = new NodeSetFunction(
   "itext",
   [{ arityType: "required", typeHint: "string" }],
   (context, [itextIDExpression]) => {
     const itextID = itextIDExpression.evaluate(context).toString();
-    return XFormsXPathEvaluator.getDefaultTranslationText(context, itextID);
+    return XFormsXPathEvaluator.getTranslationValues(context, itextID) ?? [];
   }
 );
 
-const string$1 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+const nodeSet = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
   __proto__: null,
   itext
 }, Symbol.toStringTag, { value: 'Module' }));
 
-const jr$2 = new FunctionLibrary(JAVAROSA_NAMESPACE_URI, [...Object.values(string$1)]);
+const jr$2 = new FunctionLibrary(JAVAROSA_NAMESPACE_URI, [...Object.values(nodeSet)]);
 
 const booleanFromString = new BooleanFunction(
   "boolean-from-string",
@@ -19307,46 +19307,39 @@ class XFormsItextTranslations {
     return textMap.get(itextID) ?? null;
   }
   /**
+   * Retrieves all translation value elements for a given Itext in the active language.
+   *
    * @package
    *
-   * Here, "default" is meant as more precise language than "regular" as
-   * {@link https://getodk.github.io/xforms-spec/#languages | specified by ODK XForms}. In other words, this is equivalent to the following hypothetical XPath pseudo-code (whitespace added to improve structural clarity):
+   * This method fetches the `text` element matching `itextID` and returns its child `value` elements,
+   * which may have an optional `@form` attribute.
+   *
+   * The operation is conceptually similar to the following XPath query:
    *
    * ```xpath
-   * string(
-   *   imaginary:itext-translation(
-   *     xpath3-fn:environment-variable('activeLanguage')
-   *   )
-   *     /text[@id = $itextID]
-   *       /value[not(@form)]
+   * imaginary:itext-translation(
+   *   xpath3-fn:environment-variable('activeLanguage')
    * )
+   *   /text[@id = $itextID]
+   *     /value
    * ```
    *
    * Or alternately:
    *
    * ```xpath
-   * string(
-   *   imaginary:itext-root()
-   *     /translation[@lang = xpath3-fn:environment-variable('activeLanguage')]
-   *       /text[@id = $itextID]
-   *         /value[not(@form)]
-   * )
+   * imaginary:itext-root()
+   *   /translation[@lang = xpath3-fn:environment-variable('activeLanguage')]
+   *     /text[@id = $itextID]
+   *       /value
    * ```
-   *
-   * @todo The above really feels like it adds some helpful clarity to how `jr:itext()` is designed to work, and the kinds of structures, state and input involved. Since there's already some discomfort around that API as specified, it's worth considering
+   * Returns an array of `XFormsItextTranslationValueElement<T>`
    */
-  getDefaultTranslationText(itextID) {
+  getTranslationValues(itextID) {
     const textElement = this.getTranslationTextElement(itextID);
     if (textElement == null) {
-      return "";
-    }
-    const { domProvider } = this;
-    for (const valueElement of domProvider.getChildrenByLocalName(textElement, "value")) {
-      if (!domProvider.hasLocalNamedAttribute(valueElement, "form")) {
-        return domProvider.getNodeValue(valueElement);
-      }
+      return [];
     }
-    return "";
+    return [...this.domProvider.getChildrenByLocalName(textElement, "value")];
   }
   getLanguages() {
     return this.languages;
@@ -19383,9 +19376,9 @@ class XFormsXPathEvaluator extends Evaluator {
     assertInternalXFormsXPathEvaluatorContext(context);
     return context.evaluator.secondaryInstancesById.get(id) ?? null;
   }
-  static getDefaultTranslationText(context, itextID) {
+  static getTranslationValues(context, itextID) {
     assertInternalXFormsXPathEvaluatorContext(context);
-    return context.evaluator.itextTranslations.getDefaultTranslationText(itextID);
+    return context.evaluator.itextTranslations.getTranslationValues(itextID);
   }
   rootNode;
   /**
@@ -19939,8 +19932,13 @@ const isTranslationFunctionCall = (syntaxNode) => {
   ]);
 };
 const isTranslationExpression = (expression) => {
-  const { rootNode } = expressionParser.parse(expression);
-  const functionCallNode = findTypedPrincipalExpressionNode(["function_call"], rootNode);
+  let result;
+  try {
+    result = expressionParser.parse(expression);
+  } catch {
+    return false;
+  }
+  const functionCallNode = findTypedPrincipalExpressionNode(["function_call"], result.rootNode);
   if (functionCallNode == null) {
     return false;
   }
@@ -20104,77 +20102,43 @@ class DependentExpression {
   }
 }
 
+const isOutputElement = (element) => {
+  return element.localName === "output" && element.hasAttribute("value");
+};
 class TextChunkExpression extends DependentExpression {
+  source;
+  // Set for the literal source, blank otherwise
   stringValue;
-  constructor(context, expression, options = {}) {
-    super(context, "string", expression, {
+  constructor(context, resultType, expression, source, options = {}, literalValue = "") {
+    super(context, resultType, expression, {
       semanticDependencies: {
         translations: options.isTranslated
       },
       ignoreContextReference: true
     });
+    this.source = source;
+    this.stringValue = literalValue;
   }
-}
-
-class TextLiteralExpression extends TextChunkExpression {
-  constructor(context, stringValue) {
-    super(context, "null");
-    this.stringValue = stringValue;
-  }
-  static from(context, stringValue) {
-    return new this(context, stringValue);
-  }
-  source = "literal";
-}
-
-const isOutputElement = (element) => {
-  return element.localName === "output" && element.hasAttribute("value");
-};
-class TextOutputExpression extends TextChunkExpression {
-  static from(context, element) {
-    if (isOutputElement(element)) {
-      return new this(context, element);
-    }
-    return null;
-  }
-  source = "output";
-  constructor(context, element) {
-    super(context, element.getAttribute("value"));
-  }
-}
-
-class TextReferenceExpression extends TextChunkExpression {
-  static from(context, refExpression) {
-    return new this(context, refExpression);
+  static fromLiteral(context, stringValue) {
+    return new TextChunkExpression(context, "string", "null", "literal", {}, stringValue);
   }
-  source = "reference";
-  constructor(context, refExpression) {
-    super(context, refExpression);
+  static fromReference(context, ref) {
+    return new TextChunkExpression(context, "string", ref, "reference");
   }
-}
-
-class TextTranslationExpression extends TextChunkExpression {
-  static fromMessage(context, maybeExpression) {
-    try {
-      expressionParser.parse(maybeExpression);
-    } catch {
+  static fromOutput(context, element) {
+    if (!isOutputElement(element)) {
       return null;
     }
-    if (isTranslationExpression(maybeExpression)) {
-      return new this(context, maybeExpression);
-    }
-    return null;
+    return new TextChunkExpression(context, "string", element.getAttribute("value"), "output");
   }
-  static from(context, maybeExpression) {
+  static fromTranslation(context, maybeExpression) {
     if (isTranslationExpression(maybeExpression)) {
-      return new this(context, maybeExpression);
+      return new TextChunkExpression(context, "nodes", maybeExpression, "translation", {
+        isTranslated: true
+      });
     }
     return null;
   }
-  source = "translation";
-  constructor(context, expression) {
-    super(context, expression, { isTranslated: true });
-  }
 }
 
 const absolutePathNodeList = (pathNode) => {
@@ -20423,16 +20387,20 @@ class TextElementDefinition extends TextRangeDefinition {
     if (refExpression == null) {
       this.chunks = Array.from(sourceNode.childNodes).flatMap((childNode) => {
         if (isElementNode(childNode)) {
-          return TextOutputExpression.from(context, childNode) ?? [];
+          return TextChunkExpression.fromOutput(context, childNode) ?? [];
         }
         if (isTextNode(childNode)) {
-          return TextLiteralExpression.from(context, childNode.data);
+          return TextChunkExpression.fromLiteral(context, childNode.data);
         }
         return [];
       });
     } else {
-      const refChunk = TextTranslationExpression.from(context, refExpression) ?? TextReferenceExpression.from(context, refExpression);
-      this.chunks = [refChunk];
+      const expression = TextChunkExpression.fromTranslation(context, refExpression);
+      if (expression != null) {
+        this.chunks = [expression];
+      } else {
+        this.chunks = [TextChunkExpression.fromReference(context, refExpression)];
+      }
     }
   }
 }
@@ -20684,8 +20652,12 @@ class ItemsetLabelDefinition extends TextRangeDefinition {
     if (refExpression == null) {
       throw new Error("<itemset><label> missing ref attribute");
     }
-    const refChunk = TextTranslationExpression.from(this, refExpression) ?? TextReferenceExpression.from(this, refExpression);
-    this.chunks = [refChunk];
+    const expression = TextChunkExpression.fromTranslation(this, refExpression);
+    if (expression != null) {
+      this.chunks = [expression];
+    } else {
+      this.chunks = [TextChunkExpression.fromReference(this, refExpression)];
+    }
   }
 }
 
@@ -21593,8 +21565,12 @@ class MessageDefinition extends TextRangeDefinition {
   constructor(bind, role, message) {
     super(bind.form, bind, null);
     this.role = role;
-    const chunk = TextTranslationExpression.fromMessage(this, message) ?? TextLiteralExpression.from(this, message);
-    this.chunks = [chunk];
+    const expression = TextChunkExpression.fromTranslation(this, message);
+    if (expression != null) {
+      this.chunks = [expression];
+    } else {
+      this.chunks = [TextChunkExpression.fromLiteral(this, message)];
+    }
   }
   static from(bind, type) {
     const message = bind.bindElement.getAttributeNS(JAVAROSA_NAMESPACE_URI$1, type);
@@ -29479,10 +29455,11 @@ class TextChunk {
 }
 
 class TextRange {
-  constructor(origin, role, chunks) {
+  constructor(origin, role, chunks, mediaSources) {
     this.origin = origin;
     this.role = role;
     this.chunks = chunks;
+    this.mediaSources = mediaSources;
   }
   *[Symbol.iterator]() {
     yield* this.chunks;
@@ -29493,44 +29470,56 @@ class TextRange {
   get asString() {
     return this.chunks.map((chunk) => chunk.asString).join("");
   }
+  get imageSource() {
+    return this.mediaSources?.image;
+  }
+  get audioSource() {
+    return this.mediaSources?.audio;
+  }
+  get videoSource() {
+    return this.mediaSources?.video;
+  }
 }
 
-const createComputedTextChunk = (context, textSource) => {
-  const { source } = textSource;
-  if (source === "literal") {
-    const { stringValue } = textSource;
-    return {
-      source,
-      getText: () => stringValue
-    };
-  }
-  return context.scope.runTask(() => {
-    const getText = createComputedExpression(context, textSource, {
-      defaultValue: ""
-    });
-    return {
-      source,
-      getText
-    };
-  });
-};
-const createTextChunks = (context, textSources) => {
-  return context.scope.runTask(() => {
-    const chunkComputations = textSources.map((textSource) => {
-      return createComputedTextChunk(context, textSource);
-    });
-    return createMemo(() => {
-      return chunkComputations.map(({ source, getText }) => {
-        return new TextChunk(context, source, getText());
-      });
+const createTextChunks = (context, chunkExpressions) => {
+  return createMemo(() => {
+    const chunks = [];
+    const mediaSources = {};
+    chunkExpressions.forEach((chunkExpression) => {
+      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);
+              }
+            }
+          }
+        });
+      }
     });
+    return { chunks, mediaSources };
   });
 };
 const createTextRange = (context, role, definition) => {
   return context.scope.runTask(() => {
-    const getTextChunks = createTextChunks(context, definition.chunks);
+    const textChunks = createTextChunks(context, definition.chunks);
     return createMemo(() => {
-      return new TextRange("form", role, getTextChunks());
+      const chunks = textChunks();
+      return new TextRange("form", role, chunks.chunks, chunks.mediaSources);
     });
   });
 };
@@ -29697,8 +29686,7 @@ const createInstanceValueState = (context) => {
 const engineViolationMessage = (context, role) => {
   const messageText = VALIDATION_TEXT[role];
   const chunk = new TextChunk(context, "literal", messageText);
-  const message = new TextRange("engine", role, [chunk]);
-  return () => message;
+  return () => new TextRange("engine", role, [chunk]);
 };
 const createViolationMessage = (context, role, definition) => {
   if (definition == null) {
@@ -30875,6 +30863,9 @@ class SelectControl extends ValueNode {
     this.appearances = definition.bodyElement.appearances;
     this.selectType = definition.bodyElement.type;
     const valueOptions = createItemCollection(this);
+    const isSelectWithImages = this.scope.runTask(() => {
+      return createMemo(() => valueOptions().some((item) => !!item.label.imageSource));
+    });
     const mapOptionsByValue = this.scope.runTask(() => {
       return createMemo(() => {
         return new Map(valueOptions().map((item) => [item.value, item]));
@@ -30909,7 +30900,8 @@ class SelectControl extends ValueNode {
         children: null,
         valueOptions,
         value: valueState,
-        instanceValue: this.getInstanceValue
+        instanceValue: this.getInstanceValue,
+        isSelectWithImages
       },
       this.instanceConfig
     );