@getodk/xforms-engine 0.9.0 → 0.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getodk/xforms-engine",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "license": "Apache-2.0",
   "description": "XForms engine for ODK Web Forms",
   "type": "module",
@@ -62,7 +62,7 @@
   "devDependencies": {
     "@babel/core": "^7.26.10",
     "@getodk/tree-sitter-xpath": "0.1.3",
-    "@getodk/xpath": "0.5.0",
+    "@getodk/xpath": "0.6.0",
     "@playwright/test": "^1.49.1",
     "@types/papaparse": "^5.3.15",
     "@vitest/browser": "^3.0.9",

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/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)];
+		}
 	}
 }
 

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

@@ -2,10 +2,7 @@ import { isElementNode, isTextNode } from '@getodk/common/lib/dom/predicates.ts'
 import type { ElementTextRole } from '../../../client/TextRange.ts';
 import type { XFormDefinition } from '../../../parse/XFormDefinition.ts';
 import type { ItemDefinition } from '../../body/control/ItemDefinition.ts';
-import { TextLiteralExpression } from '../../expression/TextLiteralExpression.ts';
-import { TextOutputExpression } from '../../expression/TextOutputExpression.ts';
-import { TextReferenceExpression } from '../../expression/TextReferenceExpression.ts';
-import { TextTranslationExpression } from '../../expression/TextTranslationExpression.ts';
+import { TextChunkExpression } from '../../expression/TextChunkExpression.ts';
 import { parseNodesetReference } from '../../xpath/reference-parsing.ts';
 import type { HintDefinition } from '../HintDefinition.ts';
 import type { ItemLabelDefinition } from '../ItemLabelDefinition.ts';
@@ -14,27 +11,12 @@ import type { LabelDefinition, LabelOwner } from '../LabelDefinition.ts';
 import type { TextSourceNode } from './TextRangeDefinition.ts';
 import { TextRangeDefinition } from './TextRangeDefinition.ts';
 
-// prettier-ignore
-export type RefAttributeChunk =
-	| TextReferenceExpression
-	| TextTranslationExpression;
-
-// prettier-ignore
-type TextElementChildChunk =
-	| TextLiteralExpression
-	| TextOutputExpression;
-
-// prettier-ignore
-type TextElementChunks =
-	| readonly [RefAttributeChunk]
-	| readonly TextElementChildChunk[];
-
 type TextElementOwner = ItemDefinition | LabelOwner;
 
 export abstract class TextElementDefinition<
 	Role extends ElementTextRole,
 > extends TextRangeDefinition<Role> {
-	readonly chunks: TextElementChunks;
+	readonly chunks: ReadonlyArray<TextChunkExpression<'nodes' | 'string'>>;
 
 	constructor(form: XFormDefinition, owner: TextElementOwner, sourceNode: TextSourceNode<Role>) {
 		super(form, owner, sourceNode);
@@ -45,20 +27,22 @@ export abstract class TextElementDefinition<
 		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)];
+			}
 		}
 	}
 }

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

@@ -2,7 +2,7 @@ import type { LocalNamedElement } from '@getodk/common/types/dom.ts';
 import type { TextRole } from '../../../client/TextRange.ts';
 import type { XFormDefinition } from '../../../parse/XFormDefinition.ts';
 import { DependencyContext } from '../../expression/abstract/DependencyContext.ts';
-import type { AnyTextChunkExpression } from '../../expression/abstract/TextChunkExpression.ts';
+import type { TextChunkExpression } from '../../expression/TextChunkExpression.ts';
 import type { AnyMessageDefinition } from '../MessageDefinition.ts';
 import type { AnyTextElementDefinition } from './TextElementDefinition.ts';
 
@@ -24,7 +24,7 @@ export abstract class TextRangeDefinition<Role extends TextRole> extends Depende
 	readonly parentReference: string | null;
 	readonly reference: string | null;
 
-	abstract readonly chunks: readonly AnyTextChunkExpression[];
+	abstract readonly chunks: ReadonlyArray<TextChunkExpression<'nodes' | 'string'>>;
 
 	override get isTranslated(): boolean {
 		return (

package/src/parse/xpath/semantic-analysis.ts

@@ -117,9 +117,14 @@ export type TranslationExpression = LocalNamedFunctionCallLiteral<'itext'>;
 export const isTranslationExpression = (
 	expression: string
 ): expression is TranslationExpression => {
-	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;
 	}

package/dist/parse/expression/TextLiteralExpression.d.ts

@@ -1,9 +0,0 @@
-import { AnyTextRangeDefinition } from '../text/abstract/TextRangeDefinition.ts';
-import { TextChunkExpression } from './abstract/TextChunkExpression.ts';
-export type TextLiteralSourceNode = Attr | Text;
-export declare class TextLiteralExpression extends TextChunkExpression<'literal'> {
-    readonly stringValue: string;
-    static from(context: AnyTextRangeDefinition, stringValue: string): TextLiteralExpression;
-    readonly source = "literal";
-    private constructor();
-}

package/dist/parse/expression/TextOutputExpression.d.ts

@@ -1,7 +0,0 @@
-import { AnyTextRangeDefinition } from '../text/abstract/TextRangeDefinition.ts';
-import { TextChunkExpression } from './abstract/TextChunkExpression.ts';
-export declare class TextOutputExpression extends TextChunkExpression<'output'> {
-    static from(context: AnyTextRangeDefinition, element: Element): TextOutputExpression | null;
-    readonly source = "output";
-    private constructor();
-}

package/dist/parse/expression/TextReferenceExpression.d.ts

@@ -1,7 +0,0 @@
-import { AnyTextRangeDefinition } from '../text/abstract/TextRangeDefinition.ts';
-import { TextChunkExpression } from './abstract/TextChunkExpression.ts';
-export declare class TextReferenceExpression extends TextChunkExpression<'reference'> {
-    static from(context: AnyTextRangeDefinition, refExpression: string): TextReferenceExpression;
-    readonly source = "reference";
-    private constructor();
-}

package/dist/parse/expression/TextTranslationExpression.d.ts

@@ -1,8 +0,0 @@
-import { AnyTextRangeDefinition } from '../text/abstract/TextRangeDefinition.ts';
-import { TextChunkExpression } from './abstract/TextChunkExpression.ts';
-export declare class TextTranslationExpression extends TextChunkExpression<'translation'> {
-    static fromMessage(context: AnyTextRangeDefinition, maybeExpression: string): TextTranslationExpression | null;
-    static from(context: AnyTextRangeDefinition, maybeExpression: string): TextTranslationExpression | null;
-    readonly source = "translation";
-    private constructor();
-}

package/dist/parse/expression/abstract/TextChunkExpression.d.ts

@@ -1,17 +0,0 @@
-import { TextChunkSource } from '../../../client/TextRange.ts';
-import { AnyTextRangeDefinition } from '../../text/abstract/TextRangeDefinition.ts';
-import { TextLiteralExpression } from '../TextLiteralExpression.ts';
-import { TextOutputExpression } from '../TextOutputExpression.ts';
-import { TextReferenceExpression } from '../TextReferenceExpression.ts';
-import { TextTranslationExpression } from '../TextTranslationExpression.ts';
-import { DependentExpression } from './DependentExpression.ts';
-interface TextChunkExpressionOptions {
-    readonly isTranslated?: true;
-}
-export declare abstract class TextChunkExpression<Source extends TextChunkSource> extends DependentExpression<'string'> {
-    abstract readonly source: Source;
-    readonly stringValue?: string;
-    constructor(context: AnyTextRangeDefinition, expression: string, options?: TextChunkExpressionOptions);
-}
-export type AnyTextChunkExpression = TextLiteralExpression | TextOutputExpression | TextReferenceExpression | TextTranslationExpression;
-export {};

package/src/parse/expression/TextLiteralExpression.ts

@@ -1,19 +0,0 @@
-import type { AnyTextRangeDefinition } from '../text/abstract/TextRangeDefinition.ts';
-import { TextChunkExpression } from './abstract/TextChunkExpression.ts';
-
-export type TextLiteralSourceNode = Attr | Text;
-
-export class TextLiteralExpression extends TextChunkExpression<'literal'> {
-	static from(context: AnyTextRangeDefinition, stringValue: string): TextLiteralExpression {
-		return new this(context, stringValue);
-	}
-
-	readonly source = 'literal';
-
-	private constructor(
-		context: AnyTextRangeDefinition,
-		override readonly stringValue: string
-	) {
-		super(context, 'null');
-	}
-}

package/src/parse/expression/TextOutputExpression.ts

@@ -1,25 +0,0 @@
-import type { KnownAttributeLocalNamedElement } from '@getodk/common/types/dom.ts';
-import type { AnyTextRangeDefinition } from '../text/abstract/TextRangeDefinition.ts';
-import { TextChunkExpression } from './abstract/TextChunkExpression.ts';
-
-interface OutputElement extends KnownAttributeLocalNamedElement<'output', 'value'> {}
-
-const isOutputElement = (element: Element): element is OutputElement => {
-	return element.localName === 'output' && element.hasAttribute('value');
-};
-
-export class TextOutputExpression extends TextChunkExpression<'output'> {
-	static from(context: AnyTextRangeDefinition, element: Element): TextOutputExpression | null {
-		if (isOutputElement(element)) {
-			return new this(context, element);
-		}
-
-		return null;
-	}
-
-	readonly source = 'output';
-
-	private constructor(context: AnyTextRangeDefinition, element: OutputElement) {
-		super(context, element.getAttribute('value'));
-	}
-}

package/src/parse/expression/TextReferenceExpression.ts

@@ -1,14 +0,0 @@
-import type { AnyTextRangeDefinition } from '../text/abstract/TextRangeDefinition.ts';
-import { TextChunkExpression } from './abstract/TextChunkExpression.ts';
-
-export class TextReferenceExpression extends TextChunkExpression<'reference'> {
-	static from(context: AnyTextRangeDefinition, refExpression: string): TextReferenceExpression {
-		return new this(context, refExpression);
-	}
-
-	readonly source = 'reference';
-
-	private constructor(context: AnyTextRangeDefinition, refExpression: string) {
-		super(context, refExpression);
-	}
-}