@getodk/xforms-engine 0.3.0 → 0.5.0

package/src/parse/{text/TranslationChunkDefinition.ts → expression/TextTranslationExpression.ts}

@@ -1,14 +1,14 @@
 import { expressionParser } from '@getodk/xpath/expressionParser.js';
+import type { AnyTextRangeDefinition } from '../text/abstract/TextRangeDefinition.ts';
 import type { TranslationExpression } from '../xpath/semantic-analysis.ts';
 import { isTranslationExpression } from '../xpath/semantic-analysis.ts';
-import { TextChunkDefinition } from './abstract/TextChunkDefinition.ts';
-import type { AnyTextRangeDefinition } from './abstract/TextRangeDefinition.ts';
+import { TextChunkExpression } from './abstract/TextChunkExpression.ts';
 
-export class TranslationChunkDefinition extends TextChunkDefinition<'translation'> {
+export class TextTranslationExpression extends TextChunkExpression<'translation'> {
 	static fromMessage(
 		context: AnyTextRangeDefinition,
 		maybeExpression: string
-	): TranslationChunkDefinition | null {
+	): TextTranslationExpression | null {
 		try {
 			expressionParser.parse(maybeExpression);
 		} catch {

package/src/{expression → parse/expression/abstract}/DependencyContext.ts

@@ -1,28 +1,7 @@
-import type { AnyDependentExpression } from './DependentExpression.ts';
-
 export abstract class DependencyContext {
 	abstract get parentReference(): string | null;
 	abstract get reference(): string | null;
 
-	protected readonly dependentExpressions = new Set<AnyDependentExpression>();
-
-	protected dependencyExpressionsCache: ReadonlySet<string> | null = null;
-
-	get dependencyExpressions(): ReadonlySet<string> {
-		let { dependencyExpressionsCache } = this;
-
-		if (dependencyExpressionsCache == null) {
-			dependencyExpressionsCache = new Set(
-				Array.from(this.dependentExpressions).flatMap((expression) => {
-					return Array.from(expression.dependencyReferences);
-				})
-			);
-			this.dependencyExpressionsCache = dependencyExpressionsCache;
-		}
-
-		return dependencyExpressionsCache;
-	}
-
 	get isTranslated(): boolean {
 		return this._isTranslated;
 	}
@@ -45,9 +24,4 @@ export abstract class DependencyContext {
 
 	// Update note on `set isTranslated` if this internal storage changes.
 	protected _isTranslated = false;
-
-	registerDependentExpression(expression: AnyDependentExpression): void {
-		this.dependencyExpressionsCache = null;
-		this.dependentExpressions.add(expression);
-	}
 }

package/src/{expression → parse/expression/abstract}/DependentExpression.ts

@@ -1,14 +1,13 @@
-import type { XFormsXPathEvaluator } from '@getodk/xpath';
-import { resolveDependencyNodesets } from '../parse/xpath/dependency-analysis.ts';
+import type { EngineXPathEvaluator } from '../../../integration/xpath/EngineXPathEvaluator.ts';
 import type {
 	ConstantExpression,
 	ConstantTruthyExpression,
-} from '../parse/xpath/semantic-analysis.ts';
+} from '../../xpath/semantic-analysis.ts';
 import {
 	isConstantExpression,
 	isConstantTruthyExpression,
 	isTranslationExpression,
-} from '../parse/xpath/semantic-analysis.ts';
+} from '../../xpath/semantic-analysis.ts';
 import type { DependencyContext } from './DependencyContext.ts';
 
 const evaluatorMethodsByResultType = {
@@ -26,7 +25,7 @@ export type DependentExpressionEvaluatorMethod<Type extends DependentExpressionR
 	EvaluatorMethodsByResultType[Type];
 
 export type DependentExpressionResult<Type extends DependentExpressionResultType> = ReturnType<
-	XFormsXPathEvaluator[DependentExpressionEvaluatorMethod<Type>]
+	EngineXPathEvaluator[DependentExpressionEvaluatorMethod<Type>]
 >;
 
 interface SemanticDependencyOptions {
@@ -54,8 +53,7 @@ export interface ConstantTruthyDependentExpression extends ConstantDependentExpr
 	readonly expression: ConstantTruthyExpression;
 }
 
-export class DependentExpression<Type extends DependentExpressionResultType> {
-	readonly dependencyReferences: ReadonlySet<string> = new Set();
+export abstract class DependentExpression<Type extends DependentExpressionResultType> {
 	readonly isTranslated: boolean = false;
 	readonly evaluatorMethod: DependentExpressionEvaluatorMethod<Type>;
 	readonly constantExpression: ConstantExpression | null;
@@ -81,26 +79,17 @@ export class DependentExpression<Type extends DependentExpressionResultType> {
 		this.evaluatorMethod = evaluatorMethodsByResultType[resultType];
 
 		const {
-			ignoreContextReference = false,
 			semanticDependencies = {
 				translations: false,
 			},
 		} = options;
 
-		this.dependencyReferences = new Set(
-			resolveDependencyNodesets(context.reference, expression, {
-				ignoreReferenceToContextPath: ignoreContextReference,
-			})
-		);
-
 		const isTranslated = semanticDependencies.translations && isTranslationExpression(expression);
 
 		if (isTranslated) {
 			this.isTranslated = true;
 			context.isTranslated = true;
 		}
-
-		context.registerDependentExpression(this);
 	}
 
 	isConstantExpression(): this is ConstantDependentExpression<Type> {

package/src/parse/expression/abstract/TextChunkExpression.ts

@@ -0,0 +1,38 @@
+import type { TextChunkSource } from '../../../client/TextRange.ts';
+import type { AnyTextRangeDefinition } from '../../text/abstract/TextRangeDefinition.ts';
+import type { TextLiteralExpression } from '../TextLiteralExpression.ts';
+import type { TextOutputExpression } from '../TextOutputExpression.ts';
+import type { TextReferenceExpression } from '../TextReferenceExpression.ts';
+import type { TextTranslationExpression } from '../TextTranslationExpression.ts';
+import { DependentExpression } from './DependentExpression.ts';
+
+interface TextChunkExpressionOptions {
+	readonly isTranslated?: true;
+}
+
+export abstract class TextChunkExpression<
+	Source extends TextChunkSource,
+> extends DependentExpression<'string'> {
+	abstract readonly source: Source;
+	readonly stringValue?: string;
+
+	constructor(
+		context: AnyTextRangeDefinition,
+		expression: string,
+		options: TextChunkExpressionOptions = {}
+	) {
+		super(context, 'string', expression, {
+			semanticDependencies: {
+				translations: options.isTranslated,
+			},
+			ignoreContextReference: true,
+		});
+	}
+}
+
+// prettier-ignore
+export type AnyTextChunkExpression =
+	| TextLiteralExpression
+	| TextOutputExpression
+	| TextReferenceExpression
+	| TextTranslationExpression;

package/src/parse/model/BindDefinition.ts

@@ -0,0 +1,104 @@
+import { DependencyContext } from '../expression/abstract/DependencyContext.ts';
+import type { DependentExpression } from '../expression/abstract/DependentExpression.ts';
+import { BindComputationExpression } from '../expression/BindComputationExpression.ts';
+import { MessageDefinition } from '../text/MessageDefinition.ts';
+import type { XFormDefinition } from '../XFormDefinition.ts';
+import type { BindElement } from './BindElement.ts';
+import type { BindType } from './BindTypeDefinition.ts';
+import { BindTypeDefinition } from './BindTypeDefinition.ts';
+import type { ModelDefinition } from './ModelDefinition.ts';
+
+export class BindDefinition<T extends BindType = BindType> extends DependencyContext {
+	readonly type: BindTypeDefinition<T>;
+	readonly parentNodeset: string | null;
+
+	readonly calculate: BindComputationExpression<'calculate'> | null;
+	readonly readonly: BindComputationExpression<'readonly'>;
+	readonly relevant: BindComputationExpression<'relevant'>;
+	readonly required: BindComputationExpression<'required'>;
+
+	/**
+	 * 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 BindComputationExpression}, via its {@link DependentExpression}
+	 * super class).
+	 */
+	readonly constraint: BindComputationExpression<'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: BindComputationExpression<'saveIncomplete'>;
+
+	// TODO: these are deferred until prioritized
+	// readonly preload: string | null;
+	// readonly preloadParams: string | null;
+	// readonly 'max-pixels': string | null;
+
+	protected _parentBind: BindDefinition | null | undefined;
+
+	get parentBind(): BindDefinition | null {
+		let bind = this._parentBind;
+
+		if (typeof bind === 'undefined') {
+			const { parentNodeset } = this;
+
+			if (parentNodeset == null) {
+				bind = null;
+			} else {
+				bind = this.form.model.binds.get(parentNodeset) ?? null;
+			}
+
+			this._parentBind = bind;
+		}
+
+		return bind;
+	}
+
+	// DependencyContext
+	get reference(): string {
+		return this.nodeset;
+	}
+
+	get parentReference(): string | null {
+		return this.parentNodeset;
+	}
+
+	constructor(
+		readonly form: XFormDefinition,
+		protected readonly model: ModelDefinition,
+		readonly nodeset: string,
+		readonly bindElement: BindElement
+	) {
+		super();
+
+		this.type = BindTypeDefinition.from(bindElement);
+
+		const parentNodeset = nodeset.replace(/\/[^/]+$/, '');
+
+		this.parentNodeset = parentNodeset.length > 1 ? parentNodeset : null;
+		this.calculate = BindComputationExpression.forComputation(this, 'calculate');
+		this.readonly = BindComputationExpression.forComputation(this, 'readonly');
+		this.relevant = BindComputationExpression.forComputation(this, 'relevant');
+		this.required = BindComputationExpression.forComputation(this, 'required');
+		this.constraint = BindComputationExpression.forComputation(this, 'constraint');
+		this.saveIncomplete = BindComputationExpression.forComputation(this, 'saveIncomplete');
+		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');
+	}
+
+	toJSON() {
+		const { form, model, /* modelElement, */ bindElement, ...rest } = this;
+
+		return rest;
+	}
+}

package/src/parse/model/BindTypeDefinition.ts

@@ -0,0 +1,175 @@
+import { XSD_NAMESPACE_URI, XSD_PREFIX } from '@getodk/common/constants/xmlns.ts';
+import { parseQualifiedNameExpression } from '../xpath/semantic-analysis.ts';
+import type { BindElement } from './BindElement.ts';
+
+/**
+ * As specified by {@link https://getodk.github.io/xforms-spec/#bind-attributes}
+ */
+export const DEFAULT_BIND_TYPE = 'string';
+
+export type DefaultBindType = typeof DEFAULT_BIND_TYPE;
+
+/**
+ * As specified by {@link https://getodk.github.io/xforms-spec/#data-types}
+ */
+const BIND_TYPES = [
+	DEFAULT_BIND_TYPE,
+	'int',
+	'boolean',
+	'decimal',
+	'date',
+	'time',
+	'dateTime',
+	'geopoint',
+	'geotrace',
+	'geoshape',
+	'binary',
+	'barcode',
+	'intent',
+] as const;
+
+type BindTypes = typeof BIND_TYPES;
+
+export type BindType = BindTypes[number];
+
+const isBindType = (value: string): value is BindType => {
+	return BIND_TYPES.includes(value as BindType);
+};
+
+const resolveSupportedBindType = (sourceType: string): BindType | null => {
+	return isBindType(sourceType) ? sourceType : null;
+};
+
+type BindTypeAliasMapping = Readonly<Record<string, BindType>>;
+
+/**
+ * @todo should we make these aliases explicit (rather than relying on {@link resolveUnsupportedBindType})?
+ *
+ * - select1
+ * - rank
+ * - odk:rank
+ */
+const BIND_TYPE_ALIASES: BindTypeAliasMapping = {
+	integer: 'int',
+};
+
+/**
+ * @todo Should this be marked deprecated?
+ * @todo Should we warn on alias resolution?
+ */
+const resolveAliasedBindType = (sourceType: string): BindType | null => {
+	return BIND_TYPE_ALIASES[sourceType] ?? null;
+};
+
+/**
+ * @todo Should we warn on this fallback?
+ */
+const resolveUnsupportedBindType = (_unsupportedType: string): BindType => {
+	return DEFAULT_BIND_TYPE;
+};
+
+interface BindDataTypeNamespaceResolver {
+	lookupNamespaceURI(prefix: string | null): string | null;
+	lookupPrefix(namespaceURI: string | null): string | null;
+}
+
+/**
+ * Resolves the XML Schema namespace prefix by:
+ *
+ * - Explicitly declared prefix, if any
+ * - Default to {@link XSD_PREFIX} _unless that prefix is bound to some other
+ *   namespace URI_
+ */
+const resolveXMLSchemaNamespacePrefix = (
+	resolver: BindDataTypeNamespaceResolver
+): string | null => {
+	const declaredPrefix = resolver.lookupPrefix(XSD_NAMESPACE_URI);
+
+	if (declaredPrefix != null) {
+		return declaredPrefix;
+	}
+
+	if (resolver.lookupNamespaceURI(XSD_PREFIX) == null) {
+		return XSD_PREFIX;
+	}
+
+	return null;
+};
+
+interface MaybeBindElementNamespaceResolver
+	extends BindElement,
+		Partial<BindDataTypeNamespaceResolver> {}
+
+interface BindElementNamespaceResolver extends BindElement, BindDataTypeNamespaceResolver {}
+
+const isNamespaceResolver = (
+	bindElement: MaybeBindElementNamespaceResolver
+): bindElement is BindElementNamespaceResolver => {
+	return (
+		typeof bindElement.lookupNamespaceURI === 'function' &&
+		typeof bindElement.lookupPrefix === 'function'
+	);
+};
+
+const resolveNamespacedBindType = (
+	bindElement: BindElement,
+	sourceType: string
+): BindType | null => {
+	if (!isNamespaceResolver(bindElement)) {
+		return null;
+	}
+
+	const qualifiedName = parseQualifiedNameExpression(sourceType);
+
+	if (qualifiedName == null) {
+		return null;
+	}
+
+	const xsdPrefix = resolveXMLSchemaNamespacePrefix(bindElement);
+
+	if (xsdPrefix == null) {
+		return null;
+	}
+
+	const { prefix, localPart } = qualifiedName;
+
+	if (prefix === xsdPrefix) {
+		return (
+			resolveSupportedBindType(localPart) ??
+			resolveAliasedBindType(localPart) ??
+			resolveUnsupportedBindType(localPart)
+		);
+	}
+
+	return null;
+};
+
+const resolveBindType = (bindElement: BindElement, sourceType: string): BindType => {
+	return (
+		resolveSupportedBindType(sourceType) ??
+		resolveAliasedBindType(sourceType) ??
+		resolveNamespacedBindType(bindElement, sourceType) ??
+		resolveUnsupportedBindType(sourceType)
+	);
+};
+
+export class BindTypeDefinition<T extends BindType = BindType> {
+	static from<T extends BindType>(bindElement: BindElement): BindTypeDefinition<T> {
+		const sourceType = bindElement.getAttribute('type');
+
+		if (sourceType == null) {
+			return new this(sourceType, DEFAULT_BIND_TYPE);
+		}
+
+		const resolved = resolveBindType(bindElement, sourceType);
+
+		return new this(sourceType, resolved);
+	}
+
+	private constructor(source: null, resolved: DefaultBindType);
+	private constructor(source: string, resolved: BindType);
+	private constructor(
+		readonly source: string | null,
+		readonly resolved: T
+	) {}
+}

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

@@ -29,7 +29,6 @@ export abstract class DescendentNodeDefinition<
 
 	readonly root: RootDefinition;
 	readonly nodeset: string;
-	readonly dependencyExpressions: ReadonlySet<string>;
 	readonly isTranslated: boolean = false;
 
 	constructor(
@@ -43,11 +42,6 @@ export abstract class DescendentNodeDefinition<
 		if (bind.isTranslated || bodyElement?.isTranslated) {
 			this.isTranslated = true;
 		}
-
-		this.dependencyExpressions = new Set([
-			...bind.dependencyExpressions,
-			...(bodyElement?.dependencyExpressions ?? []),
-		]);
 	}
 }
 

package/src/parse/model/FormSubmissionDefinition.ts

@@ -0,0 +1,44 @@
+import type { SubmissionDefinition } from '../../client/submission/SubmissionDefinition.ts';
+import { getSubmissionElement } from '../../lib/dom/query.ts';
+import type { XFormDOM } from '../XFormDOM.ts';
+
+export class FormSubmissionDefinition implements SubmissionDefinition {
+	readonly submissionAction!: URL | null;
+	readonly submissionMethod = 'post';
+	readonly encryptionKey!: string | null;
+
+	constructor(xformDOM: XFormDOM) {
+		const submissionElement = getSubmissionElement(xformDOM.model);
+
+		let submissionAction: URL | null = null;
+		let submissionMethod: 'post';
+		let encryptionKey: string | null = null;
+
+		if (submissionElement == null) {
+			submissionAction = null;
+			submissionMethod = 'post';
+			encryptionKey = null;
+		} else {
+			const method = submissionElement.getAttribute('method')?.trim();
+
+			if (method == null || method === 'post' || method === 'form-data-post') {
+				submissionMethod = 'post';
+			} else {
+				throw new Error(`Unexpected <submission method>: ${method}`);
+			}
+
+			const action = submissionElement.getAttribute('action');
+
+			if (action != null) {
+				// TODO: this is known-fallible.
+				submissionAction = new URL(action.trim());
+			}
+
+			encryptionKey = submissionElement.getAttribute('base64RsaPublicKey');
+		}
+
+		this.submissionAction = submissionAction;
+		this.submissionMethod = submissionMethod;
+		this.encryptionKey = encryptionKey;
+	}
+}

package/src/parse/model/ItextTranslation/ItextTranslationDefinition.ts

@@ -0,0 +1,4 @@
+import { StaticDocument } from '../../../integration/xpath/static-dom/StaticDocument.ts';
+import { ItextTranslationRootDefinition } from './ItextTranslationRootDefinition.ts';
+
+export class ItextTranslationDefinition extends StaticDocument<ItextTranslationRootDefinition> {}

package/src/parse/model/ItextTranslation/ItextTranslationRootDefinition.ts

@@ -0,0 +1,41 @@
+import type { XFormsItextTranslationElement } from '@getodk/xpath';
+import { XFORMS_KNOWN_ATTRIBUTE, XFORMS_LOCAL_NAME } from '@getodk/xpath';
+import { StaticElement } from '../../../integration/xpath/static-dom/StaticElement.ts';
+
+// prettier-ignore
+type ItextTranslationRootKnownAttributeValue<LocalName extends string> =
+	LocalName extends 'lang'
+		? string
+		: string | null;
+
+type AssertItextTranslationRootKnownAttributeValue = <LocalName extends string>(
+	localName: LocalName,
+	value: string | null
+) => asserts value is ItextTranslationRootKnownAttributeValue<LocalName>;
+
+const assertItextTranslationRootKnownAttributeValue: AssertItextTranslationRootKnownAttributeValue =
+	(localName, value) => {
+		if (localName === 'lang' && value == null) {
+			throw new Error('Invalid itext <translation> element: missing `lang` attribute');
+		}
+	};
+
+export class ItextTranslationRootDefinition
+	extends StaticElement
+	implements XFormsItextTranslationElement<ItextTranslationRootDefinition>
+{
+	override readonly [XFORMS_LOCAL_NAME] = 'translation';
+	override readonly [XFORMS_KNOWN_ATTRIBUTE] = 'lang';
+
+	override getAttributeValue(localName: 'lang'): string;
+	override getAttributeValue(localName: string): string | null;
+	override getAttributeValue<LocalName extends string>(
+		localName: LocalName
+	): ItextTranslationRootKnownAttributeValue<LocalName> {
+		const value = super.getAttributeValue(localName);
+
+		assertItextTranslationRootKnownAttributeValue(localName, value);
+
+		return value;
+	}
+}

package/src/parse/model/ItextTranslation/ItextTranslationsDefinition.ts

@@ -0,0 +1,31 @@
+import type { XFormsItextTranslationMap } from '@getodk/xpath';
+import type { EngineXPathNode } from '../../../integration/xpath/adapter/kind.ts';
+import { parseStaticDocumentFromDOMSubtree } from '../../shared/parseStaticDocumentFromDOMSubtree.ts';
+import type { XFormDOM } from '../../XFormDOM.ts';
+import { ItextTranslationDefinition } from './ItextTranslationDefinition.ts';
+import { ItextTranslationRootDefinition } from './ItextTranslationRootDefinition.ts';
+
+export class ItextTranslationsDefinition
+	extends Map<string, ItextTranslationRootDefinition>
+	implements XFormsItextTranslationMap<EngineXPathNode>
+{
+	static from(xformDOM: XFormDOM): ItextTranslationsDefinition {
+		const translationDefinitions = xformDOM.itextTranslationElements.map((element) => {
+			return parseStaticDocumentFromDOMSubtree(
+				ItextTranslationDefinition,
+				ItextTranslationRootDefinition,
+				element
+			);
+		});
+
+		return new this(translationDefinitions);
+	}
+
+	private constructor(translations: readonly ItextTranslationDefinition[]) {
+		super(
+			translations.map(({ root }) => {
+				return [root.getAttributeValue('lang'), root];
+			})
+		);
+	}
+}

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

@@ -1,13 +1,15 @@
+import type { ValueType } from '../../client/ValueType.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 LeafNodeDefinition
+export class LeafNodeDefinition<V extends ValueType = ValueType>
 	extends DescendentNodeDefinition<'leaf-node', ControlElementDefinition | null>
 	implements NodeDefinition<'leaf-node'>
 {
 	readonly type = 'leaf-node';
+	readonly valueType: V;
 
 	readonly nodeName: string;
 	readonly children = null;
@@ -26,6 +28,7 @@ export class LeafNodeDefinition
 
 		super(parent, bind, bodyElement);
 
+		this.valueType = bind.type.resolved satisfies ValueType as V;
 		this.nodeName = node.localName;
 		this.defaultValue = node.textContent ?? '';
 	}

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

@@ -1,6 +1,7 @@
 import type { XFormDefinition } from '../XFormDefinition.ts';
 import { BindDefinition } from './BindDefinition.ts';
 import type { BindElement, BindNodeset } from './BindElement.ts';
+import { DEFAULT_BIND_TYPE } from './BindTypeDefinition.ts';
 import type { ModelDefinition } from './ModelDefinition.ts';
 
 class ArtificialBindElement implements BindElement {
@@ -15,6 +16,10 @@ class ArtificialBindElement implements BindElement {
 			return this.ancestorNodeset;
 		}
 
+		if (name === 'type') {
+			return DEFAULT_BIND_TYPE;
+		}
+
 		return null;
 	}
 
@@ -37,15 +42,8 @@ export class ModelBindMap extends Map<BindNodeset, BindDefinition> {
 		protected readonly form: XFormDefinition,
 		protected readonly model: ModelDefinition
 	) {
-		const bindElements = form.xformDOM.rootEvaluator.evaluateNodes<BindElement & Element>(
-			'./xf:bind[@nodeset]',
-			{
-				contextNode: form.xformDOM.model,
-			}
-		);
-
 		super(
-			bindElements.map((bindElement) => {
+			form.xformDOM.binds.map((bindElement) => {
 				const nodeset = bindElement.getAttribute('nodeset');
 				const bind = new BindDefinition(form, model, nodeset, bindElement);
 

package/src/parse/model/ModelDefinition.ts

@@ -0,0 +1,24 @@
+import type { XFormDefinition } from '../XFormDefinition.ts';
+import { FormSubmissionDefinition } from './FormSubmissionDefinition.ts';
+import { ItextTranslationsDefinition } from './ItextTranslation/ItextTranslationsDefinition.ts';
+import { ModelBindMap } from './ModelBindMap.ts';
+import { RootDefinition } from './RootDefinition.ts';
+
+export class ModelDefinition {
+	readonly binds: ModelBindMap;
+	readonly root: RootDefinition;
+	readonly itextTranslations: ItextTranslationsDefinition;
+
+	constructor(readonly form: XFormDefinition) {
+		const submission = new FormSubmissionDefinition(form.xformDOM);
+		this.binds = ModelBindMap.fromModel(this);
+		this.root = new RootDefinition(form, this, submission, form.body.classes);
+		this.itextTranslations = ItextTranslationsDefinition.from(form.xformDOM);
+	}
+
+	toJSON() {
+		const { form, ...rest } = this;
+
+		return rest;
+	}
+}

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

@@ -121,10 +121,7 @@ export interface NodeDefinition<Type extends NodeDefinitionType> {
 	readonly nodeset: string;
 	readonly nodeName: string;
 	readonly bodyElement: AnyBodyElementDefinition | RepeatElementDefinition | null;
-
 	readonly isTranslated: boolean;
-	readonly dependencyExpressions: ReadonlySet<string>;
-
 	readonly root: RootDefinition;
 	readonly parent: NodeParent<Type>;
 	readonly children: NodeChildren<Type>;