@getodk/xforms-engine 0.4.0 → 0.5.0

package/src/instance/InputControl.ts

@@ -0,0 +1,119 @@
+import { XPathNodeKindKey } from '@getodk/xpath';
+import type { Accessor } from 'solid-js';
+import type {
+	InputDefinition,
+	InputNode,
+	InputNodeAppearances,
+	InputNodeInputValue,
+} from '../client/InputNode.ts';
+import type { TextRange } from '../client/TextRange.ts';
+import type { ValueType } from '../client/ValueType.ts';
+import type { XFormsXPathElement } from '../integration/xpath/adapter/XFormsXPathNode.ts';
+import type { RuntimeInputValue, RuntimeValue } from '../lib/codecs/getSharedValueCodec.ts';
+import { getSharedValueCodec } from '../lib/codecs/getSharedValueCodec.ts';
+import type { CurrentState } from '../lib/reactivity/node-state/createCurrentState.ts';
+import type { EngineState } from '../lib/reactivity/node-state/createEngineState.ts';
+import type { SharedNodeState } from '../lib/reactivity/node-state/createSharedNodeState.ts';
+import { createSharedNodeState } from '../lib/reactivity/node-state/createSharedNodeState.ts';
+import { createFieldHint } from '../lib/reactivity/text/createFieldHint.ts';
+import { createNodeLabel } from '../lib/reactivity/text/createNodeLabel.ts';
+import type { Root } from './Root.ts';
+import { ValueNode, type ValueNodeStateSpec } from './abstract/ValueNode.ts';
+import type { GeneralParentNode } from './hierarchy.ts';
+import type { EvaluationContext } from './internal-api/EvaluationContext.ts';
+import type { ValidationContext } from './internal-api/ValidationContext.ts';
+import type { ClientReactiveSubmittableValueNode } from './internal-api/submission/ClientReactiveSubmittableValueNode.ts';
+
+export type AnyInputDefinition = {
+	[V in ValueType]: InputDefinition<V>;
+}[ValueType];
+
+interface InputControlStateSpec<V extends ValueType> extends ValueNodeStateSpec<RuntimeValue<V>> {
+	readonly label: Accessor<TextRange<'label'> | null>;
+	readonly hint: Accessor<TextRange<'hint'> | null>;
+}
+
+export class InputControl<V extends ValueType = ValueType>
+	extends ValueNode<V, InputDefinition<V>, RuntimeValue<V>, RuntimeInputValue<V>>
+	implements
+		InputNode<V>,
+		XFormsXPathElement,
+		EvaluationContext,
+		ValidationContext,
+		ClientReactiveSubmittableValueNode
+{
+	static from(parent: GeneralParentNode, definition: InputDefinition): AnyInputControl;
+	static from<V extends ValueType>(
+		parent: GeneralParentNode,
+		definition: InputDefinition<V>
+	): InputControl<V> {
+		return new this(parent, definition);
+	}
+
+	// XFormsXPathElement
+	override readonly [XPathNodeKindKey] = 'element';
+
+	// InstanceNode
+	protected readonly state: SharedNodeState<InputControlStateSpec<V>>;
+	protected readonly engineState: EngineState<InputControlStateSpec<V>>;
+
+	// InputNode
+	readonly nodeType = 'input';
+	readonly appearances: InputNodeAppearances;
+	readonly currentState: CurrentState<InputControlStateSpec<V>>;
+
+	constructor(parent: GeneralParentNode, definition: InputDefinition<V>) {
+		const codec = getSharedValueCodec(definition.valueType);
+
+		super(parent, definition, codec);
+
+		this.appearances = definition.bodyElement.appearances;
+
+		const sharedStateOptions = {
+			clientStateFactory: this.engineConfig.stateFactory,
+		};
+
+		const state = createSharedNodeState(
+			this.scope,
+			{
+				reference: this.contextReference,
+				readonly: this.isReadonly,
+				relevant: this.isRelevant,
+				required: this.isRequired,
+
+				label: createNodeLabel(this, definition),
+				hint: createFieldHint(this, definition),
+				children: null,
+				valueOptions: null,
+				value: this.valueState,
+				instanceValue: this.getInstanceValue,
+			},
+			sharedStateOptions
+		);
+
+		this.state = state;
+		this.engineState = state.engineState;
+		this.currentState = state.currentState;
+	}
+
+	setValue(value: InputNodeInputValue<V>): Root {
+		this.setValueState(value);
+
+		return this.root;
+	}
+}
+
+export type AnyInputControl =
+	| InputControl<'barcode'>
+	| InputControl<'binary'>
+	| InputControl<'boolean'>
+	| InputControl<'date'>
+	| InputControl<'dateTime'>
+	| InputControl<'decimal'>
+	| InputControl<'geopoint'>
+	| InputControl<'geoshape'>
+	| InputControl<'geotrace'>
+	| InputControl<'int'>
+	| InputControl<'intent'>
+	| InputControl<'string'>
+	| InputControl<'time'>;

package/src/instance/ModelValue.ts

@@ -1,65 +1,57 @@
-import { identity } from '@getodk/common/lib/identity.ts';
-import type { ModelValueNode } from '../client/ModelValueNode.ts';
-import type { AnyViolation, LeafNodeValidationState } from '../client/validation.ts';
-import { createValueState } from '../lib/reactivity/createValueState.ts';
+import { XPathNodeKindKey } from '@getodk/xpath';
+import type { ModelValueDefinition, ModelValueNode } from '../client/ModelValueNode.ts';
+import type { ValueType } from '../client/ValueType.ts';
+import type { XFormsXPathElement } from '../integration/xpath/adapter/XFormsXPathNode.ts';
+import type { RuntimeInputValue, RuntimeValue } from '../lib/codecs/getSharedValueCodec.ts';
+import { getSharedValueCodec } from '../lib/codecs/getSharedValueCodec.ts';
 import type { CurrentState } from '../lib/reactivity/node-state/createCurrentState.ts';
 import type { EngineState } from '../lib/reactivity/node-state/createEngineState.ts';
 import type { SharedNodeState } from '../lib/reactivity/node-state/createSharedNodeState.ts';
 import { createSharedNodeState } from '../lib/reactivity/node-state/createSharedNodeState.ts';
-import type { SimpleAtomicState } from '../lib/reactivity/types.ts';
-import type { SharedValidationState } from '../lib/reactivity/validation/createValidation.ts';
-import { createValidationState } from '../lib/reactivity/validation/createValidation.ts';
-import type { LeafNodeDefinition } from '../parse/model/LeafNodeDefinition.ts';
-import type { DescendantNodeStateSpec } from './abstract/DescendantNode.ts';
-import { DescendantNode } from './abstract/DescendantNode.ts';
+import { ValueNode, type ValueNodeStateSpec } from './abstract/ValueNode.ts';
 import type { GeneralParentNode } from './hierarchy.ts';
 import type { EvaluationContext } from './internal-api/EvaluationContext.ts';
-import type { SubscribableDependency } from './internal-api/SubscribableDependency.ts';
 import type { ValidationContext } from './internal-api/ValidationContext.ts';
-import type { ValueContext } from './internal-api/ValueContext.ts';
+import type { ClientReactiveSubmittableValueNode } from './internal-api/submission/ClientReactiveSubmittableValueNode.ts';
 
-export interface ModelValueDefinition extends LeafNodeDefinition {
-	readonly bodyElement: null;
-}
-
-interface ModelValueStateSpec extends DescendantNodeStateSpec<string> {
+interface ModelValueStateSpec<V extends ValueType> extends ValueNodeStateSpec<RuntimeValue<V>> {
 	readonly label: null;
 	readonly hint: null;
-	readonly children: null;
-	readonly value: SimpleAtomicState<string>;
-	readonly valueOptions: null;
 }
 
-export class ModelValue
-	extends DescendantNode<ModelValueDefinition, ModelValueStateSpec, null>
+export class ModelValue<V extends ValueType = ValueType>
+	extends ValueNode<V, ModelValueDefinition<V>, RuntimeValue<V>, RuntimeInputValue<V>>
 	implements
-		ModelValueNode,
+		ModelValueNode<V>,
+		XFormsXPathElement,
 		EvaluationContext,
-		SubscribableDependency,
 		ValidationContext,
-		ValueContext<string>
+		ClientReactiveSubmittableValueNode
 {
-	private readonly validation: SharedValidationState;
-	protected readonly state: SharedNodeState<ModelValueStateSpec>;
+	static from(parent: GeneralParentNode, definition: ModelValueDefinition): AnyModelValue;
+	static from<V extends ValueType>(
+		parent: GeneralParentNode,
+		definition: ModelValueDefinition<V>
+	): ModelValue<V> {
+		return new this(parent, definition);
+	}
+
+	// XFormsXPathElement
+	override readonly [XPathNodeKindKey] = 'element';
 
 	// InstanceNode
-	protected engineState: EngineState<ModelValueStateSpec>;
+	protected readonly state: SharedNodeState<ModelValueStateSpec<V>>;
+	protected readonly engineState: EngineState<ModelValueStateSpec<V>>;
 
 	// ModelValueNode
 	readonly nodeType = 'model-value';
 	readonly appearances = null;
-	readonly currentState: CurrentState<ModelValueStateSpec>;
+	readonly currentState: CurrentState<ModelValueStateSpec<V>>;
 
-	get validationState(): LeafNodeValidationState {
-		return this.validation.currentState;
-	}
-
-	// ValueContext
-	readonly encodeValue = identity<string>;
-	readonly decodeValue = identity<string>;
+	constructor(parent: GeneralParentNode, definition: ModelValueDefinition<V>) {
+		const codec = getSharedValueCodec(definition.valueType);
 
-	constructor(parent: GeneralParentNode, definition: ModelValueDefinition) {
-		super(parent, definition);
+		super(parent, definition, codec);
 
 		const sharedStateOptions = {
 			clientStateFactory: this.engineConfig.stateFactory,
@@ -77,7 +69,8 @@ export class ModelValue
 				hint: null,
 				children: null,
 				valueOptions: null,
-				value: createValueState(this),
+				value: this.valueState,
+				instanceValue: this.getInstanceValue,
 			},
 			sharedStateOptions
 		);
@@ -85,20 +78,20 @@ export class ModelValue
 		this.state = state;
 		this.engineState = state.engineState;
 		this.currentState = state.currentState;
-		this.validation = createValidationState(this, sharedStateOptions);
-	}
-
-	// ValidationContext
-	getViolation(): AnyViolation | null {
-		return this.validation.engineState.violation;
-	}
-
-	isBlank(): boolean {
-		return this.engineState.value === '';
-	}
-
-	// InstanceNode
-	getChildren(): readonly [] {
-		return [];
 	}
 }
+
+export type AnyModelValue =
+	| ModelValue<'barcode'>
+	| ModelValue<'binary'>
+	| ModelValue<'boolean'>
+	| ModelValue<'date'>
+	| ModelValue<'dateTime'>
+	| ModelValue<'decimal'>
+	| ModelValue<'geopoint'>
+	| ModelValue<'geoshape'>
+	| ModelValue<'geotrace'>
+	| ModelValue<'int'>
+	| ModelValue<'intent'>
+	| ModelValue<'string'>
+	| ModelValue<'time'>;

package/src/instance/Note.ts

@@ -1,9 +1,13 @@
 import { UnreachableError } from '@getodk/common/lib/error/UnreachableError.ts';
 import { identity } from '@getodk/common/lib/identity.ts';
+import { XPathNodeKindKey } from '@getodk/xpath';
 import type { Accessor } from 'solid-js';
 import type { NoteNode, NoteNodeAppearances } from '../client/NoteNode.ts';
+import type { SubmissionState } from '../client/submission/SubmissionState.ts';
 import type { TextRange } from '../client/TextRange.ts';
 import type { AnyViolation, LeafNodeValidationState } from '../client/validation.ts';
+import type { XFormsXPathElement } from '../integration/xpath/adapter/XFormsXPathNode.ts';
+import { createLeafNodeSubmissionState } from '../lib/client-reactivity/submission/createLeafNodeSubmissionState.ts';
 import { createNoteReadonlyThunk } from '../lib/reactivity/createNoteReadonlyThunk.ts';
 import { createValueState } from '../lib/reactivity/createValueState.ts';
 import type { CurrentState } from '../lib/reactivity/node-state/createCurrentState.ts';
@@ -21,7 +25,7 @@ import type { DescendantNodeStateSpec } from './abstract/DescendantNode.ts';
 import { DescendantNode } from './abstract/DescendantNode.ts';
 import type { GeneralParentNode } from './hierarchy.ts';
 import type { EvaluationContext } from './internal-api/EvaluationContext.ts';
-import type { SubscribableDependency } from './internal-api/SubscribableDependency.ts';
+import type { ClientReactiveSubmittableLeafNode } from './internal-api/submission/ClientReactiveSubmittableLeafNode.ts';
 import type { ValidationContext } from './internal-api/ValidationContext.ts';
 import type { ValueContext } from './internal-api/ValueContext.ts';
 
@@ -36,19 +40,23 @@ interface NoteStateSpec extends DescendantNodeStateSpec<string> {
 }
 
 export class Note
-	extends DescendantNode<NoteNodeDefinition, NoteStateSpec, null>
+	extends DescendantNode<NoteNodeDefinition, NoteStateSpec, GeneralParentNode, null>
 	implements
 		NoteNode,
+		XFormsXPathElement,
 		EvaluationContext,
-		SubscribableDependency,
 		ValidationContext,
-		ValueContext<string>
+		ValueContext<string>,
+		ClientReactiveSubmittableLeafNode<string>
 {
 	private readonly validation: SharedValidationState;
-	protected readonly state: SharedNodeState<NoteStateSpec>;
+
+	// XFormsXPathElement
+	override readonly [XPathNodeKindKey] = 'element';
 
 	// InstanceNode
-	protected engineState: EngineState<NoteStateSpec>;
+	protected readonly state: SharedNodeState<NoteStateSpec>;
+	protected readonly engineState: EngineState<NoteStateSpec>;
 
 	// NoteNode
 	readonly nodeType = 'note';
@@ -59,9 +67,11 @@ export class Note
 		return this.validation.currentState;
 	}
 
+	readonly submissionState: SubmissionState;
+
 	// ValueContext
+	override readonly contextNode = this;
 	readonly encodeValue = identity<string>;
-
 	readonly decodeValue = identity<string>;
 
 	constructor(parent: GeneralParentNode, definition: NoteNodeDefinition) {
@@ -73,7 +83,7 @@ export class Note
 			clientStateFactory: this.engineConfig.stateFactory,
 		};
 
-		const isReadonly = createNoteReadonlyThunk(this, definition.bind.readonly);
+		const isReadonly = createNoteReadonlyThunk(this, definition);
 		const noteTextComputation = createNoteText(this, definition.noteTextDefinition);
 
 		let noteText: ComputedNoteText;
@@ -124,6 +134,12 @@ export class Note
 		this.engineState = state.engineState;
 		this.currentState = state.currentState;
 		this.validation = createValidationState(this, sharedStateOptions);
+		this.submissionState = createLeafNodeSubmissionState(this);
+	}
+
+	// XFormsXPathElement
+	override getXPathValue(): string {
+		return this.engineState.value;
 	}
 
 	// ValidationContext

package/src/instance/PrimaryInstance.ts

@@ -0,0 +1,244 @@
+import { XPathNodeKindKey } from '@getodk/xpath';
+import type { Accessor } from 'solid-js';
+import { createSignal } from 'solid-js';
+import type { ActiveLanguage, FormLanguage, FormLanguages } from '../client/FormLanguage.ts';
+import type { FormNodeID } from '../client/identity.ts';
+import type { RootNode } from '../client/RootNode.ts';
+import type {
+	SubmissionChunkedType,
+	SubmissionOptions,
+} from '../client/submission/SubmissionOptions.ts';
+import type { SubmissionResult } from '../client/submission/SubmissionResult.ts';
+import type { SubmissionState } from '../client/submission/SubmissionState.ts';
+import type { AncestorNodeValidationState } from '../client/validation.ts';
+import type { XFormsXPathDocument } from '../integration/xpath/adapter/XFormsXPathNode.ts';
+import { EngineXPathEvaluator } from '../integration/xpath/EngineXPathEvaluator.ts';
+import { createInstanceSubmissionState } from '../lib/client-reactivity/submission/createInstanceSubmissionState.ts';
+import { prepareSubmission } from '../lib/client-reactivity/submission/prepareSubmission.ts';
+import { createChildrenState } from '../lib/reactivity/createChildrenState.ts';
+import { createTranslationState } from '../lib/reactivity/createTranslationState.ts';
+import type { MaterializedChildren } from '../lib/reactivity/materializeCurrentStateChildren.ts';
+import { materializeCurrentStateChildren } from '../lib/reactivity/materializeCurrentStateChildren.ts';
+import type { CurrentState } from '../lib/reactivity/node-state/createCurrentState.ts';
+import type { EngineState } from '../lib/reactivity/node-state/createEngineState.ts';
+import type { SharedNodeState } from '../lib/reactivity/node-state/createSharedNodeState.ts';
+import { createSharedNodeState } from '../lib/reactivity/node-state/createSharedNodeState.ts';
+import type { ReactiveScope } from '../lib/reactivity/scope.ts';
+import type { SimpleAtomicStateSetter } from '../lib/reactivity/types.ts';
+import type { BodyClassList } from '../parse/body/BodyDefinition.ts';
+import type { ModelDefinition } from '../parse/model/ModelDefinition.ts';
+import type { RootDefinition } from '../parse/model/RootDefinition.ts';
+import type { SecondaryInstancesDefinition } from '../parse/model/SecondaryInstance/SecondaryInstancesDefinition.ts';
+import { InstanceNode } from './abstract/InstanceNode.ts';
+import type { EvaluationContext } from './internal-api/EvaluationContext.ts';
+import type { InstanceConfig } from './internal-api/InstanceConfig.ts';
+import type { PrimaryInstanceDocument } from './internal-api/PrimaryInstanceDocument.ts';
+import type { ClientReactiveSubmittableInstance } from './internal-api/submission/ClientReactiveSubmittableInstance.ts';
+import type { TranslationContext } from './internal-api/TranslationContext.ts';
+import { Root } from './Root.ts';
+
+/**
+ * As specified by {@link | XPath 1.0}:
+ *
+ * > A `/` by itself selects the root node of the document containing the
+ * > context node.
+ *
+ * Important note: "root node" here references the same semantics currently
+ * represented by `@getodk/xpath` as {@link XPathDocument}. It is an infortunate
+ * historical mistake that our internal representation of a primary instance has
+ * conflated the same "root" term to represent the "document element" with the
+ * same semantic name.
+ *
+ * {@link PrimaryInstance} exists specifically to provide XPath document
+ * semantics. At time of writing, it is expected that every XPath evaluation
+ * will be performed with a context node either:
+ *
+ * - somewhere in this primary instance document's hierarchy; or
+ * - in a related subtree where the primary instance document is still
+ *   semantically represented as the context root node
+ */
+const PRIMARY_INSTANCE_REFERENCE = '/';
+
+interface PrimaryInstanceStateSpec {
+	readonly reference: string;
+	readonly readonly: boolean;
+	readonly relevant: boolean;
+	readonly required: boolean;
+	readonly label: null;
+	readonly hint: null;
+	readonly children: Accessor<readonly FormNodeID[]>;
+	readonly valueOptions: null;
+	readonly value: null;
+
+	// Root-specific
+	readonly activeLanguage: Accessor<ActiveLanguage>;
+}
+
+export class PrimaryInstance
+	extends InstanceNode<RootDefinition, PrimaryInstanceStateSpec, null, Root>
+	implements
+		PrimaryInstanceDocument,
+		XFormsXPathDocument,
+		TranslationContext,
+		EvaluationContext,
+		ClientReactiveSubmittableInstance
+{
+	// InstanceNode
+	protected readonly state: SharedNodeState<PrimaryInstanceStateSpec>;
+	protected readonly engineState: EngineState<PrimaryInstanceStateSpec>;
+	readonly getChildren: Accessor<readonly Root[]>;
+
+	readonly hasReadonlyAncestor = () => false;
+	readonly isReadonly = () => false;
+	readonly hasNonRelevantAncestor = () => false;
+	readonly isRelevant = () => true;
+
+	// TranslationContext (support)
+	private readonly setActiveLanguage: SimpleAtomicStateSetter<FormLanguage>;
+
+	// XFormsXPathDocument
+	readonly [XPathNodeKindKey] = 'document';
+
+	// PrimaryInstanceDocument, ClientReactiveSubmittableInstance
+	readonly nodeType = 'primary-instance';
+	readonly appearances = null;
+	readonly classes: BodyClassList;
+	readonly root: Root;
+	readonly currentState: MaterializedChildren<CurrentState<PrimaryInstanceStateSpec>, Root>;
+	readonly validationState: AncestorNodeValidationState;
+	readonly submissionState: SubmissionState;
+	readonly languages: FormLanguages;
+
+	// TranslationContext (+ EvaluationContext)
+	readonly getActiveLanguage: Accessor<ActiveLanguage>;
+
+	// EvaluationContext
+	readonly isAttached: Accessor<boolean>;
+	readonly evaluator: EngineXPathEvaluator;
+	override readonly contextNode = this;
+
+	constructor(
+		scope: ReactiveScope,
+		model: ModelDefinition,
+		secondaryInstances: SecondaryInstancesDefinition,
+		engineConfig: InstanceConfig
+	) {
+		const { root: definition } = model;
+
+		super(engineConfig, null, definition, {
+			scope,
+			computeReference: () => PRIMARY_INSTANCE_REFERENCE,
+		});
+
+		const [isAttached, setIsAttached] = createSignal(false);
+
+		this.isAttached = isAttached;
+
+		const evaluator = new EngineXPathEvaluator({
+			rootNode: this,
+			itextTranslationsByLanguage: model.itextTranslations,
+			secondaryInstancesById: secondaryInstances,
+		});
+
+		const { languages, getActiveLanguage, setActiveLanguage } = createTranslationState(
+			scope,
+			evaluator
+		);
+
+		this.languages = languages;
+		this.getActiveLanguage = getActiveLanguage;
+		this.setActiveLanguage = setActiveLanguage;
+
+		this.evaluator = evaluator;
+		this.classes = definition.classes;
+
+		const childrenState = createChildrenState<this, Root>(this);
+
+		this.getChildren = childrenState.getChildren;
+
+		const stateSpec: PrimaryInstanceStateSpec = {
+			activeLanguage: getActiveLanguage,
+			reference: PRIMARY_INSTANCE_REFERENCE,
+			label: null,
+			hint: null,
+			readonly: false,
+			relevant: true,
+			required: false,
+			valueOptions: null,
+			value: null,
+			children: childrenState.childIds,
+		};
+
+		const state = createSharedNodeState(scope, stateSpec, {
+			clientStateFactory: engineConfig.stateFactory,
+		});
+
+		this.state = state;
+		this.engineState = state.engineState;
+		this.currentState = materializeCurrentStateChildren(scope, state.currentState, childrenState);
+
+		const root = new Root(this);
+
+		this.root = root;
+
+		this.validationState = {
+			get violations() {
+				return root.validationState.violations;
+			},
+		};
+		this.submissionState = createInstanceSubmissionState(this);
+
+		childrenState.setChildren([root]);
+		setIsAttached(true);
+	}
+
+	// PrimaryInstanceDocument
+	/**
+	 * @todo Note that this method's signature is intentionally derived from
+	 * {@link RootNode.setLanguage}, but its return type differs! The design
+	 * intent of returning {@link RootNode} from all of the client-facing state
+	 * setter methods has proven… interesting philosophically. But nothing
+	 * downstream has availed itself of that philosophy, and otherwise it's not
+	 * particularly pragmatic or ergonomic (internally or for clients alike).
+	 *
+	 * Since this class is (currently) engine-internal, this seems like an
+	 * excellent place to start a discussion around what we want longer term for
+	 * state setter signatures in _client-facing_ APIs. As a first pass, it seems
+	 * reasonable to borrow the idiomatic convention of returning the effective
+	 * value assigned by the setter.
+	 *
+	 * @see
+	 * {@link https://github.com/getodk/web-forms/issues/45#issuecomment-1967932261 | Initial read interface design between engine and UI - design summary comment}
+	 * (and some of the comments leading up to it) for background on the
+	 * philosophical reasoning behind the existing signature convention.
+	 */
+	setLanguage(language: FormLanguage): FormLanguage {
+		const availableFormLanguage = this.languages.find(
+			(formLanguage): formLanguage is FormLanguage => {
+				return (
+					formLanguage.isSyntheticDefault == null && formLanguage.language === language.language
+				);
+			}
+		);
+
+		if (availableFormLanguage == null) {
+			throw new Error(`Language "${language.language}" not available`);
+		}
+
+		this.evaluator.setActiveLanguage(availableFormLanguage.language);
+
+		return this.setActiveLanguage(availableFormLanguage);
+	}
+
+	// PrimaryInstanceDocument, ClientReactiveSubmittableInstance
+	prepareSubmission<ChunkedType extends SubmissionChunkedType = 'monolithic'>(
+		options?: SubmissionOptions<ChunkedType>
+	): Promise<SubmissionResult<ChunkedType>> {
+		const result = prepareSubmission(this, {
+			chunked: (options?.chunked ?? 'monolithic') as ChunkedType,
+			maxSize: options?.maxSize ?? Infinity,
+		});
+
+		return Promise.resolve(result);
+	}
+}