@getodk/xforms-engine 0.16.1 → 0.17.0

package/src/lib/codecs/{Geopoint/Geopoint.ts → geolocation/Geolocation.ts}

@@ -1,8 +1,3 @@
-/**
- * This abstract class defines the minimal behavior for a default geopoint.
- * It can be expanded later to support units (e.g., degrees or meters),
- * which would also serve as documentation to clarify what each value represents.
- */
 abstract class SemanticValue<Semantic extends string, Value extends number | null> {
 	abstract readonly semantic: Semantic;
 
@@ -25,26 +20,21 @@ class Accuracy<Value extends number | null = number> extends SemanticValue<'accu
 	readonly semantic = 'accuracy';
 }
 
-export interface GeopointValue {
+export interface LocationPoint {
 	readonly latitude: number;
 	readonly longitude: number;
 	readonly altitude: number | null;
 	readonly accuracy: number | null;
 }
 
-export type GeopointRuntimeValue = GeopointValue | null;
-
-// TODO: Add support for GeoJSONValue
-export type GeopointInputValue = GeopointRuntimeValue | string;
-
-interface GeopointInternalValue {
+interface GeolocationInternalValue {
 	readonly latitude: Latitude;
 	readonly longitude: Longitude;
 	readonly altitude: Altitude<null> | Altitude<number>;
 	readonly accuracy: Accuracy<null> | Accuracy<number>;
 }
 
-type GeopointTuple =
+type LocationPointTuple =
 	| readonly [
 			latitude: Latitude,
 			longitude: Longitude,
@@ -54,6 +44,8 @@ type GeopointTuple =
 	| readonly [latitude: Latitude, longitude: Longitude, altitude: Altitude]
 	| readonly [latitude: Latitude, longitude: Longitude];
 
+export const SEGMENT_SEPARATOR = ';';
+
 const DEGREES_MAX = {
 	latitude: 90,
 	longitude: 180,
@@ -61,10 +53,10 @@ const DEGREES_MAX = {
 
 type CoordinateType = keyof typeof DEGREES_MAX;
 
-export class Geopoint {
-	private readonly internalValue: GeopointInternalValue;
+export class Geolocation {
+	private readonly internalValue: GeolocationInternalValue;
 
-	constructor(coordinates: GeopointValue) {
+	constructor(coordinates: LocationPoint) {
 		const { latitude, longitude, altitude, accuracy } = coordinates;
 
 		this.internalValue = {
@@ -75,7 +67,7 @@ export class Geopoint {
 		};
 	}
 
-	getTuple(): GeopointTuple {
+	getTuple(): LocationPointTuple {
 		const { latitude, longitude, altitude, accuracy } = this.internalValue;
 
 		if (accuracy.value != null) {
@@ -89,12 +81,16 @@ export class Geopoint {
 		return [latitude, longitude];
 	}
 
-	getRuntimeValue(): GeopointRuntimeValue {
+	getRuntimeValue(): LocationPoint | null {
 		const { latitude, longitude, altitude, accuracy } = this.internalValue;
 		const isLatitude = this.isValidDegrees('latitude', latitude.value);
 		const isLongitude = this.isValidDegrees('longitude', longitude.value);
 
-		if (!isLatitude || !isLongitude || Geopoint.isNullLocation(latitude.value, longitude.value)) {
+		if (
+			!isLatitude ||
+			!isLongitude ||
+			Geolocation.isNullLocation(latitude.value, longitude.value)
+		) {
 			return null;
 		}
 
@@ -118,8 +114,9 @@ export class Geopoint {
 		return latitude === 0 && longitude === 0;
 	}
 
-	static parseString(value: string): GeopointRuntimeValue {
-		if (value.trim() === '') {
+	static parseString(value: string): LocationPoint | null {
+		value = value.trim();
+		if (value === '') {
 			return null;
 		}
 
@@ -132,12 +129,12 @@ export class Geopoint {
 		return new this({ latitude, longitude, altitude, accuracy }).getRuntimeValue();
 	}
 
-	static toCoordinatesString(value: GeopointInputValue): string {
-		const decodedValue = typeof value === 'string' ? Geopoint.parseString(value) : value;
+	static toCoordinatesString(value: LocationPoint | string | null): string {
+		const decodedValue = typeof value === 'string' ? Geolocation.parseString(value) : value;
 
 		if (
 			decodedValue == null ||
-			Geopoint.isNullLocation(decodedValue.latitude, decodedValue.longitude)
+			Geolocation.isNullLocation(decodedValue.latitude, decodedValue.longitude)
 		) {
 			return '';
 		}
@@ -147,4 +144,26 @@ export class Geopoint {
 			.map((item) => item.value ?? 0)
 			.join(' ');
 	}
+
+	static isClosedShape(points: LocationPoint[]) {
+		const firstPoint = points[0];
+		const lastPoint = points[points.length - 1];
+		return (
+			firstPoint?.latitude === lastPoint?.latitude && firstPoint?.longitude === lastPoint?.longitude
+		);
+	}
+
+	static getSegments(value: string): string[] | null {
+		if (value.trim() === '') {
+			return null;
+		}
+
+		const parts = value.split(SEGMENT_SEPARATOR);
+		// Handles trailing semicolon, which is valid and common in ODK.
+		if (parts[parts.length - 1]?.trim() === '') {
+			parts.pop();
+		}
+
+		return parts;
+	}
 }

package/src/lib/codecs/geolocation/Geopoint.ts

@@ -0,0 +1,15 @@
+import { Geolocation, type LocationPoint } from './Geolocation.ts';
+
+export type GeopointRuntimeValue = LocationPoint | null;
+
+export type GeopointInputValue = GeopointRuntimeValue | string;
+
+export class Geopoint extends Geolocation {
+	static parseStringToGeopoint(value: string): GeopointRuntimeValue {
+		return Geolocation.parseString(value);
+	}
+
+	static parseGeopointToString(value: GeopointInputValue): string {
+		return Geolocation.toCoordinatesString(value);
+	}
+}

package/src/lib/codecs/geolocation/Geoshape.ts

@@ -0,0 +1,36 @@
+import { Geolocation, type LocationPoint, SEGMENT_SEPARATOR } from './Geolocation.ts';
+
+export type GeoshapeRuntimeValue = LocationPoint[] | null;
+
+export type GeoshapeInputValue = GeoshapeRuntimeValue | string;
+
+export class Geoshape extends Geolocation {
+	static parseStringToGeoshape(value: string): GeoshapeRuntimeValue {
+		const parts = Geolocation.getSegments(value);
+		if (parts === null) {
+			return null;
+		}
+
+		const points = parts.map((point) => Geolocation.parseString(point)) as LocationPoint[];
+		if (points.some((p) => p === null) || points.length < 3 || !Geolocation.isClosedShape(points)) {
+			return null;
+		}
+
+		return points;
+	}
+
+	static parseGeoshapeString(points: GeoshapeInputValue): string {
+		const decodedPoints =
+			typeof points === 'string' ? Geoshape.parseStringToGeoshape(points) : points;
+		if (!decodedPoints) {
+			return '';
+		}
+
+		const segments = decodedPoints.map((point) => Geolocation.toCoordinatesString(point));
+		if (segments.some((s) => !s.length)) {
+			return '';
+		}
+
+		return segments.join(SEGMENT_SEPARATOR);
+	}
+}

package/src/lib/codecs/geolocation/Geotrace.ts

@@ -0,0 +1,36 @@
+import { Geolocation, type LocationPoint, SEGMENT_SEPARATOR } from './Geolocation.ts';
+
+export type GeotraceRuntimeValue = LocationPoint[] | null;
+
+export type GeotraceInputValue = GeotraceRuntimeValue | string;
+
+export class Geotrace extends Geolocation {
+	static parseStringToGeotrace(value: string): GeotraceRuntimeValue {
+		const parts = Geolocation.getSegments(value);
+		if (parts === null) {
+			return null;
+		}
+
+		const points = parts.map((point) => Geolocation.parseString(point)) as LocationPoint[];
+		if (points.some((p) => p === null) || points.length < 2 || Geolocation.isClosedShape(points)) {
+			return null;
+		}
+
+		return points;
+	}
+
+	static parseGeotraceString(points: GeotraceInputValue): string {
+		const decodedPoints =
+			typeof points === 'string' ? Geotrace.parseStringToGeotrace(points) : points;
+		if (!decodedPoints) {
+			return '';
+		}
+
+		const segments = decodedPoints.map((point) => Geolocation.toCoordinatesString(point));
+		if (segments.some((s) => !s.length)) {
+			return '';
+		}
+
+		return segments.join(SEGMENT_SEPARATOR);
+	}
+}

package/src/lib/codecs/geolocation/createGeolocationValueCodec.ts

@@ -0,0 +1,18 @@
+import type { ValueType } from '../../../client';
+import { type CodecDecoder, type CodecEncoder, ValueCodec } from '../ValueCodec.ts';
+
+export function createGeolocationValueCodec<
+	V extends ValueType,
+	RuntimeValue extends RuntimeInputValue,
+	RuntimeInputValue = RuntimeValue,
+>(
+	valueType: V,
+	encodeValue: CodecEncoder<RuntimeInputValue>,
+	decodeValue: CodecDecoder<RuntimeValue>
+): ValueCodec<V, RuntimeValue, RuntimeInputValue> {
+	return new (class extends ValueCodec<V, RuntimeValue, RuntimeInputValue> {})(
+		valueType,
+		encodeValue,
+		decodeValue
+	);
+}

package/src/lib/codecs/getSharedValueCodec.ts

@@ -2,13 +2,27 @@ import type { ValueType } from '../../client/ValueType.ts';
 import type { DatetimeInputValue, DatetimeRuntimeValue } from './DateValueCodec.ts';
 import { DateValueCodec } from './DateValueCodec.ts';
 import {
-	DecimalValueCodec,
 	type DecimalInputValue,
 	type DecimalRuntimeValue,
+	DecimalValueCodec,
 } from './DecimalValueCodec.ts';
-import type { GeopointInputValue, GeopointRuntimeValue } from './Geopoint/Geopoint.ts';
-import { GeopointValueCodec } from './Geopoint/GeopointValueCodec.ts';
-import { IntValueCodec, type IntInputValue, type IntRuntimeValue } from './IntValueCodec.ts';
+import { createGeolocationValueCodec } from './geolocation/createGeolocationValueCodec.ts';
+import {
+	Geopoint,
+	type GeopointInputValue,
+	type GeopointRuntimeValue,
+} from './geolocation/Geopoint.ts';
+import {
+	Geoshape,
+	type GeoshapeInputValue,
+	type GeoshapeRuntimeValue,
+} from './geolocation/Geoshape.ts';
+import {
+	Geotrace,
+	type GeotraceInputValue,
+	type GeotraceRuntimeValue,
+} from './geolocation/Geotrace.ts';
+import { type IntInputValue, type IntRuntimeValue, IntValueCodec } from './IntValueCodec.ts';
 import { StringValueCodec } from './StringValueCodec.ts';
 import type { ValueCodec } from './ValueCodec.ts';
 import { ValueTypePlaceholderCodec } from './ValueTypePlaceholderCodec.ts';
@@ -22,8 +36,8 @@ interface RuntimeValuesByType {
 	readonly time: string;
 	readonly dateTime: string;
 	readonly geopoint: GeopointRuntimeValue;
-	readonly geotrace: string;
-	readonly geoshape: string;
+	readonly geotrace: GeotraceRuntimeValue;
+	readonly geoshape: GeoshapeRuntimeValue;
 	readonly binary: string;
 	readonly barcode: string;
 	readonly intent: string;
@@ -40,8 +54,8 @@ interface RuntimeInputValuesByType {
 	readonly time: string;
 	readonly dateTime: string;
 	readonly geopoint: GeopointInputValue;
-	readonly geotrace: string;
-	readonly geoshape: string;
+	readonly geotrace: GeotraceInputValue;
+	readonly geoshape: GeoshapeInputValue;
 	readonly binary: string;
 	readonly barcode: string;
 	readonly intent: string;
@@ -68,12 +82,24 @@ export const sharedValueCodecs: SharedValueCodecs = {
 	date: new DateValueCodec(),
 	time: new ValueTypePlaceholderCodec('time'),
 	dateTime: new ValueTypePlaceholderCodec('dateTime'),
-	geopoint: new GeopointValueCodec(),
-	geotrace: new ValueTypePlaceholderCodec('geotrace'),
-	geoshape: new ValueTypePlaceholderCodec('geoshape'),
 	binary: new ValueTypePlaceholderCodec('binary'),
 	barcode: new ValueTypePlaceholderCodec('barcode'),
 	intent: new ValueTypePlaceholderCodec('intent'),
+	geopoint: createGeolocationValueCodec<'geopoint', GeopointRuntimeValue, GeopointInputValue>(
+		'geopoint',
+		(value) => Geopoint.parseGeopointToString(value),
+		(value) => Geopoint.parseStringToGeopoint(value)
+	),
+	geotrace: createGeolocationValueCodec<'geotrace', GeotraceRuntimeValue, GeotraceInputValue>(
+		'geotrace',
+		(value) => Geotrace.parseGeotraceString(value),
+		(value) => Geotrace.parseStringToGeotrace(value)
+	),
+	geoshape: createGeolocationValueCodec<'geoshape', GeoshapeRuntimeValue, GeoshapeInputValue>(
+		'geoshape',
+		(value) => Geoshape.parseGeoshapeString(value),
+		(value) => Geoshape.parseStringToGeoshape(value)
+	),
 };
 
 export const getSharedValueCodec = <V extends ValueType>(valueType: V): SharedValueCodec<V> => {

package/src/lib/reactivity/createInstanceValueState.ts

@@ -7,6 +7,8 @@ import type { BindComputationExpression } from '../../parse/expression/BindCompu
 import { ActionDefinition } from '../../parse/model/ActionDefinition.ts';
 import type { AnyBindPreloadDefinition } from '../../parse/model/BindPreloadDefinition.ts';
 import { XFORM_EVENT } from '../../parse/model/Event.ts';
+import { SET_GEOPOINT_LOCAL_NAME } from '../../parse/XFormDOM.ts';
+import { sharedValueCodecs } from '../codecs/getSharedValueCodec.ts';
 import { createComputedExpression } from './createComputedExpression.ts';
 import type { SimpleAtomicState, SimpleAtomicStateSetter } from './types.ts';
 
@@ -15,7 +17,7 @@ const REPEAT_INDEX_REGEX = /([^[]*)(\[[0-9]+\])/g;
 type ValueContext = AttributeContext | InstanceValueContext;
 
 const isInstanceFirstLoad = (context: ValueContext) => {
-	return context.rootDocument.initializationMode === 'create';
+	return context.rootDocument.initializationMode === 'create' && !isAddingRepeatChild(context);
 };
 
 const isAddingRepeatChild = (context: ValueContext) => {
@@ -26,7 +28,7 @@ const isAddingRepeatChild = (context: ValueContext) => {
  * Special case, does not correspond to any event.
  */
 const isEditInitialLoad = (context: ValueContext) => {
-	return context.rootDocument.initializationMode === 'edit';
+	return context.rootDocument.initializationMode === 'edit' && !isAddingRepeatChild(context);
 };
 
 const getInitialValue = (context: ValueContext): string => {
@@ -94,16 +96,6 @@ const guardDownstreamReadonlyWrites = (
 	return [getValue, setValue];
 };
 
-/**
- * @todo It feels increasingly awkward to keep piling up preload stuff here, but it won't stay that way for long. In the meantime, this seems like the best way to express the cases where `preload="uid"` should be effective, i.e.:
- *
- * - When an instance is first loaded ({@link isInstanceFirstLoad})
- * - When an instance is initially loaded for editing ({@link isEditInitialLoad})
- */
-const isLoading = (context: ValueContext) => {
-	return isInstanceFirstLoad(context) || isEditInitialLoad(context);
-};
-
 const setValueIfPreloadDefined = (
 	context: ValueContext,
 	setValue: SimpleAtomicStateSetter<string>,
@@ -134,11 +126,14 @@ const preloadValue = (context: ValueContext, setValue: SimpleAtomicStateSetter<s
 
 	if (preload.event === XFORM_EVENT.xformsRevalidate) {
 		postloadValue(context, setValue, preload);
-		return;
-	}
-
-	if (isLoading(context)) {
-		setValueIfPreloadDefined(context, setValue, preload);
+	} else if (preload.event === XFORM_EVENT.odkInstanceFirstLoad) {
+		if (isInstanceFirstLoad(context)) {
+			setValueIfPreloadDefined(context, setValue, preload);
+		}
+	} else if (preload.event === XFORM_EVENT.odkInstanceLoad) {
+		if (isInstanceFirstLoad(context) || isEditInitialLoad(context)) {
+			setValueIfPreloadDefined(context, setValue, preload);
+		}
 	}
 };
 
@@ -225,6 +220,16 @@ const createActionCalculation = (
 	});
 };
 
+const resolveAndSetValueChanged = (
+	context: ValueContext,
+	setRelevantValue: SimpleAtomicStateSetter<string>,
+	expression: string
+): void => {
+	const calc = context.evaluator.evaluateString(expression, context);
+	const value = context.decodeInstanceValue(calc);
+	setRelevantValue(value);
+};
+
 const createValueChangedCalculation = (
 	context: ValueContext,
 	setRelevantValue: SimpleAtomicStateSetter<string>,
@@ -232,21 +237,27 @@ const createValueChangedCalculation = (
 ): void => {
 	const { source, ref } = bindToRepeatInstance(context, action);
 	if (!source) {
-		// no element to listen to
+		// No element to listen to
 		return;
 	}
-	let previous = '';
+	let previous: string;
 	const sourceElementExpression = new ActionComputationExpression('string', source);
-	const calculateValueSource = createComputedExpression(context, sourceElementExpression); // registers listener
+	const calculateValueSource = createComputedExpression(context, sourceElementExpression); // Registers listener
 	createComputed(() => {
 		if (context.isAttached() && context.isRelevant()) {
 			const valueSource = calculateValueSource();
-			if (previous !== valueSource) {
-				// only update if value has changed
-				if (referencesCurrentNode(context, ref)) {
-					const calc = context.evaluator.evaluateString(action.computation.expression, context);
-					const value = context.decodeInstanceValue(calc);
-					setRelevantValue(value);
+			if (
+				previous !== undefined &&
+				previous !== valueSource &&
+				referencesCurrentNode(context, ref)
+			) {
+				// Only update if value has changed
+				if (action.element.nodeName === SET_GEOPOINT_LOCAL_NAME) {
+					getGeopointValue(context, (point) => {
+						setRelevantValue(point);
+					});
+				} else {
+					resolveAndSetValueChanged(context, setRelevantValue, action.computation.expression);
 				}
 			}
 			previous = valueSource;
@@ -254,24 +265,45 @@ const createValueChangedCalculation = (
 	});
 };
 
-const registerAction = (
+const getGeopointValue = (context: ValueContext, callback: (value: string) => void) => {
+	// eslint-disable-next-line @typescript-eslint/no-floating-promises -- we don't want to block
+	context.rootDocument.getBackgroundGeopoint()?.then((point) => {
+		// Allow the codec to manage all geolocation validation.
+		// It decodes and encodes the value, and setValue expects a string.
+		callback(sharedValueCodecs.geopoint.encodeValue(point));
+	});
+};
+
+const performActionComputation = (
+	context: ValueContext,
+	setValue: SimpleAtomicStateSetter<string>,
+	action: ActionDefinition
+) => {
+	if (action.element.nodeName === SET_GEOPOINT_LOCAL_NAME) {
+		getGeopointValue(context, (point) => setValue(point));
+		return;
+	}
+	createActionCalculation(context, setValue, action.computation);
+};
+
+const dispatchAction = (
 	context: ValueContext,
 	setValue: SimpleAtomicStateSetter<string>,
 	action: ActionDefinition
 ) => {
 	if (action.events.includes(XFORM_EVENT.odkInstanceFirstLoad)) {
 		if (isInstanceFirstLoad(context)) {
-			createActionCalculation(context, setValue, action.computation);
+			performActionComputation(context, setValue, action);
 		}
 	}
 	if (action.events.includes(XFORM_EVENT.odkInstanceLoad)) {
 		if (!isAddingRepeatChild(context)) {
-			createActionCalculation(context, setValue, action.computation);
+			performActionComputation(context, setValue, action);
 		}
 	}
 	if (action.events.includes(XFORM_EVENT.odkNewRepeat)) {
 		if (isAddingRepeatChild(context)) {
-			createActionCalculation(context, setValue, action.computation);
+			performActionComputation(context, setValue, action);
 		}
 	}
 	if (action.events.includes(XFORM_EVENT.xformsValueChanged)) {
@@ -307,10 +339,8 @@ export const createInstanceValueState = (context: ValueContext): InstanceValueSt
 			createCalculation(context, setValue, calculate);
 		}
 
-		const action = context.definition.model.actions.get(context.contextReference());
-		if (action) {
-			registerAction(context, setValue, action);
-		}
+		const actions = context.definition.model.actions.get(context.contextReference());
+		actions?.forEach((action) => dispatchAction(context, setValue, action));
 
 		return guardDownstreamReadonlyWrites(context, relevantValueState);
 	});

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

@@ -1,14 +1,17 @@
 import {
+	isResourceType,
 	JRResourceURL,
 	type JRResourceURLString,
+	type ResourceType,
 } from '@getodk/common/jr-resources/JRResourceURL.ts';
+import { isElementNode, isTextNode } from '@getodk/common/lib/dom/predicates.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 { type TextChunkExpression } from '../../../parse/expression/TextChunkExpression.ts';
+import { TextChunkExpression } from '../../../parse/expression/TextChunkExpression.ts';
 import type { TextRangeDefinition } from '../../../parse/text/abstract/TextRangeDefinition.ts';
 import { createComputedExpression } from '../createComputedExpression.ts';
 
@@ -17,57 +20,84 @@ interface ChunksAndMedia {
 	mediaSources: MediaSources;
 }
 
+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 generateChunksForTranslation = (
+	textElement: Element
+): Array<TextChunkExpression<'string'>> => {
+	const chunks = [];
+	for (const child of textElement.childNodes) {
+		for (const grandchild of child.childNodes) {
+			const chunk = generateChunk(grandchild);
+			if (chunk) {
+				chunks.push(chunk);
+			}
+		}
+	}
+	return chunks;
+};
+
+const getChunkExpressions = <Role extends TextRole>(
+	context: EvaluationContext,
+	definition: TextRangeDefinition<Role>
+): ReadonlyArray<TextChunkExpression<'string'>> => {
+	if (definition.chunks[0]?.source !== 'translation') {
+		// only translations have 'nodes' chunks
+		return definition.chunks as Array<TextChunkExpression<'string'>>;
+	}
+	const itextId = context.evaluator.evaluateString(definition.chunks[0].toString()!, {
+		contextNode: context.contextNode,
+	});
+	const lang = context.getActiveLanguage();
+	const elem = definition.form.model.getItextElement(lang, itextId);
+	return elem ? generateChunksForTranslation(elem) : [];
+};
+
 /**
- * Creates a reactive accessor for text chunks and an optional image from text source expressions.
+ * Creates a reactive accessor for text chunks and an optional image, audio and video 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.
+ * - Captures the first image found with a 'from=<"image"|"audio"|"video">' 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).
+ * @param context The evaluation context for reactive XPath computations.
+ * @param definition The definition for the text range which contains chunks to transform
+ * @returns An accessor for an object with all chunks and the first image, audio and video (if any).
  */
 const createTextChunks = <Role extends TextRole>(
 	context: EvaluationContext,
 	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()
+): ChunksAndMedia => {
+	const chunks: TextChunk[] = [];
+	const mediaSources: MediaSources = {};
+	const chunkExpressions = getChunkExpressions(context, definition);
+	chunkExpressions.forEach((chunkExpression) => {
+		if (chunkExpression.resourceType) {
+			mediaSources[chunkExpression.resourceType] = JRResourceURL.from(
+				chunkExpression.stringValue as JRResourceURLString
 			);
-		} else {
-			// only translations have 'nodes' chunks
-			chunkExpressions = definition.chunks as Array<TextChunkExpression<'string'>>;
+			return;
 		}
 
-		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)();
-			chunks.push(new TextChunk(context, chunkExpression.source, computed));
-		});
+		if (chunkExpression.source === 'literal') {
+			chunks.push(new TextChunk(context, chunkExpression.source, chunkExpression.stringValue));
+			return;
+		}
 
-		return { chunks, mediaSources };
+		const computed = createComputedExpression(context, chunkExpression)();
+		chunks.push(new TextChunk(context, chunkExpression.source, computed));
 	});
+	return { chunks, mediaSources };
 };
 
 type ComputedFormTextRange<Role extends TextRole> = Accessor<TextRange<Role, 'form'>>;
@@ -77,8 +107,6 @@ type ComputedFormTextRange<Role extends TextRole> = Accessor<TextRange<Role, 'fo
  *
  * - The form's current language (e.g. `<label ref="jr:itext('text-id')" />`)
  * - Direct `<output>` references within the label's children
- *
- * @todo This does not yet handle itext translations **with** outputs!
  */
 export const createTextRange = <Role extends TextRole>(
 	context: EvaluationContext,
@@ -86,10 +114,8 @@ export const createTextRange = <Role extends TextRole>(
 	definition: TextRangeDefinition<Role>
 ): ComputedFormTextRange<Role> => {
 	return context.scope.runTask(() => {
-		const textChunks = createTextChunks(context, definition);
-
 		return createMemo(() => {
-			const chunks = textChunks();
+			const chunks = createTextChunks(context, definition);
 			return new TextRange('form', role, chunks.chunks, chunks.mediaSources);
 		});
 	});