@getodk/xforms-engine 0.2.0 → 0.4.0

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

@@ -17,6 +17,10 @@ class ArtificialBindElement implements BindElement {
 
 		return null;
 	}
+
+	getAttributeNS() {
+		return null;
+	}
 }
 
 type TopologicalSortIndex = number;

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

@@ -1,12 +1,12 @@
 import type { AnyBodyElementDefinition } from '../body/BodyDefinition.ts';
 import type { RepeatElementDefinition } from '../body/RepeatElementDefinition.ts';
 import type { BindDefinition } from './BindDefinition.ts';
+import type { LeafNodeDefinition } from './LeafNodeDefinition.ts';
 import type { RepeatInstanceDefinition } from './RepeatInstanceDefinition.ts';
-import type { RepeatRangeDefinition } from './RepeatRangeDefinition.ts';
+import type { AnyRepeatRangeDefinition } from './RepeatRangeDefinition.ts';
 import type { RepeatTemplateDefinition } from './RepeatTemplateDefinition.ts';
 import type { RootDefinition } from './RootDefinition.ts';
 import type { SubtreeDefinition } from './SubtreeDefinition.ts';
-import type { ValueNodeDefinition } from './ValueNodeDefinition.ts';
 
 /**
  * Corresponds to the model/entry DOM root node, i.e.:
@@ -49,7 +49,7 @@ export type SubtreeNodeType = 'subtree';
  * - An element with no child elements
  * - Any attribute corresponding to a bind's `nodeset` expression
  */
-export type ValueNodeType = 'value-node';
+export type LeafNodeType = 'leaf-node';
 
 // prettier-ignore
 export type NodeDefinitionType =
@@ -59,7 +59,7 @@ export type NodeDefinitionType =
 	| RepeatTemplateType
 	| RepeatInstanceType
 	| SubtreeNodeType
-	| ValueNodeType;
+	| LeafNodeType;
 
 // prettier-ignore
 export type ParentNodeDefinition =
@@ -71,9 +71,9 @@ export type ParentNodeDefinition =
 
 // prettier-ignore
 export type ChildNodeDefinition =
-	| RepeatRangeDefinition
-	| SubtreeDefinition
-	| ValueNodeDefinition;
+	| AnyRepeatRangeDefinition
+	| LeafNodeDefinition
+	| SubtreeDefinition;
 
 // prettier-ignore
 export type ChildNodeInstanceDefinition =
@@ -81,7 +81,7 @@ export type ChildNodeInstanceDefinition =
 	| RepeatTemplateDefinition
 	| RepeatInstanceDefinition
 	| SubtreeDefinition
-	| ValueNodeDefinition;
+	| LeafNodeDefinition;
 
 // prettier-ignore
 export type NodeChildren<Type extends NodeDefinitionType> =
@@ -101,7 +101,7 @@ export type NodeParent<Type extends NodeDefinitionType> =
 		? ParentNodeDefinition
 		: null;
 
-// TODO: value-node may be Attr
+// TODO: leaf-node may be Attr
 // prettier-ignore
 export type ModelNode<Type extends NodeDefinitionType> =
 	Type extends 'repeat-range'
@@ -110,7 +110,7 @@ export type ModelNode<Type extends NodeDefinitionType> =
 
 // prettier-ignore
 export type NodeDefaultValue<Type extends NodeDefinitionType> =
-	Type extends 'value-node'
+	Type extends 'leaf-node'
 		? string
 		: null;
 
@@ -137,10 +137,10 @@ export interface NodeDefinition<Type extends NodeDefinitionType> {
 export type AnyNodeDefinition =
 	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
 	| RootDefinition
-	| RepeatRangeDefinition
+	| AnyRepeatRangeDefinition
 	| RepeatTemplateDefinition
 	| RepeatInstanceDefinition
 	| SubtreeDefinition
-	| ValueNodeDefinition;
+	| LeafNodeDefinition;
 
 export type TypedNodeDefinition<Type> = Extract<AnyNodeDefinition, { readonly type: Type }>;

package/src/parse/model/NoteNodeDefinition.ts

@@ -0,0 +1,70 @@
+import type { NoteNode } from '../../client/NoteNode.ts';
+import type { AnyBodyElementDefinition } from '../body/BodyDefinition.ts';
+import type { InputDefinition } from '../body/control/InputDefinition.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 =
+	&	BindComputationExpression<'readonly'>
+	& ConstantTruthyDependentExpression;
+
+export interface NoteBindDefinition extends BindDefinition {
+	readonly readonly: NoteReadonlyDefinition;
+}
+
+const isNoteBindDefinition = (bind: BindDefinition): bind is NoteBindDefinition => {
+	return bind.readonly.isConstantTruthyExpression();
+};
+
+// prettier-ignore
+export type NoteTextDefinition =
+	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
+	| LabelDefinition
+	| HintDefinition;
+
+/**
+ * @package This class is used internally, both in static types and at runtime,
+ * to guard and guide the distinction between instance state nodes for 'note'
+ * and 'string' node types. It is intentionally package-private! The less
+ * specific {@link NoteNode.definition} type, if it has any client value at all,
+ * should be more than sufficient. Clients are otherwise expected to use other
+ * aspects of the node's interface (such as its {@link NoteNode.nodeType} and
+ * distinct {@link NoteNode.currentState} types) to handle note-specific logic.
+ */
+export class NoteNodeDefinition extends LeafNodeDefinition {
+	static from(
+		parent: ParentNodeDefinition,
+		bind: BindDefinition,
+		bodyElement: AnyBodyElementDefinition | null,
+		node: Element
+	): NoteNodeDefinition | null {
+		if (!isNoteBindDefinition(bind) || bodyElement?.type !== 'input') {
+			return null;
+		}
+
+		const { label, hint } = bodyElement;
+		const noteTextDefinition = label ?? hint;
+
+		if (noteTextDefinition == null) {
+			return null;
+		}
+
+		return new this(parent, bind, bodyElement, noteTextDefinition, node);
+	}
+
+	constructor(
+		parent: ParentNodeDefinition,
+		override readonly bind: NoteBindDefinition,
+		override readonly bodyElement: InputDefinition,
+		readonly noteTextDefinition: NoteTextDefinition,
+		node: Element
+	) {
+		super(parent, bind, bodyElement, node);
+	}
+}

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

@@ -1,7 +1,7 @@
 import { RepeatElementDefinition } from '../body/RepeatElementDefinition.ts';
 import { DescendentNodeDefinition } from './DescendentNodeDefinition.ts';
 import type { ChildNodeDefinition, NodeDefinition } from './NodeDefinition.ts';
-import type { RepeatRangeDefinition } from './RepeatRangeDefinition.ts';
+import type { AnyRepeatRangeDefinition } from './RepeatRangeDefinition.ts';
 
 export class RepeatInstanceDefinition
 	extends DescendentNodeDefinition<'repeat-instance', RepeatElementDefinition>
@@ -15,7 +15,7 @@ export class RepeatInstanceDefinition
 	readonly defaultValue = null;
 
 	constructor(
-		range: RepeatRangeDefinition,
+		range: AnyRepeatRangeDefinition,
 		readonly node: Element
 	) {
 		const { bind, bodyElement, parent, root } = range;

package/src/parse/model/RepeatRangeDefinition.ts

@@ -0,0 +1,94 @@
+import type { RepeatElementDefinition } from '../body/RepeatElementDefinition.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';
+import { RepeatInstanceDefinition } from './RepeatInstanceDefinition.ts';
+import { RepeatTemplateDefinition } from './RepeatTemplateDefinition.ts';
+
+export interface ControlledRepeatRangeDefinition extends RepeatRangeDefinition {
+	readonly count: RepeatCountControlExpression;
+}
+
+export interface UncontrolledRepeatRangeDefinition extends RepeatRangeDefinition {
+	readonly count: null;
+}
+
+// prettier-ignore
+export type AnyRepeatRangeDefinition =
+	| ControlledRepeatRangeDefinition
+	| UncontrolledRepeatRangeDefinition;
+
+type AssertRepeatRangeDefinitionUnion = (
+	definition: RepeatRangeDefinition
+) => asserts definition is AnyRepeatRangeDefinition;
+
+const assertRepeatRangeDefinitionUnion: AssertRepeatRangeDefinitionUnion = (_definition) => {
+	// Intentional no-op, used to guide the type checker. Implementation would
+	// check _definition.count == null || _definition.count != null, which is
+	// tautologically true!
+};
+
+export class RepeatRangeDefinition
+	extends DescendentNodeDefinition<'repeat-range', RepeatElementDefinition>
+	implements NodeDefinition<'repeat-range'>
+{
+	static from(
+		parent: ParentNodeDefinition,
+		bind: BindDefinition,
+		bodyElement: RepeatElementDefinition,
+		modelNodes: readonly [Element, ...Element[]]
+	): AnyRepeatRangeDefinition {
+		const definition = new this(parent, bind, bodyElement, modelNodes);
+
+		assertRepeatRangeDefinitionUnion(definition);
+
+		return definition;
+	}
+
+	readonly type = 'repeat-range';
+
+	readonly template: RepeatTemplateDefinition;
+	readonly children = null;
+	readonly instances: RepeatInstanceDefinition[];
+	readonly count: RepeatCountControlExpression | null;
+
+	readonly node = null;
+	readonly nodeName: string;
+	readonly defaultValue = null;
+
+	private constructor(
+		parent: ParentNodeDefinition,
+		bind: BindDefinition,
+		bodyElement: RepeatElementDefinition,
+		modelNodes: readonly [Element, ...Element[]]
+	) {
+		super(parent, bind, bodyElement);
+
+		const { template, instanceNodes } = RepeatTemplateDefinition.parseModelNodes(this, modelNodes);
+
+		this.template = template;
+		this.nodeName = template.nodeName;
+		this.count = RepeatCountControlExpression.from(bodyElement, instanceNodes.length);
+
+		assertRepeatRangeDefinitionUnion(this);
+
+		this.instances = instanceNodes.map((element) => {
+			return new RepeatInstanceDefinition(this, element);
+		});
+	}
+
+	isControlled(): this is ControlledRepeatRangeDefinition {
+		return this.count != null;
+	}
+
+	isUncontrolled(): this is UncontrolledRepeatRangeDefinition {
+		return this.count == null;
+	}
+
+	toJSON() {
+		const { bind, bodyElement: groupDefinition, parent, root, ...rest } = this;
+
+		return rest;
+	}
+}

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

@@ -1,15 +1,16 @@
-import type { XFormDefinition } from '../XFormDefinition.ts';
 import type { BodyClassList } from '../body/BodyDefinition.ts';
+import type { XFormDefinition } from '../XFormDefinition.ts';
 import type { BindDefinition } from './BindDefinition.ts';
+import { LeafNodeDefinition } from './LeafNodeDefinition.ts';
 import type { ModelDefinition } from './ModelDefinition.ts';
 import type {
 	ChildNodeDefinition,
 	NodeDefinition,
 	ParentNodeDefinition,
 } from './NodeDefinition.ts';
+import { NoteNodeDefinition } from './NoteNodeDefinition.ts';
 import { RepeatRangeDefinition } from './RepeatRangeDefinition.ts';
 import { SubtreeDefinition } from './SubtreeDefinition.ts';
-import { ValueNodeDefinition } from './ValueNodeDefinition.ts';
 
 export class RootDefinition implements NodeDefinition<'root'> {
 	readonly type = 'root';
@@ -89,7 +90,7 @@ export class RootDefinition implements NodeDefinition<'root'> {
 			const [firstChild, ...restChildren] = children;
 
 			if (bodyElement?.type === 'repeat') {
-				return new RepeatRangeDefinition(parent, bind, bodyElement, children);
+				return RepeatRangeDefinition.from(parent, bind, bodyElement, children);
 			}
 
 			if (restChildren.length) {
@@ -100,7 +101,10 @@ export class RootDefinition implements NodeDefinition<'root'> {
 			const isLeafNode = element.childElementCount === 0;
 
 			if (isLeafNode) {
-				return new ValueNodeDefinition(parent, bind, bodyElement, element);
+				return (
+					NoteNodeDefinition.from(parent, bind, bodyElement, element) ??
+					new LeafNodeDefinition(parent, bind, bodyElement, element)
+				);
 			}
 
 			return new SubtreeDefinition(parent, bind, bodyElement, element);

package/src/parse/text/HintDefinition.ts

@@ -0,0 +1,25 @@
+import type { LocalNamedElement } from '@getodk/common/types/dom.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'> {}
+
+export class HintDefinition extends TextElementDefinition<'hint'> {
+	static forElement(form: XFormDefinition, owner: AnyControlDefinition): HintDefinition | null {
+		const hintElement = getHintElement(owner.element);
+
+		if (hintElement == null) {
+			return null;
+		}
+
+		return new this(form, owner, hintElement);
+	}
+
+	readonly role = 'hint';
+
+	private constructor(form: XFormDefinition, owner: AnyControlDefinition, element: HintElement) {
+		super(form, owner, element);
+	}
+}

package/src/parse/text/ItemLabelDefinition.ts

@@ -0,0 +1,25 @@
+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/select/ItemDefinition.ts';
+import { TextElementDefinition } from './abstract/TextElementDefinition.ts';
+
+interface LabelElement extends LocalNamedElement<'label'> {}
+
+export class ItemLabelDefinition extends TextElementDefinition<'item-label'> {
+	static from(form: XFormDefinition, owner: ItemDefinition): ItemLabelDefinition | null {
+		const labelElement = getLabelElement(owner.element);
+
+		if (labelElement == null) {
+			return null;
+		}
+
+		return new this(form, owner, labelElement);
+	}
+
+	readonly role = 'item-label';
+
+	private constructor(form: XFormDefinition, owner: ItemDefinition, element: LabelElement) {
+		super(form, owner, element);
+	}
+}

package/src/parse/text/ItemsetLabelDefinition.ts

@@ -0,0 +1,44 @@
+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/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';
+
+export type ItemLabelOwner = ItemDefinition | ItemsetDefinition;
+
+interface LabelElement extends LocalNamedElement<'label'> {}
+
+export class ItemsetLabelDefinition extends TextRangeDefinition<'item-label'> {
+	static from(form: XFormDefinition, owner: ItemsetDefinition): ItemsetLabelDefinition | null {
+		const labelElement = getLabelElement(owner.element);
+
+		if (labelElement == null) {
+			return null;
+		}
+
+		return new this(form, owner, labelElement);
+	}
+
+	readonly role = 'item-label';
+	readonly chunks: readonly [RefAttributeChunk];
+
+	private constructor(form: XFormDefinition, owner: ItemsetDefinition, element: LabelElement) {
+		super(form, owner, element);
+
+		const refExpression = element.getAttribute('ref');
+
+		if (refExpression == null) {
+			throw new Error('<itemset><label> missing ref attribute');
+		}
+
+		const refChunk =
+			TextTranslationExpression.from(this, refExpression) ??
+			TextReferenceExpression.from(this, refExpression);
+
+		this.chunks = [refChunk];
+	}
+}

package/src/parse/text/LabelDefinition.ts

@@ -0,0 +1,61 @@
+import type { LocalNamedElement } from '@getodk/common/types/dom.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
+export type LabelOwner =
+	| AnyControlDefinition
+	| AnyGroupElementDefinition
+	| RepeatElementDefinition;
+
+interface LabelElement extends LocalNamedElement<'label'> {}
+
+export class LabelDefinition extends TextElementDefinition<'label'> {
+	static forControl(form: XFormDefinition, control: AnyControlDefinition): LabelDefinition | null {
+		const labelElement = getLabelElement(control.element);
+
+		if (labelElement == null) {
+			return null;
+		}
+
+		return new this(form, control, labelElement);
+	}
+
+	static forRepeatGroup(
+		form: XFormDefinition,
+		repeat: RepeatElementDefinition
+	): LabelDefinition | null {
+		const repeatGroupLabel = getRepeatGroupLabelElement(repeat.element);
+
+		if (repeatGroupLabel == null) {
+			return null;
+		}
+
+		return new this(form, repeat, repeatGroupLabel);
+	}
+
+	static forGroup(
+		form: XFormDefinition,
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		group: BaseGroupDefinition<any>
+	): LabelDefinition | null {
+		const labelElement = getLabelElement(group.element);
+
+		if (labelElement == null) {
+			return null;
+		}
+
+		return new this(form, group, labelElement);
+	}
+
+	readonly role = 'label';
+
+	private constructor(form: XFormDefinition, owner: LabelOwner, element: LabelElement) {
+		super(form, owner, element);
+	}
+}

package/src/parse/text/MessageDefinition.ts

@@ -0,0 +1,49 @@
+import { JAVAROSA_NAMESPACE_URI } from '@getodk/common/constants/xmlns.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';
+
+export type MessageSourceNode = TextSourceNode<TextBindAttributeLocalName>;
+
+// prettier-ignore
+type MessageChunk =
+	| TextLiteralExpression
+	| TextTranslationExpression;
+
+export class MessageDefinition<
+	Type extends TextBindAttributeLocalName,
+> extends TextRangeDefinition<Type> {
+	static from<Type extends TextBindAttributeLocalName>(
+		bind: BindDefinition,
+		type: Type
+	): MessageDefinition<Type> | null {
+		const message = bind.bindElement.getAttributeNS(JAVAROSA_NAMESPACE_URI, type);
+
+		if (message == null) {
+			return null;
+		}
+
+		return new this(bind, type, message);
+	}
+
+	readonly chunks: readonly [MessageChunk];
+
+	private constructor(
+		bind: BindDefinition,
+		readonly role: Type,
+		message: string
+	) {
+		super(bind.form, bind, null);
+
+		const chunk: MessageChunk =
+			TextTranslationExpression.fromMessage(this, message) ??
+			TextLiteralExpression.from(this, message);
+
+		this.chunks = [chunk];
+	}
+}
+
+// prettier-ignore
+export type AnyMessageDefinition = MessageDefinition<TextBindAttributeLocalName>;

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

@@ -0,0 +1,71 @@
+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/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 type { TextSourceNode } from './TextRangeDefinition.ts';
+import { TextRangeDefinition } from './TextRangeDefinition.ts';
+
+// prettier-ignore
+export type RefAttributeChunk =
+	| TextReferenceExpression
+	| TextTranslationExpression;
+
+// prettier-ignore
+type TextElementChildChunk =
+	| TextOutputExpression
+	| TextLiteralExpression;
+
+// 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;
+
+	constructor(form: XFormDefinition, owner: TextElementOwner, sourceNode: TextSourceNode<Role>) {
+		super(form, owner, sourceNode);
+
+		const context = this as AnyTextElementDefinition;
+		const refExpression = parseNodesetReference(owner, sourceNode, 'ref');
+
+		if (refExpression == null) {
+			this.chunks = Array.from(sourceNode.childNodes).flatMap((childNode) => {
+				if (isElementNode(childNode)) {
+					return TextOutputExpression.from(context, childNode) ?? [];
+				}
+
+				if (isTextNode(childNode)) {
+					return TextLiteralExpression.from(context, childNode.data);
+				}
+
+				return [];
+			});
+		} else {
+			const refChunk =
+				TextTranslationExpression.from(context, refExpression) ??
+				TextReferenceExpression.from(context, refExpression);
+			this.chunks = [refChunk];
+		}
+	}
+}
+
+// prettier-ignore
+export type AnyTextElementDefinition =
+	| HintDefinition
+	| ItemLabelDefinition
+	| ItemsetLabelDefinition
+	| LabelDefinition;

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

@@ -0,0 +1,70 @@
+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 { AnyDependentExpression } from '../../expression/abstract/DependentExpression.ts';
+import type { AnyTextChunkExpression } from '../../expression/abstract/TextChunkExpression.ts';
+import type { AnyMessageDefinition } from '../MessageDefinition.ts';
+import type { AnyTextElementDefinition } from './TextElementDefinition.ts';
+
+export type TextBindAttributeLocalName = 'constraintMsg' | 'requiredMsg';
+export type TextBodyElementLocalName = 'hint' | 'label';
+
+interface TextSourceNodes {
+	readonly constraintMsg: null;
+	readonly hint: LocalNamedElement<'hint'>;
+	readonly label: LocalNamedElement<'label'>;
+	readonly 'item-label': LocalNamedElement<'label'>;
+	readonly requiredMsg: null;
+}
+
+export type TextSourceNode<Type extends TextRole> = TextSourceNodes[Type];
+
+export abstract class TextRangeDefinition<Role extends TextRole> extends DependencyContext {
+	abstract readonly role: Role;
+	readonly parentReference: string | null;
+	readonly reference: string | null;
+
+	abstract readonly chunks: readonly AnyTextChunkExpression[];
+
+	override get isTranslated(): boolean {
+		return (
+			this.ownerContext.isTranslated || this.chunks.some((chunk) => chunk.source === 'translation')
+		);
+	}
+
+	override set isTranslated(value: true) {
+		if (this.ownerContext != null) {
+			this.ownerContext.isTranslated = value;
+		}
+
+		super.isTranslated = value;
+	}
+
+	protected constructor(
+		readonly form: XFormDefinition,
+		readonly ownerContext: DependencyContext,
+		readonly sourceNode: TextSourceNode<Role>
+	) {
+		super();
+
+		this.reference = ownerContext.reference;
+		this.parentReference = ownerContext.parentReference;
+	}
+
+	override registerDependentExpression(expression: AnyDependentExpression): void {
+		this.ownerContext.registerDependentExpression(expression);
+		super.registerDependentExpression(expression);
+	}
+
+	toJSON(): object {
+		const { form, ownerContext, ...rest } = this;
+
+		return rest;
+	}
+}
+
+// prettier-ignore
+export type AnyTextRangeDefinition =
+	| AnyMessageDefinition
+	| AnyTextElementDefinition;