@getodk/xforms-engine 0.4.0 → 0.5.0

package/src/parse/XFormDOM.ts

@@ -1,5 +1,37 @@
 import { XFORMS_NAMESPACE_URI, XMLNS_NAMESPACE_URI } from '@getodk/common/constants/xmlns.ts';
-import { XFormsXPathEvaluator } from '@getodk/xpath';
+import type {
+	KnownAttributeLocalNamedElement,
+	LocalNamedElement,
+} from '@getodk/common/types/dom.ts';
+import { DefaultEvaluator } from '@getodk/xpath';
+
+interface DOMBindElement extends KnownAttributeLocalNamedElement<'bind', 'nodeset'> {}
+
+export interface DOMItextTranslationElement
+	extends KnownAttributeLocalNamedElement<'translation', 'lang'> {}
+
+interface DOMInstanceElement extends LocalNamedElement<'instance'> {}
+
+export interface DOMSecondaryInstanceElement
+	extends KnownAttributeLocalNamedElement<'instance', 'id'> {}
+
+type AssertDOMSecondaryInstanceElement = (
+	element: DOMInstanceElement
+) => asserts element is DOMSecondaryInstanceElement;
+
+const assertDOMSecondaryInstanceElement: AssertDOMSecondaryInstanceElement = (element) => {
+	if (!element.hasAttribute('id')) {
+		throw new Error('Invalid secondary instance element: missing `id` attribute');
+	}
+};
+
+type AssertDOMSecondaryInstanceElements = (
+	elements: readonly DOMInstanceElement[]
+) => asserts elements is readonly DOMSecondaryInstanceElement[];
+
+const assertDOMSecondaryInstanceElements: AssertDOMSecondaryInstanceElements = (elements) => {
+	elements.forEach(assertDOMSecondaryInstanceElement);
+};
 
 const domParser = new DOMParser();
 
@@ -145,61 +177,33 @@ const normalizeRepeatGroups = (body: Element): void => {
 	}
 };
 
-interface NormalizedXForm {
-	readonly xformDocument: XMLDocument;
-	readonly rootEvaluator: XFormsXPathEvaluator;
-	readonly html: Element;
-	readonly body: Element;
-	readonly normalizedXML: string;
-}
-
-interface XFormDOMNormalizationOptions {
-	readonly isNormalized: boolean;
-}
-
 /**
- * Performs preprocess operations to normalize certain aspects of an XForm
- * structure for consistency when building up its runtime representations.
+ * Performs preprocess operations to normalize certain aspects of the body of an
+ * XForm, for consistency when parsing its runtime representations.
+ *
  * Currently this preprocessing:
  *
- * - Ensures consistent use of `ref` and `nodeset` where ambiguous in the
- *   ODK XForms spec
- * - Ensures `<repeat>` body elements are always enclosed by a `<group>`
- *   with the same `ref`
+ * - Ensures consistent use of `ref` and `nodeset` where ambiguous in the ODK
+ *   XForms spec
+ * - Ensures `<repeat>` body elements are always enclosed by a `<group>` with
+ *   the same `ref`
  */
-const parseNormalizedXForm = (
-	sourceXML: string,
-	options: XFormDOMNormalizationOptions
-): NormalizedXForm => {
-	const xformDocument: XMLDocument = domParser.parseFromString(sourceXML, 'text/xml');
-	const rootEvaluator = new XFormsXPathEvaluator({
-		rootNode: xformDocument,
-	});
-	const html = rootEvaluator.evaluateNonNullElement('/h:html');
-	const body = rootEvaluator.evaluateNonNullElement('./h:body', {
-		contextNode: html,
-	});
-
-	let normalizedXML: string;
+const normalizeXFormBody = <T extends Element>(body: T): T => {
+	normalizeBodyRefNodesetAttributes(body);
+	normalizeRepeatGroups(body);
 
-	if (options.isNormalized) {
-		normalizedXML = sourceXML;
-	} else {
-		normalizeBodyRefNodesetAttributes(body);
-		normalizeRepeatGroups(body);
-
-		normalizedXML = html.outerHTML;
-	}
-
-	return {
-		xformDocument,
-		rootEvaluator,
-		html,
-		body,
-		normalizedXML,
-	};
+	return body;
 };
 
+interface XFormDOMOptions {
+	readonly isNormalized: boolean;
+}
+
+/**
+ * @todo **Everything** in this class should be cacheable. Maybe not worth it
+ * for small forms, but may make a pretty substantial difference for very large
+ * forms (in bytes) in sessions creating multiple instances of the same form.
+ */
 export class XFormDOM {
 	static from(sourceXML: string) {
 		return new this(sourceXML, { isNormalized: false });
@@ -207,10 +211,6 @@ export class XFormDOM {
 
 	protected readonly normalizedXML: string;
 
-	// XPath
-	readonly rootEvaluator: XFormsXPathEvaluator;
-	readonly primaryInstanceEvaluator: XFormsXPathEvaluator;
-
 	// Commonly accessed landmark nodes
 	readonly xformDocument: XMLDocument;
 
@@ -220,59 +220,94 @@ export class XFormDOM {
 	readonly title: Element;
 
 	readonly model: Element;
+	readonly binds: readonly DOMBindElement[];
 	readonly primaryInstance: Element;
 	readonly primaryInstanceRoot: Element;
 
+	readonly itextTranslationElements: readonly DOMItextTranslationElement[];
+	readonly secondaryInstanceElements: readonly DOMSecondaryInstanceElement[];
+
 	readonly body: Element;
 
 	protected constructor(
 		protected readonly sourceXML: string,
-		options: XFormDOMNormalizationOptions
+		options: XFormDOMOptions
 	) {
-		const normalizedXForm: NormalizedXForm = parseNormalizedXForm(sourceXML, options);
-		const { xformDocument, html, body, rootEvaluator, normalizedXML } = normalizedXForm;
-		const head = rootEvaluator.evaluateNonNullElement('./h:head', {
+		const evaluator = new DefaultEvaluator();
+		const xformDocument: XMLDocument = domParser.parseFromString(sourceXML, 'text/xml');
+		const html = evaluator.evaluateNonNullElement('/h:html', {
+			contextNode: xformDocument,
+		});
+
+		let body = evaluator.evaluateNonNullElement('./h:body', {
 			contextNode: html,
 		});
-		const title = rootEvaluator.evaluateNonNullElement('./h:title', {
+		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,
+		});
+		const title = evaluator.evaluateNonNullElement('./h:title', {
 			contextNode: head,
 		});
-		const model = rootEvaluator.evaluateNonNullElement('./xf:model', {
+		const model = evaluator.evaluateNonNullElement('./xf:model', {
 			contextNode: head,
 		});
-		// TODO: Evidently primary instance root will not always have an id
-		const primaryInstanceRoot = rootEvaluator.evaluateNonNullElement('./xf:instance/*[@id]', {
+		const binds = evaluator.evaluateNodes<DOMBindElement>('./xf:bind[@nodeset]', {
 			contextNode: model,
 		});
-		// TODO: invert primary instance/root lookups
-		const primaryInstance = rootEvaluator.evaluateNonNullElement('..', {
-			contextNode: primaryInstanceRoot,
+
+		const instances = evaluator.evaluateNodes<DOMInstanceElement>('./xf:instance', {
+			contextNode: model,
 		});
 
-		this.normalizedXML = normalizedXML;
-		this.rootEvaluator = rootEvaluator;
-		this.primaryInstanceEvaluator = new XFormsXPathEvaluator({
-			rootNode: primaryInstance,
+		const [primaryInstance, ...secondaryInstanceElements] = instances;
+
+		assertDOMSecondaryInstanceElements(secondaryInstanceElements);
+
+		if (primaryInstance == null) {
+			throw new Error('Form is missing primary instance');
+		}
+
+		// TODO: Evidently primary instance root will not always have an id
+		const primaryInstanceRoot = evaluator.evaluateNonNullElement('./*[@id]', {
+			contextNode: primaryInstance,
 		});
+
+		const itextTranslationElements = evaluator.evaluateNodes<DOMItextTranslationElement>(
+			'./xf:itext/xf:translation[@lang]',
+			{
+				contextNode: model,
+			}
+		);
+
+		this.normalizedXML = normalizedXML;
 		this.xformDocument = xformDocument;
 		this.html = html;
 		this.head = head;
 		this.title = title;
 		this.model = model;
+		this.binds = binds;
 		this.primaryInstance = primaryInstance;
 		this.primaryInstanceRoot = primaryInstanceRoot;
+		this.itextTranslationElements = itextTranslationElements;
+		this.secondaryInstanceElements = secondaryInstanceElements;
 		this.body = body;
 	}
 
-	// TODO: anticipating this will be an entry point for edits as well
-	createInstance(): XFormDOM {
-		return new XFormDOM(this.normalizedXML, { isNormalized: true });
-	}
-
 	toJSON() {
 		const {
-			rootEvaluator,
-			primaryInstanceEvaluator,
 			html,
 			head,
 			title,

package/src/parse/XFormDefinition.ts

@@ -3,7 +3,6 @@ import { ModelDefinition } from './model/ModelDefinition.ts';
 import { XFormDOM } from './XFormDOM.ts';
 
 export class XFormDefinition {
-	readonly xformDOM: XFormDOM;
 	readonly xformDocument: XMLDocument;
 
 	readonly id: string;
@@ -14,11 +13,7 @@ export class XFormDefinition {
 	readonly body: BodyDefinition;
 	readonly model: ModelDefinition;
 
-	constructor(readonly sourceXML: string) {
-		const xformDOM = XFormDOM.from(sourceXML);
-
-		this.xformDOM = xformDOM;
-
+	constructor(readonly xformDOM: XFormDOM) {
 		const { primaryInstanceRoot, title, xformDocument } = xformDOM;
 		const id = primaryInstanceRoot.getAttribute('id');
 

package/src/parse/attachments/FormAttachmentResource.ts

@@ -0,0 +1,40 @@
+import type { JRResourceURL } from '@getodk/common/jr-resources/JRResourceURL.ts';
+
+export type FormAttachmentDataType = 'media' | 'secondary-instance';
+
+/**
+ * @todo This type anticipates work to support media form attachments, which
+ * will tend to be associated with binary data. The
+ * expectation is that:
+ *
+ * - {@link Blob} would be appropriate for representing data from attachment
+ *   resources which are conventionally loaded to completion (where network
+ *   conditions are favorable), such as images
+ *
+ * - {@link MediaSource} or {@link ReadableStream} may be more appropriate for
+ *   representing data from resources which are conventionally streamed in a
+ *   browser context (often regardless of network conditions), such as video and
+ *   audio
+ */
+// prettier-ignore
+export type FormAttachmentMediaData =
+	| Blob
+	| MediaSource
+	| ReadableStream<unknown>;
+
+export type FormAttachmentSecondaryInstanceData = string;
+
+// prettier-ignore
+type FormAttachmentData<DataType extends FormAttachmentDataType> =
+	DataType extends 'media'
+		? FormAttachmentMediaData
+		: FormAttachmentSecondaryInstanceData;
+
+export abstract class FormAttachmentResource<DataType extends FormAttachmentDataType> {
+	protected constructor(
+		readonly dataType: DataType,
+		readonly resourceURL: JRResourceURL,
+		readonly contentType: string,
+		readonly data: FormAttachmentData<DataType>
+	) {}
+}

package/src/parse/body/BodyDefinition.ts

@@ -3,7 +3,7 @@ import { TokenListParser } from '../../lib/TokenListParser.ts';
 import type { XFormDefinition } from '../../parse/XFormDefinition.ts';
 import { DependencyContext } from '../expression/abstract/DependencyContext.ts';
 import { ControlDefinition } from './control/ControlDefinition.ts';
-import { InputDefinition } from './control/InputDefinition.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';
@@ -25,7 +25,7 @@ export interface BodyElementParentContext {
 // prettier-ignore
 export type ControlElementDefinition =
 	| AnySelectDefinition
-	| InputDefinition
+	| InputControlDefinition
 	| RangeControlDefinition
 	| RankControlDefinition
 	| TriggerControlDefinition
@@ -47,7 +47,7 @@ const BodyElementDefinitionConstructors = [
 	LogicalGroupDefinition,
 	PresentationGroupDefinition,
 	StructuralGroupDefinition,
-	InputDefinition,
+	InputControlDefinition,
 	SelectDefinition,
 	RangeControlDefinition,
 	RankControlDefinition,

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

@@ -4,7 +4,7 @@ export const inputAppearanceParser = new TokenListParser([
 	'multiline',
 	'numbers',
 	'url',
-	'thousand-sep',
+	'thousands-sep',
 
 	// date (TODO: data types)
 	'no-calendar',

package/src/parse/body/control/{InputDefinition.ts → InputControlDefinition.ts}

@@ -1,12 +1,10 @@
 import type { XFormDefinition } from '../../XFormDefinition.ts';
-import {
-	inputAppearanceParser,
-	type InputAppearanceDefinition,
-} from '../appearance/inputAppearanceParser.ts';
+import type { InputAppearanceDefinition } from '../appearance/inputAppearanceParser.ts';
+import { inputAppearanceParser } from '../appearance/inputAppearanceParser.ts';
 import type { BodyElementParentContext } from '../BodyDefinition.ts';
 import { ControlDefinition } from './ControlDefinition.ts';
 
-export class InputDefinition extends ControlDefinition<'input'> {
+export class InputControlDefinition extends ControlDefinition<'input'> {
 	static override isCompatible(localName: string): boolean {
 		return localName === 'input';
 	}

package/src/parse/body/control/select/ItemsetNodesetContext.ts

@@ -1,5 +1,4 @@
 import { DependencyContext } from '../../../expression/abstract/DependencyContext.ts';
-import type { AnyDependentExpression } from '../../../expression/abstract/DependentExpression.ts';
 import type { ItemsetDefinition } from './ItemsetDefinition.ts';
 
 export class ItemsetNodesetContext extends DependencyContext {
@@ -19,8 +18,4 @@ export class ItemsetNodesetContext extends DependencyContext {
 		super.isTranslated = value;
 		this.itemset.isTranslated = value;
 	}
-
-	override registerDependentExpression(expression: AnyDependentExpression): void {
-		this.itemset.registerDependentExpression(expression);
-	}
 }

package/src/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/parse/expression/abstract/DependentExpression.ts

@@ -1,5 +1,4 @@
-import type { XFormsXPathEvaluator } from '@getodk/xpath';
-import { resolveDependencyNodesets } from '../../xpath/dependency-analysis.ts';
+import type { EngineXPathEvaluator } from '../../../integration/xpath/EngineXPathEvaluator.ts';
 import type {
 	ConstantExpression,
 	ConstantTruthyExpression,
@@ -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 {
@@ -55,7 +54,6 @@ export interface ConstantTruthyDependentExpression extends ConstantDependentExpr
 }
 
 export abstract class DependentExpression<Type extends DependentExpressionResultType> {
-	readonly dependencyReferences: ReadonlySet<string> = new Set();
 	readonly isTranslated: boolean = false;
 	readonly evaluatorMethod: DependentExpressionEvaluatorMethod<Type>;
 	readonly constantExpression: ConstantExpression | null;
@@ -81,26 +79,17 @@ export abstract class DependentExpression<Type extends DependentExpressionResult
 		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/model/BindDefinition.ts

@@ -2,15 +2,14 @@ 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 { XFormDataType } from '../XFormDataType.ts';
-import { bindDataType } from '../XFormDataType.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 extends DependencyContext {
-	readonly bindType: string | null;
-	readonly dataType: XFormDataType;
+export class BindDefinition<T extends BindType = BindType> extends DependencyContext {
+	readonly type: BindTypeDefinition<T>;
 	readonly parentNodeset: string | null;
 
 	readonly calculate: BindComputationExpression<'calculate'> | null;
@@ -78,9 +77,7 @@ export class BindDefinition extends DependencyContext {
 	) {
 		super();
 
-		const bindType = (this.bindType = bindElement.getAttribute('type'));
-
-		this.dataType = bindDataType(bindType);
+		this.type = BindTypeDefinition.from(bindElement);
 
 		const parentNodeset = nodeset.replace(/\/[^/]+$/, '');
 

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
+	) {}
+}