@getodk/xforms-engine 0.2.0 → 0.3.0

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

@@ -0,0 +1,196 @@
+import type { Accessor } from 'solid-js';
+import { createMemo } from 'solid-js';
+import type { OpaqueReactiveObjectFactory } from '../../../client/OpaqueReactiveObjectFactory.ts';
+import type {
+	TextRange as ClientTextRange,
+	ValidationTextRole,
+} from '../../../client/TextRange.ts';
+import { VALIDATION_TEXT } from '../../../client/constants.ts';
+import type {
+	AnyViolation,
+	ConditionSatisfied,
+	ConditionValidation,
+	ConditionViolation,
+	ValidationCondition,
+} from '../../../client/validation.ts';
+import type { ValidationContext } from '../../../instance/internal-api/ValidationContext.ts';
+import { TextChunk } from '../../../instance/text/TextChunk.ts';
+import { TextRange } from '../../../instance/text/TextRange.ts';
+import type { MessageDefinition } from '../../../parse/text/MessageDefinition.ts';
+import { createComputedExpression } from '../createComputedExpression.ts';
+import type {
+	SharedNodeState,
+	SharedNodeStateOptions,
+} from '../node-state/createSharedNodeState.ts';
+import { createSharedNodeState } from '../node-state/createSharedNodeState.ts';
+import type { ReactiveScope } from '../scope.ts';
+import { createTextRange } from '../text/createTextRange.ts';
+
+type EngineViolationMessage<Role extends ValidationTextRole> = ClientTextRange<Role, 'engine'>;
+
+const engineViolationMessage = <Role extends ValidationTextRole>(
+	context: ValidationContext,
+	role: Role
+): Accessor<EngineViolationMessage<Role>> => {
+	const messageText = VALIDATION_TEXT[role];
+	const chunk = new TextChunk(context.root, 'static', messageText);
+	const message = new TextRange('engine', role, [chunk]);
+
+	return () => message;
+};
+
+const createViolationMessage = <Role extends ValidationTextRole>(
+	context: ValidationContext,
+	role: Role,
+	definition: MessageDefinition<Role> | null
+) => {
+	if (definition == null) {
+		return engineViolationMessage(context, role);
+	}
+
+	return createTextRange(context, role, definition);
+};
+
+// prettier-ignore
+type ComputedConditionValidation<
+	Condition extends ValidationCondition
+> = Accessor<ConditionValidation<Condition>>;
+
+const constraintValid = (): ConditionSatisfied<'constraint'> => {
+	return {
+		condition: 'constraint',
+		valid: true,
+		message: null,
+	};
+};
+
+const createConstraintValidation = (
+	context: ValidationContext
+): ComputedConditionValidation<'constraint'> => {
+	return context.scope.runTask(() => {
+		const { constraint, constraintMsg } = context.definition.bind;
+
+		if (constraint == null) {
+			return constraintValid;
+		}
+
+		const isValid = createComputedExpression(context, constraint, {
+			arbitraryDependencies: [context],
+		});
+
+		const message = createViolationMessage(context, 'constraintMsg', constraintMsg);
+
+		return createMemo(() => {
+			if (!context.isRelevant() || context.isBlank() || isValid()) {
+				return constraintValid();
+			}
+
+			return {
+				condition: 'constraint',
+				valid: false,
+				message: message(),
+			} as const;
+		});
+	});
+};
+
+const requiredValid = (): ConditionSatisfied<'required'> => {
+	return {
+		condition: 'required',
+		valid: true,
+		message: null,
+	};
+};
+
+const createRequiredValidation = (
+	context: ValidationContext
+): ComputedConditionValidation<'required'> => {
+	return context.scope.runTask(() => {
+		const { required, requiredMsg } = context.definition.bind;
+
+		if (required.isDefaultExpression) {
+			return requiredValid;
+		}
+
+		const isValid = () => {
+			if (context.isRequired()) {
+				return !context.isBlank();
+			}
+
+			return true;
+		};
+
+		const message = createViolationMessage(context, 'requiredMsg', requiredMsg);
+
+		return createMemo(() => {
+			if (!context.isRelevant() || isValid()) {
+				return requiredValid();
+			}
+
+			return {
+				condition: 'required',
+				valid: false,
+				message: message(),
+			} as const;
+		});
+	});
+};
+
+type OptionalViolation<Condition extends ValidationCondition> =
+	Accessor<ConditionViolation<Condition> | null>;
+
+const createComputedViolation = <Condition extends ValidationCondition>(
+	scope: ReactiveScope,
+	validateCondition: ComputedConditionValidation<Condition>
+): OptionalViolation<Condition> => {
+	return scope.runTask(() => {
+		return createMemo(() => {
+			const validation = validateCondition();
+
+			if (validation.valid) {
+				return null;
+			}
+
+			return validation;
+		});
+	});
+};
+
+type ComputedViolation = Accessor<AnyViolation | null>;
+
+interface ValidationStateSpec {
+	readonly constraint: ComputedConditionValidation<'constraint'>;
+	readonly required: ComputedConditionValidation<'required'>;
+	readonly violation: ComputedViolation;
+}
+
+export type SharedValidationState = SharedNodeState<ValidationStateSpec>;
+
+interface ValidationStateOptions<Factory extends OpaqueReactiveObjectFactory>
+	extends SharedNodeStateOptions<Factory, ValidationStateSpec> {}
+
+export const createValidationState = <Factory extends OpaqueReactiveObjectFactory>(
+	context: ValidationContext,
+	options: ValidationStateOptions<Factory>
+): SharedValidationState => {
+	const { scope } = context;
+
+	return scope.runTask(() => {
+		const constraint = createConstraintValidation(context);
+		const constraintViolation = createComputedViolation(scope, constraint);
+		const required = createRequiredValidation(context);
+		const requiredViolation = createComputedViolation(scope, required);
+
+		const violation = createMemo(() => {
+			return constraintViolation() ?? requiredViolation();
+		});
+
+		const spec: ValidationStateSpec = {
+			constraint,
+			required,
+			violation,
+		};
+
+		return createSharedNodeState(scope, spec, options);
+	});
+};

package/src/model/BindComputation.ts

@@ -57,7 +57,6 @@ export class BindComputation<Computation extends BindComputationType> extends De
 		readonly computation: Computation,
 		expression: string | null
 	) {
-		const isInherited = computation === 'readonly' || computation === 'relevant';
 		const ignoreContextReference = computation === 'constraint';
 
 		let isDefaultExpression: boolean;
@@ -78,9 +77,6 @@ export class BindComputation<Computation extends BindComputationType> extends De
 
 		super(bind, bindComputationResultTypes[computation], resolvedExpression, {
 			ignoreContextReference,
-			semanticDependencies: {
-				parentContext: isInherited,
-			},
 		});
 
 		this.isDefaultExpression = isDefaultExpression;

package/src/model/BindDefinition.ts

@@ -3,6 +3,7 @@ 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';
@@ -25,15 +26,16 @@ export class BindDefinition extends DependencyContext {
 	/**
 	 * 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'> & DependentExpression<'boolean'>;
+	readonly constraint: BindComputation<'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'>;
 
-	// TODO: these are deferred just to put off sharing namespace stuff
-	// readonly requiredMsg: string | null;
-	// readonly constraintMsg: string | null;
+	// TODO: these are deferred until prioritized
 	// readonly preload: string | null;
 	// readonly preloadParams: string | null;
 	// readonly 'max-pixels': string | null;
@@ -88,9 +90,9 @@ export class BindDefinition extends DependencyContext {
 		this.required = BindComputation.forExpression(this, 'required');
 		this.constraint = BindComputation.forExpression(this, 'constraint');
 		this.saveIncomplete = BindComputation.forExpression(this, 'saveIncomplete');
+		this.constraintMsg = MessageDefinition.from(this, 'constraintMsg');
+		this.requiredMsg = MessageDefinition.from(this, 'requiredMsg');
 
-		// this.requiredMsg = BindComputation.forExpression(this, 'requiredMsg');
-		// this.constraintMsg = BindComputation.forExpression(this, 'constraintMsg');
 		// this.preload = BindComputation.forExpression(this, 'preload');
 		// this.preloadParams = BindComputation.forExpression(this, 'preloadParams');
 		// this['max-pixels'] = BindComputation.forExpression(this, 'max-pixels');

package/src/model/BindElement.ts

@@ -5,4 +5,5 @@ export interface BindElement {
 
 	getAttribute(name: 'nodeset'): BindNodeset;
 	getAttribute(name: string): string | null;
+	getAttributeNS(namespaceURI: string | null, localName: string): string | null;
 }

package/src/model/{ValueNodeDefinition.ts → LeafNodeDefinition.ts}

@@ -3,11 +3,11 @@ import type { BindDefinition } from './BindDefinition.ts';
 import { DescendentNodeDefinition } from './DescendentNodeDefinition.ts';
 import type { NodeDefinition, ParentNodeDefinition } from './NodeDefinition.ts';
 
-export class ValueNodeDefinition
-	extends DescendentNodeDefinition<'value-node', ControlElementDefinition | null>
-	implements NodeDefinition<'value-node'>
+export class LeafNodeDefinition
+	extends DescendentNodeDefinition<'leaf-node', ControlElementDefinition | null>
+	implements NodeDefinition<'leaf-node'>
 {
-	readonly type = 'value-node';
+	readonly type = 'leaf-node';
 
 	readonly nodeName: string;
 	readonly children = null;

package/src/model/ModelBindMap.ts

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

package/src/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/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/model/RepeatRangeDefinition.ts

@@ -1,22 +1,49 @@
 import type { RepeatElementDefinition } from '../body/RepeatElementDefinition.ts';
+import { RepeatCountControlExpression } from '../parse/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'>
 {
-	// TODO: if an implicit template is derived from an instance in a form
-	// definition, should its default values (if any) be cleared? Probably!
-	static createTemplateElement(instanceElement: Element): Element {
-		return instanceElement.cloneNode(true) as Element;
-	}
+	static from(
+		parent: ParentNodeDefinition,
+		bind: BindDefinition,
+		bodyElement: RepeatElementDefinition,
+		modelNodes: readonly [Element, ...Element[]]
+	): AnyRepeatRangeDefinition {
+		const definition = new this(parent, bind, bodyElement, modelNodes);
+
+		assertRepeatRangeDefinitionUnion(definition);
 
-	static createInstanceElement(templateElement: Element): Element {
-		return templateElement.cloneNode(true) as Element;
+		return definition;
 	}
 
 	readonly type = 'repeat-range';
@@ -24,27 +51,41 @@ export class RepeatRangeDefinition
 	readonly template: RepeatTemplateDefinition;
 	readonly children = null;
 	readonly instances: RepeatInstanceDefinition[];
+	readonly count: RepeatCountControlExpression | null;
 
 	readonly node = null;
 	readonly nodeName: string;
 	readonly defaultValue = null;
 
-	constructor(
+	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;
 

package/src/model/RootDefinition.ts

@@ -1,6 +1,8 @@
 import type { XFormDefinition } from '../XFormDefinition.ts';
 import type { BodyClassList } from '../body/BodyDefinition.ts';
+import { NoteNodeDefinition } from '../parse/NoteNodeDefinition.ts';
 import type { BindDefinition } from './BindDefinition.ts';
+import { LeafNodeDefinition } from './LeafNodeDefinition.ts';
 import type { ModelDefinition } from './ModelDefinition.ts';
 import type {
 	ChildNodeDefinition,
@@ -9,7 +11,6 @@ import type {
 } from './NodeDefinition.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/NoteNodeDefinition.ts

@@ -0,0 +1,70 @@
+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';
+
+// prettier-ignore
+export type NoteReadonlyDefinition =
+	&	BindComputation<'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/parse/TODO.md

@@ -0,0 +1,3 @@
+# @getodk/xforms-engine: parse
+
+Presence of this file is intended to be temporary! It is here to signal the intent to make a clearer distinction between the parsing and runtime aspects of the engine implementation. For entirely pragmatic purposes, newly introduced will be added here to start. We can decide in review if we want to move the rest into this directory right away. (For existing/untouched code, this would just mean moving the files and updating imports to reflect that. Small effort, lots of potential diff noise.)

package/src/parse/expression/RepeatCountControlExpression.ts

@@ -0,0 +1,44 @@
+import { RepeatElementDefinition } from '../../body/RepeatElementDefinition.ts';
+import type { RepeatRangeControlledNode } from '../../client/repeat/RepeatRangeControlledNode.ts';
+import { DependentExpression } from '../../expression/DependentExpression.ts';
+import { isConstantTruthyExpression } from '../xpath/semantic-analysis.ts';
+
+/**
+ * Represents either of these
+ * {@link https://getodk.github.io/xforms-spec/#body-attributes | body attributes}:
+ *
+ * - `jr:count`
+ * - `jr:noAddRemove`
+ *
+ * In both cases, the downstream effect is that the engine is responsible for
+ * controlling the count of a repeat range's instances. Representing both cases
+ * should simplify client usage, as well as implementation of the internal
+ * representation of {@link RepeatRangeControlledNode}.
+ */
+export class RepeatCountControlExpression extends DependentExpression<'number'> {
+	static from(
+		bodyElement: RepeatElementDefinition,
+		initialCount: number
+	): RepeatCountControlExpression | null {
+		const { countExpression, noAddRemoveExpression } = bodyElement;
+
+		if (countExpression != null) {
+			return new this(bodyElement, countExpression);
+		}
+
+		if (noAddRemoveExpression != null && isConstantTruthyExpression(noAddRemoveExpression)) {
+			// Assumption: `noAddRemove` with no form-defined repeat instances has no
+			// purpose. Infer intent as a single repeat instance, as defined by the
+			// repeat's template.
+			const fixedCountExpression = String(Math.max(initialCount, 1));
+
+			return new this(bodyElement, fixedCountExpression);
+		}
+
+		return null;
+	}
+
+	private constructor(context: RepeatElementDefinition, expression: string) {
+		super(context, 'number', expression);
+	}
+}

package/src/parse/text/HintDefinition.ts

@@ -0,0 +1,25 @@
+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 { 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);
+	}
+}