@getodk/xforms-engine 0.3.0 → 0.4.0

package/src/{body → parse/body}/group/BaseGroupDefinition.ts

@@ -1,16 +1,15 @@
 import { UpsertableMap } from '@getodk/common/lib/collections/UpsertableMap.ts';
+import { getLabelElement } from '../../../lib/dom/query.ts';
+import { LabelDefinition } from '../../text/LabelDefinition.ts';
 import type { XFormDefinition } from '../../XFormDefinition.ts';
-import { getLabelElement } from '../../lib/dom/query.ts';
-import { LabelDefinition } from '../../parse/text/LabelDefinition.ts';
-import { parseNodesetReference } from '../../parse/xpath/reference-parsing.ts';
+import { parseNodesetReference } from '../../xpath/reference-parsing.ts';
+import type { StructureElementAppearanceDefinition } from '../appearance/structureElementAppearanceParser.ts';
+import { structureElementAppearanceParser } from '../appearance/structureElementAppearanceParser.ts';
 import {
-	BodyDefinition,
 	type BodyElementDefinitionArray,
 	type BodyElementParentContext,
 } from '../BodyDefinition.ts';
 import { BodyElementDefinition } from '../BodyElementDefinition.ts';
-import type { StructureElementAppearanceDefinition } from '../appearance/structureElementAppearanceParser.ts';
-import { structureElementAppearanceParser } from '../appearance/structureElementAppearanceParser.ts';
 
 /**
  * These type names are derived from **and expand upon** the language used in
@@ -73,28 +72,18 @@ export abstract class BaseGroupDefinition<
 	readonly appearances: StructureElementAppearanceDefinition;
 	override readonly label: LabelDefinition | null;
 
-	constructor(
-		form: XFormDefinition,
-		parent: BodyElementParentContext,
-		element: Element,
-		children?: BodyElementDefinitionArray
-	) {
+	constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element) {
 		super(form, parent, element);
 
-		this.children = children ?? this.getChildren(element);
-		this.reference = parseNodesetReference(parent, element, 'ref');
-		this.appearances = structureElementAppearanceParser.parseFrom(element, 'appearance');
-		this.label = LabelDefinition.forGroup(form, this);
-	}
-
-	getChildren(element: Element): BodyElementDefinitionArray {
-		const { form } = this;
-		const children = Array.from(element.children).filter((child) => {
+		const childElements = Array.from(element.children).filter((child) => {
 			const childName = child.localName;
 
 			return childName !== 'label';
 		});
 
-		return BodyDefinition.getChildElementDefinitions(form, this, element, children);
+		this.children = this.body.getChildElementDefinitions(form, this, element, childElements);
+		this.reference = parseNodesetReference(parent, element, 'ref');
+		this.appearances = structureElementAppearanceParser.parseFrom(element, 'appearance');
+		this.label = LabelDefinition.forGroup(form, this);
 	}
 }

package/src/{body → parse/body}/group/PresentationGroupDefinition.ts

@@ -1,5 +1,5 @@
+import { LabelDefinition } from '../../text/LabelDefinition.ts';
 import type { XFormDefinition } from '../../XFormDefinition.ts';
-import { LabelDefinition } from '../../parse/text/LabelDefinition.ts';
 import type { BodyElementParentContext } from '../BodyDefinition.ts';
 import { BaseGroupDefinition } from './BaseGroupDefinition.ts';
 

package/src/{model/BindComputation.ts → parse/expression/BindComputationExpression.ts}

@@ -1,5 +1,5 @@
-import { DependentExpression } from '../expression/DependentExpression.ts';
-import type { BindDefinition } from './BindDefinition.ts';
+import type { BindDefinition } from '../model/BindDefinition.ts';
+import { DependentExpression } from './abstract/DependentExpression.ts';
 
 const defaultBindComputationExpressions = {
 	calculate: null,
@@ -16,8 +16,8 @@ export type BindComputationType = keyof DefaultBindComputationExpressions;
 
 type BindComputationFactoryResult<Type extends BindComputationType> =
 	DefaultBindComputationExpressions[Type] extends null
-		? BindComputation<Type> | null
-		: BindComputation<Type>;
+		? BindComputationExpression<Type> | null
+		: BindComputationExpression<Type>;
 
 const bindComputationResultTypes = {
 	calculate: 'string',
@@ -33,10 +33,10 @@ type BindComputationResultTypes = typeof bindComputationResultTypes;
 export type BindComputationResultType<Computation extends BindComputationType> =
 	BindComputationResultTypes[Computation];
 
-export class BindComputation<Computation extends BindComputationType> extends DependentExpression<
-	BindComputationResultType<Computation>
-> {
-	static forExpression<Type extends BindComputationType>(
+export class BindComputationExpression<
+	Computation extends BindComputationType,
+> extends DependentExpression<BindComputationResultType<Computation>> {
+	static forComputation<Type extends BindComputationType>(
 		bind: BindDefinition,
 		computation: Type
 	): BindComputationFactoryResult<Type> {

package/src/{body/control/select → parse/expression}/ItemsetNodesetExpression.ts

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

package/src/{body/control/select → parse/expression}/ItemsetValueExpression.ts

@@ -1,5 +1,5 @@
-import { DependentExpression } from '../../../expression/DependentExpression.ts';
-import type { ItemsetDefinition } from './ItemsetDefinition.ts';
+import type { ItemsetDefinition } from '../body/control/select/ItemsetDefinition.ts';
+import { DependentExpression } from './abstract/DependentExpression.ts';
 
 export class ItemsetValueExpression extends DependentExpression<'string'> {
 	constructor(

package/src/parse/expression/RepeatCountControlExpression.ts

@@ -1,7 +1,7 @@
-import { RepeatElementDefinition } from '../../body/RepeatElementDefinition.ts';
 import type { RepeatRangeControlledNode } from '../../client/repeat/RepeatRangeControlledNode.ts';
-import { DependentExpression } from '../../expression/DependentExpression.ts';
+import { RepeatElementDefinition } from '../body/RepeatElementDefinition.ts';
 import { isConstantTruthyExpression } from '../xpath/semantic-analysis.ts';
+import { DependentExpression } from './abstract/DependentExpression.ts';
 
 /**
  * Represents either of these

package/src/parse/expression/TextLiteralExpression.ts

@@ -0,0 +1,19 @@
+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/{text/OutputChunkDefinition.ts → expression/TextOutputExpression.ts}

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

package/src/parse/{text/ReferenceChunkDefinition.ts → expression/TextReferenceExpression.ts}

@@ -1,8 +1,8 @@
-import { TextChunkDefinition } from './abstract/TextChunkDefinition.ts';
-import type { AnyTextRangeDefinition } from './abstract/TextRangeDefinition.ts';
+import type { AnyTextRangeDefinition } from '../text/abstract/TextRangeDefinition.ts';
+import { TextChunkExpression } from './abstract/TextChunkExpression.ts';
 
-export class ReferenceChunkDefinition extends TextChunkDefinition<'reference'> {
-	static from(context: AnyTextRangeDefinition, refExpression: string): ReferenceChunkDefinition {
+export class TextReferenceExpression extends TextChunkExpression<'reference'> {
+	static from(context: AnyTextRangeDefinition, refExpression: string): TextReferenceExpression {
 		return new this(context, refExpression);
 	}
 

package/src/parse/{text/TranslationChunkDefinition.ts → expression/TextTranslationExpression.ts}

@@ -1,14 +1,14 @@
 import { expressionParser } from '@getodk/xpath/expressionParser.js';
+import type { AnyTextRangeDefinition } from '../text/abstract/TextRangeDefinition.ts';
 import type { TranslationExpression } from '../xpath/semantic-analysis.ts';
 import { isTranslationExpression } from '../xpath/semantic-analysis.ts';
-import { TextChunkDefinition } from './abstract/TextChunkDefinition.ts';
-import type { AnyTextRangeDefinition } from './abstract/TextRangeDefinition.ts';
+import { TextChunkExpression } from './abstract/TextChunkExpression.ts';
 
-export class TranslationChunkDefinition extends TextChunkDefinition<'translation'> {
+export class TextTranslationExpression extends TextChunkExpression<'translation'> {
 	static fromMessage(
 		context: AnyTextRangeDefinition,
 		maybeExpression: string
-	): TranslationChunkDefinition | null {
+	): TextTranslationExpression | null {
 		try {
 			expressionParser.parse(maybeExpression);
 		} catch {

package/src/{expression → parse/expression/abstract}/DependentExpression.ts

@@ -1,14 +1,14 @@
 import type { XFormsXPathEvaluator } from '@getodk/xpath';
-import { resolveDependencyNodesets } from '../parse/xpath/dependency-analysis.ts';
+import { resolveDependencyNodesets } from '../../xpath/dependency-analysis.ts';
 import type {
 	ConstantExpression,
 	ConstantTruthyExpression,
-} from '../parse/xpath/semantic-analysis.ts';
+} from '../../xpath/semantic-analysis.ts';
 import {
 	isConstantExpression,
 	isConstantTruthyExpression,
 	isTranslationExpression,
-} from '../parse/xpath/semantic-analysis.ts';
+} from '../../xpath/semantic-analysis.ts';
 import type { DependencyContext } from './DependencyContext.ts';
 
 const evaluatorMethodsByResultType = {
@@ -54,7 +54,7 @@ export interface ConstantTruthyDependentExpression extends ConstantDependentExpr
 	readonly expression: ConstantTruthyExpression;
 }
 
-export class DependentExpression<Type extends DependentExpressionResultType> {
+export abstract class DependentExpression<Type extends DependentExpressionResultType> {
 	readonly dependencyReferences: ReadonlySet<string> = new Set();
 	readonly isTranslated: boolean = false;
 	readonly evaluatorMethod: DependentExpressionEvaluatorMethod<Type>;

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

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

package/src/{model → parse/model}/BindDefinition.ts

@@ -1,10 +1,10 @@
+import { DependencyContext } from '../expression/abstract/DependencyContext.ts';
+import type { DependentExpression } from '../expression/abstract/DependentExpression.ts';
+import { BindComputationExpression } from '../expression/BindComputationExpression.ts';
+import { MessageDefinition } from '../text/MessageDefinition.ts';
 import type { XFormDataType } from '../XFormDataType.ts';
 import { bindDataType } from '../XFormDataType.ts';
 import type { XFormDefinition } from '../XFormDefinition.ts';
-import { DependencyContext } from '../expression/DependencyContext.ts';
-import type { DependentExpression } from '../expression/DependentExpression.ts';
-import { MessageDefinition } from '../parse/text/MessageDefinition.ts';
-import { BindComputation } from './BindComputation.ts';
 import type { BindElement } from './BindElement.ts';
 import type { ModelDefinition } from './ModelDefinition.ts';
 
@@ -13,27 +13,28 @@ export class BindDefinition extends DependencyContext {
 	readonly dataType: XFormDataType;
 	readonly parentNodeset: string | null;
 
-	readonly calculate: BindComputation<'calculate'> | null;
-	readonly readonly: BindComputation<'readonly'>;
-	readonly relevant: BindComputation<'relevant'>;
-	readonly required: BindComputation<'required'>;
+	readonly calculate: BindComputationExpression<'calculate'> | null;
+	readonly readonly: BindComputationExpression<'readonly'>;
+	readonly relevant: BindComputationExpression<'relevant'>;
+	readonly required: BindComputationExpression<'required'>;
 
-	// According to
-	//
-	// this is not stored in the DAG. In contrast, we do compute constraint
-	// dependencies, but self-references are ignored (handled by `BindComputation`
-	// and its `DependentExpression` parent class).
 	/**
-	 * Diverges from {@link https://github.com/getodk/javarosa/blob/059321160e6f8dbb3e81d9add61d68dd35b13cc8/dag.md | JavaRosa's}, which excludes `constraint` expressions. We compute `constraint` dependencies like the other <bind> computation expressions, but explicitly ignore self-references (this is currently handled by {@link BindComputation}, via its {@link DependentExpression} parent class).
+	 * Diverges from
+	 * {@link https://github.com/getodk/javarosa/blob/059321160e6f8dbb3e81d9add61d68dd35b13cc8/dag.md | JavaRosa's},
+	 * which excludes `constraint` expressions. We compute `constraint`
+	 * dependencies like the other <bind> computation expressions, but explicitly
+	 * ignore self-references (this is currently handled by
+	 * {@link BindComputationExpression}, via its {@link DependentExpression}
+	 * super class).
 	 */
-	readonly constraint: BindComputation<'constraint'>;
+	readonly constraint: BindComputationExpression<'constraint'>;
 
 	readonly constraintMsg: MessageDefinition<'constraintMsg'> | null;
 	readonly requiredMsg: MessageDefinition<'requiredMsg'> | null;
 
 	// TODO: it is unclear whether this will need to be supported.
 	// https://github.com/getodk/collect/issues/3758 mentions deprecation.
-	readonly saveIncomplete: BindComputation<'saveIncomplete'>;
+	readonly saveIncomplete: BindComputationExpression<'saveIncomplete'>;
 
 	// TODO: these are deferred until prioritized
 	// readonly preload: string | null;
@@ -84,12 +85,12 @@ export class BindDefinition extends DependencyContext {
 		const parentNodeset = nodeset.replace(/\/[^/]+$/, '');
 
 		this.parentNodeset = parentNodeset.length > 1 ? parentNodeset : null;
-		this.calculate = BindComputation.forExpression(this, 'calculate');
-		this.readonly = BindComputation.forExpression(this, 'readonly');
-		this.relevant = BindComputation.forExpression(this, 'relevant');
-		this.required = BindComputation.forExpression(this, 'required');
-		this.constraint = BindComputation.forExpression(this, 'constraint');
-		this.saveIncomplete = BindComputation.forExpression(this, 'saveIncomplete');
+		this.calculate = BindComputationExpression.forComputation(this, 'calculate');
+		this.readonly = BindComputationExpression.forComputation(this, 'readonly');
+		this.relevant = BindComputationExpression.forComputation(this, 'relevant');
+		this.required = BindComputationExpression.forComputation(this, 'required');
+		this.constraint = BindComputationExpression.forComputation(this, 'constraint');
+		this.saveIncomplete = BindComputationExpression.forComputation(this, 'saveIncomplete');
 		this.constraintMsg = MessageDefinition.from(this, 'constraintMsg');
 		this.requiredMsg = MessageDefinition.from(this, 'requiredMsg');
 

package/src/parse/{NoteNodeDefinition.ts → model/NoteNodeDefinition.ts}

@@ -1,17 +1,17 @@
+import type { NoteNode } from '../../client/NoteNode.ts';
 import type { AnyBodyElementDefinition } from '../body/BodyDefinition.ts';
 import type { InputDefinition } from '../body/control/InputDefinition.ts';
-import type { NoteNode } from '../client/NoteNode.ts';
-import type { ConstantTruthyDependentExpression } from '../expression/DependentExpression.ts';
-import { BindComputation } from '../model/BindComputation.ts';
-import type { BindDefinition } from '../model/BindDefinition.ts';
-import { LeafNodeDefinition } from '../model/LeafNodeDefinition.ts';
-import type { ParentNodeDefinition } from '../model/NodeDefinition.ts';
-import type { HintDefinition } from './text/HintDefinition.ts';
-import type { LabelDefinition } from './text/LabelDefinition.ts';
+import { BindComputationExpression } from '../expression/BindComputationExpression.ts';
+import type { ConstantTruthyDependentExpression } from '../expression/abstract/DependentExpression.ts';
+import type { HintDefinition } from '../text/HintDefinition.ts';
+import type { LabelDefinition } from '../text/LabelDefinition.ts';
+import type { BindDefinition } from './BindDefinition.ts';
+import { LeafNodeDefinition } from './LeafNodeDefinition.ts';
+import type { ParentNodeDefinition } from './NodeDefinition.ts';
 
 // prettier-ignore
 export type NoteReadonlyDefinition =
-	&	BindComputation<'readonly'>
+	&	BindComputationExpression<'readonly'>
 	& ConstantTruthyDependentExpression;
 
 export interface NoteBindDefinition extends BindDefinition {

package/src/{model → parse/model}/RepeatRangeDefinition.ts

@@ -1,5 +1,5 @@
 import type { RepeatElementDefinition } from '../body/RepeatElementDefinition.ts';
-import { RepeatCountControlExpression } from '../parse/expression/RepeatCountControlExpression.ts';
+import { RepeatCountControlExpression } from '../expression/RepeatCountControlExpression.ts';
 import type { BindDefinition } from './BindDefinition.ts';
 import { DescendentNodeDefinition } from './DescendentNodeDefinition.ts';
 import type { NodeDefinition, ParentNodeDefinition } from './NodeDefinition.ts';

package/src/{model → parse/model}/RootDefinition.ts

@@ -1,6 +1,5 @@
-import type { XFormDefinition } from '../XFormDefinition.ts';
 import type { BodyClassList } from '../body/BodyDefinition.ts';
-import { NoteNodeDefinition } from '../parse/NoteNodeDefinition.ts';
+import type { XFormDefinition } from '../XFormDefinition.ts';
 import type { BindDefinition } from './BindDefinition.ts';
 import { LeafNodeDefinition } from './LeafNodeDefinition.ts';
 import type { ModelDefinition } from './ModelDefinition.ts';
@@ -9,6 +8,7 @@ import type {
 	NodeDefinition,
 	ParentNodeDefinition,
 } from './NodeDefinition.ts';
+import { NoteNodeDefinition } from './NoteNodeDefinition.ts';
 import { RepeatRangeDefinition } from './RepeatRangeDefinition.ts';
 import { SubtreeDefinition } from './SubtreeDefinition.ts';
 

package/src/parse/text/HintDefinition.ts

@@ -1,7 +1,7 @@
 import type { LocalNamedElement } from '@getodk/common/types/dom.ts';
-import type { XFormDefinition } from '../../XFormDefinition.ts';
-import type { AnyControlDefinition } from '../../body/control/ControlDefinition.ts';
 import { getHintElement } from '../../lib/dom/query.ts';
+import type { XFormDefinition } from '../../parse/XFormDefinition.ts';
+import type { AnyControlDefinition } from '../body/control/ControlDefinition.ts';
 import { TextElementDefinition } from './abstract/TextElementDefinition.ts';
 
 interface HintElement extends LocalNamedElement<'hint'> {}

package/src/parse/text/ItemLabelDefinition.ts

@@ -1,7 +1,7 @@
 import type { LocalNamedElement } from '@getodk/common/types/dom.ts';
-import type { XFormDefinition } from '../../XFormDefinition.ts';
-import type { ItemDefinition } from '../../body/control/select/ItemDefinition.ts';
 import { getLabelElement } from '../../lib/dom/query.ts';
+import type { XFormDefinition } from '../../parse/XFormDefinition.ts';
+import type { ItemDefinition } from '../body/control/select/ItemDefinition.ts';
 import { TextElementDefinition } from './abstract/TextElementDefinition.ts';
 
 interface LabelElement extends LocalNamedElement<'label'> {}

package/src/parse/text/ItemsetLabelDefinition.ts

@@ -1,10 +1,10 @@
 import type { LocalNamedElement } from '@getodk/common/types/dom.ts';
-import type { XFormDefinition } from '../../XFormDefinition.ts';
-import type { ItemDefinition } from '../../body/control/select/ItemDefinition.ts';
-import type { ItemsetDefinition } from '../../body/control/select/ItemsetDefinition.ts';
 import { getLabelElement } from '../../lib/dom/query.ts';
-import { ReferenceChunkDefinition } from './ReferenceChunkDefinition.ts';
-import { TranslationChunkDefinition } from './TranslationChunkDefinition.ts';
+import type { XFormDefinition } from '../../parse/XFormDefinition.ts';
+import type { ItemDefinition } from '../body/control/select/ItemDefinition.ts';
+import type { ItemsetDefinition } from '../body/control/select/ItemsetDefinition.ts';
+import { TextReferenceExpression } from '../expression/TextReferenceExpression.ts';
+import { TextTranslationExpression } from '../expression/TextTranslationExpression.ts';
 import type { RefAttributeChunk } from './abstract/TextElementDefinition.ts';
 import { TextRangeDefinition } from './abstract/TextRangeDefinition.ts';
 
@@ -36,8 +36,8 @@ export class ItemsetLabelDefinition extends TextRangeDefinition<'item-label'> {
 		}
 
 		const refChunk =
-			TranslationChunkDefinition.from(this, refExpression) ??
-			ReferenceChunkDefinition.from(this, refExpression);
+			TextTranslationExpression.from(this, refExpression) ??
+			TextReferenceExpression.from(this, refExpression);
 
 		this.chunks = [refChunk];
 	}

package/src/parse/text/LabelDefinition.ts

@@ -1,10 +1,10 @@
 import type { LocalNamedElement } from '@getodk/common/types/dom.ts';
-import type { XFormDefinition } from '../../XFormDefinition.ts';
-import type { AnyGroupElementDefinition } from '../../body/BodyDefinition.ts';
-import type { RepeatElementDefinition } from '../../body/RepeatElementDefinition.ts';
-import type { AnyControlDefinition } from '../../body/control/ControlDefinition.ts';
-import type { BaseGroupDefinition } from '../../body/group/BaseGroupDefinition.ts';
 import { getLabelElement, getRepeatGroupLabelElement } from '../../lib/dom/query.ts';
+import type { XFormDefinition } from '../../parse/XFormDefinition.ts';
+import type { AnyGroupElementDefinition } from '../../parse/body/BodyDefinition.ts';
+import type { RepeatElementDefinition } from '../body/RepeatElementDefinition.ts';
+import type { AnyControlDefinition } from '../body/control/ControlDefinition.ts';
+import type { BaseGroupDefinition } from '../body/group/BaseGroupDefinition.ts';
 import { TextElementDefinition } from './abstract/TextElementDefinition.ts';
 
 // prettier-ignore

package/src/parse/text/MessageDefinition.ts

@@ -1,7 +1,7 @@
 import { JAVAROSA_NAMESPACE_URI } from '@getodk/common/constants/xmlns.ts';
-import type { BindDefinition } from '../../model/BindDefinition.ts';
-import { StaticTextChunkDefinition } from './StaticTextChunkDefinition.ts';
-import { TranslationChunkDefinition } from './TranslationChunkDefinition.ts';
+import { TextLiteralExpression } from '../expression/TextLiteralExpression.ts';
+import { TextTranslationExpression } from '../expression/TextTranslationExpression.ts';
+import type { BindDefinition } from '../model/BindDefinition.ts';
 import type { TextBindAttributeLocalName, TextSourceNode } from './abstract/TextRangeDefinition.ts';
 import { TextRangeDefinition } from './abstract/TextRangeDefinition.ts';
 
@@ -9,8 +9,8 @@ export type MessageSourceNode = TextSourceNode<TextBindAttributeLocalName>;
 
 // prettier-ignore
 type MessageChunk =
-	| StaticTextChunkDefinition
-	| TranslationChunkDefinition;
+	| TextLiteralExpression
+	| TextTranslationExpression;
 
 export class MessageDefinition<
 	Type extends TextBindAttributeLocalName,
@@ -38,8 +38,8 @@ export class MessageDefinition<
 		super(bind.form, bind, null);
 
 		const chunk: MessageChunk =
-			TranslationChunkDefinition.fromMessage(this, message) ??
-			StaticTextChunkDefinition.from(this, message);
+			TextTranslationExpression.fromMessage(this, message) ??
+			TextLiteralExpression.from(this, message);
 
 		this.chunks = [chunk];
 	}

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

@@ -1,28 +1,28 @@
 import { isElementNode, isTextNode } from '@getodk/common/lib/dom/predicates.ts';
-import type { XFormDefinition } from '../../../XFormDefinition.ts';
-import type { ItemDefinition } from '../../../body/control/select/ItemDefinition.ts';
 import type { ElementTextRole } from '../../../client/TextRange.ts';
+import type { XFormDefinition } from '../../../parse/XFormDefinition.ts';
+import type { ItemDefinition } from '../../body/control/select/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 { parseNodesetReference } from '../../xpath/reference-parsing.ts';
 import type { HintDefinition } from '../HintDefinition.ts';
 import type { ItemLabelDefinition } from '../ItemLabelDefinition.ts';
 import type { ItemsetLabelDefinition } from '../ItemsetLabelDefinition.ts';
 import type { LabelDefinition, LabelOwner } from '../LabelDefinition.ts';
-import { OutputChunkDefinition } from '../OutputChunkDefinition.ts';
-import { ReferenceChunkDefinition } from '../ReferenceChunkDefinition.ts';
-import { StaticTextChunkDefinition } from '../StaticTextChunkDefinition.ts';
-import { TranslationChunkDefinition } from '../TranslationChunkDefinition.ts';
 import type { TextSourceNode } from './TextRangeDefinition.ts';
 import { TextRangeDefinition } from './TextRangeDefinition.ts';
 
 // prettier-ignore
 export type RefAttributeChunk =
-	| ReferenceChunkDefinition
-	| TranslationChunkDefinition;
+	| TextReferenceExpression
+	| TextTranslationExpression;
 
 // prettier-ignore
 type TextElementChildChunk =
-	| OutputChunkDefinition
-	| StaticTextChunkDefinition;
+	| TextOutputExpression
+	| TextLiteralExpression;
 
 // prettier-ignore
 type TextElementChunks =
@@ -45,19 +45,19 @@ export abstract class TextElementDefinition<
 		if (refExpression == null) {
 			this.chunks = Array.from(sourceNode.childNodes).flatMap((childNode) => {
 				if (isElementNode(childNode)) {
-					return OutputChunkDefinition.from(context, childNode) ?? [];
+					return TextOutputExpression.from(context, childNode) ?? [];
 				}
 
 				if (isTextNode(childNode)) {
-					return StaticTextChunkDefinition.from(context, childNode.data);
+					return TextLiteralExpression.from(context, childNode.data);
 				}
 
 				return [];
 			});
 		} else {
 			const refChunk =
-				TranslationChunkDefinition.from(context, refExpression) ??
-				ReferenceChunkDefinition.from(context, refExpression);
+				TextTranslationExpression.from(context, refExpression) ??
+				TextReferenceExpression.from(context, refExpression);
 			this.chunks = [refChunk];
 		}
 	}

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

@@ -1,10 +1,10 @@
 import type { LocalNamedElement } from '@getodk/common/types/dom.ts';
-import type { XFormDefinition } from '../../../XFormDefinition.ts';
 import type { TextRole } from '../../../client/TextRange.ts';
-import { DependencyContext } from '../../../expression/DependencyContext.ts';
-import type { AnyDependentExpression } from '../../../expression/DependentExpression.ts';
+import type { XFormDefinition } from '../../../parse/XFormDefinition.ts';
+import { DependencyContext } from '../../expression/abstract/DependencyContext.ts';
+import type { AnyDependentExpression } from '../../expression/abstract/DependentExpression.ts';
+import type { AnyTextChunkExpression } from '../../expression/abstract/TextChunkExpression.ts';
 import type { AnyMessageDefinition } from '../MessageDefinition.ts';
-import type { AnyTextChunkDefinition } from './TextChunkDefinition.ts';
 import type { AnyTextElementDefinition } from './TextElementDefinition.ts';
 
 export type TextBindAttributeLocalName = 'constraintMsg' | 'requiredMsg';
@@ -25,7 +25,7 @@ export abstract class TextRangeDefinition<Role extends TextRole> extends Depende
 	readonly parentReference: string | null;
 	readonly reference: string | null;
 
-	abstract readonly chunks: readonly AnyTextChunkDefinition[];
+	abstract readonly chunks: readonly AnyTextChunkExpression[];
 
 	override get isTranslated(): boolean {
 		return (

package/dist/model/BindDefinition.d.ts

@@ -1,34 +0,0 @@
-import { XFormDataType } from '../XFormDataType.ts';
-import { XFormDefinition } from '../XFormDefinition.ts';
-import { DependencyContext } from '../expression/DependencyContext.ts';
-import { MessageDefinition } from '../parse/text/MessageDefinition.ts';
-import { BindComputation } from './BindComputation.ts';
-import { BindElement } from './BindElement.ts';
-import { ModelDefinition } from './ModelDefinition.ts';
-
-export declare class BindDefinition extends DependencyContext {
-    readonly form: XFormDefinition;
-    protected readonly model: ModelDefinition;
-    readonly nodeset: string;
-    readonly bindElement: BindElement;
-    readonly bindType: string | null;
-    readonly dataType: XFormDataType;
-    readonly parentNodeset: string | null;
-    readonly calculate: BindComputation<'calculate'> | null;
-    readonly readonly: BindComputation<'readonly'>;
-    readonly relevant: BindComputation<'relevant'>;
-    readonly required: BindComputation<'required'>;
-    /**
-     * Diverges from {@link https://github.com/getodk/javarosa/blob/059321160e6f8dbb3e81d9add61d68dd35b13cc8/dag.md | JavaRosa's}, which excludes `constraint` expressions. We compute `constraint` dependencies like the other <bind> computation expressions, but explicitly ignore self-references (this is currently handled by {@link BindComputation}, via its {@link DependentExpression} parent class).
-     */
-    readonly constraint: BindComputation<'constraint'>;
-    readonly constraintMsg: MessageDefinition<'constraintMsg'> | null;
-    readonly requiredMsg: MessageDefinition<'requiredMsg'> | null;
-    readonly saveIncomplete: BindComputation<'saveIncomplete'>;
-    protected _parentBind: BindDefinition | null | undefined;
-    get parentBind(): BindDefinition | null;
-    get reference(): string;
-    get parentReference(): string | null;
-    constructor(form: XFormDefinition, model: ModelDefinition, nodeset: string, bindElement: BindElement);
-    toJSON(): Omit<this, "model" | "toJSON" | "form" | "reference" | "parentReference" | "isTranslated" | "registerDependentExpression" | "dependencyExpressions" | "bindElement" | "parentBind">;
-}