@getodk/xforms-engine 0.12.0 → 0.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getodk/xforms-engine",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "license": "Apache-2.0",
   "description": "XForms engine for ODK Web Forms",
   "type": "module",
@@ -62,7 +62,7 @@
   "devDependencies": {
     "@babel/core": "^7.28.0",
     "@getodk/tree-sitter-xpath": "0.2.0",
-    "@getodk/xpath": "0.7.0",
+    "@getodk/xpath": "0.8.0",
     "@playwright/test": "^1.53.2",
     "@types/papaparse": "^5.3.16",
     "@vitest/browser": "^3.2.4",

package/src/client/TextRange.ts

@@ -48,15 +48,6 @@ import type { 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).
  */
 // prettier-ignore
 export type TextChunkSource =

package/src/instance/RankControl.ts

@@ -1,4 +1,4 @@
-import { XPathNodeKindKey } from '@getodk/xpath';
+import { type XPathChoiceNode, XPathNodeKindKey } from '@getodk/xpath';
 import type { Accessor } from 'solid-js';
 import { createMemo } from 'solid-js';
 import type { RankDefinition, RankItem, RankNode, RankValueOptions } from '../client/RankNode.ts';
@@ -67,7 +67,8 @@ export class RankControl
 		XFormsXPathElement,
 		EvaluationContext,
 		ValidationContext,
-		ClientReactiveSerializableValueNode
+		ClientReactiveSerializableValueNode,
+		XPathChoiceNode
 {
 	static from(
 		parent: GeneralParentNode,
@@ -205,4 +206,9 @@ export class RankControl
 		this.setValueState(valuesInOrder);
 		return this.root;
 	}
+
+	getChoiceName(value: string): string | null {
+		const option = this.mapOptionsByValue().get(value);
+		return option?.label?.asString ?? null;
+	}
 }

package/src/instance/SelectControl.ts

@@ -1,4 +1,4 @@
-import { XPathNodeKindKey } from '@getodk/xpath';
+import { type XPathChoiceNode, XPathNodeKindKey } from '@getodk/xpath';
 import type { Accessor } from 'solid-js';
 import { createMemo } from 'solid-js';
 import type {
@@ -61,7 +61,8 @@ export class SelectControl
 		XFormsXPathElement,
 		EvaluationContext,
 		ValidationContext,
-		ClientReactiveSerializableValueNode
+		ClientReactiveSerializableValueNode,
+		XPathChoiceNode
 {
 	static from(
 		parent: GeneralParentNode,
@@ -231,4 +232,9 @@ export class SelectControl
 
 		return this.root;
 	}
+
+	getChoiceName(value: string): string | null {
+		const option = this.mapOptionsByValue().get(value);
+		return option?.label?.asString ?? null;
+	}
 }

package/src/lib/reactivity/text/createTextRange.ts

@@ -1,12 +1,13 @@
-import { JRResourceURL } from '@getodk/common/jr-resources/JRResourceURL.ts';
+import {
+	JRResourceURL,
+	type JRResourceURLString,
+} from '@getodk/common/jr-resources/JRResourceURL.ts';
 import type { Accessor } from 'solid-js';
 import { createMemo } from 'solid-js';
 import type { TextRole } from '../../../client/TextRange.ts';
 import type { EvaluationContext } from '../../../instance/internal-api/EvaluationContext.ts';
 import { TextChunk } from '../../../instance/text/TextChunk.ts';
 import { TextRange, type MediaSources } from '../../../instance/text/TextRange.ts';
-import { isEngineXPathElement } from '../../../integration/xpath/adapter/kind.ts';
-import { StaticElement } from '../../../integration/xpath/static-dom/StaticElement.ts';
 import { type TextChunkExpression } from '../../../parse/expression/TextChunkExpression.ts';
 import type { TextRangeDefinition } from '../../../parse/text/abstract/TextRangeDefinition.ts';
 import { createComputedExpression } from '../createComputedExpression.ts';
@@ -25,45 +26,44 @@ interface ChunksAndMedia {
  * @param chunkExpressions - Array of text source expressions to process.
  * @returns An accessor for an object with all chunks and the first image (if any).
  */
-const createTextChunks = (
+const createTextChunks = <Role extends TextRole>(
 	context: EvaluationContext,
-	chunkExpressions: ReadonlyArray<TextChunkExpression<'nodes' | 'string'>>
+	definition: TextRangeDefinition<Role>
 ): Accessor<ChunksAndMedia> => {
 	return createMemo(() => {
 		const chunks: TextChunk[] = [];
 		const mediaSources: MediaSources = {};
 
+		let chunkExpressions: ReadonlyArray<TextChunkExpression<'string'>>;
+
+		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 {
+			// only translations have 'nodes' chunks
+			chunkExpressions = definition.chunks as Array<TextChunkExpression<'string'>>;
+		}
+
 		chunkExpressions.forEach((chunkExpression) => {
+			if (chunkExpression.resourceType) {
+				mediaSources[chunkExpression.resourceType] = JRResourceURL.from(
+					chunkExpression.stringValue as JRResourceURLString
+				);
+				return;
+			}
+
 			if (chunkExpression.source === 'literal') {
 				chunks.push(new TextChunk(context, chunkExpression.source, chunkExpression.stringValue));
 				return;
 			}
 
 			const computed = createComputedExpression(context, chunkExpression)();
-
-			if (typeof computed === 'string') {
-				// not a translation expression
-				chunks.push(new TextChunk(context, chunkExpression.source, computed));
-				return;
-			} else {
-				// translation expression evaluates to an entire itext block, process forms separately
-				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 as keyof MediaSources] = JRResourceURL.from(formValue);
-							}
-						}
-					}
-				});
-			}
+			chunks.push(new TextChunk(context, chunkExpression.source, computed));
 		});
 
 		return { chunks, mediaSources };
@@ -86,7 +86,7 @@ export const createTextRange = <Role extends TextRole>(
 	definition: TextRangeDefinition<Role>
 ): ComputedFormTextRange<Role> => {
 	return context.scope.runTask(() => {
-		const textChunks = createTextChunks(context, definition.chunks);
+		const textChunks = createTextChunks(context, definition);
 
 		return createMemo(() => {
 			const chunks = textChunks();

package/src/parse/body/control/ItemsetDefinition.ts

@@ -6,8 +6,8 @@ import { ItemsetLabelDefinition } from '../../text/ItemsetLabelDefinition.ts';
 import type { XFormDefinition } from '../../XFormDefinition.ts';
 import { parseNodesetReference } from '../../xpath/reference-parsing.ts';
 import { BodyElementDefinition } from '../BodyElementDefinition.ts';
-import type { AnySelectControlDefinition } from './SelectControlDefinition.ts';
 import { RankControlDefinition } from './RankControlDefinition.ts';
+import type { AnySelectControlDefinition } from './SelectControlDefinition.ts';
 
 export class ItemsetDefinition extends BodyElementDefinition<'itemset'> {
 	override readonly category = 'support';
@@ -28,7 +28,7 @@ export class ItemsetDefinition extends BodyElementDefinition<'itemset'> {
 
 		const nodesetExpression = parseNodesetReference(parent, element, 'nodeset');
 
-		this.nodes = new ItemsetNodesetExpression(this, nodesetExpression);
+		this.nodes = new ItemsetNodesetExpression(nodesetExpression);
 		this.reference = nodesetExpression;
 
 		const valueElement = getValueElement(element);

package/src/parse/expression/BindComputationExpression.ts

@@ -47,18 +47,15 @@ export class BindComputationExpression<
 			return null as BindComputationFactoryResult<Type>;
 		}
 
-		return new this(bind, computation, expression);
+		return new this(computation, expression);
 	}
 
 	readonly isDefaultExpression: boolean;
 
 	protected constructor(
-		bind: BindDefinition,
 		readonly computation: Computation,
 		expression: string | null
 	) {
-		const ignoreContextReference = computation === 'constraint';
-
 		let isDefaultExpression: boolean;
 		let resolvedExpression: string;
 
@@ -75,9 +72,7 @@ export class BindComputationExpression<
 			resolvedExpression = expression;
 		}
 
-		super(bind, bindComputationResultTypes[computation], resolvedExpression, {
-			ignoreContextReference,
-		});
+		super(bindComputationResultTypes[computation], resolvedExpression);
 
 		this.isDefaultExpression = isDefaultExpression;
 	}

package/src/parse/expression/ItemsetNodesetExpression.ts

@@ -1,8 +1,7 @@
-import type { ItemsetDefinition } from '../body/control/ItemsetDefinition.ts';
 import { DependentExpression } from './abstract/DependentExpression.ts';
 
 export class ItemsetNodesetExpression extends DependentExpression<'nodes'> {
-	constructor(itemset: ItemsetDefinition, nodesetExpression: string) {
-		super(itemset.parent, 'nodes', nodesetExpression);
+	constructor(nodesetExpression: string) {
+		super('nodes', nodesetExpression);
 	}
 }

package/src/parse/expression/ItemsetValueExpression.ts

@@ -6,6 +6,6 @@ export class ItemsetValueExpression extends DependentExpression<'string'> {
 		readonly itemset: ItemsetDefinition,
 		expression: string
 	) {
-		super(itemset, 'string', expression);
+		super('string', expression);
 	}
 }

package/src/parse/expression/RepeatCountControlExpression.ts

@@ -23,7 +23,7 @@ export class RepeatCountControlExpression extends DependentExpression<'number'>
 		const { countExpression, noAddRemoveExpression } = bodyElement;
 
 		if (countExpression != null) {
-			return new this(bodyElement, countExpression);
+			return new this(countExpression);
 		}
 
 		if (noAddRemoveExpression != null && isConstantTruthyExpression(noAddRemoveExpression)) {
@@ -32,13 +32,13 @@ export class RepeatCountControlExpression extends DependentExpression<'number'>
 			// repeat's template.
 			const fixedCountExpression = String(Math.max(initialCount, 1));
 
-			return new this(bodyElement, fixedCountExpression);
+			return new this(fixedCountExpression);
 		}
 
 		return null;
 	}
 
-	private constructor(context: RepeatElementDefinition, expression: string) {
-		super(context, 'number', expression);
+	private constructor(expression: string) {
+		super('number', expression);
 	}
 }

package/src/parse/expression/TextChunkExpression.ts

@@ -1,11 +1,14 @@
+import type {
+	JRResourceURLString,
+	ResourceType,
+} from '@getodk/common/jr-resources/JRResourceURL.ts';
 import type { KnownAttributeLocalNamedElement } from '@getodk/common/types/dom.ts';
 import type { TextChunkSource } from '../../client/TextRange.ts';
-import type { AnyTextRangeDefinition } from '../text/abstract/TextRangeDefinition.ts';
-import { isTranslationExpression } from '../xpath/semantic-analysis.ts';
+import { getTranslationExpression } from '../xpath/semantic-analysis.ts';
 import { DependentExpression } from './abstract/DependentExpression.ts';
 
 interface TextChunkExpressionOptions {
-	readonly isTranslated?: true;
+	readonly type?: ResourceType;
 }
 
 interface OutputElement extends KnownAttributeLocalNamedElement<'output', 'value'> {}
@@ -18,59 +21,46 @@ export class TextChunkExpression<T extends 'nodes' | 'string'> extends Dependent
 	readonly source: TextChunkSource;
 	// Set for the literal source, blank otherwise
 	readonly stringValue: string;
+	readonly resourceType: ResourceType | null;
 
 	constructor(
-		context: AnyTextRangeDefinition,
 		resultType: T,
 		expression: string,
 		source: TextChunkSource,
-		options: TextChunkExpressionOptions = {},
-		literalValue = ''
+		literalValue = '',
+		options: TextChunkExpressionOptions = {}
 	) {
-		super(context, resultType, expression, {
-			semanticDependencies: {
-				translations: options.isTranslated,
-			},
-			ignoreContextReference: true,
-		});
+		super(resultType, expression);
 
+		this.resourceType = options.type ?? null;
 		this.source = source;
 		this.stringValue = literalValue;
 	}
 
-	static fromLiteral(
-		context: AnyTextRangeDefinition,
-		stringValue: string
-	): TextChunkExpression<'string'> {
-		return new TextChunkExpression(context, 'string', 'null', 'literal', {}, stringValue);
+	static fromLiteral(stringValue: string): TextChunkExpression<'string'> {
+		return new TextChunkExpression('string', 'null', 'literal', stringValue);
 	}
 
-	static fromReference(
-		context: AnyTextRangeDefinition,
-		ref: string
-	): TextChunkExpression<'string'> {
-		return new TextChunkExpression(context, 'string', ref, 'reference');
+	static fromReference(ref: string): TextChunkExpression<'string'> {
+		return new TextChunkExpression('string', ref, 'reference');
 	}
 
-	static fromOutput(
-		context: AnyTextRangeDefinition,
-		element: Element
-	): TextChunkExpression<'string'> | null {
+	static fromOutput(element: Element): TextChunkExpression<'string'> | null {
 		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: AnyTextRangeDefinition,
-		maybeExpression: string
-	): TextChunkExpression<'nodes'> | null {
-		if (isTranslationExpression(maybeExpression)) {
-			return new TextChunkExpression(context, 'nodes', maybeExpression, 'translation', {
-				isTranslated: true,
-			});
+	static fromResource(url: JRResourceURLString, type: ResourceType): TextChunkExpression<'string'> {
+		return new TextChunkExpression('string', 'null', 'literal', url, { type });
+	}
+
+	static fromTranslation(maybeExpression: string): TextChunkExpression<'nodes'> | null {
+		const translationExpression = getTranslationExpression(maybeExpression);
+		if (translationExpression) {
+			return new TextChunkExpression('nodes', translationExpression, 'translation');
 		}
 
 		return null;

package/src/parse/expression/abstract/DependentExpression.ts

@@ -3,12 +3,7 @@ import type {
 	ConstantExpression,
 	ConstantTruthyExpression,
 } from '../../xpath/semantic-analysis.ts';
-import {
-	isConstantExpression,
-	isConstantTruthyExpression,
-	isTranslationExpression,
-} from '../../xpath/semantic-analysis.ts';
-import type { DependencyContext } from './DependencyContext.ts';
+import { isConstantExpression, isConstantTruthyExpression } from '../../xpath/semantic-analysis.ts';
 
 const evaluatorMethodsByResultType = {
 	boolean: 'evaluateBoolean',
@@ -28,22 +23,6 @@ export type DependentExpressionResult<Type extends DependentExpressionResultType
 	EngineXPathEvaluator[DependentExpressionEvaluatorMethod<Type>]
 >;
 
-interface SemanticDependencyOptions {
-	/**
-	 * @default false
-	 */
-	readonly translations?: boolean | undefined;
-}
-
-interface DependentExpressionOptions {
-	/**
-	 * @default false
-	 */
-	readonly ignoreContextReference?: boolean;
-
-	readonly semanticDependencies?: SemanticDependencyOptions;
-}
-
 export interface ConstantDependentExpression<Type extends DependentExpressionResultType>
 	extends DependentExpression<Type> {
 	readonly expression: ConstantExpression;
@@ -60,10 +39,8 @@ export abstract class DependentExpression<Type extends DependentExpressionResult
 	readonly constantTruthyExpression: ConstantTruthyExpression | null;
 
 	constructor(
-		context: DependencyContext,
 		readonly resultType: Type,
-		readonly expression: string,
-		options: DependentExpressionOptions = {}
+		readonly expression: string
 	) {
 		if (resultType === 'boolean' && isConstantTruthyExpression(expression)) {
 			this.constantTruthyExpression = expression;
@@ -77,19 +54,6 @@ export abstract class DependentExpression<Type extends DependentExpressionResult
 		}
 
 		this.evaluatorMethod = evaluatorMethodsByResultType[resultType];
-
-		const {
-			semanticDependencies = {
-				translations: false,
-			},
-		} = options;
-
-		const isTranslated = semanticDependencies.translations && isTranslationExpression(expression);
-
-		if (isTranslated) {
-			this.isTranslated = true;
-			context.isTranslated = true;
-		}
 	}
 
 	isConstantExpression(): this is ConstantDependentExpression<Type> {

package/src/parse/model/ModelDefinition.ts

@@ -1,7 +1,10 @@
+import type { ActiveLanguage } from '../../client/FormLanguage.ts';
 import { ErrorProductionDesignPendingError } from '../../error/ErrorProductionDesignPendingError.ts';
 import type { StaticDocument } from '../../integration/xpath/static-dom/StaticDocument.ts';
+import { TextChunkExpression } from '../expression/TextChunkExpression.ts';
 import { parseStaticDocumentFromDOMSubtree } from '../shared/parseStaticDocumentFromDOMSubtree.ts';
 import type { XFormDefinition } from '../XFormDefinition.ts';
+import { generateItextChunks, type ChunkExpressionsByItextId } from './generateItextChunks.ts';
 import { ItextTranslationsDefinition } from './ItextTranslationsDefinition.ts';
 import { ModelBindMap } from './ModelBindMap.ts';
 import type { AnyNodeDefinition } from './NodeDefinition.ts';
@@ -16,6 +19,7 @@ export class ModelDefinition {
 	readonly nodes: NodeDefinitionMap;
 	readonly instance: StaticDocument;
 	readonly itextTranslations: ItextTranslationsDefinition;
+	readonly itextChunks: Map<string, ChunkExpressionsByItextId>;
 
 	constructor(readonly form: XFormDefinition) {
 		const submission = new SubmissionDefinition(form.xformDOM);
@@ -27,6 +31,7 @@ export 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);
 	}
 
 	getNodeDefinition(nodeset: string): AnyNodeDefinition {
@@ -54,4 +59,12 @@ export class ModelDefinition {
 
 		return rest;
 	}
+
+	getTranslationChunks(
+		itextId: string,
+		activeLanguage: ActiveLanguage
+	): ReadonlyArray<TextChunkExpression<'string'>> {
+		const languageMap = this.itextChunks.get(activeLanguage.language);
+		return languageMap?.get(itextId) ?? [];
+	}
 }

package/src/parse/model/generateItextChunks.ts

@@ -0,0 +1,61 @@
+import {
+	isResourceType,
+	type JRResourceURLString,
+	type ResourceType,
+} from '@getodk/common/jr-resources/JRResourceURL.ts';
+import { isElementNode, isTextNode } from '@getodk/common/lib/dom/predicates.ts';
+import { TextChunkExpression } from '../expression/TextChunkExpression.ts';
+import type { DOMItextTranslationElement } from '../XFormDOM.ts';
+
+const generateChunk = (node: Node): TextChunkExpression<'string'> | null => {
+	if (isElementNode(node)) {
+		return TextChunkExpression.fromOutput(node);
+	}
+	if (isTextNode(node)) {
+		const formAttribute = node.parentElement!.getAttribute('form') as ResourceType;
+		if (isResourceType(formAttribute)) {
+			return TextChunkExpression.fromResource(node.data as JRResourceURLString, formAttribute);
+		}
+		return TextChunkExpression.fromLiteral(node.data);
+	}
+	return null;
+};
+
+const generateChunksForValues = (valueElement: ChildNode): Array<TextChunkExpression<'string'>> => {
+	return Array.from(valueElement.childNodes)
+		.map((node) => generateChunk(node))
+		.filter((chunk) => chunk !== null);
+};
+
+const generateChunksForTranslation = (
+	textElement: Element
+): Array<TextChunkExpression<'string'>> => {
+	return Array.from(textElement.childNodes).flatMap((valueElement) =>
+		generateChunksForValues(valueElement)
+	);
+};
+
+const generateChunksForLanguage = (
+	translationElement: DOMItextTranslationElement
+): Map<string, ReadonlyArray<TextChunkExpression<'string'>>> => {
+	return new Map(
+		Array.from(translationElement.children).map((textElement) => {
+			const itextId = textElement.getAttribute('id');
+			return [itextId!, generateChunksForTranslation(textElement)] as const;
+		})
+	);
+};
+
+export interface ChunkExpressionsByItextId
+	extends Map<string, ReadonlyArray<TextChunkExpression<'string'>>> {}
+
+export const generateItextChunks = (
+	translationElements: readonly DOMItextTranslationElement[]
+): Map<string, ChunkExpressionsByItextId> => {
+	return new Map(
+		translationElements.map((translationElement) => {
+			const lang = translationElement.getAttribute('lang');
+			return [lang, generateChunksForLanguage(translationElement)] as const;
+		})
+	);
+};

package/src/parse/text/ItemsetLabelDefinition.ts

@@ -30,11 +30,11 @@ export class ItemsetLabelDefinition extends TextRangeDefinition<'item-label'> {
 			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)];
 		}
 	}
 }

package/src/parse/text/MessageDefinition.ts

@@ -29,11 +29,11 @@ export class MessageDefinition<
 	) {
 		super(bind.form, bind, null);
 
-		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)];
 		}
 	}
 }

package/src/parse/text/abstract/TextElementDefinition.ts

@@ -21,27 +21,26 @@ export abstract class TextElementDefinition<
 	constructor(form: XFormDefinition, owner: TextElementOwner, sourceNode: TextSourceNode<Role>) {
 		super(form, owner, sourceNode);
 
-		const context = this as AnyTextElementDefinition;
 		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)];
 			}
 		}
 	}