@getodk/xforms-engine 0.4.0 → 0.5.0

package/src/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/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/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

@@ -1,14 +1,19 @@
 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, form.body.classes);
+		this.root = new RootDefinition(form, this, submission, form.body.classes);
+		this.itextTranslations = ItextTranslationsDefinition.from(form.xformDOM);
 	}
 
 	toJSON() {

package/src/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>;

package/src/parse/model/NoteNodeDefinition.ts

@@ -1,6 +1,6 @@
 import type { NoteNode } from '../../client/NoteNode.ts';
 import type { AnyBodyElementDefinition } from '../body/BodyDefinition.ts';
-import type { InputDefinition } from '../body/control/InputDefinition.ts';
+import type { InputControlDefinition } from '../body/control/InputControlDefinition.ts';
 import { BindComputationExpression } from '../expression/BindComputationExpression.ts';
 import type { ConstantTruthyDependentExpression } from '../expression/abstract/DependentExpression.ts';
 import type { HintDefinition } from '../text/HintDefinition.ts';
@@ -31,7 +31,7 @@ export type NoteTextDefinition =
 /**
  * @package This class is used internally, both in static types and at runtime,
  * to guard and guide the distinction between instance state nodes for 'note'
- * and 'string' node types. It is intentionally package-private! The less
+ * and 'input' node types. It is intentionally package-private! The less
  * specific {@link NoteNode.definition} type, if it has any client value at all,
  * should be more than sufficient. Clients are otherwise expected to use other
  * aspects of the node's interface (such as its {@link NoteNode.nodeType} and
@@ -61,7 +61,7 @@ export class NoteNodeDefinition extends LeafNodeDefinition {
 	constructor(
 		parent: ParentNodeDefinition,
 		override readonly bind: NoteBindDefinition,
-		override readonly bodyElement: InputDefinition,
+		override readonly bodyElement: InputControlDefinition,
 		readonly noteTextDefinition: NoteTextDefinition,
 		node: Element
 	) {

package/src/parse/model/RootDefinition.ts

@@ -1,6 +1,7 @@
 import type { BodyClassList } from '../body/BodyDefinition.ts';
 import type { XFormDefinition } from '../XFormDefinition.ts';
 import type { BindDefinition } from './BindDefinition.ts';
+import type { FormSubmissionDefinition } from './FormSubmissionDefinition.ts';
 import { LeafNodeDefinition } from './LeafNodeDefinition.ts';
 import type { ModelDefinition } from './ModelDefinition.ts';
 import type {
@@ -26,11 +27,11 @@ export class RootDefinition implements NodeDefinition<'root'> {
 	readonly defaultValue = null;
 
 	readonly isTranslated = false;
-	readonly dependencyExpressions: ReadonlySet<string> = new Set<string>();
 
 	constructor(
 		protected readonly form: XFormDefinition,
 		protected readonly model: ModelDefinition,
+		readonly submission: FormSubmissionDefinition,
 		readonly classes: BodyClassList
 	) {
 		// TODO: theoretically the pertinent step in the bind's `nodeset` *could* be

package/src/parse/model/SecondaryInstance/SecondaryInstanceDefinition.ts

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

package/src/parse/model/SecondaryInstance/SecondaryInstanceRootDefinition.ts

@@ -0,0 +1,12 @@
+import type { XFormsSecondaryInstanceElement } from '@getodk/xpath';
+import { XFORMS_KNOWN_ATTRIBUTE, XFORMS_LOCAL_NAME } from '@getodk/xpath';
+import { StaticElement } from '../../../integration/xpath/static-dom/StaticElement.ts';
+import type { SecondaryInstanceDefinition } from './SecondaryInstanceDefinition.ts';
+
+export class SecondaryInstanceRootDefinition
+	extends StaticElement<SecondaryInstanceDefinition>
+	implements XFormsSecondaryInstanceElement<StaticElement>
+{
+	override readonly [XFORMS_LOCAL_NAME] = 'instance';
+	override readonly [XFORMS_KNOWN_ATTRIBUTE] = 'id';
+}

package/src/parse/model/SecondaryInstance/SecondaryInstancesDefinition.ts

@@ -0,0 +1,102 @@
+import { JRResourceURL } from '@getodk/common/jr-resources/JRResourceURL.ts';
+import { UnreachableError } from '@getodk/common/lib/error/UnreachableError.ts';
+import type { XFormsSecondaryInstanceMap } from '@getodk/xpath';
+import { ErrorProductionDesignPendingError } from '../../../error/ErrorProductionDesignPendingError.ts';
+import type { EngineXPathNode } from '../../../integration/xpath/adapter/kind.ts';
+import type { XFormDOM } from '../../XFormDOM.ts';
+import { SecondaryInstanceRootDefinition } from './SecondaryInstanceRootDefinition.ts';
+import { BlankSecondaryInstanceSource } from './sources/BlankSecondaryInstanceSource.ts';
+import { CSVExternalSecondaryInstanceSource } from './sources/CSVExternalSecondaryInstance.ts';
+import type { ExternalSecondaryInstanceResourceLoadOptions } from './sources/ExternalSecondaryInstanceResource.ts';
+import { ExternalSecondaryInstanceResource } from './sources/ExternalSecondaryInstanceResource.ts';
+import { GeoJSONExternalSecondaryInstanceSource } from './sources/GeoJSONExternalSecondaryInstance.ts';
+import { InternalSecondaryInstanceSource } from './sources/InternalSecondaryInstanceSource.ts';
+import type { SecondaryInstanceSource } from './sources/SecondaryInstanceSource.ts';
+import { XMLExternalSecondaryInstanceSource } from './sources/XMLExternalSecondaryInstanceSource.ts';
+
+export class SecondaryInstancesDefinition
+	extends Map<string, SecondaryInstanceRootDefinition>
+	implements XFormsSecondaryInstanceMap<EngineXPathNode>
+{
+	/**
+	 * @package Only to be used for testing
+	 */
+	static loadSync(xformDOM: XFormDOM): SecondaryInstancesDefinition {
+		const { secondaryInstanceElements } = xformDOM;
+		const sources = secondaryInstanceElements.map((domElement) => {
+			const instanceId = domElement.getAttribute('id');
+			const src = domElement.getAttribute('src');
+
+			if (src != null) {
+				throw new ErrorProductionDesignPendingError(
+					`Unexpected external secondary instance src attribute: ${src}`
+				);
+			}
+
+			return new InternalSecondaryInstanceSource(instanceId, src, domElement);
+		});
+
+		return new this(sources);
+	}
+
+	static async load(
+		xformDOM: XFormDOM,
+		options: ExternalSecondaryInstanceResourceLoadOptions
+	): Promise<SecondaryInstancesDefinition> {
+		const { secondaryInstanceElements } = xformDOM;
+
+		const sources = await Promise.all(
+			secondaryInstanceElements.map(async (domElement) => {
+				const instanceId = domElement.getAttribute('id');
+				const src = domElement.getAttribute('src');
+
+				if (src == null) {
+					return new InternalSecondaryInstanceSource(instanceId, src, domElement);
+				}
+
+				if (!JRResourceURL.isJRResourceReference(src)) {
+					throw new ErrorProductionDesignPendingError(
+						`Unexpected external secondary instance src attribute: ${src}`
+					);
+				}
+
+				const resourceURL = JRResourceURL.from(src);
+				const resource = await ExternalSecondaryInstanceResource.load(
+					instanceId,
+					resourceURL,
+					options
+				);
+
+				if (resource.isBlank) {
+					return new BlankSecondaryInstanceSource(instanceId, resourceURL, domElement);
+				}
+
+				switch (resource.format) {
+					case 'csv':
+						return new CSVExternalSecondaryInstanceSource(domElement, resource);
+
+					case 'geojson':
+						return new GeoJSONExternalSecondaryInstanceSource(domElement, resource);
+
+					case 'xml':
+						return new XMLExternalSecondaryInstanceSource(domElement, resource);
+
+					default:
+						throw new UnreachableError(resource);
+				}
+			})
+		);
+
+		return new this(sources);
+	}
+
+	private constructor(sources: readonly SecondaryInstanceSource[]) {
+		super(
+			sources.map((source) => {
+				const { root } = source.parseDefinition();
+
+				return [root.getAttributeValue('id'), root];
+			})
+		);
+	}
+}

package/src/parse/model/SecondaryInstance/sources/BlankSecondaryInstanceSource.ts

@@ -0,0 +1,40 @@
+import { XFORMS_NAMESPACE_URI } from '@getodk/common/constants/xmlns.ts';
+import type { JRResourceURL } from '@getodk/common/jr-resources/JRResourceURL.ts';
+import type { StaticNode } from '../../../../integration/xpath/static-dom/StaticNode.ts';
+import { parseStaticDocumentFromDOMSubtree } from '../../../shared/parseStaticDocumentFromDOMSubtree.ts';
+import type { DOMSecondaryInstanceElement } from '../../../XFormDOM.ts';
+import { SecondaryInstanceDefinition } from '../SecondaryInstanceDefinition.ts';
+import { SecondaryInstanceRootDefinition } from '../SecondaryInstanceRootDefinition.ts';
+import { SecondaryInstanceSource } from './SecondaryInstanceSource.ts';
+
+export class BlankSecondaryInstanceSource extends SecondaryInstanceSource<'blank'> {
+	constructor(
+		instanceId: string,
+		resourceURL: JRResourceURL,
+		domElement: DOMSecondaryInstanceElement
+	) {
+		super('blank', instanceId, resourceURL, domElement);
+	}
+
+	/**
+	 * @todo there is really no sense in using the DOM for this, other than it was
+	 * quicker/more ergonomic than constructing the requisite {@link StaticNode}
+	 * structures directly. Pretty good sign those constructor signatures could
+	 * use some TLC!
+	 */
+	parseDefinition(): SecondaryInstanceDefinition {
+		const xmlDocument = this.domElement.ownerDocument.implementation.createDocument(
+			XFORMS_NAMESPACE_URI,
+			'instance'
+		);
+		const instanceElement = xmlDocument.documentElement;
+
+		instanceElement.setAttribute('id', this.instanceId);
+
+		return parseStaticDocumentFromDOMSubtree(
+			SecondaryInstanceDefinition,
+			SecondaryInstanceRootDefinition,
+			instanceElement
+		);
+	}
+}