@getodk/xforms-engine 0.15.0 → 0.16.0

package/src/lib/reactivity/createInstanceValueState.ts

@@ -1,24 +1,35 @@
 import type { Signal } from 'solid-js';
 import { createComputed, createMemo, createSignal, untrack } from 'solid-js';
+import type { AttributeContext } from '../../instance/internal-api/AttributeContext.ts';
 import type { InstanceValueContext } from '../../instance/internal-api/InstanceValueContext.ts';
+import { ActionComputationExpression } from '../../parse/expression/ActionComputationExpression.ts';
 import type { BindComputationExpression } from '../../parse/expression/BindComputationExpression.ts';
+import { ActionDefinition } from '../../parse/model/ActionDefinition.ts';
+import type { AnyBindPreloadDefinition } from '../../parse/model/BindPreloadDefinition.ts';
+import { XFORM_EVENT } from '../../parse/model/Event.ts';
 import { createComputedExpression } from './createComputedExpression.ts';
 import type { SimpleAtomicState, SimpleAtomicStateSetter } from './types.ts';
 
-const isInstanceFirstLoad = (context: InstanceValueContext) => {
+const REPEAT_INDEX_REGEX = /([^[]*)(\[[0-9]+\])/g;
+
+type ValueContext = AttributeContext | InstanceValueContext;
+
+const isInstanceFirstLoad = (context: ValueContext) => {
 	return context.rootDocument.initializationMode === 'create';
 };
 
+const isAddingRepeatChild = (context: ValueContext) => {
+	return context.rootDocument.isAttached();
+};
+
 /**
  * Special case, does not correspond to any event.
- *
- * @see {@link shouldPreloadUID}
  */
-const isEditInitialLoad = (context: InstanceValueContext) => {
+const isEditInitialLoad = (context: ValueContext) => {
 	return context.rootDocument.initializationMode === 'edit';
 };
 
-const getInitialValue = (context: InstanceValueContext): string => {
+const getInitialValue = (context: ValueContext): string => {
 	const sourceNode = context.instanceNode ?? context.definition.template;
 
 	return context.decodeInstanceValue(sourceNode.value);
@@ -36,7 +47,7 @@ type RelevantValueState = SimpleAtomicState<string>;
  *   node/context's relevance is restored
  */
 const createRelevantValueState = (
-	context: InstanceValueContext,
+	context: ValueContext,
 	baseValueState: BaseValueState
 ): RelevantValueState => {
 	return context.scope.runTask(() => {
@@ -59,7 +70,7 @@ const createRelevantValueState = (
  * (client/user) writes when the field is in a `readonly` state.
  */
 const guardDownstreamReadonlyWrites = (
-	context: InstanceValueContext,
+	context: ValueContext,
 	baseState: SimpleAtomicState<string>
 ): SimpleAtomicState<string> => {
 	const { readonly } = context.definition.bind;
@@ -83,47 +94,86 @@ const guardDownstreamReadonlyWrites = (
 	return [getValue, setValue];
 };
 
-/**
- * Per {@link https://getodk.github.io/xforms-spec/#preload-attributes:~:text=concatenation%20of%20%E2%80%98uuid%3A%E2%80%99%20and%20uuid()}
- */
-const PRELOAD_UID_EXPRESSION = 'concat("uuid:", uuid())';
-
 /**
  * @todo It feels increasingly awkward to keep piling up preload stuff here, but it won't stay that way for long. In the meantime, this seems like the best way to express the cases where `preload="uid"` should be effective, i.e.:
  *
  * - When an instance is first loaded ({@link isInstanceFirstLoad})
  * - When an instance is initially loaded for editing ({@link isEditInitialLoad})
  */
-const shouldPreloadUID = (context: InstanceValueContext) => {
+const isLoading = (context: ValueContext) => {
 	return isInstanceFirstLoad(context) || isEditInitialLoad(context);
 };
 
-/**
- * @todo This is a temporary one-off, until we support the full range of
- * {@link https://getodk.github.io/xforms-spec/#preload-attributes | preloads}.
- *
- * @todo ALSO, IMPORTANTLY(!): the **call site** for this function is
- * semantically where we would expect to trigger a
- * {@link https://getodk.github.io/xforms-spec/#event:odk-instance-first-load | odk-instance-first-load event},
- * _and compute_ preloads semantically associated with that event.
- */
-const setPreloadUIDValue = (
-	context: InstanceValueContext,
-	valueState: RelevantValueState
-): void => {
+const setValueIfPreloadDefined = (
+	context: ValueContext,
+	setValue: SimpleAtomicStateSetter<string>,
+	preload: AnyBindPreloadDefinition
+) => {
+	const value = preload.getValue(context);
+	if (value) {
+		setValue(value);
+	}
+};
+
+const postloadValue = (
+	context: ValueContext,
+	setValue: SimpleAtomicStateSetter<string>,
+	preload: AnyBindPreloadDefinition
+) => {
+	const ref = context.contextReference();
+	context.definition.model.registerXformsRevalidateListener(ref, () => {
+		setValueIfPreloadDefined(context, setValue, preload);
+	});
+};
+
+const preloadValue = (context: ValueContext, setValue: SimpleAtomicStateSetter<string>): void => {
 	const { preload } = context.definition.bind;
+	if (!preload) {
+		return;
+	}
 
-	if (preload?.type !== 'uid' || !shouldPreloadUID(context)) {
+	if (preload.event === XFORM_EVENT.xformsRevalidate) {
+		postloadValue(context, setValue, preload);
 		return;
 	}
 
-	const preloadUIDValue = context.evaluator.evaluateString(PRELOAD_UID_EXPRESSION, {
+	if (isLoading(context)) {
+		setValueIfPreloadDefined(context, setValue, preload);
+	}
+};
+
+const referencesCurrentNode = (context: ValueContext, ref: string): boolean => {
+	const nodes = context.evaluator.evaluateNodes(ref, {
 		contextNode: context.contextNode,
 	});
+	if (nodes.length > 1) {
+		throw new Error(
+			'You are trying to target a repeated field. Currently you may only target a field in a specific repeat instance. XPath nodeset has more than one node.'
+		);
+	}
+	return nodes.includes(context.contextNode);
+};
 
-	const [, setValue] = valueState;
-
-	setValue(preloadUIDValue);
+// Replaces the unbound repeat references in source and ref, with references
+// bound to the repeat instace of the context.
+const bindToRepeatInstance = (
+	context: ValueContext,
+	action: ActionDefinition
+): { source: string | undefined; ref: string } => {
+	let source = action.source;
+	let ref = action.ref;
+	if (source) {
+		const contextRef = context.contextReference();
+		for (const part of contextRef.matchAll(REPEAT_INDEX_REGEX)) {
+			const unbound = part[1] + '/';
+			if (source.includes(unbound)) {
+				const bound = part[0] + '/';
+				source = source.replace(unbound, bound);
+				ref = ref.replace(unbound, bound);
+			}
+		}
+	}
+	return { source, ref };
 };
 
 /**
@@ -131,30 +181,78 @@ const setPreloadUIDValue = (
  * computations to the provided value setter, on initialization and any
  * subsequent reactive update.
  *
- * @see {@link setPreloadUIDValue} for important details about spec ordering of
+ * @see {@link preloadValue} for important details about spec ordering of
  * events and computations.
  */
 const createCalculation = (
-	context: InstanceValueContext,
+	context: ValueContext,
 	setRelevantValue: SimpleAtomicStateSetter<string>,
-	calculateDefinition: BindComputationExpression<'calculate'>
+	computation: ActionComputationExpression<'string'> | BindComputationExpression<'calculate'>
 ): void => {
-	context.scope.runTask(() => {
-		const calculate = createComputedExpression(context, calculateDefinition, {
-			defaultValue: '',
-		});
-
-		createComputed(() => {
-			if (context.isAttached() && context.isRelevant()) {
-				const calculated = calculate();
-				const value = context.decodeInstanceValue(calculated);
+	const calculate = createComputedExpression(context, computation);
+	createComputed(() => {
+		if (context.isAttached() && context.isRelevant()) {
+			const calculated = calculate();
+			const value = context.decodeInstanceValue(calculated);
+			setRelevantValue(value);
+		}
+	});
+};
 
-				setRelevantValue(value);
+const createValueChangedCalculation = (
+	context: ValueContext,
+	setRelevantValue: SimpleAtomicStateSetter<string>,
+	action: ActionDefinition
+): void => {
+	const { source, ref } = bindToRepeatInstance(context, action);
+	if (!source) {
+		// no element to listen to
+		return;
+	}
+	let previous = '';
+	const sourceElementExpression = new ActionComputationExpression('string', source);
+	const calculateValueSource = createComputedExpression(context, sourceElementExpression); // registers listener
+	createComputed(() => {
+		if (context.isAttached() && context.isRelevant()) {
+			const valueSource = calculateValueSource();
+			if (previous !== valueSource) {
+				// only update if value has changed
+				if (referencesCurrentNode(context, ref)) {
+					const calc = context.evaluator.evaluateString(action.computation.expression, context);
+					const value = context.decodeInstanceValue(calc);
+					setRelevantValue(value);
+				}
 			}
-		});
+			previous = valueSource;
+		}
 	});
 };
 
+const registerAction = (
+	context: ValueContext,
+	setValue: SimpleAtomicStateSetter<string>,
+	action: ActionDefinition
+) => {
+	if (action.events.includes(XFORM_EVENT.odkInstanceFirstLoad)) {
+		if (isInstanceFirstLoad(context)) {
+			createCalculation(context, setValue, action.computation);
+		}
+	}
+	if (action.events.includes(XFORM_EVENT.odkInstanceLoad)) {
+		if (!isAddingRepeatChild(context)) {
+			createCalculation(context, setValue, action.computation);
+		}
+	}
+	if (action.events.includes(XFORM_EVENT.odkNewRepeat)) {
+		if (isAddingRepeatChild(context)) {
+			createCalculation(context, setValue, action.computation);
+		}
+	}
+	if (action.events.includes(XFORM_EVENT.xformsValueChanged)) {
+		createValueChangedCalculation(context, setValue, action);
+	}
+};
+
 export type InstanceValueState = SimpleAtomicState<string>;
 
 /**
@@ -168,25 +266,26 @@ export type InstanceValueState = SimpleAtomicState<string>;
  *   nodes defined with one
  * - prevents downstream writes to nodes in a readonly state
  */
-export const createInstanceValueState = (context: InstanceValueContext): InstanceValueState => {
+export const createInstanceValueState = (context: ValueContext): InstanceValueState => {
 	return context.scope.runTask(() => {
 		const initialValue = getInitialValue(context);
 		const baseValueState = createSignal(initialValue);
 		const relevantValueState = createRelevantValueState(context, baseValueState);
 
-		/**
-		 * @see {@link setPreloadUIDValue} for important details about spec ordering of events and computations.
-		 */
-		setPreloadUIDValue(context, relevantValueState);
+		const [, setValue] = relevantValueState;
 
-		const { calculate } = context.definition.bind;
+		preloadValue(context, setValue);
 
+		const { calculate } = context.definition.bind;
 		if (calculate != null) {
-			const [, setValue] = relevantValueState;
-
 			createCalculation(context, setValue, calculate);
 		}
 
+		const action = context.definition.model.actions.get(context.contextReference());
+		if (action) {
+			registerAction(context, setValue, action);
+		}
+
 		return guardDownstreamReadonlyWrites(context, relevantValueState);
 	});
 };

package/src/lib/reactivity/node-state/createSharedNodeState.ts

@@ -13,10 +13,10 @@ import { isComputedPropertySpec, isMutablePropertySpec } from './createSpecified
 // prettier-ignore
 type MutableKeyOf<Spec extends StateSpec> = {
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	[K in string & keyof Spec]: Spec[K] extends MutablePropertySpec<any>
+	[K in Extract<keyof Spec, string>]: Spec[K] extends MutablePropertySpec<any>
 		? K
 		: never;
-}[string & keyof Spec];
+}[Extract<keyof Spec, string>];
 
 type SetEnginePropertyState<Spec extends StateSpec> = <K extends MutableKeyOf<Spec>>(
 	key: K,

package/src/lib/xml-serialization.ts

@@ -153,7 +153,15 @@ export const serializeParentElementXML = (
 export const serializeLeafElementXML = (
 	qualifiedName: QualifiedName,
 	xmlValue: EscapedXMLText,
+	attributes: readonly Attribute[],
 	namespaceDeclarations?: NamespaceDeclarationMap
 ): string => {
-	return serializeElementXML(qualifiedName, xmlValue.normalize(), '', namespaceDeclarations);
+	const serializedAttributes =
+		attributes?.map((attribute) => attribute.instanceState.instanceXML).join('') ?? '';
+	return serializeElementXML(
+		qualifiedName,
+		xmlValue.normalize(),
+		serializedAttributes,
+		namespaceDeclarations
+	);
 };

package/src/parse/XFormDOM.ts

@@ -11,6 +11,7 @@ import type {
 import { DefaultEvaluator } from '@getodk/xpath';
 
 interface DOMBindElement extends KnownAttributeLocalNamedElement<'bind', 'nodeset'> {}
+interface DOMSetValueElement extends KnownAttributeLocalNamedElement<'setvalue', 'event'> {}
 
 const getMetaElement = (primaryInstanceRoot: Element): Element | null => {
 	for (const child of primaryInstanceRoot.children) {
@@ -336,6 +337,7 @@ export class XFormDOM {
 
 	readonly model: Element;
 	readonly binds: readonly DOMBindElement[];
+	readonly setValues: readonly DOMSetValueElement[];
 	readonly primaryInstance: Element;
 	readonly primaryInstanceRoot: Element;
 
@@ -368,6 +370,12 @@ export class XFormDOM {
 				contextNode: model,
 			}
 		);
+		const setValues: readonly DOMSetValueElement[] = evaluator.evaluateNodes<DOMSetValueElement>(
+			'./xf:setvalue[@event]',
+			{
+				contextNode: model,
+			}
+		);
 
 		const instances = evaluator.evaluateNodes<DOMInstanceElement>('./xf:instance', {
 			contextNode: model,
@@ -417,6 +425,7 @@ export class XFormDOM {
 		this.title = title;
 		this.model = model;
 		this.binds = binds;
+		this.setValues = setValues;
 		this.primaryInstance = primaryInstance;
 		this.primaryInstanceRoot = primaryInstanceRoot;
 		this.itextTranslationElements = itextTranslationElements;

package/src/parse/body/GroupElementDefinition.ts

@@ -39,8 +39,8 @@ export class GroupElementDefinition extends BodyElementDefinition<'group'> {
 			return childName !== 'label';
 		});
 
-		this.children = this.body.getChildElementDefinitions(form, this, element, childElements);
 		this.reference = parseNodesetReference(parent, element, 'ref');
+		this.children = this.body.getChildElementDefinitions(form, this, element, childElements);
 		this.appearances = structureElementAppearanceParser.parseFrom(element, 'appearance');
 		this.label = LabelDefinition.forGroup(form, this);
 	}

package/src/parse/body/control/InputControlDefinition.ts

@@ -1,8 +1,8 @@
+import { parseToFloat, parseToInteger } from '../../../lib/number-parsers.ts';
 import type { XFormDefinition } from '../../XFormDefinition.ts';
 import type { InputAppearanceDefinition } from '../appearance/inputAppearanceParser.ts';
 import { inputAppearanceParser } from '../appearance/inputAppearanceParser.ts';
 import type { BodyElementParentContext } from '../BodyDefinition.ts';
-import { parseToFloat, parseToInteger } from '../../../lib/number-parsers.ts';
 import { ControlDefinition } from './ControlDefinition.ts';
 
 export class InputControlDefinition extends ControlDefinition<'input'> {

package/src/parse/expression/ActionComputationExpression.ts

@@ -0,0 +1,12 @@
+import {
+	DependentExpression,
+	type DependentExpressionResultType,
+} from './abstract/DependentExpression.ts';
+
+export class ActionComputationExpression<
+	Type extends DependentExpressionResultType,
+> extends DependentExpression<Type> {
+	constructor(resultType: Type, expression: string) {
+		super(resultType, expression);
+	}
+}

package/src/parse/model/ActionDefinition.ts

@@ -0,0 +1,70 @@
+import { isTextNode } from '@getodk/common/lib/dom/predicates.ts';
+import { ActionComputationExpression } from '../expression/ActionComputationExpression.ts';
+import { type XFormEvent, XFORM_EVENT } from './Event.ts';
+import type { ModelDefinition } from './ModelDefinition.ts';
+
+export class ActionDefinition {
+	static getRef(model: ModelDefinition, setValueElement: Element): string | null {
+		if (setValueElement.hasAttribute('ref')) {
+			return setValueElement.getAttribute('ref') ?? null;
+		}
+		if (setValueElement.hasAttribute('bind')) {
+			const bindId = setValueElement.getAttribute('bind');
+			const bindDefinition = Array.from(model.binds.values()).find((definition) => {
+				return definition.bindElement.getAttribute('id') === bindId;
+			});
+			return bindDefinition?.nodeset ?? null;
+		}
+		return null;
+	}
+
+	static getValue(element: Element): string {
+		if (element.hasAttribute('value')) {
+			// eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+			return element.getAttribute('value') || "''";
+		}
+		if (element.firstChild && isTextNode(element.firstChild)) {
+			// use the text content as the literal value
+			return `'${element.firstChild.nodeValue}'`;
+		}
+		return "''";
+	}
+
+	static isKnownEvent = (event: XFormEvent): event is XFormEvent => {
+		return Object.values(XFORM_EVENT).includes(event);
+	};
+
+	static getEvents(element: Element): XFormEvent[] {
+		const events = element.getAttribute('event')?.split(' ') ?? [];
+		const unknownEvents = events.filter((event) => !this.isKnownEvent(event as XFormEvent));
+		if (unknownEvents.length) {
+			throw new Error(
+				`An action was registered for unsupported events: ${unknownEvents.join(', ')}`
+			);
+		}
+		return events as XFormEvent[];
+	}
+
+	readonly ref: string;
+	readonly events: XFormEvent[];
+	readonly computation: ActionComputationExpression<'string'>;
+	readonly source: string | undefined;
+
+	constructor(
+		model: ModelDefinition,
+		readonly element: Element,
+		source?: string
+	) {
+		const ref = ActionDefinition.getRef(model, element);
+		if (!ref) {
+			throw new Error(
+				'Invalid setvalue element - you must define either "ref" or "bind" attribute'
+			);
+		}
+		this.ref = ref;
+		this.events = ActionDefinition.getEvents(element);
+		const value = ActionDefinition.getValue(element);
+		this.computation = new ActionComputationExpression('string', value);
+		this.source = source;
+	}
+}

package/src/parse/model/AttributeDefinition.ts

@@ -7,6 +7,7 @@ import {
 import { QualifiedName } from '../../lib/names/QualifiedName.ts';
 import { escapeXMLText, serializeAttributeXML } from '../../lib/xml-serialization.ts';
 import type { BindDefinition } from './BindDefinition.ts';
+import type { ModelDefinition } from './ModelDefinition.ts';
 import { NodeDefinition } from './NodeDefinition.ts';
 import type { RootDefinition } from './RootDefinition.ts';
 
@@ -29,7 +30,7 @@ export class AttributeDefinition
 	readonly qualifiedName: QualifiedName;
 
 	constructor(
-		root: RootDefinition,
+		readonly model: ModelDefinition,
 		bind: BindDefinition,
 		readonly template: StaticAttribute
 	) {
@@ -37,7 +38,7 @@ export class AttributeDefinition
 
 		const { value } = template;
 
-		this.root = root;
+		this.root = model.root;
 
 		this.value = value;
 		this.qualifiedName = template.qualifiedName;

package/src/parse/model/AttributeDefinitionMap.ts

@@ -28,7 +28,7 @@ export class AttributeDefinitionMap extends Map<QualifiedName, AttributeDefiniti
 		const nonNamespaceAttributes = instanceNode.attributes.filter(isNonNamespaceAttribute);
 		const definitions = nonNamespaceAttributes.map((attribute) => {
 			const bind = model.binds.getOrCreateBindDefinition(attribute.nodeset);
-			return new AttributeDefinition(model.root, bind, attribute);
+			return new AttributeDefinition(model, bind, attribute);
 		});
 		return new this(definitions);
 	}

package/src/parse/model/BindDefinition.ts

@@ -38,10 +38,7 @@ export class BindDefinition<T extends BindType = BindType> extends DependencyCon
 	// https://github.com/getodk/collect/issues/3758 mentions deprecation.
 	readonly saveIncomplete: BindComputationExpression<'saveIncomplete'>;
 
-	// TODO: these are deferred until prioritized
-	// readonly preload: string | null;
-	// readonly preloadParams: string | null;
-	// readonly 'max-pixels': string | null;
+	// TODO: deferred until prioritized: readonly 'max-pixels': string | null;
 
 	protected _parentBind: BindDefinition | null | undefined;
 
@@ -95,8 +92,6 @@ export class BindDefinition<T extends BindType = BindType> extends DependencyCon
 		this.constraintMsg = MessageDefinition.from(this, 'constraintMsg');
 		this.requiredMsg = MessageDefinition.from(this, 'requiredMsg');
 
-		// this.preload = BindComputation.forExpression(this, 'preload');
-		// this.preloadParams = BindComputation.forExpression(this, 'preloadParams');
 		// this['max-pixels'] = BindComputation.forExpression(this, 'max-pixels');
 	}
 

package/src/parse/model/BindPreloadDefinition.ts

@@ -1,10 +1,18 @@
 import { JAVAROSA_NAMESPACE_URI } from '@getodk/common/constants/xmlns.ts';
 import type { PartiallyKnownString } from '@getodk/common/types/string/PartiallyKnownString.ts';
+import type { AttributeContext } from '../../instance/internal-api/AttributeContext.ts';
+import type { InstanceValueContext } from '../../instance/internal-api/InstanceValueContext.ts';
 import type { BindElement } from './BindElement.ts';
+import { XFORM_EVENT, type XFormEvent } from './Event.ts';
 
-type PartiallyKnownPreloadParameter<Known extends string> =
-	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
-	PartiallyKnownString<NonNullable<Known>> | Extract<Known, null>;
+/**
+ * Per {@link https://getodk.github.io/xforms-spec/#preload-attributes:~:text=concatenation%20of%20%E2%80%98uuid%3A%E2%80%99%20and%20uuid()}
+ */
+const PRELOAD_UID_EXPRESSION = 'concat("uuid:", uuid())';
+
+type PartiallyKnownPreloadParameter<Known extends string> = PartiallyKnownString<
+	NonNullable<Known>
+>;
 
 interface PreloadParametersByType {
 	readonly uid: string | null;
@@ -61,15 +69,6 @@ const getPreloadInput = (bindElement: BindElement): AnyPreloadInput | null => {
  *
  * - {@link type}, a `jr:preload`
  * - {@link parameter}, an associated `jr:preloadParams` value
- *
- * @todo It would probably make sense for the _definition_ to also convey:
- *
- * 1. Which {@link https://getodk.github.io/xforms-spec/#events | event} the
- *    preload is semantically associated with (noting that the spec may be a tad
- *    overzealous about this association).
- *
- * 2. The constant XPath expression (or other computation?) expressed by the
- *    combined {@link type} and {@link parameter}.
  */
 export class BindPreloadDefinition<Type extends PreloadType> implements PreloadInput<Type> {
 	static from(bindElement: BindElement): AnyBindPreloadDefinition | null {
@@ -84,10 +83,43 @@ export class BindPreloadDefinition<Type extends PreloadType> implements PreloadI
 
 	readonly type: Type;
 	readonly parameter: PreloadParameter<Type>;
+	readonly event: XFormEvent;
+
+	getValue(context: AttributeContext | InstanceValueContext): string | undefined {
+		if (this.type === 'uid') {
+			return context.evaluator.evaluateString(PRELOAD_UID_EXPRESSION);
+		}
+		if (this.type === 'timestamp') {
+			return context.evaluator.evaluateString('now()');
+		}
+		if (this.type === 'date') {
+			return context.evaluator.evaluateString('today()');
+		}
+		if (this.type === 'property') {
+			const properties = context.instanceConfig.preloadProperties;
+			if (this.parameter === 'deviceid') {
+				return properties.deviceID;
+			}
+			if (this.parameter === 'email') {
+				return properties.email;
+			}
+			if (this.parameter === 'phonenumber') {
+				return properties.phoneNumber;
+			}
+			if (this.parameter === 'username') {
+				return properties.username;
+			}
+		}
+		return;
+	}
 
 	private constructor(input: PreloadInput<Type>) {
 		this.type = input.type;
 		this.parameter = input.parameter;
+		this.event =
+			this.type === 'timestamp' && this.parameter === 'end'
+				? XFORM_EVENT.xformsRevalidate
+				: XFORM_EVENT.odkInstanceFirstLoad;
 	}
 }
 

package/src/parse/model/Event.ts

@@ -0,0 +1,9 @@
+export const XFORM_EVENT = {
+	odkInstanceLoad: 'odk-instance-load',
+	odkInstanceFirstLoad: 'odk-instance-first-load',
+	odkNewRepeat: 'odk-new-repeat',
+	xformsRevalidate: 'xforms-revalidate',
+	xformsValueChanged: 'xforms-value-changed',
+} as const;
+
+export type XFormEvent = (typeof XFORM_EVENT)[keyof typeof XFORM_EVENT];

package/src/parse/model/LeafNodeDefinition.ts

@@ -6,8 +6,10 @@ import {
 } from '../../lib/names/NamespaceDeclarationMap.ts';
 import { QualifiedName } from '../../lib/names/QualifiedName.ts';
 import type { AnyBodyElementDefinition, ControlElementDefinition } from '../body/BodyDefinition.ts';
+import { AttributeDefinitionMap } from './AttributeDefinitionMap.ts';
 import type { BindDefinition } from './BindDefinition.ts';
 import { DescendentNodeDefinition } from './DescendentNodeDefinition.ts';
+import type { ModelDefinition } from './ModelDefinition.ts';
 import type { ParentNodeDefinition } from './NodeDefinition.ts';
 
 export class LeafNodeDefinition<V extends ValueType = ValueType>
@@ -20,9 +22,10 @@ export class LeafNodeDefinition<V extends ValueType = ValueType>
 	readonly namespaceDeclarations: NamespaceDeclarationMap;
 	readonly qualifiedName: QualifiedName;
 	readonly children = null;
-	readonly attributes = null;
+	readonly attributes: AttributeDefinitionMap;
 
 	constructor(
+		readonly model: ModelDefinition,
 		parent: ParentNodeDefinition,
 		bind: BindDefinition,
 		bodyElement: AnyBodyElementDefinition | null,
@@ -37,6 +40,7 @@ export class LeafNodeDefinition<V extends ValueType = ValueType>
 		this.valueType = bind.type.resolved satisfies ValueType as V;
 		this.qualifiedName = template.qualifiedName;
 		this.namespaceDeclarations = new NamespaceDeclarationMap(this);
+		this.attributes = AttributeDefinitionMap.from(model, template);
 	}
 
 	toJSON() {