@getodk/xforms-engine 0.1.1 → 0.3.0

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

@@ -0,0 +1,72 @@
+import { UnreachableError } from '@getodk/common/lib/error/UnreachableError.ts';
+import type { Accessor } from 'solid-js';
+import type { TextRange } from '../../../client/TextRange.ts';
+import type { EvaluationContext } from '../../../instance/internal-api/EvaluationContext.ts';
+import type { NoteTextDefinition } from '../../../parse/NoteNodeDefinition.ts';
+import { createTextRange } from './createTextRange.ts';
+
+// eslint-disable-next-line @typescript-eslint/sort-type-constituents
+export type NoteTextRole = 'label' | 'hint';
+
+export type ComputedNoteText<Role extends NoteTextRole = NoteTextRole> = Accessor<
+	TextRange<Role, 'form'>
+>;
+
+interface BaseNoteText {
+	readonly role: NoteTextRole;
+	readonly label: ComputedNoteText<'label'> | null;
+	readonly hint: ComputedNoteText<'hint'> | null;
+}
+
+interface LabelNoteText extends BaseNoteText {
+	readonly role: 'label';
+	readonly label: ComputedNoteText<'label'>;
+	readonly hint: null;
+}
+
+interface HintNoteText extends BaseNoteText {
+	readonly role: 'hint';
+	readonly label: null;
+	readonly hint: ComputedNoteText<'hint'>;
+}
+
+// prettier-ignore
+export type NoteTextComputation =
+	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
+	| LabelNoteText
+	| HintNoteText;
+
+export const createNoteText = (
+	context: EvaluationContext,
+	noteTextDefinition: NoteTextDefinition
+): NoteTextComputation => {
+	const { scope } = context;
+	const { role } = noteTextDefinition;
+
+	return scope.runTask(() => {
+		switch (role) {
+			case 'label': {
+				const label = createTextRange(context, role, noteTextDefinition);
+
+				return {
+					role,
+					label,
+					hint: null,
+				};
+			}
+
+			case 'hint': {
+				const hint = createTextRange(context, role, noteTextDefinition);
+
+				return {
+					role,
+					label: null,
+					hint,
+				};
+			}
+
+			default:
+				throw new UnreachableError(noteTextDefinition);
+		}
+	});
+};

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

@@ -1,23 +1,13 @@
-import type { CollectionValues } from '@getodk/common/types/collections/CollectionValues.ts';
-import { createMemo, type Accessor } from 'solid-js';
-import type {
-	TextElementChild,
-	TextElementDefinition,
-} from '../../../body/text/TextElementDefinition.ts';
-import type { TextElementReferencePart } from '../../../body/text/TextElementReferencePart.ts';
-import type { TextChunkSource } from '../../../client/TextRange.ts';
+import type { Accessor } from 'solid-js';
+import { createMemo } from 'solid-js';
+import type { TextChunkSource, TextRole } from '../../../client/TextRange.ts';
 import type { EvaluationContext } from '../../../instance/internal-api/EvaluationContext.ts';
 import { TextChunk } from '../../../instance/text/TextChunk.ts';
-import { TextRange, type TextRole } from '../../../instance/text/TextRange.ts';
+import { TextRange } from '../../../instance/text/TextRange.ts';
+import type { AnyTextChunkDefinition } from '../../../parse/text/abstract/TextChunkDefinition.ts';
+import type { TextRangeDefinition } from '../../../parse/text/abstract/TextRangeDefinition.ts';
 import { createComputedExpression } from '../createComputedExpression.ts';
 
-// prettier-ignore
-type TextSources =
-	| readonly [TextElementReferencePart]
-	| readonly TextElementChild[];
-
-type TextSource = CollectionValues<TextSources>;
-
 interface TextChunkComputation {
 	readonly source: TextChunkSource;
 	readonly getText: Accessor<string>;
@@ -25,21 +15,20 @@ interface TextChunkComputation {
 
 const createComputedTextChunk = (
 	context: EvaluationContext,
-	textSource: TextSource
+	textSource: AnyTextChunkDefinition
 ): TextChunkComputation => {
-	const { type } = textSource;
+	const { source } = textSource;
 
-	if (type === 'static') {
+	if (source === 'static') {
 		const { stringValue } = textSource;
 
 		return {
-			source: type,
+			source,
 			getText: () => stringValue,
 		};
 	}
 
 	return context.scope.runTask(() => {
-		const source: TextChunkSource = type === 'reference' ? 'itext' : type;
 		const getText = createComputedExpression(context, textSource);
 
 		return {
@@ -51,7 +40,7 @@ const createComputedTextChunk = (
 
 const createTextChunks = (
 	context: EvaluationContext,
-	textSources: TextSources
+	textSources: readonly AnyTextChunkDefinition[]
 ): Accessor<readonly TextChunk[]> => {
 	return context.scope.runTask(() => {
 		const { root } = context;
@@ -67,45 +56,7 @@ const createTextChunks = (
 	});
 };
 
-interface CreateTextRangeOptions<FallbackValue extends string | null> {
-	readonly fallbackValue?: FallbackValue;
-}
-
-// prettier-ignore
-type ComputedTextRange<
-	Role extends TextRole,
-	Definition extends TextElementDefinition<Role> | null,
-	FallbackValue extends string | null
-> = Accessor<
-	Definition extends null
-		?  FallbackValue extends null
-			? TextRange<Role> | null
-			: TextRange<Role>
-		: TextRange<Role>
->;
-
-// prettier-ignore
-type FallbackTextRange<
-	Role extends TextRole,
-	FallbackValue extends string | null
-> =
-	FallbackValue extends null
-		? TextRange<Role> | null
-		: TextRange<Role>;
-
-const createFallbackTextRange = <Role extends TextRole, FallbackValue extends string | null>(
-	context: EvaluationContext,
-	role: Role,
-	fallbackValue: FallbackValue
-): FallbackTextRange<Role, FallbackValue> => {
-	if (fallbackValue == null) {
-		return null as FallbackTextRange<Role, FallbackValue>;
-	}
-
-	const staticChunk = new TextChunk(context.root, 'static', fallbackValue);
-
-	return new TextRange(role, [staticChunk]);
-};
+type ComputedFormTextRange<Role extends TextRole> = Accessor<TextRange<Role, 'form'>>;
 
 /**
  * Creates a text range (e.g. label or hint) from the provided definition,
@@ -116,40 +67,16 @@ const createFallbackTextRange = <Role extends TextRole, FallbackValue extends st
  *
  * @todo This does not yet handle itext translations **with** outputs!
  */
-export const createTextRange = <
-	Role extends TextRole,
-	Definition extends TextElementDefinition<Role> | null,
-	FallbackValue extends string | null = null,
->(
+export const createTextRange = <Role extends TextRole>(
 	context: EvaluationContext,
 	role: Role,
-	definition: Definition,
-	options?: CreateTextRangeOptions<FallbackValue>
-): ComputedTextRange<Role, Definition, FallbackValue> => {
+	definition: TextRangeDefinition<Role>
+): ComputedFormTextRange<Role> => {
 	return context.scope.runTask(() => {
-		if (definition == null) {
-			const textRange = createFallbackTextRange(
-				context,
-				role,
-				options?.fallbackValue ?? (null as FallbackValue)
-			);
-			const getTextRange = () => textRange;
-
-			return getTextRange as ComputedTextRange<Role, Definition, FallbackValue>;
-		}
-
-		const { children, referenceExpression } = definition;
-
-		let getTextChunks: Accessor<readonly TextChunk[]>;
-
-		if (referenceExpression == null) {
-			getTextChunks = createTextChunks(context, children);
-		} else {
-			getTextChunks = createTextChunks(context, [referenceExpression]);
-		}
+		const getTextChunks = createTextChunks(context, definition.chunks);
 
 		return createMemo(() => {
-			return new TextRange(role, getTextChunks());
+			return new TextRange('form', role, getTextChunks());
 		});
 	});
 };

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

@@ -0,0 +1,70 @@
+import { createMemo } from 'solid-js';
+import type { OpaqueReactiveObjectFactory } from '../../../client/OpaqueReactiveObjectFactory.ts';
+import type {
+	AncestorNodeValidationState,
+	DescendantNodeViolationReference,
+} from '../../../client/validation.ts';
+import type { AnyParentNode, AnyValueNode } from '../../../instance/hierarchy.ts';
+import { createSharedNodeState } from '../node-state/createSharedNodeState.ts';
+
+const violationReference = (node: AnyValueNode): DescendantNodeViolationReference | null => {
+	const violation = node.getViolation();
+
+	if (violation == null) {
+		return null;
+	}
+
+	const { nodeId } = node;
+
+	return {
+		nodeId,
+		get reference() {
+			return node.currentState.reference;
+		},
+		violation,
+	};
+};
+
+const collectViolationReferences = (
+	context: AnyParentNode
+): readonly DescendantNodeViolationReference[] => {
+	return context.getChildren().flatMap((child) => {
+		switch (child.nodeType) {
+			case 'model-value':
+			case 'note':
+			case 'string':
+			case 'select': {
+				const reference = violationReference(child);
+
+				if (reference == null) {
+					return [];
+				}
+
+				return [reference];
+			}
+
+			default:
+				return collectViolationReferences(child);
+		}
+	});
+};
+
+interface AggregatedViolationsOptions {
+	readonly clientStateFactory: OpaqueReactiveObjectFactory<AncestorNodeValidationState>;
+}
+
+export const createAggregatedViolations = (
+	context: AnyParentNode,
+	options: AggregatedViolationsOptions
+): AncestorNodeValidationState => {
+	const { scope } = context;
+
+	return scope.runTask(() => {
+		const violations = createMemo(() => {
+			return collectViolationReferences(context);
+		});
+		const spec = { violations };
+
+		return createSharedNodeState(scope, spec, options).currentState;
+	});
+};

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/DescendentNodeDefinition.ts

@@ -1,5 +1,4 @@
 import type { AnyBodyElementDefinition } from '../body/BodyDefinition.ts';
-import type { RepeatDefinition } from '../body/RepeatDefinition.ts';
 import type { BindDefinition } from './BindDefinition.ts';
 import type {
 	ModelNode,
@@ -14,7 +13,7 @@ import type { RootDefinition } from './RootDefinition.ts';
 
 export type DescendentNodeType = Exclude<NodeDefinitionType, 'root'>;
 
-type DescendentNodeBodyElement = AnyBodyElementDefinition | RepeatDefinition;
+type DescendentNodeBodyElement = AnyBodyElementDefinition;
 
 export abstract class DescendentNodeDefinition<
 	Type extends DescendentNodeType,

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

@@ -1,14 +1,13 @@
-import type { AnyBodyElementDefinition } from '../body/BodyDefinition.ts';
-import type { AnyControlDefinition } from '../body/control/ControlDefinition.ts';
+import type { AnyBodyElementDefinition, ControlElementDefinition } from '../body/BodyDefinition.ts';
 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', AnyControlDefinition | 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/ModelDefinition.ts

@@ -8,7 +8,7 @@ export class ModelDefinition {
 
 	constructor(readonly form: XFormDefinition) {
 		this.binds = ModelBindMap.fromModel(this);
-		this.root = new RootDefinition(form, this);
+		this.root = new RootDefinition(form, this, form.body.classes);
 	}
 
 	toJSON() {