@getodk/xforms-engine 0.8.0 → 0.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getodk/xforms-engine",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "license": "Apache-2.0",
   "description": "XForms engine for ODK Web Forms",
   "type": "module",
@@ -56,12 +56,13 @@
   "dependencies": {
     "bin-packer": "1.7.0",
     "papaparse": "^5.5.2",
-    "solid-js": "^1.9.5"
+    "solid-js": "^1.9.5",
+    "temporal-polyfill": "^0.3.0"
   },
   "devDependencies": {
     "@babel/core": "^7.26.10",
     "@getodk/tree-sitter-xpath": "0.1.3",
-    "@getodk/xpath": "0.4.1",
+    "@getodk/xpath": "0.6.0",
     "@playwright/test": "^1.49.1",
     "@types/papaparse": "^5.3.15",
     "@vitest/browser": "^3.0.9",

package/src/client/InputNode.ts

@@ -84,11 +84,13 @@ export interface InputNode<V extends ValueType = ValueType>
 export type StringInputValue = InputValue<'string'>;
 export type IntInputValue = InputValue<'int'>;
 export type DecimalInputValue = InputValue<'decimal'>;
+export type DateInputValue = InputValue<'date'>;
 export type GeopointInputValue = InputValue<'geopoint'>;
 
 export type StringInputNode = InputNode<'string'>;
 export type IntInputNode = InputNode<'int'>;
 export type DecimalInputNode = InputNode<'decimal'>;
+export type DateInputNode = InputNode<'date'>;
 export type GeopointInputNode = InputNode<'geopoint'>;
 
 // prettier-ignore
@@ -97,6 +99,7 @@ type SupportedInputValueType =
 	| 'string'
 	| 'int'
 	| 'decimal'
+	| 'date'
 	| 'geopoint';
 
 type TemporaryStringValueType = Exclude<ValueType, SupportedInputValueType>;
@@ -109,5 +112,6 @@ export type AnyInputNode =
 	| StringInputNode
 	| IntInputNode
 	| DecimalInputNode
+	| DateInputNode
 	| GeopointInputNode
 	| TemporaryStringValueInputNode;

package/src/client/NoteNode.ts

@@ -81,11 +81,13 @@ export interface NoteNode<V extends ValueType = ValueType> extends BaseValueNode
 export type StringNoteValue = NoteValue<'string'>;
 export type IntNoteValue = NoteValue<'int'>;
 export type DecimalNoteValue = NoteValue<'decimal'>;
+export type DateNoteValue = NoteValue<'date'>;
 export type GeopointNoteValue = NoteValue<'geopoint'>;
 
 export type StringNoteNode = NoteNode<'string'>;
 export type IntNoteNode = NoteNode<'int'>;
 export type DecimalNoteNode = NoteNode<'decimal'>;
+export type DateNoteNode = NoteNode<'date'>;
 export type GeopointNoteNode = NoteNode<'geopoint'>;
 
 // prettier-ignore
@@ -94,6 +96,7 @@ type SupportedNoteValueType =
 	| 'string'
 	| 'int'
 	| 'decimal'
+	| 'date'
 	| 'geopoint';
 
 type TemporaryStringValueType = Exclude<ValueType, SupportedNoteValueType>;
@@ -106,5 +109,6 @@ export type AnyNoteNode =
 	| StringNoteNode
 	| IntNoteNode
 	| DecimalNoteNode
+	| DateNoteNode
 	| GeopointNoteNode
 	| TemporaryStringValueNoteNode;

package/src/client/SelectNode.ts

@@ -19,6 +19,8 @@ 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/src/client/TextRange.ts

@@ -1,5 +1,5 @@
+import { JRResourceURL } from '@getodk/common/jr-resources/JRResourceURL.ts';
 import type { ActiveLanguage } from './FormLanguage.ts';
-import type { RootNodeState } from './RootNode.ts';
 
 /**
  * **COMMENTARY**
@@ -156,4 +156,8 @@ export interface TextRange<Role extends TextRole, Origin extends TextOrigin = Te
 
 	get asString(): string;
 	get formatted(): unknown;
+
+	get imageSource(): JRResourceURL | undefined;
+	get audioSource(): JRResourceURL | undefined;
+	get videoSource(): JRResourceURL | undefined;
 }

package/src/instance/SelectControl.ts

@@ -51,6 +51,7 @@ interface SelectControlStateSpec extends ValueNodeStateSpec<readonly string[]> {
 	readonly label: Accessor<TextRange<'label'> | null>;
 	readonly hint: Accessor<TextRange<'hint'> | null>;
 	readonly valueOptions: Accessor<SelectValueOptions>;
+	readonly isSelectWithImages: Accessor<boolean>;
 }
 
 export class SelectControl
@@ -109,6 +110,10 @@ export class SelectControl
 
 		const valueOptions = createItemCollection(this);
 
+		const isSelectWithImages = this.scope.runTask(() => {
+			return createMemo(() => valueOptions().some((item) => !!item.label.imageSource));
+		});
+
 		const mapOptionsByValue: Accessor<SelectItemMap> = this.scope.runTask(() => {
 			return createMemo(() => {
 				return new Map(valueOptions().map((item) => [item.value, item]));
@@ -150,6 +155,7 @@ export class SelectControl
 				valueOptions,
 				value: valueState,
 				instanceValue: this.getInstanceValue,
+				isSelectWithImages,
 			},
 			this.instanceConfig
 		);

package/src/instance/text/TextRange.ts

@@ -1,3 +1,4 @@
+import { JRResourceURL } from '@getodk/common/jr-resources/JRResourceURL.ts';
 import type {
 	TextRange as ClientTextRange,
 	TextChunk,
@@ -6,6 +7,12 @@ import type {
 } from '../../client/TextRange.ts';
 import { FormattedTextStub } from './FormattedTextStub.ts';
 
+export interface MediaSources {
+	image?: JRResourceURL;
+	video?: JRResourceURL;
+	audio?: JRResourceURL;
+}
+
 export class TextRange<Role extends TextRole, Origin extends TextOrigin>
 	implements ClientTextRange<Role, Origin>
 {
@@ -21,9 +28,22 @@ export class TextRange<Role extends TextRole, Origin extends TextOrigin>
 		return this.chunks.map((chunk) => chunk.asString).join('');
 	}
 
+	get imageSource(): JRResourceURL | undefined {
+		return this.mediaSources?.image;
+	}
+
+	get audioSource(): JRResourceURL | undefined {
+		return this.mediaSources?.audio;
+	}
+
+	get videoSource(): JRResourceURL | undefined {
+		return this.mediaSources?.video;
+	}
+
 	constructor(
 		readonly origin: Origin,
 		readonly role: Role,
-		protected readonly chunks: readonly TextChunk[]
+		protected readonly chunks: readonly TextChunk[],
+		protected readonly mediaSources?: MediaSources
 	) {}
 }

package/src/integration/xpath/adapter/traversal.ts

@@ -18,7 +18,9 @@ export const getContainingEngineXPathDocument = (node: EngineXPathNode): EngineX
 	return node.rootDocument;
 };
 
-export const getEngineXPathAttributes = (node: EngineXPathNode): Iterable<EngineXPathAttribute> => {
+export const getEngineXPathAttributes = (
+	node: EngineXPathNode
+): readonly EngineXPathAttribute[] => {
 	if (node.nodeType === 'static-element') {
 		return node.attributes;
 	}
@@ -39,7 +41,7 @@ export const getEngineXPathAttributes = (node: EngineXPathNode): Iterable<Engine
  * it throw? It might be nice to be alerted if the assumptions in point 2 above
  * are somehow wrong (or become wrong).
  */
-export const getNamespaceDeclarations = (): Iterable<never> => [];
+export const getNamespaceDeclarations = (): readonly [] => [];
 
 export const getParentNode = (node: EngineXPathNode): EngineXPathParentNode | null => {
 	if (node.nodeType === 'repeat-instance') {

package/src/lib/codecs/DateValueCodec.ts

@@ -0,0 +1,94 @@
+import { ISO_DATE_OR_DATE_TIME_NO_OFFSET_PATTERN } from '@getodk/common/constants/datetime.ts';
+import { Temporal } from 'temporal-polyfill';
+import { type CodecDecoder, type CodecEncoder, ValueCodec } from './ValueCodec.ts';
+
+export type DatetimeRuntimeValue = Temporal.PlainDate | null;
+
+export type DatetimeInputValue =
+	| Date
+	| Temporal.PlainDate
+	| Temporal.PlainDateTime
+	| Temporal.ZonedDateTime
+	| string
+	| null;
+
+/**
+ * Parses a string in the format 'YYYY-MM-DD' or 'YYYY-MM-DDTHH:MM:SS' (no offset)
+ * into a Temporal.PlainDate.
+ * TODO: Datetimes with a valid timezone offset are treated as errors.
+ *       User research is needed to determine whether the date should honor
+ *       the timezone or be truncated to the yyyy-mm-dd format only.
+ *
+ * @param value - The string to parse.
+ * @returns A {@link DatetimeRuntimeValue}
+ */
+const parseString = (value: string): DatetimeRuntimeValue => {
+	if (
+		value == null ||
+		typeof value !== 'string' ||
+		!ISO_DATE_OR_DATE_TIME_NO_OFFSET_PATTERN.test(value)
+	) {
+		return null;
+	}
+
+	try {
+		const dateOnly = value.split('T')[0]!;
+		return Temporal.PlainDate.from(dateOnly);
+	} catch {
+		// TODO: should we throw when codec cannot interpret the value?
+		return null;
+	}
+};
+
+/**
+ * Converts a date-like value ({@link DatetimeInputValue}) to a 'YYYY-MM-DD' string.
+ * TODO: Datetimes with a valid timezone offset are treated as errors.
+ *       User research is needed to determine whether the date should honor
+ *       the timezone or be truncated to the yyyy-mm-dd format only.
+ *
+ * @param value - The value to convert.
+ * @returns A date string or empty string if invalid.
+ */
+const toDateString = (value: DatetimeInputValue): string => {
+	if (value == null || value instanceof Temporal.ZonedDateTime) {
+		return '';
+	}
+
+	try {
+		if (value instanceof Temporal.PlainDate) {
+			return value.toString();
+		}
+
+		if (value instanceof Temporal.PlainDateTime) {
+			return value.toPlainDate().toString();
+		}
+
+		if (value instanceof Date) {
+			return Temporal.PlainDate.from({
+				year: value.getFullYear(),
+				month: value.getMonth() + 1,
+				day: value.getDate(),
+			}).toString();
+		}
+
+		const parsed = parseString(String(value));
+		return parsed?.toString() ?? '';
+	} catch {
+		// TODO: should we throw when codec cannot interpret the value?
+		return '';
+	}
+};
+
+export class DateValueCodec extends ValueCodec<'date', DatetimeRuntimeValue, DatetimeInputValue> {
+	constructor() {
+		const encodeValue: CodecEncoder<DatetimeInputValue> = (value) => {
+			return toDateString(value);
+		};
+
+		const decodeValue: CodecDecoder<DatetimeRuntimeValue> = (value: string) => {
+			return parseString(value);
+		};
+
+		super('date', encodeValue, decodeValue);
+	}
+}

package/src/lib/codecs/getSharedValueCodec.ts

@@ -1,4 +1,6 @@
 import type { ValueType } from '../../client/ValueType.ts';
+import type { DatetimeInputValue, DatetimeRuntimeValue } from './DateValueCodec.ts';
+import { DateValueCodec } from './DateValueCodec.ts';
 import {
 	DecimalValueCodec,
 	type DecimalInputValue,
@@ -16,7 +18,7 @@ interface RuntimeValuesByType {
 	readonly int: IntRuntimeValue;
 	readonly decimal: DecimalRuntimeValue;
 	readonly boolean: string;
-	readonly date: string;
+	readonly date: DatetimeRuntimeValue;
 	readonly time: string;
 	readonly dateTime: string;
 	readonly geopoint: GeopointRuntimeValue;
@@ -34,7 +36,7 @@ interface RuntimeInputValuesByType {
 	readonly int: IntInputValue;
 	readonly decimal: DecimalInputValue;
 	readonly boolean: string;
-	readonly date: string;
+	readonly date: DatetimeInputValue;
 	readonly time: string;
 	readonly dateTime: string;
 	readonly geopoint: GeopointInputValue;
@@ -63,7 +65,7 @@ export const sharedValueCodecs: SharedValueCodecs = {
 	int: new IntValueCodec(),
 	decimal: new DecimalValueCodec(),
 	boolean: new ValueTypePlaceholderCodec('boolean'),
-	date: new ValueTypePlaceholderCodec('date'),
+	date: new DateValueCodec(),
 	time: new ValueTypePlaceholderCodec('time'),
 	dateTime: new ValueTypePlaceholderCodec('dateTime'),
 	geopoint: new GeopointValueCodec(),

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

@@ -1,67 +1,79 @@
+import { JRResourceURL } from '@getodk/common/jr-resources/JRResourceURL.ts';
 import type { Accessor } from 'solid-js';
 import { createMemo } from 'solid-js';
-import type { TextChunkSource, TextRole } from '../../../client/TextRange.ts';
+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 } from '../../../instance/text/TextRange.ts';
-import type { AnyTextChunkExpression } from '../../../parse/expression/abstract/TextChunkExpression.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';
 
-interface TextChunkComputation {
-	readonly source: TextChunkSource;
-	readonly getText: Accessor<string>;
+interface ChunksAndMedia {
+	chunks: readonly TextChunk[];
+	mediaSources: MediaSources;
 }
 
-const createComputedTextChunk = (
+/**
+ * Creates a reactive accessor for text chunks and an optional image from text source expressions.
+ * - Combines chunks from literal and computed sources into a single array.
+ * - Captures the first image found with a 'from="image"' attribute.
+ *
+ * @param context - The evaluation context for reactive XPath computations.
+ * @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 = (
 	context: EvaluationContext,
-	textSource: AnyTextChunkExpression
-): TextChunkComputation => {
-	const { source } = textSource;
+	chunkExpressions: ReadonlyArray<TextChunkExpression<'nodes' | 'string'>>
+): Accessor<ChunksAndMedia> => {
+	return createMemo(() => {
+		const chunks: TextChunk[] = [];
+		const mediaSources: MediaSources = {};
 
-	if (source === 'literal') {
-		const { stringValue } = textSource;
+		chunkExpressions.forEach((chunkExpression) => {
+			if (chunkExpression.source === 'literal') {
+				chunks.push(new TextChunk(context, chunkExpression.source, chunkExpression.stringValue));
+				return;
+			}
 
-		return {
-			source,
-			getText: () => stringValue,
-		};
-	}
+			const computed = createComputedExpression(context, chunkExpression)();
 
-	return context.scope.runTask(() => {
-		const getText = createComputedExpression(context, textSource, {
-			defaultValue: '',
-		});
+			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');
 
-		return {
-			source,
-			getText,
-		};
-	});
-};
+						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();
 
-const createTextChunks = (
-	context: EvaluationContext,
-	textSources: readonly AnyTextChunkExpression[]
-): Accessor<readonly TextChunk[]> => {
-	return context.scope.runTask(() => {
-		const chunkComputations = textSources.map((textSource) => {
-			return createComputedTextChunk(context, textSource);
+							if (JRResourceURL.isJRResourceReference(formValue)) {
+								mediaSources[formAttribute as keyof MediaSources] = JRResourceURL.from(formValue);
+							}
+						}
+					}
+				});
+			}
 		});
 
-		return createMemo(() => {
-			return chunkComputations.map(({ source, getText }) => {
-				return new TextChunk(context, source, getText());
-			});
-		});
+		return { chunks, mediaSources };
 	});
 };
 
 type ComputedFormTextRange<Role extends TextRole> = Accessor<TextRange<Role, 'form'>>;
 
 /**
- * Creates a text range (e.g. label or hint) from the provided definition,
- * reactive to:
+ * Creates a text range (e.g. label or hint) from the provided definition, reactive to:
  *
  * - The form's current language (e.g. `<label ref="jr:itext('text-id')" />`)
  * - Direct `<output>` references within the label's children
@@ -74,10 +86,11 @@ export const createTextRange = <Role extends TextRole>(
 	definition: TextRangeDefinition<Role>
 ): ComputedFormTextRange<Role> => {
 	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);
 		});
 	});
 };

package/src/lib/reactivity/validation/createValidation.ts

@@ -34,9 +34,7 @@ const engineViolationMessage = <Role extends ValidationTextRole>(
 ): Accessor<EngineViolationMessage<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 = <Role extends ValidationTextRole>(

package/src/parse/expression/TextChunkExpression.ts

@@ -0,0 +1,78 @@
+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 { DependentExpression } from './abstract/DependentExpression.ts';
+
+interface TextChunkExpressionOptions {
+	readonly isTranslated?: true;
+}
+
+interface OutputElement extends KnownAttributeLocalNamedElement<'output', 'value'> {}
+
+const isOutputElement = (element: Element): element is OutputElement => {
+	return element.localName === 'output' && element.hasAttribute('value');
+};
+
+export class TextChunkExpression<T extends 'nodes' | 'string'> extends DependentExpression<T> {
+	readonly source: TextChunkSource;
+	// Set for the literal source, blank otherwise
+	readonly stringValue: string;
+
+	constructor(
+		context: AnyTextRangeDefinition,
+		resultType: T,
+		expression: string,
+		source: TextChunkSource,
+		options: TextChunkExpressionOptions = {},
+		literalValue = ''
+	) {
+		super(context, resultType, expression, {
+			semanticDependencies: {
+				translations: options.isTranslated,
+			},
+			ignoreContextReference: true,
+		});
+
+		this.source = source;
+		this.stringValue = literalValue;
+	}
+
+	static fromLiteral(
+		context: AnyTextRangeDefinition,
+		stringValue: string
+	): TextChunkExpression<'string'> {
+		return new TextChunkExpression(context, 'string', 'null', 'literal', {}, stringValue);
+	}
+
+	static fromReference(
+		context: AnyTextRangeDefinition,
+		ref: string
+	): TextChunkExpression<'string'> {
+		return new TextChunkExpression(context, 'string', ref, 'reference');
+	}
+
+	static fromOutput(
+		context: AnyTextRangeDefinition,
+		element: Element
+	): TextChunkExpression<'string'> | null {
+		if (!isOutputElement(element)) {
+			return null;
+		}
+
+		return new TextChunkExpression(context, '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,
+			});
+		}
+
+		return null;
+	}
+}

package/src/parse/text/ItemsetLabelDefinition.ts

@@ -1,15 +1,10 @@
 import type { LocalNamedElement } from '@getodk/common/types/dom.ts';
 import { getLabelElement } from '../../lib/dom/query.ts';
 import type { XFormDefinition } from '../../parse/XFormDefinition.ts';
-import type { ItemDefinition } from '../body/control/ItemDefinition.ts';
 import type { ItemsetDefinition } from '../body/control/ItemsetDefinition.ts';
-import { TextReferenceExpression } from '../expression/TextReferenceExpression.ts';
-import { TextTranslationExpression } from '../expression/TextTranslationExpression.ts';
-import type { RefAttributeChunk } from './abstract/TextElementDefinition.ts';
+import { TextChunkExpression } from '../expression/TextChunkExpression.ts';
 import { TextRangeDefinition } from './abstract/TextRangeDefinition.ts';
 
-export type ItemLabelOwner = ItemDefinition | ItemsetDefinition;
-
 interface LabelElement extends LocalNamedElement<'label'> {}
 
 export class ItemsetLabelDefinition extends TextRangeDefinition<'item-label'> {
@@ -24,7 +19,7 @@ export class ItemsetLabelDefinition extends TextRangeDefinition<'item-label'> {
 	}
 
 	readonly role = 'item-label';
-	readonly chunks: readonly [RefAttributeChunk];
+	readonly chunks: ReadonlyArray<TextChunkExpression<'nodes' | 'string'>>;
 
 	private constructor(form: XFormDefinition, owner: ItemsetDefinition, element: LabelElement) {
 		super(form, owner, element);
@@ -35,10 +30,11 @@ export class ItemsetLabelDefinition extends TextRangeDefinition<'item-label'> {
 			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)];
+		}
 	}
 }

package/src/parse/text/MessageDefinition.ts

@@ -1,17 +1,9 @@
 import { JAVAROSA_NAMESPACE_URI } from '@getodk/common/constants/xmlns.ts';
-import { TextLiteralExpression } from '../expression/TextLiteralExpression.ts';
-import { TextTranslationExpression } from '../expression/TextTranslationExpression.ts';
+import { TextChunkExpression } from '../expression/TextChunkExpression.ts';
 import type { BindDefinition } from '../model/BindDefinition.ts';
-import type { TextBindAttributeLocalName, TextSourceNode } from './abstract/TextRangeDefinition.ts';
+import type { TextBindAttributeLocalName } from './abstract/TextRangeDefinition.ts';
 import { TextRangeDefinition } from './abstract/TextRangeDefinition.ts';
 
-export type MessageSourceNode = TextSourceNode<TextBindAttributeLocalName>;
-
-// prettier-ignore
-type MessageChunk =
-	| TextLiteralExpression
-	| TextTranslationExpression;
-
 export class MessageDefinition<
 	Type extends TextBindAttributeLocalName,
 > extends TextRangeDefinition<Type> {
@@ -28,7 +20,7 @@ export class MessageDefinition<
 		return new this(bind, type, message);
 	}
 
-	readonly chunks: readonly [MessageChunk];
+	readonly chunks: ReadonlyArray<TextChunkExpression<'nodes' | 'string'>>;
 
 	private constructor(
 		bind: BindDefinition,
@@ -37,11 +29,12 @@ export class MessageDefinition<
 	) {
 		super(bind.form, bind, null);
 
-		const chunk: MessageChunk =
-			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)];
+		}
 	}
 }