@getodk/xforms-engine 0.5.0 → 0.7.0

package/src/parse/XFormDOM.ts

@@ -1,4 +1,9 @@
-import { XFORMS_NAMESPACE_URI, XMLNS_NAMESPACE_URI } from '@getodk/common/constants/xmlns.ts';
+import {
+	JAVAROSA_NAMESPACE_URI,
+	OPENROSA_XFORMS_NAMESPACE_URI,
+	XFORMS_NAMESPACE_URI,
+	XMLNS_NAMESPACE_URI,
+} from '@getodk/common/constants/xmlns.ts';
 import type {
 	KnownAttributeLocalNamedElement,
 	LocalNamedElement,
@@ -7,6 +12,118 @@ import { DefaultEvaluator } from '@getodk/xpath';
 
 interface DOMBindElement extends KnownAttributeLocalNamedElement<'bind', 'nodeset'> {}
 
+const getMetaElement = (primaryInstanceRoot: Element): Element | null => {
+	for (const child of primaryInstanceRoot.children) {
+		const { localName, namespaceURI } = child;
+
+		if (
+			(namespaceURI === OPENROSA_XFORMS_NAMESPACE_URI || namespaceURI === XFORMS_NAMESPACE_URI) &&
+			localName === 'meta'
+		) {
+			return child;
+		}
+	}
+
+	return null;
+};
+
+const getMetaChildElement = (meta: Element | null, localName: string): Element | null => {
+	if (meta == null) {
+		return null;
+	}
+
+	const { namespaceURI } = meta;
+
+	for (const child of meta.children) {
+		if (child.localName === localName && child.namespaceURI === namespaceURI) {
+			return child;
+		}
+	}
+
+	return null;
+};
+
+const getQualifiedName = (
+	contextNode: Node,
+	namespaceURI: string | null,
+	localName: string
+): string => {
+	const prefix = contextNode.lookupPrefix(namespaceURI);
+
+	if (prefix == null) {
+		return localName;
+	}
+
+	return `${prefix}:${localName}`;
+};
+
+const createNamespacedChildElement = (
+	parent: Element,
+	namespaceURI: string | null,
+	localName: string
+): Element => {
+	const qualifiedName = getQualifiedName(parent, namespaceURI, localName);
+	const child = parent.ownerDocument.createElementNS(namespaceURI, qualifiedName);
+
+	parent.append(child);
+
+	return child;
+};
+
+const setNamespacedAttributeValue = (
+	element: Element,
+	namespaceURI: string | null,
+	localName: string,
+	value: string
+) => {
+	const qualifiedName = getQualifiedName(element, namespaceURI, localName);
+
+	element.setAttributeNS(namespaceURI, qualifiedName, value);
+};
+
+const createDefaultInstanceIDBinding = (
+	model: Element,
+	primaryInstanceRoot: Element,
+	meta: Element,
+	instanceID: Element
+): DOMBindElement => {
+	const bind = createNamespacedChildElement(model, model.namespaceURI, 'bind');
+	const nodeset = `/${primaryInstanceRoot.nodeName}/${meta.nodeName}/${instanceID.nodeName}`;
+
+	bind.setAttribute('nodeset', nodeset);
+	setNamespacedAttributeValue(bind, JAVAROSA_NAMESPACE_URI, 'preload', 'uid');
+
+	return bind as DOMBindElement;
+};
+
+const normalizeDefaultMetaBindings = (
+	model: Element,
+	primaryInstanceRoot: Element,
+	binds: readonly DOMBindElement[]
+): readonly DOMBindElement[] => {
+	let meta = getMetaElement(primaryInstanceRoot);
+	let instanceID = getMetaChildElement(meta, 'instanceID');
+
+	if (meta == null) {
+		meta = createNamespacedChildElement(primaryInstanceRoot, OPENROSA_XFORMS_NAMESPACE_URI, 'meta');
+	}
+
+	if (instanceID == null) {
+		instanceID = createNamespacedChildElement(meta, meta.namespaceURI, 'instanceID');
+
+		const instanceIDBinding = createDefaultInstanceIDBinding(
+			model,
+			primaryInstanceRoot,
+			meta,
+			instanceID
+		);
+
+		return [...binds, instanceIDBinding];
+	}
+
+	return binds;
+};
+
 export interface DOMItextTranslationElement
 	extends KnownAttributeLocalNamedElement<'translation', 'lang'> {}
 
@@ -238,23 +355,6 @@ export class XFormDOM {
 		const html = evaluator.evaluateNonNullElement('/h:html', {
 			contextNode: xformDocument,
 		});
-
-		let body = evaluator.evaluateNonNullElement('./h:body', {
-			contextNode: html,
-		});
-		let normalizedXML: string;
-
-		if (options.isNormalized) {
-			normalizedXML = sourceXML;
-		} else {
-			body = normalizeXFormBody(body);
-
-			// TODO: if we keep doing normalization this way long term (or using the DOM
-			// for parsing long term, for that matter!), we should measure this. And we
-			// should measure against XMLSerializer while we're at it!
-			normalizedXML = xformDocument.documentElement.outerHTML;
-		}
-
 		const head = evaluator.evaluateNonNullElement('./h:head', {
 			contextNode: html,
 		});
@@ -264,9 +364,12 @@ export class XFormDOM {
 		const model = evaluator.evaluateNonNullElement('./xf:model', {
 			contextNode: head,
 		});
-		const binds = evaluator.evaluateNodes<DOMBindElement>('./xf:bind[@nodeset]', {
-			contextNode: model,
-		});
+		let binds: readonly DOMBindElement[] = evaluator.evaluateNodes<DOMBindElement>(
+			'./xf:bind[@nodeset]',
+			{
+				contextNode: model,
+			}
+		);
 
 		const instances = evaluator.evaluateNodes<DOMInstanceElement>('./xf:instance', {
 			contextNode: model,
@@ -292,6 +395,23 @@ export class XFormDOM {
 			}
 		);
 
+		let body = evaluator.evaluateNonNullElement('./h:body', {
+			contextNode: html,
+		});
+		let normalizedXML: string;
+
+		if (options.isNormalized) {
+			normalizedXML = sourceXML;
+		} else {
+			body = normalizeXFormBody(body);
+			binds = normalizeDefaultMetaBindings(model, primaryInstanceRoot, binds);
+
+			// TODO: if we keep doing normalization this way long term (or using the DOM
+			// for parsing long term, for that matter!), we should measure this. And we
+			// should measure against XMLSerializer while we're at it!
+			normalizedXML = xformDocument.documentElement.outerHTML;
+		}
+
 		this.normalizedXML = normalizedXML;
 		this.xformDocument = xformDocument;
 		this.html = html;

package/src/parse/XFormDefinition.ts

@@ -24,10 +24,7 @@ export class XFormDefinition {
 		this.xformDocument = xformDocument;
 		this.id = id;
 		this.title = title.textContent ?? '';
-
-		// TODO: highly unlikely primary instance root will need a namespace prefix
-		// but noting it just in case there is such weird usage...
-		this.rootReference = `/${primaryInstanceRoot.localName}`;
+		this.rootReference = `/${primaryInstanceRoot.nodeName}`;
 
 		this.body = new BodyDefinition(this);
 		this.model = new ModelDefinition(this);

package/src/parse/body/BodyDefinition.ts

@@ -6,8 +6,8 @@ import { ControlDefinition } from './control/ControlDefinition.ts';
 import { InputControlDefinition } from './control/InputControlDefinition.ts';
 import { RangeControlDefinition } from './control/RangeControlDefinition.ts';
 import { RankControlDefinition } from './control/RankControlDefinition.ts';
-import type { AnySelectDefinition } from './control/select/SelectDefinition.ts';
-import { SelectDefinition } from './control/select/SelectDefinition.ts';
+import type { AnySelectControlDefinition } from './control/SelectControlDefinition.ts';
+import { SelectControlDefinition } from './control/SelectControlDefinition.ts';
 import { TriggerControlDefinition } from './control/TriggerControlDefinition.ts';
 import { UploadControlDefinition } from './control/UploadControlDefinition.ts';
 import { LogicalGroupDefinition } from './group/LogicalGroupDefinition.ts';
@@ -24,7 +24,7 @@ export interface BodyElementParentContext {
 
 // prettier-ignore
 export type ControlElementDefinition =
-	| AnySelectDefinition
+	| AnySelectControlDefinition
 	| InputControlDefinition
 	| RangeControlDefinition
 	| RankControlDefinition
@@ -48,7 +48,7 @@ const BodyElementDefinitionConstructors = [
 	PresentationGroupDefinition,
 	StructuralGroupDefinition,
 	InputControlDefinition,
-	SelectDefinition,
+	SelectControlDefinition,
 	RangeControlDefinition,
 	RankControlDefinition,
 	TriggerControlDefinition,

package/src/parse/body/appearance/rangeAppearanceParser.ts

@@ -0,0 +1,11 @@
+import type { ParsedTokenList } from '../../../lib/TokenListParser.ts';
+import { TokenListParser } from '../../../lib/TokenListParser.ts';
+
+export const rangeAppearanceParser = new TokenListParser([
+	'no-ticks',
+	'picker',
+	'rating',
+	'vertical',
+]);
+
+export type RangeAppearanceDefinition = ParsedTokenList<typeof rangeAppearanceParser>;

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

@@ -2,6 +2,7 @@ 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'> {
@@ -11,10 +12,18 @@ export class InputControlDefinition extends ControlDefinition<'input'> {
 
 	readonly type = 'input';
 	readonly appearances: InputAppearanceDefinition;
+	readonly rows: number | null;
+	readonly accuracyThreshold: number | null;
+	readonly unacceptableAccuracyThreshold: number | null;
 
 	constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element) {
 		super(form, parent, element);
 
 		this.appearances = inputAppearanceParser.parseFrom(element, 'appearance');
+		this.rows = parseToInteger(element.getAttribute('rows'));
+		this.accuracyThreshold = parseToFloat(element.getAttribute('accuracyThreshold'));
+		this.unacceptableAccuracyThreshold = parseToFloat(
+			element.getAttribute('unacceptableAccuracyThreshold')
+		);
 	}
 }

package/src/parse/body/control/{select/ItemDefinition.ts → ItemDefinition.ts}

@@ -1,8 +1,10 @@
-import { getValueElement, type ItemElement } from '../../../../lib/dom/query.ts';
-import { ItemLabelDefinition } from '../../../text/ItemLabelDefinition.ts';
-import type { XFormDefinition } from '../../../XFormDefinition.ts';
-import { BodyElementDefinition } from '../../BodyElementDefinition.ts';
-import type { AnySelectDefinition } from './SelectDefinition.ts';
+import type { ItemElement } from '../../../lib/dom/query.ts';
+import { getValueElement } from '../../../lib/dom/query.ts';
+import { ItemLabelDefinition } from '../../text/ItemLabelDefinition.ts';
+import type { XFormDefinition } from '../../XFormDefinition.ts';
+import { BodyElementDefinition } from '../BodyElementDefinition.ts';
+import type { AnySelectControlDefinition } from './SelectControlDefinition.ts';
+import { RankControlDefinition } from './RankControlDefinition.ts';
 
 export class ItemDefinition extends BodyElementDefinition<'item'> {
 	override readonly category = 'support';
@@ -13,7 +15,7 @@ export class ItemDefinition extends BodyElementDefinition<'item'> {
 
 	constructor(
 		form: XFormDefinition,
-		override readonly parent: AnySelectDefinition,
+		override readonly parent: AnySelectControlDefinition | RankControlDefinition,
 		element: ItemElement
 	) {
 		const valueElement = getValueElement(element);

package/src/parse/body/control/{select/ItemsetDefinition.ts → ItemsetDefinition.ts}

@@ -1,11 +1,13 @@
-import { getValueElement, type ItemsetElement } from '../../../../lib/dom/query.ts';
-import { ItemsetNodesetExpression } from '../../../expression/ItemsetNodesetExpression.ts';
-import { ItemsetValueExpression } from '../../../expression/ItemsetValueExpression.ts';
-import { ItemsetLabelDefinition } from '../../../text/ItemsetLabelDefinition.ts';
-import type { XFormDefinition } from '../../../XFormDefinition.ts';
-import { parseNodesetReference } from '../../../xpath/reference-parsing.ts';
-import { BodyElementDefinition } from '../../BodyElementDefinition.ts';
-import type { AnySelectDefinition } from './SelectDefinition.ts';
+import type { ItemsetElement } from '../../../lib/dom/query.ts';
+import { getValueElement } from '../../../lib/dom/query.ts';
+import { ItemsetNodesetExpression } from '../../expression/ItemsetNodesetExpression.ts';
+import { ItemsetValueExpression } from '../../expression/ItemsetValueExpression.ts';
+import { ItemsetLabelDefinition } from '../../text/ItemsetLabelDefinition.ts';
+import type { XFormDefinition } from '../../XFormDefinition.ts';
+import { parseNodesetReference } from '../../xpath/reference-parsing.ts';
+import { BodyElementDefinition } from '../BodyElementDefinition.ts';
+import type { AnySelectControlDefinition } from './SelectControlDefinition.ts';
+import { RankControlDefinition } from './RankControlDefinition.ts';
 
 export class ItemsetDefinition extends BodyElementDefinition<'itemset'> {
 	override readonly category = 'support';
@@ -19,7 +21,7 @@ export class ItemsetDefinition extends BodyElementDefinition<'itemset'> {
 
 	constructor(
 		form: XFormDefinition,
-		override readonly parent: AnySelectDefinition,
+		override readonly parent: AnySelectControlDefinition | RankControlDefinition,
 		element: ItemsetElement
 	) {
 		super(form, parent, element);

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

@@ -1,23 +1,108 @@
+import { ErrorProductionDesignPendingError } from '../../../error/ErrorProductionDesignPendingError.ts';
 import type { XFormDefinition } from '../../XFormDefinition.ts';
-import {
-	unknownAppearanceParser,
-	type UnknownAppearanceDefinition,
-} from '../appearance/unknownAppearanceParser.ts';
+import type { RangeAppearanceDefinition } from '../appearance/rangeAppearanceParser.ts';
+import { rangeAppearanceParser } from '../appearance/rangeAppearanceParser.ts';
 import type { BodyElementParentContext } from '../BodyDefinition.ts';
 import { ControlDefinition } from './ControlDefinition.ts';
 
+type NumericString = `${number}`;
+
+/**
+ * @todo this should likely become a basis for generalizing how we parse number
+ * values from strings. Note for when we take that on: number semantics vary
+ * between:
+ *
+ * - {@link https://www.w3.org/TR/1999/REC-xpath-19991116/#numbers | XPath}:
+ *   XPath "64-bit [...] IEEE 754" number values are almost totally consistent
+ *   with JavaScript numbers; the main difference is that JavaScript's
+ *   {@link Number} factory is more flexible in casting from string than the
+ *   casting semantics specified by XPath
+ *
+ * - {@link https://getodk.github.io/xforms-spec/#data-types | [ODK] XForms}:
+ *   specifies both `int` and `decimal` types. Decimals are **NOT** expected to
+ *   have the same precision tradeoffs as IEEE 754 numbers, and we'll want to
+ *   take special care that parsing does not introduce precision errors.
+ */
+const NUMERIC_STRING_PATTERN = /^-?\d+(\.\d+)?$/;
+
+const isNumericString = (value: string): value is NumericString => {
+	return NUMERIC_STRING_PATTERN.test(value);
+};
+
+type AssertNumericStringAttribute = (
+	localName: string,
+	value: string | null
+) => asserts value is NumericString;
+
+const assertNumericStringAttribute: AssertNumericStringAttribute = (localName, value) => {
+	if (value == null) {
+		throw new ErrorProductionDesignPendingError(`Expected attribute ${localName} is not defined`);
+	}
+
+	if (!isNumericString(value)) {
+		throw new ErrorProductionDesignPendingError(
+			`Expected attribute ${localName} to be defined with numeric string, got: ${JSON.stringify(value)}`
+		);
+	}
+};
+
+const parseNumericStringAttribute = (element: Element, localName: string): NumericString => {
+	const value = element.getAttribute(localName);
+
+	assertNumericStringAttribute(localName, value);
+
+	return value;
+};
+
+/**
+ * Per
+ * {@link https://getodk.github.io/xforms-spec/#body-elements | ODK XForms spec},
+ * the following attributes are required:
+ *
+ * - `start`
+ * - `end`
+ * - `step`
+ *
+ * While we also know that a `<range>` control is expected to have a bind type
+ * of either `decimal` or `int`, at this parsing stage we do not yet know which
+ * type is associated with the control. So we parse the attributes as strings,
+ * checking only that they appear to be numeric values. We also preserve the
+ * attributes' names here, for consistency with the spec.
+ *
+ * Downstream, we parse these to their appropriate numeric runtime types, and
+ * alias them to their more conventional names (i.e. "start" -> "min", "end" ->
+ * "max").
+ */
+export class RangeControlBoundsDefinition {
+	static from(element: Element) {
+		const start = parseNumericStringAttribute(element, 'start');
+		const end = parseNumericStringAttribute(element, 'end');
+		const step = parseNumericStringAttribute(element, 'step');
+
+		return new this(start, end, step);
+	}
+
+	constructor(
+		readonly start: NumericString,
+		readonly end: NumericString,
+		readonly step: NumericString
+	) {}
+}
+
 export class RangeControlDefinition extends ControlDefinition<'range'> {
 	static override isCompatible(localName: string): boolean {
 		return localName === 'range';
 	}
 
 	readonly type = 'range';
-	readonly appearances: UnknownAppearanceDefinition;
+	readonly appearances: RangeAppearanceDefinition;
+	readonly bounds: RangeControlBoundsDefinition;
 
 	constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element) {
 		super(form, parent, element);
 
-		this.appearances = unknownAppearanceParser.parseFrom(element, 'appearance');
+		this.appearances = rangeAppearanceParser.parseFrom(element, 'appearance');
+		this.bounds = RangeControlBoundsDefinition.from(element);
 	}
 
 	override toJSON(): object {

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

@@ -1,27 +1,45 @@
-import { ODK_NAMESPACE_URI } from '@getodk/common/constants/xmlns.ts';
+import { getItemElements, getItemsetElement } from '../../../lib/dom/query.ts';
 import type { XFormDefinition } from '../../XFormDefinition.ts';
+import type { BodyElementParentContext } from '../BodyDefinition.ts';
+import { ControlDefinition } from './ControlDefinition.ts';
+import { ItemsetDefinition } from './ItemsetDefinition.ts';
+import { ItemDefinition } from './ItemDefinition.ts';
 import {
-	unknownAppearanceParser,
 	type UnknownAppearanceDefinition,
+	unknownAppearanceParser,
 } from '../appearance/unknownAppearanceParser.ts';
-import type { BodyElementParentContext } from '../BodyDefinition.ts';
-import { ControlDefinition } from './ControlDefinition.ts';
 
 export class RankControlDefinition extends ControlDefinition<'rank'> {
-	static override isCompatible(localName: string, element: Element): boolean {
-		return localName === 'rank' && element.namespaceURI === ODK_NAMESPACE_URI;
+	static override isCompatible(localName: string): boolean {
+		return localName === 'rank';
 	}
 
 	readonly type = 'rank';
 	readonly appearances: UnknownAppearanceDefinition;
+	readonly itemset: ItemsetDefinition | null;
+	readonly items: readonly ItemDefinition[];
 
 	constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element) {
 		super(form, parent, element);
 
 		this.appearances = unknownAppearanceParser.parseFrom(element, 'appearance');
+		const itemsetElement = getItemsetElement(element);
+		const itemElements = getItemElements(element);
+
+		if (itemsetElement === null || itemElements === undefined) {
+			this.itemset = null;
+			this.items = itemElements.map((itemElement) => new ItemDefinition(form, this, itemElement));
+		} else {
+			if (itemElements.length > 0) {
+				throw new Error(`<${element.nodeName}> has both <itemset> and <item> children`);
+			}
+
+			this.items = [];
+			this.itemset = new ItemsetDefinition(form, this, itemsetElement);
+		}
 	}
 
-	override toJSON(): object {
+	override toJSON() {
 		return {};
 	}
 }

package/src/parse/body/control/{select/SelectDefinition.ts → SelectControlDefinition.ts}

@@ -1,11 +1,11 @@
 import type { CollectionValues } from '@getodk/common/types/collections/CollectionValues.ts';
 import type { LocalNamedElement } from '@getodk/common/types/dom.ts';
-import { getItemElements, getItemsetElement } from '../../../../lib/dom/query.ts';
-import type { XFormDefinition } from '../../../XFormDefinition.ts';
-import type { SelectAppearanceDefinition } from '../../appearance/selectAppearanceParser.ts';
-import { selectAppearanceParser } from '../../appearance/selectAppearanceParser.ts';
-import type { AnyBodyElementDefinition, BodyElementParentContext } from '../../BodyDefinition.ts';
-import { ControlDefinition } from '../ControlDefinition.ts';
+import { getItemElements, getItemsetElement } from '../../../lib/dom/query.ts';
+import type { XFormDefinition } from '../../XFormDefinition.ts';
+import type { SelectAppearanceDefinition } from '../appearance/selectAppearanceParser.ts';
+import { selectAppearanceParser } from '../appearance/selectAppearanceParser.ts';
+import type { AnyBodyElementDefinition, BodyElementParentContext } from '../BodyDefinition.ts';
+import { ControlDefinition } from './ControlDefinition.ts';
 import { ItemDefinition } from './ItemDefinition.ts';
 import { ItemsetDefinition } from './ItemsetDefinition.ts';
 
@@ -22,12 +22,12 @@ const isSelectElement = (
 	return selectLocalNames.has(localName as SelectType);
 };
 
-export class SelectDefinition<Type extends SelectType> extends ControlDefinition<Type> {
+export class SelectControlDefinition<Type extends SelectType> extends ControlDefinition<Type> {
 	static override isCompatible(localName: string, element: Element): boolean {
 		return isSelectElement(element, localName);
 	}
 
-	static isSelect(element: AnyBodyElementDefinition): element is AnySelectDefinition {
+	static isSelect(element: AnyBodyElementDefinition): element is AnySelectControlDefinition {
 		return selectLocalNames.has(element.type as SelectType);
 	}
 
@@ -72,4 +72,4 @@ export class SelectDefinition<Type extends SelectType> extends ControlDefinition
 	}
 }
 
-export type AnySelectDefinition = SelectDefinition<SelectType>;
+export type AnySelectControlDefinition = SelectControlDefinition<SelectType>;

package/src/parse/expression/ItemsetNodesetExpression.ts

@@ -1,4 +1,4 @@
-import type { ItemsetDefinition } from '../body/control/select/ItemsetDefinition.ts';
+import type { ItemsetDefinition } from '../body/control/ItemsetDefinition.ts';
 import { DependentExpression } from './abstract/DependentExpression.ts';
 
 export class ItemsetNodesetExpression extends DependentExpression<'nodes'> {

package/src/parse/expression/ItemsetValueExpression.ts

@@ -1,4 +1,4 @@
-import type { ItemsetDefinition } from '../body/control/select/ItemsetDefinition.ts';
+import type { ItemsetDefinition } from '../body/control/ItemsetDefinition.ts';
 import { DependentExpression } from './abstract/DependentExpression.ts';
 
 export class ItemsetValueExpression extends DependentExpression<'string'> {

package/src/parse/model/BindDefinition.ts

@@ -4,6 +4,7 @@ import { BindComputationExpression } from '../expression/BindComputationExpressi
 import { MessageDefinition } from '../text/MessageDefinition.ts';
 import type { XFormDefinition } from '../XFormDefinition.ts';
 import type { BindElement } from './BindElement.ts';
+import { BindPreloadDefinition, type AnyBindPreloadDefinition } from './BindPreloadDefinition.ts';
 import type { BindType } from './BindTypeDefinition.ts';
 import { BindTypeDefinition } from './BindTypeDefinition.ts';
 import type { ModelDefinition } from './ModelDefinition.ts';
@@ -12,6 +13,8 @@ export class BindDefinition<T extends BindType = BindType> extends DependencyCon
 	readonly type: BindTypeDefinition<T>;
 	readonly parentNodeset: string | null;
 
+	readonly preload: AnyBindPreloadDefinition | null;
+
 	readonly calculate: BindComputationExpression<'calculate'> | null;
 	readonly readonly: BindComputationExpression<'readonly'>;
 	readonly relevant: BindComputationExpression<'relevant'>;
@@ -82,6 +85,7 @@ export class BindDefinition<T extends BindType = BindType> extends DependencyCon
 		const parentNodeset = nodeset.replace(/\/[^/]+$/, '');
 
 		this.parentNodeset = parentNodeset.length > 1 ? parentNodeset : null;
+		this.preload = BindPreloadDefinition.from(bindElement);
 		this.calculate = BindComputationExpression.forComputation(this, 'calculate');
 		this.readonly = BindComputationExpression.forComputation(this, 'readonly');
 		this.relevant = BindComputationExpression.forComputation(this, 'relevant');