@getodk/xforms-engine 0.5.0 → 0.7.0

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

@@ -1,7 +1,7 @@
 import { parseStaticDocumentFromDOMSubtree } from '../../../shared/parseStaticDocumentFromDOMSubtree.ts';
 import type { DOMSecondaryInstanceElement } from '../../../XFormDOM.ts';
-import { SecondaryInstanceDefinition } from '../SecondaryInstanceDefinition.ts';
-import { SecondaryInstanceRootDefinition } from '../SecondaryInstanceRootDefinition.ts';
+import { assertSecondaryInstanceDefinition } from '../assertSecondaryInstanceDefinition.ts';
+import type { SecondaryInstanceDefinition } from '../SecondaryInstancesDefinition.ts';
 import { SecondaryInstanceSource } from './SecondaryInstanceSource.ts';
 
 export class InternalSecondaryInstanceSource extends SecondaryInstanceSource<'internal'> {
@@ -10,10 +10,12 @@ export class InternalSecondaryInstanceSource extends SecondaryInstanceSource<'in
 	}
 
 	parseDefinition(): SecondaryInstanceDefinition {
-		return parseStaticDocumentFromDOMSubtree(
-			SecondaryInstanceDefinition,
-			SecondaryInstanceRootDefinition,
-			this.domElement
-		);
+		const doc = parseStaticDocumentFromDOMSubtree(this.domElement, {
+			nodesetPrefix: `instance('${this.instanceId}')`,
+		});
+
+		assertSecondaryInstanceDefinition(doc);
+
+		return doc;
 	}
 }

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

@@ -1,6 +1,6 @@
 import type { JRResourceURL } from '@getodk/common/jr-resources/JRResourceURL.ts';
 import type { DOMSecondaryInstanceElement } from '../../../XFormDOM.ts';
-import type { SecondaryInstanceDefinition } from '../SecondaryInstanceDefinition.ts';
+import type { SecondaryInstanceDefinition } from '../SecondaryInstancesDefinition.ts';
 
 // prettier-ignore
 export type ExternalSecondaryInstanceSourceFormat =

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

@@ -1,7 +1,7 @@
 import { XFORMS_NAMESPACE_URI } from '@getodk/common/constants/xmlns.ts';
 import { parseStaticDocumentFromDOMSubtree } from '../../../shared/parseStaticDocumentFromDOMSubtree.ts';
-import { SecondaryInstanceDefinition } from '../SecondaryInstanceDefinition.ts';
-import { SecondaryInstanceRootDefinition } from '../SecondaryInstanceRootDefinition.ts';
+import { assertSecondaryInstanceDefinition } from '../assertSecondaryInstanceDefinition.ts';
+import type { SecondaryInstanceDefinition } from '../SecondaryInstancesDefinition.ts';
 import { ExternalSecondaryInstanceSource } from './ExternalSecondaryInstanceSource.ts';
 import type { InternalSecondaryInstanceSource } from './InternalSecondaryInstanceSource.ts';
 
@@ -23,10 +23,10 @@ export class XMLExternalSecondaryInstanceSource extends ExternalSecondaryInstanc
 		instanceElement.setAttribute('id', this.instanceId);
 		instanceElement.innerHTML = this.resource.data;
 
-		return parseStaticDocumentFromDOMSubtree(
-			SecondaryInstanceDefinition,
-			SecondaryInstanceRootDefinition,
-			instanceElement
-		);
+		const doc = parseStaticDocumentFromDOMSubtree(instanceElement);
+
+		assertSecondaryInstanceDefinition(doc);
+
+		return doc;
 	}
 }

package/src/parse/model/{FormSubmissionDefinition.ts → SubmissionDefinition.ts}

@@ -1,8 +1,8 @@
-import type { SubmissionDefinition } from '../../client/submission/SubmissionDefinition.ts';
+import type { SubmissionMeta } from '../../client/submission/SubmissionMeta.ts';
 import { getSubmissionElement } from '../../lib/dom/query.ts';
 import type { XFormDOM } from '../XFormDOM.ts';
 
-export class FormSubmissionDefinition implements SubmissionDefinition {
+export class SubmissionDefinition implements SubmissionMeta {
 	readonly submissionAction!: URL | null;
 	readonly submissionMethod = 'post';
 	readonly encryptionKey!: string | null;

package/src/parse/model/SubtreeDefinition.ts

@@ -1,31 +1,29 @@
+import type { StaticElement } from '../../integration/xpath/static-dom/StaticElement.ts';
+import { NamespaceDeclarationMap } from '../../lib/names/NamespaceDeclarationMap.ts';
+import { QualifiedName } from '../../lib/names/QualifiedName.ts';
 import type {
 	AnyBodyElementDefinition,
 	AnyGroupElementDefinition,
 } from '../body/BodyDefinition.ts';
 import type { BindDefinition } from './BindDefinition.ts';
 import { DescendentNodeDefinition } from './DescendentNodeDefinition.ts';
-import type {
-	ChildNodeDefinition,
-	NodeDefinition,
-	ParentNodeDefinition,
-} from './NodeDefinition.ts';
-
-export class SubtreeDefinition
-	extends DescendentNodeDefinition<'subtree', AnyGroupElementDefinition | null>
-	implements NodeDefinition<'subtree'>
-{
+import type { ChildNodeDefinition, ParentNodeDefinition } from './NodeDefinition.ts';
+
+export class SubtreeDefinition extends DescendentNodeDefinition<
+	'subtree',
+	AnyGroupElementDefinition | null
+> {
 	readonly type = 'subtree';
 
-	readonly nodeName: string;
+	readonly namespaceDeclarations: NamespaceDeclarationMap;
+	readonly qualifiedName: QualifiedName;
 	readonly children: readonly ChildNodeDefinition[];
-	readonly instances = null;
-	readonly defaultValue = null;
 
 	constructor(
 		parent: ParentNodeDefinition,
 		bind: BindDefinition,
 		bodyElement: AnyBodyElementDefinition | null,
-		readonly node: Element
+		readonly template: StaticElement
 	) {
 		if (
 			bodyElement != null &&
@@ -38,8 +36,9 @@ export class SubtreeDefinition
 
 		const { root } = parent;
 
-		this.nodeName = node.localName;
-		this.children = root.buildSubtree(this);
+		this.qualifiedName = template.qualifiedName;
+		this.namespaceDeclarations = new NamespaceDeclarationMap(this);
+		this.children = root.buildSubtree(this, template);
 	}
 
 	toJSON() {

package/src/parse/model/nodeDefinitionMap.ts

@@ -0,0 +1,34 @@
+import { ErrorProductionDesignPendingError } from '../../error/ErrorProductionDesignPendingError.ts';
+import type { AnyNodeDefinition } from './NodeDefinition.ts';
+import type { RootDefinition } from './RootDefinition.ts';
+
+export type NodesetReference = string;
+
+const collectDefinitions = (
+	result: Map<NodesetReference, AnyNodeDefinition>,
+	definition: AnyNodeDefinition
+): Map<NodesetReference, AnyNodeDefinition> => {
+	const { nodeset } = definition;
+
+	if (result.has(nodeset)) {
+		throw new ErrorProductionDesignPendingError();
+	}
+
+	result.set(nodeset, definition);
+
+	if (definition.type === 'leaf-node') {
+		return result;
+	}
+
+	for (const child of definition.children) {
+		collectDefinitions(result, child);
+	}
+
+	return result;
+};
+
+export type NodeDefinitionMap = ReadonlyMap<NodesetReference, AnyNodeDefinition>;
+
+export const nodeDefinitionMap = (root: RootDefinition): NodeDefinitionMap => {
+	return collectDefinitions(new Map(), root);
+};

package/src/parse/shared/parseInstanceXML.ts

@@ -0,0 +1,79 @@
+import { ErrorProductionDesignPendingError } from '../../error/ErrorProductionDesignPendingError.ts';
+import type { StaticDocument } from '../../integration/xpath/static-dom/StaticDocument.ts';
+import type { StaticNode } from '../../integration/xpath/static-dom/StaticNode.ts';
+import type { NamespaceDeclarationMap } from '../../lib/names/NamespaceDeclarationMap.ts';
+import { escapeXMLText } from '../../lib/xml-serialization.ts';
+import type { ModelDefinition } from '../model/ModelDefinition.ts';
+import type { RootDefinition } from '../model/RootDefinition.ts';
+import { parseStaticDocumentFromDOMSubtree } from './parseStaticDocumentFromDOMSubtree.ts';
+
+type WrappedInstanceXML = `<wrapped${string}</wrapped>`;
+
+const wrapInstanceXML = (model: ModelDefinition, instanceXML: string): WrappedInstanceXML => {
+	const defaultNamespace = model.root.namespaceDeclarations.get(null);
+	const defaultNamespaceURI = defaultNamespace?.declaredURI?.href;
+
+	if (defaultNamespaceURI == null) {
+		return `<wrapped>${instanceXML}</wrapped>`;
+	}
+
+	return /* xml */ `<wrapped xmlns="${escapeXMLText(defaultNamespaceURI, true)}">
+		${instanceXML}
+	</wrapped>`;
+};
+
+type AssertSoleChildElement = (element?: Element | null) => asserts element is Element;
+
+const assertSoleChildElement: AssertSoleChildElement = (element) => {
+	if (element == null) {
+		throw new ErrorProductionDesignPendingError('Expected a child element');
+	}
+
+	const { parentNode } = element;
+
+	if (parentNode == null) {
+		throw new ErrorProductionDesignPendingError('Expected element to be a child of a parent node');
+	}
+
+	if (element !== parentNode.firstElementChild || element !== parentNode.lastElementChild) {
+		throw new ErrorProductionDesignPendingError(
+			"Expected child element to be parent node's only element child."
+		);
+	}
+};
+
+const getWrappedInstanceRootElement = (xml: WrappedInstanceXML): Element => {
+	const domParser = new DOMParser();
+	const doc = domParser.parseFromString(xml, 'text/xml');
+	const { documentElement } = doc;
+	const [root] = documentElement.children;
+
+	assertSoleChildElement(root);
+
+	return root;
+};
+
+/**
+ * Parses incoming instance XML input into a {@link StaticDocument}, preserving
+ * the form definition's default namespace URI (when the instance XML does not
+ * explicitly declare a default namespace).
+ *
+ * @todo This is a hack! A proper solution will involve extending namespace
+ * resolution (i.e. probably {@link NamespaceDeclarationMap}) from
+ * {@link RootDefinition} on down throughout the instance's {@link StaticNode}
+ * tree. The same will probably be the case for parsing (XML) external secondary
+ * instances as well, so at that point we can also stop using this specialized
+ * name!
+ *
+ * @todo Aside from this being a hack, it's not very robust because it makes
+ * assumptions which are _likely but definitely not guaranteed_!
+ *
+ * - Instance XML (probably) doeesn't declare a default namespace
+ * - Instance XML **definitely** declares non-default namespaces
+ */
+export const parseInstanceXML = (model: ModelDefinition, instanceXML: string): StaticDocument => {
+	const wrappedXML = wrapInstanceXML(model, instanceXML);
+	const root = getWrappedInstanceRootElement(wrappedXML);
+
+	return parseStaticDocumentFromDOMSubtree(root);
+};

package/src/parse/shared/parseStaticDocumentFromDOMSubtree.ts

@@ -1,149 +1,64 @@
-import { UnreachableError } from '@getodk/common/lib/error/UnreachableError.ts';
-import type { AnyConstructor } from '@getodk/common/types/helpers.js';
-import { StaticAttribute } from '../../integration/xpath/static-dom/StaticAttribute.ts';
+import type { StaticAttributeOptions } from '../../integration/xpath/static-dom/StaticAttribute.ts';
+import { StaticDocument } from '../../integration/xpath/static-dom/StaticDocument.ts';
 import type {
-	StaticDocument,
-	StaticDocumentRootFactory,
-} from '../../integration/xpath/static-dom/StaticDocument.ts';
-import type {
-	StaticElementAttributesFactory,
-	StaticElementChildNodesFactory,
+	StaticElementChildOption,
+	StaticElementOptions,
 } from '../../integration/xpath/static-dom/StaticElement.ts';
-import { StaticElement } from '../../integration/xpath/static-dom/StaticElement.ts';
-import type { StaticNamedNodeOptions } from '../../integration/xpath/static-dom/StaticNamedNode.ts';
-import type { StaticParentNode } from '../../integration/xpath/static-dom/StaticNode.ts';
-import { StaticText } from '../../integration/xpath/static-dom/StaticText.ts';
-
-type ConcreteConstructor<T extends AnyConstructor> = Pick<T, keyof T>;
-
-// prettier-ignore
-export type ConcreteStaticDocumentConstructor<
-	T extends StaticDocument<Root>,
-	Root extends StaticElement,
-> =
-	& ConcreteConstructor<typeof StaticDocument<Root>>
-	& (new (rootFactory: StaticDocumentRootFactory<T, Root>) => T);
-
-const domElementAttributesFactory = (domElement: Element): StaticElementAttributesFactory => {
-	const attributes = Array.from(domElement.attributes);
+import type { QualifiedNameSource } from '../../lib/names/QualifiedName.ts';
 
-	return (element) => {
-		return attributes.map((attr) => {
-			return new StaticAttribute(element, attr);
-		});
+const parseNodeName = (domNode: Attr | Element): QualifiedNameSource => {
+	return {
+		namespaceURI: domNode.namespaceURI,
+		prefix: domNode.prefix,
+		localName: domNode.localName,
 	};
 };
 
-const { ELEMENT_NODE, CDATA_SECTION_NODE, TEXT_NODE } = Node;
-
-interface StaticChildElementSource {
-	readonly domType: typeof ELEMENT_NODE;
-	readonly domNode: Element;
-}
-
-interface StaticChildTextSource {
-	readonly domType: typeof CDATA_SECTION_NODE | typeof TEXT_NODE;
-	readonly domNode: CharacterData;
-}
-
-// prettier-ignore
-type StaticChildNodeSource =
-	| StaticChildElementSource
-	| StaticChildTextSource;
-
-export const toStaticChildNodeSource = (childNode: ChildNode): StaticChildNodeSource | null => {
-	const domType = childNode.nodeType;
-
-	switch (domType) {
-		case ELEMENT_NODE:
-			return {
-				domType,
-				domNode: childNode as Element,
-			};
-
-		case TEXT_NODE:
-			return {
-				domType,
-				domNode: childNode as Text,
-			};
-
-		case CDATA_SECTION_NODE:
-			return {
-				domType,
-				domNode: childNode as CDATASection,
-			};
-
-		default:
-			return null;
-	}
-};
-
-const toStaticChildNodeSources = (childNode: ChildNode): StaticChildNodeSource | readonly [] => {
-	return toStaticChildNodeSource(childNode) ?? [];
+const parseStaticElementAttributes = (domElement: Element): readonly StaticAttributeOptions[] => {
+	return Array.from(domElement.attributes).map((attr) => ({
+		name: attr,
+		value: attr.value,
+	}));
 };
 
-const domElementChildNodesFactory = (domElement: Element): StaticElementChildNodesFactory => {
-	const childNodeSources = Array.from(domElement.childNodes).flatMap(toStaticChildNodeSources);
+const { ELEMENT_NODE, CDATA_SECTION_NODE, TEXT_NODE } = Node;
 
-	return (parent) => {
-		return childNodeSources.map((domSource) => {
-			switch (domSource.domType) {
-				case ELEMENT_NODE:
-					return parseStaticElementFromDOMElement(parent, StaticElement, domSource.domNode);
+const parseStaticElementChildren = (domElement: Element): readonly StaticElementChildOption[] => {
+	return Array.from(domElement.childNodes).flatMap((child) => {
+		switch (child.nodeType) {
+			case ELEMENT_NODE:
+				return parseStaticElementOptions(child as Element);
 
-				case TEXT_NODE:
-				case CDATA_SECTION_NODE:
-					return new StaticText(parent, domSource.domNode.data);
+			case TEXT_NODE:
+			case CDATA_SECTION_NODE:
+				return (child as CharacterData).data;
 
-				default:
-					throw new UnreachableError(domSource);
-			}
-		});
-	};
+			default:
+				return [];
+		}
+	});
 };
 
-// prettier-ignore
-export type StaticElementConstructor<
-	T extends StaticElement<Parent>,
-	Parent extends StaticParentNode = StaticParentNode
-> =
-	& ConcreteConstructor<typeof StaticElement>
-	& {
-			readonly prototype: T;
-
-			new (
-				parent: Parent,
-				attributesFactory: StaticElementAttributesFactory,
-				childNodesFactory: StaticElementChildNodesFactory,
-				options: StaticNamedNodeOptions
-			): T;
+const parseStaticElementOptions = (domElement: Element): StaticElementOptions => {
+	return {
+		name: parseNodeName(domElement),
+		attributes: parseStaticElementAttributes(domElement),
+		children: parseStaticElementChildren(domElement),
 	};
-
-const parseStaticElementFromDOMElement = <
-	T extends StaticElement,
-	Parent extends StaticParentNode = StaticParentNode,
->(
-	parent: Parent,
-	ElementConstructor: StaticElementConstructor<T, Parent>,
-	domElement: Element
-): T => {
-	const attributesFactory = domElementAttributesFactory(domElement);
-	const childNodesFactory = domElementChildNodesFactory(domElement);
-
-	return new ElementConstructor(parent, attributesFactory, childNodesFactory, domElement);
 };
 
-export const parseStaticDocumentFromDOMSubtree = <
-	T extends StaticDocument<Root>,
-	Root extends StaticElement<T>,
->(
-	DocumentConstructor: ConcreteStaticDocumentConstructor<T, Root>,
-	DocumentRootConstructor: StaticElementConstructor<Root, T>,
-	subtreeRootElement: Element
-): T => {
-	const rootFactory: StaticDocumentRootFactory<T, Root> = (parent) => {
-		return parseStaticElementFromDOMElement(parent, DocumentRootConstructor, subtreeRootElement);
-	};
+interface ParseStaticDocumentFromDOMSubtreeOptions {
+	readonly nodesetPrefix?: string;
+}
+
+export const parseStaticDocumentFromDOMSubtree = (
+	subtreeRootElement: Element,
+	options: ParseStaticDocumentFromDOMSubtreeOptions = {}
+): StaticDocument => {
+	const documentRoot = parseStaticElementOptions(subtreeRootElement);
 
-	return new DocumentConstructor(rootFactory);
+	return new StaticDocument({
+		...options,
+		documentRoot,
+	});
 };

package/src/parse/text/ItemLabelDefinition.ts

@@ -1,7 +1,7 @@
 import type { LocalNamedElement } from '@getodk/common/types/dom.ts';
 import { getLabelElement } from '../../lib/dom/query.ts';
 import type { XFormDefinition } from '../../parse/XFormDefinition.ts';
-import type { ItemDefinition } from '../body/control/select/ItemDefinition.ts';
+import type { ItemDefinition } from '../body/control/ItemDefinition.ts';
 import { TextElementDefinition } from './abstract/TextElementDefinition.ts';
 
 interface LabelElement extends LocalNamedElement<'label'> {}

package/src/parse/text/ItemsetLabelDefinition.ts

@@ -1,8 +1,8 @@
 import type { LocalNamedElement } from '@getodk/common/types/dom.ts';
 import { getLabelElement } from '../../lib/dom/query.ts';
 import type { XFormDefinition } from '../../parse/XFormDefinition.ts';
-import type { ItemDefinition } from '../body/control/select/ItemDefinition.ts';
-import type { ItemsetDefinition } from '../body/control/select/ItemsetDefinition.ts';
+import type { ItemDefinition } from '../body/control/ItemDefinition.ts';
+import type { ItemsetDefinition } from '../body/control/ItemsetDefinition.ts';
 import { TextReferenceExpression } from '../expression/TextReferenceExpression.ts';
 import { TextTranslationExpression } from '../expression/TextTranslationExpression.ts';
 import type { RefAttributeChunk } from './abstract/TextElementDefinition.ts';

package/src/parse/text/abstract/TextElementDefinition.ts

@@ -1,7 +1,7 @@
 import { isElementNode, isTextNode } from '@getodk/common/lib/dom/predicates.ts';
 import type { ElementTextRole } from '../../../client/TextRange.ts';
 import type { XFormDefinition } from '../../../parse/XFormDefinition.ts';
-import type { ItemDefinition } from '../../body/control/select/ItemDefinition.ts';
+import type { ItemDefinition } from '../../body/control/ItemDefinition.ts';
 import { TextLiteralExpression } from '../../expression/TextLiteralExpression.ts';
 import { TextOutputExpression } from '../../expression/TextOutputExpression.ts';
 import { TextReferenceExpression } from '../../expression/TextReferenceExpression.ts';

package/src/parse/xpath/semantic-analysis.ts

@@ -396,9 +396,10 @@ const findConstantExpressionNode = (expression: string): ConstantExpressionSynta
 	}
 };
 
-type BrandedExpression<Expression extends string, Brand extends symbol> = Expression & {
-	readonly [K in Brand]: true;
-};
+// prettier-ignore
+type BrandedExpression<Expression extends string, Brand extends symbol> =
+	& Expression
+	& Readonly<Record<Brand, true>>;
 
 const CONSTANT_EXPRESSION = Symbol('CONSTANT_EXPRESSION');
 type CONSTANT_EXPRESSION = typeof CONSTANT_EXPRESSION;

package/dist/client/EngineConfig.d.ts

@@ -1,79 +0,0 @@
-import { MissingResourceBehavior } from './constants.ts';
-import { OpaqueReactiveObjectFactory } from './OpaqueReactiveObjectFactory.ts';
-import { FetchFormAttachment, FetchResource } from './resources.ts';
-/**
- * Options provided by a client to specify certain aspects of engine runtime
- * behavior. These options will generally be intended to facilitate cooperation
- * where there is mixed responsibility between a client and the engine, or where
- * the engine may provide sensible defaults which a client could be expected to
- * override or augment.
- */
-export interface EngineConfig {
-    /**
-     * A client may specify a generic function for constructing stateful objects.
-     * The only hard requirement of this function is that it accepts an **object**
-     * and returns an object of the same shape. The engine will use this function
-     * to initialize client-facing state, and will mutate properties of the object
-     * when their corresponding state is changed.
-     *
-     * A client may use this function to provide its own implementation of
-     * reactivity with semantics like those described above. The mechanism of
-     * reactivity, if any, is at the discretion of the client. It is expected
-     * that clients providing this function will use a reactive subscribe-on-read
-     * mechanism to handle state updates conveyed by the engine.
-     */
-    readonly stateFactory?: OpaqueReactiveObjectFactory;
-    /**
-     *
-     * A client may specify an arbitrary {@link fetch}-like function for retrieving an XML XForm form
-     * definition.
-     *
-     * Notes:
-     *
-     * - This configuration will only be consuled for calls to
-     *   {@link initializeForm} with a URL referencing an XML XForm definition. It
-     *   will be ignored for calls passing an XML XForm form definition directly.
-     *
-     * - For calls to {@link initializeForm} with a URL, if this configuration is
-     *   not specified it will default to the global {@link fetch} function (if
-     *   one is defined).
-     */
-    readonly fetchFormDefinition?: FetchResource;
-    /**
-     * A client may specify an arbitrary {@link fetch}-like function to retrieve a
-     * form's attachments, i.e. any `jr:` URL referenced by the form (as specified
-     * by {@link https://getodk.github.io/xforms-spec/ | ODK XForms}).
-     *
-     * Notes:
-     *
-     * - This configuration will be consulted for all supported form attachments,
-     *   as a part of {@link initializeForm | form initialization}.
-     *
-     * - If this configuration is not specified it will default to the global
-     *   {@link fetch} function (if one is defined).
-     *
-     * This default behavior will typically result in failure to load form
-     * attachments—and in most cases this will also cause
-     * {@link initializeForm | form initialization} to fail overall—with the
-     * following exceptions:
-     *
-     * - **CLIENT-SPECIFIC:** Usage in coordination with a client-implemented
-     *   {@link https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API | Serivce Worker},
-     *   which can intercept network requests **generally**. Clients already using
-     *   a Service Worker may opt for the convenience of handling network requests
-     *   for `jr:` URLs along with any other network interception logic. Client
-     *   implementors should be warned, however, that such `jr:` URLs are not
-     *   namespaced or otherwise scoped to a particular form; such a client would
-     *   therefore inherently need to coordinate state between the Service Worker
-     *   and the main thread (or whatever other realm calls
-     *   {@link initializeForm}).
-     */
-    readonly fetchFormAttachment?: FetchFormAttachment;
-    /**
-     * @see {@link MissingResourceBehavior}
-     * @see {@link MissingResourceBehaviorDefault}
-     *
-     * @default MissingResourceBehaviorDefault
-     */
-    readonly missingResourceBehavior?: MissingResourceBehavior;
-}

package/dist/client/submission/SubmissionData.d.ts

@@ -1,7 +0,0 @@
-import { SubmissionInstanceFile, SubmissionInstanceFileName } from './SubmissionInstanceFile.ts';
-export interface SubmissionData extends FormData {
-    get(name: SubmissionInstanceFileName): SubmissionInstanceFile;
-    get(name: string): FormDataEntryValue | null;
-    has(name: SubmissionInstanceFileName): true;
-    has(name: string): boolean;
-}

package/dist/client/submission/SubmissionInstanceFile.d.ts

@@ -1,6 +0,0 @@
-import { SubmissionInstanceFileName, SubmissionInstanceFileType } from '../constants.ts';
-export type { SubmissionInstanceFileName, SubmissionInstanceFileType };
-export interface SubmissionInstanceFile extends File {
-    readonly name: SubmissionInstanceFileName;
-    readonly type: SubmissionInstanceFileType;
-}

package/dist/client/submission/SubmissionOptions.d.ts

@@ -1,23 +0,0 @@
-export type SubmissionChunkedType = 'chunked' | 'monolithic';
-interface BaseSubmissionOptions<ChunkedType extends SubmissionChunkedType> {
-    readonly chunked?: ChunkedType | undefined;
-    /**
-     * As described in the
-     * {@link https://docs.getodk.org/openrosa-form-submission/#extended-transmission-considerations | OpenRosa Form Submission API},
-     * clients may obtain this value from an OpenRosa server's
-     * `X-OpenRosa-Accept-Content-Length` header.
-     */
-    readonly maxSize?: number;
-}
-interface ChunkedSubmissionOptions extends BaseSubmissionOptions<'chunked'> {
-    readonly maxSize: number;
-}
-interface MonolithicSubmissionOptions extends BaseSubmissionOptions<'monolithic'> {
-    readonly chunked?: 'monolithic' | undefined;
-    readonly maxSize?: never;
-}
-export type SubmissionOptions<ChunkedType extends SubmissionChunkedType = 'monolithic'> = {
-    chunked: ChunkedSubmissionOptions;
-    monolithic: MonolithicSubmissionOptions;
-}[ChunkedType];
-export {};