@getodk/xforms-engine 0.14.0 → 0.16.0

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

@@ -0,0 +1,59 @@
+import { XMLNS_NAMESPACE_URI } from '@getodk/common/constants/xmlns.ts';
+import type { StaticAttribute } from '../../integration/xpath/static-dom/StaticAttribute.ts';
+import {
+	NamespaceDeclarationMap,
+	type NamedNodeDefinition,
+} from '../../lib/names/NamespaceDeclarationMap.ts';
+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';
+
+export class AttributeDefinition
+	extends NodeDefinition<'attribute'>
+	implements NamedNodeDefinition
+{
+	private readonly serializedXML: string;
+
+	readonly value: string;
+	readonly type = 'attribute';
+	readonly namespaceDeclarations: NamespaceDeclarationMap;
+	readonly bodyElement = null;
+	readonly root: RootDefinition;
+	readonly isTranslated: boolean = false;
+	readonly parent = null;
+	readonly children = null;
+	readonly attributes = null;
+
+	readonly qualifiedName: QualifiedName;
+
+	constructor(
+		readonly model: ModelDefinition,
+		bind: BindDefinition,
+		readonly template: StaticAttribute
+	) {
+		super(bind);
+
+		const { value } = template;
+
+		this.root = model.root;
+
+		this.value = value;
+		this.qualifiedName = template.qualifiedName;
+		this.namespaceDeclarations = new NamespaceDeclarationMap(this);
+
+		// We serialize namespace declarations separately
+		if (this.qualifiedName.namespaceURI?.href === XMLNS_NAMESPACE_URI) {
+			this.serializedXML = '';
+		} else {
+			const xmlValue = escapeXMLText(this.value, true);
+			this.serializedXML = serializeAttributeXML(this.qualifiedName, xmlValue);
+		}
+	}
+
+	serializeAttributeXML(): string {
+		return this.serializedXML;
+	}
+}

package/src/parse/model/{RootAttributeMap.ts → AttributeDefinitionMap.ts}

@@ -2,8 +2,8 @@ import { XMLNS_NAMESPACE_URI } from '@getodk/common/constants/xmlns.ts';
 import type { StaticAttribute } from '../../integration/xpath/static-dom/StaticAttribute.ts';
 import type { StaticElement } from '../../integration/xpath/static-dom/StaticElement.ts';
 import type { QualifiedName } from '../../lib/names/QualifiedName.ts';
-import { RootAttributeDefinition } from './RootAttributeDefinition.ts';
-import type { RootDefinition } from './RootDefinition.ts';
+import { AttributeDefinition } from './AttributeDefinition.ts';
+import type { ModelDefinition } from './ModelDefinition.ts';
 
 /**
  * @todo We should probably just distinguish these as separate `StaticNode`
@@ -14,12 +14,6 @@ const isNonNamespaceAttribute = (attribute: StaticAttribute) => {
 };
 
 /**
- * @todo This can be trivially expanded to a narrowly general case when we
- * prioritize work to
- * {@link https://github.com/getodk/web-forms/issues/285 | support attributes}
- * (as modeled form nodes on par with elements). It's been deferred here to
- * avoid expanding scope of an already fairly large yak shave.
- *
  * @todo There's a **much more expansive** general case just waiting for a good
  * opportuntity to prioritize it. E.g. a `NamedNodeMap<T>`, where T is any
  * generalized concept of a named node. This expansive generalization would have
@@ -29,17 +23,17 @@ const isNonNamespaceAttribute = (attribute: StaticAttribute) => {
  *
  * @see {@link QualifiedName} for more detail.
  */
-export class RootAttributeMap extends Map<QualifiedName, RootAttributeDefinition> {
-	static from(root: RootDefinition, instanceNode: StaticElement) {
+export class AttributeDefinitionMap extends Map<QualifiedName, AttributeDefinition> {
+	static from(model: ModelDefinition, instanceNode: StaticElement) {
 		const nonNamespaceAttributes = instanceNode.attributes.filter(isNonNamespaceAttribute);
 		const definitions = nonNamespaceAttributes.map((attribute) => {
-			return new RootAttributeDefinition(root, attribute);
+			const bind = model.binds.getOrCreateBindDefinition(attribute.nodeset);
+			return new AttributeDefinition(model, bind, attribute);
 		});
-
 		return new this(definitions);
 	}
 
-	private constructor(definitions: readonly RootAttributeDefinition[]) {
+	private constructor(definitions: readonly AttributeDefinition[]) {
 		super(
 			definitions.map((attribute) => {
 				return [attribute.qualifiedName, attribute];

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

@@ -3,8 +3,10 @@ import { NamespaceDeclarationMap } from '../../lib/names/NamespaceDeclarationMap
 import { QualifiedName } from '../../lib/names/QualifiedName.ts';
 import type { AnyBodyElementDefinition } from '../body/BodyDefinition.ts';
 import type { GroupElementDefinition } from '../body/GroupElementDefinition.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 { ChildNodeDefinition, ParentNodeDefinition } from './NodeDefinition.ts';
 
 export class GroupDefinition extends DescendentNodeDefinition<
@@ -16,8 +18,10 @@ export class GroupDefinition extends DescendentNodeDefinition<
 	readonly namespaceDeclarations: NamespaceDeclarationMap;
 	readonly qualifiedName: QualifiedName;
 	readonly children: readonly ChildNodeDefinition[];
+	readonly attributes: AttributeDefinitionMap;
 
 	constructor(
+		model: ModelDefinition,
 		parent: ParentNodeDefinition,
 		bind: BindDefinition,
 		bodyElement: AnyBodyElementDefinition | null,
@@ -37,6 +41,8 @@ export class GroupDefinition extends DescendentNodeDefinition<
 		this.qualifiedName = template.qualifiedName;
 		this.namespaceDeclarations = new NamespaceDeclarationMap(this);
 		this.children = root.buildSubtree(this, template);
+
+		this.attributes = AttributeDefinitionMap.from(model, template);
 	}
 
 	toJSON() {

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,8 +22,10 @@ export class LeafNodeDefinition<V extends ValueType = ValueType>
 	readonly namespaceDeclarations: NamespaceDeclarationMap;
 	readonly qualifiedName: QualifiedName;
 	readonly children = null;
+	readonly attributes: AttributeDefinitionMap;
 
 	constructor(
+		readonly model: ModelDefinition,
 		parent: ParentNodeDefinition,
 		bind: BindDefinition,
 		bodyElement: AnyBodyElementDefinition | null,
@@ -36,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() {

package/src/parse/model/ModelActionMap.ts

@@ -0,0 +1,37 @@
+import { ActionDefinition } from './ActionDefinition.ts';
+import { XFORM_EVENT } from './Event.ts';
+import type { ModelDefinition } from './ModelDefinition.ts';
+
+const REPEAT_REGEX = /(\[[^\]]*\])/gm;
+
+export class ModelActionMap extends Map<string, ActionDefinition> {
+	static fromModel(model: ModelDefinition): ModelActionMap {
+		return new this(model);
+	}
+
+	static getKey(ref: string): string {
+		return ref.replace(REPEAT_REGEX, '');
+	}
+
+	protected constructor(model: ModelDefinition) {
+		super(
+			model.form.xformDOM.setValues.map((setValueElement) => {
+				const action = new ActionDefinition(model, setValueElement);
+				if (action.events.includes(XFORM_EVENT.odkNewRepeat)) {
+					throw new Error('Model contains "setvalue" element with "odk-new-repeat" event');
+				}
+				const key = ModelActionMap.getKey(action.ref);
+				return [key, action];
+			})
+		);
+	}
+
+	override get(ref: string): ActionDefinition | undefined {
+		return super.get(ModelActionMap.getKey(ref));
+	}
+
+	add(action: ActionDefinition) {
+		const key = ModelActionMap.getKey(action.ref);
+		this.set(key, action);
+	}
+}

package/src/parse/model/ModelDefinition.ts

@@ -6,6 +6,7 @@ import { parseStaticDocumentFromDOMSubtree } from '../shared/parseStaticDocument
 import type { XFormDefinition } from '../XFormDefinition.ts';
 import { generateItextChunks, type ChunkExpressionsByItextId } from './generateItextChunks.ts';
 import { ItextTranslationsDefinition } from './ItextTranslationsDefinition.ts';
+import { ModelActionMap } from './ModelActionMap.ts';
 import { ModelBindMap } from './ModelBindMap.ts';
 import type { AnyNodeDefinition } from './NodeDefinition.ts';
 import type { NodeDefinitionMap } from './nodeDefinitionMap.ts';
@@ -13,18 +14,23 @@ import { nodeDefinitionMap } from './nodeDefinitionMap.ts';
 import { RootDefinition } from './RootDefinition.ts';
 import { SubmissionDefinition } from './SubmissionDefinition.ts';
 
+type XformsRevalidateListener = () => void;
+
 export class ModelDefinition {
 	readonly binds: ModelBindMap;
+	readonly actions: ModelActionMap;
 	readonly root: RootDefinition;
 	readonly nodes: NodeDefinitionMap;
 	readonly instance: StaticDocument;
 	readonly itextTranslations: ItextTranslationsDefinition;
 	readonly itextChunks: Map<string, ChunkExpressionsByItextId>;
+	readonly xformsRevalidateListeners: Map<string, XformsRevalidateListener>;
 
 	constructor(readonly form: XFormDefinition) {
 		const submission = new SubmissionDefinition(form.xformDOM);
 
 		this.binds = ModelBindMap.fromModel(this);
+		this.actions = ModelActionMap.fromModel(this);
 		this.instance = parseStaticDocumentFromDOMSubtree(form.xformDOM.primaryInstanceRoot, {
 			nodesetPrefix: '/',
 		});
@@ -32,6 +38,7 @@ export class ModelDefinition {
 		this.nodes = nodeDefinitionMap(this.root);
 		this.itextTranslations = ItextTranslationsDefinition.from(form.xformDOM);
 		this.itextChunks = generateItextChunks(form.xformDOM.itextTranslationElements);
+		this.xformsRevalidateListeners = new Map();
 	}
 
 	getNodeDefinition(nodeset: string): AnyNodeDefinition {
@@ -54,10 +61,12 @@ export class ModelDefinition {
 		return definition;
 	}
 
-	toJSON() {
-		const { form, ...rest } = this;
+	registerXformsRevalidateListener(ref: string, listener: XformsRevalidateListener) {
+		this.xformsRevalidateListeners.set(ref, listener);
+	}
 
-		return rest;
+	triggerXformsRevalidateListeners() {
+		this.xformsRevalidateListeners.forEach((listener: XformsRevalidateListener) => listener());
 	}
 
 	getTranslationChunks(
@@ -67,4 +76,10 @@ export class ModelDefinition {
 		const languageMap = this.itextChunks.get(activeLanguage.language);
 		return languageMap?.get(itextId) ?? [];
 	}
+
+	toJSON() {
+		const { form, ...rest } = this;
+
+		return rest;
+	}
 }

package/src/parse/model/NodeDefinition.ts

@@ -1,3 +1,4 @@
+import type { StaticAttribute } from '../../integration/xpath/static-dom/StaticAttribute.ts';
 import type { StaticElement } from '../../integration/xpath/static-dom/StaticElement.ts';
 import type {
 	NamedSubtreeDefinition,
@@ -6,6 +7,8 @@ import type {
 import type { QualifiedName } from '../../lib/names/QualifiedName.ts';
 import type { AnyBodyElementDefinition } from '../body/BodyDefinition.ts';
 import type { RepeatElementDefinition } from '../body/RepeatElementDefinition.ts';
+import type { AttributeDefinition } from './AttributeDefinition.ts';
+import type { AttributeDefinitionMap } from './AttributeDefinitionMap.ts';
 import type { BindDefinition } from './BindDefinition.ts';
 import type { GroupDefinition } from './GroupDefinition.ts';
 import type { LeafNodeDefinition } from './LeafNodeDefinition.ts';
@@ -45,13 +48,16 @@ export type GroupNodeType = 'group';
  */
 export type LeafNodeType = 'leaf-node';
 
+export type AttributeNodeType = 'attribute';
+
 // prettier-ignore
 export type NodeDefinitionType =
 	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
 	| RootNodeType
 	| RepeatType
 	| GroupNodeType
-	| LeafNodeType;
+	| LeafNodeType
+	| AttributeNodeType;
 
 // prettier-ignore
 export type ParentNodeDefinition =
@@ -76,8 +82,9 @@ export abstract class NodeDefinition<Type extends NodeDefinitionType>
 	abstract readonly isTranslated: boolean;
 	abstract readonly root: RootDefinition;
 	abstract readonly parent: ParentNodeDefinition | null;
-	abstract readonly template: StaticElement;
+	abstract readonly template: StaticAttribute | StaticElement;
 	abstract readonly children: readonly ChildNodeDefinition[] | null;
+	abstract readonly attributes: AttributeDefinitionMap | null;
 
 	readonly nodeset: string;
 
@@ -92,4 +99,5 @@ export type AnyNodeDefinition =
 	| RootDefinition
 	| AnyRepeatDefinition
 	| GroupDefinition
-	| LeafNodeDefinition;
+	| LeafNodeDefinition
+	| AttributeDefinition;

package/src/parse/model/NoteNodeDefinition.ts

@@ -9,6 +9,7 @@ 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 { ModelDefinition } from './ModelDefinition.ts';
 import type { ParentNodeDefinition } from './NodeDefinition.ts';
 
 // prettier-ignore
@@ -41,6 +42,7 @@ export type NoteTextDefinition =
  */
 export class NoteNodeDefinition<V extends ValueType = ValueType> extends LeafNodeDefinition<V> {
 	static from<V extends ValueType>(
+		model: ModelDefinition,
 		parent: ParentNodeDefinition,
 		bind: BindDefinition<V>,
 		bodyElement: AnyBodyElementDefinition | null,
@@ -57,16 +59,17 @@ export class NoteNodeDefinition<V extends ValueType = ValueType> extends LeafNod
 			return null;
 		}
 
-		return new this(parent, bind, bodyElement, noteTextDefinition, node);
+		return new this(model, parent, bind, bodyElement, noteTextDefinition, node);
 	}
 
 	constructor(
+		model: ModelDefinition,
 		parent: ParentNodeDefinition,
 		override readonly bind: NoteBindDefinition<V>,
 		override readonly bodyElement: InputControlDefinition,
 		readonly noteTextDefinition: NoteTextDefinition,
 		template: StaticLeafElement
 	) {
-		super(parent, bind, bodyElement, template);
+		super(model, parent, bind, bodyElement, template);
 	}
 }

package/src/parse/model/RangeNodeDefinition.ts

@@ -9,6 +9,7 @@ import type {
 } from '../body/control/RangeControlDefinition.ts';
 import type { BindDefinition } from './BindDefinition.ts';
 import { LeafNodeDefinition } from './LeafNodeDefinition.ts';
+import type { ModelDefinition } from './ModelDefinition.ts';
 import type { ParentNodeDefinition } from './NodeDefinition.ts';
 
 const RANGE_VALUE_TYPES = ['decimal', 'int'] as const;
@@ -89,6 +90,7 @@ export class RangeNodeDefinition<V extends RangeValueType = RangeValueType>
 	implements RangeLeafNodeDefinition<V>
 {
 	static from<V extends ValueType>(
+		model: ModelDefinition,
 		parent: ParentNodeDefinition,
 		bind: BindDefinition<V>,
 		bodyElement: RangeControlDefinition,
@@ -96,18 +98,19 @@ export class RangeNodeDefinition<V extends RangeValueType = RangeValueType>
 	): RangeNodeDefinition<Extract<V, RangeValueType>> {
 		assertRangeBindDefinition(bind);
 
-		return new this(parent, bind, bodyElement, node);
+		return new this(model, parent, bind, bodyElement, node);
 	}
 
 	readonly bounds: RangeNodeBoundsDefinition<V>;
 
 	private constructor(
+		model: ModelDefinition,
 		parent: ParentNodeDefinition,
 		override readonly bind: BindDefinition<V>,
 		override readonly bodyElement: RangeControlDefinition,
 		node: StaticLeafElement
 	) {
-		super(parent, bind, bodyElement, node);
+		super(model, parent, bind, bodyElement, node);
 
 		this.bounds = RangeNodeBoundsDefinition.from(bodyElement.bounds, bind);
 	}

package/src/parse/model/RepeatDefinition.ts

@@ -19,9 +19,11 @@ import type { NamespaceURL } from '../../lib/names/NamespaceURL.ts';
 import type { QualifiedName, QualifiedNameSource } from '../../lib/names/QualifiedName.ts';
 import type { RepeatElementDefinition } from '../body/RepeatElementDefinition.ts';
 import { RepeatCountControlExpression } from '../expression/RepeatCountControlExpression.ts';
+import { AttributeDefinitionMap } from './AttributeDefinitionMap.ts';
 import type { BindDefinition } from './BindDefinition.ts';
 import { DescendentNodeDefinition } from './DescendentNodeDefinition.ts';
 import type { GroupDefinition } from './GroupDefinition.ts';
+import type { ModelDefinition } from './ModelDefinition.ts';
 import type { ChildNodeDefinition, ParentNodeDefinition } from './NodeDefinition.ts';
 import type { RootDefinition } from './RootDefinition.ts';
 
@@ -313,18 +315,20 @@ export interface UncontrolledRepeatDefinition extends RepeatDefinition {
  */
 export class RepeatDefinition extends DescendentNodeDefinition<'repeat', RepeatElementDefinition> {
 	static from(
+		model: ModelDefinition,
 		parent: ParentNodeDefinition,
 		bind: BindDefinition,
 		bodyElement: RepeatElementDefinition,
 		instanceNodes: RepeatInstanceNodes
 	): AnyRepeatDefinition;
 	static from(
+		model: ModelDefinition,
 		parent: ParentNodeDefinition,
 		bind: BindDefinition,
 		bodyElement: RepeatElementDefinition,
 		instanceNodes: RepeatInstanceNodes
 	): RepeatDefinition {
-		return new this(parent, bind, bodyElement, instanceNodes);
+		return new this(model, parent, bind, bodyElement, instanceNodes);
 	}
 
 	readonly type = 'repeat';
@@ -333,8 +337,10 @@ export class RepeatDefinition extends DescendentNodeDefinition<'repeat', RepeatE
 	readonly template: StaticElement;
 	readonly namespaceDeclarations: NamespaceDeclarationMap;
 	readonly qualifiedName: QualifiedName;
+	readonly attributes: AttributeDefinitionMap;
 
 	private constructor(
+		model: ModelDefinition,
 		parent: ParentNodeDefinition,
 		bind: BindDefinition,
 		bodyElement: RepeatElementDefinition,
@@ -353,6 +359,7 @@ export class RepeatDefinition extends DescendentNodeDefinition<'repeat', RepeatE
 		this.children = root.buildSubtree(self, template);
 
 		const initialCount = this.omitTemplate(instanceNodes).length;
+		this.attributes = AttributeDefinitionMap.from(model, template);
 
 		this.count = RepeatCountControlExpression.from(bodyElement, initialCount);
 	}