@getodk/xforms-engine 0.4.0 → 0.6.0

package/src/client/submission/SubmissionResult.ts

@@ -0,0 +1,124 @@
+import type { AnyViolation, DescendantNodeViolationReference } from '../validation.ts';
+import type { SubmissionData } from './SubmissionData.ts';
+import type { SubmissionDefinition } from './SubmissionDefinition.ts';
+import type { SubmissionChunkedType, SubmissionOptions } from './SubmissionOptions.ts';
+
+// prettier-ignore
+export type SubmissionResultStatus =
+	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
+	| 'pending'
+	| 'max-size-exceeded'
+	| 'ready';
+
+// prettier-ignore
+type SubmissionResultData<ChunkedType extends SubmissionChunkedType> = {
+	chunked: readonly [SubmissionData, ...SubmissionData[]];
+	monolithic: SubmissionData;
+}[ChunkedType];
+
+/**
+ * Provides detail about an individual submission attachment {@link File}s which
+ * exceeds the client-specified {@link maxSize} for a
+ * {@link SubmissionResult<'chunked'> | chunked submission result}. Clients may
+ * use this value to provide guidance to users.
+ *
+ * @todo We may want to consider (a) making {@link maxSize} a configuration the
+ * client can provide when initializing a form instance, rather than only on
+ * submission; and then (b) treating a maximum size violation as another kind of
+ * node-level violation. This would go beyond the kinds of validation specified
+ * by ODK XForms, but it would make a lot of _conceptual sense_.
+ *
+ * It would almost certainly be helpful to alert users to violations as the
+ * occur, rather than only at submission time (where they have likely already
+ * moved on). This is something clients can do without engine support, but it
+ * would likely promote good usability patterns if the engine makes it an
+ * obvious and uniform option at the main engine/client entrypoint.
+ *
+ * @todo If we consider the above, we'd want to reframe _this interface_ to
+ * match the shape of other {@link AnyViolation | violations} (adding it as a
+ * member of that union). We'd also likely eliminate
+ * {@link MaxSizeExceededResult} in the process, since
+ * {@link PendingSubmissionResult} would then cover the case.
+ */
+interface MaxSizeViolation {
+	/**
+	 * Specifies the index of
+	 * {@link SubmissionResultData<'chunked'> | chunked submission data} where a
+	 * submission attachment {@link File} exceeds the client-specified
+	 * {@link maxSize}.
+	 */
+	readonly dataIndex: number;
+
+	/**
+	 * Specifies the name of the file which exceeds the client-specified
+	 * {@link maxSize}. This name can also be used as a key to access the
+	 * violating {@link File}/submission attachment, in the {@link SubmissionData}
+	 * at the specified {@link dataIndex}.
+	 */
+	readonly fileName: string;
+
+	/**
+	 * Reflects the client-specified maximum size for each chunk of a
+	 * {@link SubmissionResult<'chunked'> | chunked submission result}.
+	 */
+	readonly maxSize: number;
+
+	/**
+	 * Details the actual size of the violating {@link File}/submission
+	 * attachment. Along with {@link maxSize}. Clients may use the delta between
+	 * this value and {@link maxSize} to provide detailed guidance to users.
+	 */
+	readonly actualSize: number;
+}
+
+// prettier-ignore
+type SubmissionResultViolation =
+	| DescendantNodeViolationReference
+	| MaxSizeViolation;
+
+interface BaseSubmissionResult<ChunkedType extends SubmissionChunkedType> {
+	readonly status: SubmissionResultStatus;
+	readonly definition: SubmissionDefinition;
+	get violations(): readonly SubmissionResultViolation[] | null;
+
+	/**
+	 * Submission data may be chunked according to the
+	 * {@link SubmissionOptions.maxSize | maxSize submission option}
+	 */
+	readonly data: SubmissionResultData<ChunkedType>;
+}
+
+interface PendingSubmissionResult<ChunkedType extends SubmissionChunkedType>
+	extends BaseSubmissionResult<ChunkedType> {
+	readonly status: 'pending';
+	get violations(): readonly DescendantNodeViolationReference[];
+}
+
+interface MaxSizeExceededResult extends BaseSubmissionResult<'chunked'> {
+	readonly status: 'max-size-exceeded';
+	get violations(): readonly MaxSizeViolation[];
+}
+
+interface ReadySubmissionResult<ChunkedType extends SubmissionChunkedType>
+	extends BaseSubmissionResult<ChunkedType> {
+	readonly status: 'ready';
+	get violations(): null;
+}
+
+// prettier-ignore
+type CommonSubmissionResult<ChunkedType extends SubmissionChunkedType> =
+	| PendingSubmissionResult<ChunkedType>
+	| ReadySubmissionResult<ChunkedType>;
+
+// prettier-ignore
+export type ChunkedSubmissionResult =
+	| CommonSubmissionResult<'chunked'>
+	| MaxSizeExceededResult;
+
+export type MonolithicSubmissionResult = CommonSubmissionResult<'monolithic'>;
+
+// prettier-ignore
+export type SubmissionResult<ChunkedType extends SubmissionChunkedType> = {
+	chunked: ChunkedSubmissionResult;
+	monolithic: MonolithicSubmissionResult;
+}[ChunkedType];

package/src/client/submission/SubmissionState.ts

@@ -0,0 +1,14 @@
+import type { RootNode } from '../RootNode.ts';
+
+export interface SubmissionState {
+	/**
+	 * Represents the serialized XML state of a given node, as it will be prepared
+	 * for submission. The value produced in {@link RootNode.submissionState} is
+	 * the same serialization which will be produced for the complete submission.
+	 *
+	 * @todo Note that this particular aspect of the design doesn't yet address
+	 * production of unique file names. As such, this may change as we introduce
+	 * affected data types (and their supporting nodes).
+	 */
+	get submissionXML(): string;
+}

package/src/client/unsupported/UnsupportedControlNode.ts

@@ -1,6 +1,4 @@
 import type { UnknownAppearanceDefinition } from '../../parse/body/appearance/unknownAppearanceParser.ts';
-import type { RangeControlDefinition } from '../../parse/body/control/RangeControlDefinition.ts';
-import type { RankControlDefinition } from '../../parse/body/control/RankControlDefinition.ts';
 import type { UploadControlDefinition } from '../../parse/body/control/UploadControlDefinition.ts';
 import type { LeafNodeDefinition } from '../../parse/model/LeafNodeDefinition.ts';
 import type { BaseNode, BaseNodeState } from '../BaseNode.ts';
@@ -15,10 +13,8 @@ export interface UnsupportedControlNodeState extends BaseNodeState {
 	get value(): unknown;
 }
 
-export type UnsupportedControlElementDefinition =
-	| RangeControlDefinition
-	| RankControlDefinition
-	| UploadControlDefinition;
+// prettier-ignore
+export type UnsupportedControlElementDefinition = UploadControlDefinition;
 
 export interface UnsupportedControlDefinition extends LeafNodeDefinition {
 	readonly bodyElement: UnsupportedControlElementDefinition;

package/src/client/validation.ts

@@ -1,5 +1,5 @@
-import type { NodeID } from '../instance/identity.ts';
 import type { BaseNode, BaseNodeState } from './BaseNode.ts';
+import type { FormNodeID } from './identity.ts';
 import type { OpaqueReactiveObjectFactory } from './OpaqueReactiveObjectFactory.ts';
 import type { RootNode } from './RootNode.ts';
 import type { TextRange } from './TextRange.ts';
@@ -176,7 +176,7 @@ export interface LeafNodeValidationState {
  * each property will be directly computed from the affected node.
  */
 export interface DescendantNodeViolationReference {
-	readonly nodeId: NodeID;
+	readonly nodeId: FormNodeID;
 
 	get reference(): string;
 	get violation(): AnyViolation;

package/src/error/ErrorProductionDesignPendingError.ts

@@ -0,0 +1,6 @@
+/**
+ * Temporary representation of newly introduced error conditions which we may
+ * produce to clients (and beyond). Intentionally a stub pending a more concrete
+ * design and implementation of our approach to producing Result types.
+ */
+export class ErrorProductionDesignPendingError extends Error {}

package/src/error/RankMissingValueError.ts

@@ -0,0 +1,5 @@
+export class RankMissingValueError extends Error {
+	constructor(message: string) {
+		super(message);
+	}
+}

package/src/error/RankValueTypeError.ts

@@ -0,0 +1,13 @@
+import { XFormsSpecViolationError } from './XFormsSpecViolationError.ts';
+import type { RankDefinition } from '../client/RankNode.ts';
+import type { UnsupportedBaseItemValueType } from '../lib/codecs/items/BaseItemCodec.ts';
+
+export class RankValueTypeError extends XFormsSpecViolationError {
+	constructor(definition: RankDefinition<UnsupportedBaseItemValueType>) {
+		const { valueType } = definition;
+
+		super(
+			`Ranks of type ${valueType} are not currently supported. If this functionality would be useful for your form, your feedback is welcome!`
+		);
+	}
+}

package/src/error/SelectValueTypeError.ts

@@ -0,0 +1,22 @@
+import type { SelectDefinition } from '../client/SelectNode.ts';
+import type { UnsupportedBaseItemValueType } from '../lib/codecs/items/BaseItemCodec.ts';
+import { XFormsSpecViolationError } from './XFormsSpecViolationError.ts';
+
+/**
+ * @todo It would be good to have a standardized way to use specific types of
+ * errors as a prompt for feedback. There is currently a feedback link presented
+ * by `@getodk/web-forms`, which is conditionally displayed (condition is
+ * evidently controlled by a
+ * {@link https://vuejs.org/api/sfc-script-setup#defineoptions | Vue component option}).
+ *
+ * @see {@link https://github.com/getodk/web-forms/issues/276}
+ */
+export class SelectValueTypeError extends XFormsSpecViolationError {
+	constructor(definition: SelectDefinition<UnsupportedBaseItemValueType>) {
+		const { valueType } = definition;
+
+		super(
+			`Selects of type ${valueType} are not currently supported. If this functionality would be useful for your form, your feedback is welcome!`
+		);
+	}
+}

package/src/error/ValueTypeInvariantError.ts

@@ -0,0 +1,22 @@
+import type { ValueType } from '../client/ValueType.ts';
+import { ErrorProductionDesignPendingError } from './ErrorProductionDesignPendingError.ts';
+
+/**
+ * Temporary(?) representation of error conditions arising from violation of
+ * invariants specific to {@link valueType}.
+ *
+ * @todo The intent of this distinct subclass of
+ * {@link ErrorProductionDesignPendingError} is to call out cases where we may
+ * want to represent such errors to clients as **validation errors** in the
+ * future. We identified this as probably desirable in the initial work on `int`
+ * and `decimal` value types, but held off on that aspect of implementation to
+ * tame scope.
+ */
+export class ValueTypeInvariantError extends ErrorProductionDesignPendingError {
+	constructor(
+		readonly valueType: ValueType,
+		message: string
+	) {
+		super(`(${valueType}) ${message}`);
+	}
+}

package/src/error/XFormsSpecViolationError.ts

@@ -0,0 +1 @@
+export abstract class XFormsSpecViolationError extends Error {}

package/src/error/XPathFunctionalityError.ts

@@ -0,0 +1,26 @@
+import type { AnyFunction, ExpandUnion } from '@getodk/common/types/helpers.js';
+import type { XPathDOMAdapter, XPathNode } from '@getodk/xpath';
+
+/**
+ * @todo this is general enough to go in `@getodk/common`. Holding off until
+ * it's clear we actually benefit from this particular type gymnastic.
+ */
+// prettier-ignore
+type MethodNameOf<T> = {
+	[K in keyof T]:
+		T[K] extends AnyFunction
+			? K
+			: never;
+}[keyof T];
+
+// prettier-ignore
+export type XPathFunctionalityErrorCategory = ExpandUnion<
+	| MethodNameOf<XPathDOMAdapter<XPathNode>>
+	| 'processing-instruction'
+>;
+
+export abstract class XPathFunctionalityError extends Error {
+	constructor(functionalityMessagePrefix: string, category: XPathFunctionalityErrorCategory) {
+		super(`${functionalityMessagePrefix}${category}`);
+	}
+}

package/src/error/XPathFunctionalityNotSupportedError.ts

@@ -0,0 +1,18 @@
+import type { XPathFunctionalityErrorCategory } from './XPathFunctionalityError.ts';
+import { XPathFunctionalityError } from './XPathFunctionalityError.ts';
+
+type XPathFunctionalityNotSupportedStub = () => never;
+
+export class XPathFunctionalityNotSupportedError extends XPathFunctionalityError {
+	static createStubImplementation(
+		category: XPathFunctionalityErrorCategory
+	): XPathFunctionalityNotSupportedStub {
+		return () => {
+			throw new this(category);
+		};
+	}
+
+	private constructor(category: XPathFunctionalityErrorCategory) {
+		super('XPath functionality not supported: ', category);
+	}
+}

package/src/error/XPathFunctionalityPendingError.ts

@@ -0,0 +1,18 @@
+import type { XPathFunctionalityErrorCategory } from './XPathFunctionalityError.ts';
+import { XPathFunctionalityError } from './XPathFunctionalityError.ts';
+
+type XPathFunctionalityPendingStub = () => never;
+
+export class XPathFunctionalityPendingError extends XPathFunctionalityError {
+	static createStubImplementation(
+		category: XPathFunctionalityErrorCategory
+	): XPathFunctionalityPendingStub {
+		return () => {
+			throw new this(category);
+		};
+	}
+
+	private constructor(category: XPathFunctionalityErrorCategory) {
+		super('XPath functionality pending: ', category);
+	}
+}

package/src/index.ts

@@ -3,6 +3,7 @@ import { initializeForm as engine__initializeForm } from './instance/index.ts';
 
 export const initializeForm: InitializeForm = engine__initializeForm;
 
+export type * from './client/constants.ts';
 export * as constants from './client/constants.ts';
 export type * from './client/EngineConfig.ts';
 export type * from './client/FormLanguage.ts';
@@ -19,29 +20,27 @@ export type {
 	RepeatRangeNode,
 } from './client/hierarchy.ts';
 export type * from './client/index.ts';
+export type * from './client/InputNode.ts';
 export type * from './client/ModelValueNode.ts';
 export type * from './client/NoteNode.ts';
 export type * from './client/OpaqueReactiveObjectFactory.ts';
+export type * from './client/RangeNode.ts';
 export type * from './client/repeat/RepeatInstanceNode.ts';
 export type * from './client/repeat/RepeatRangeControlledNode.ts';
 export type * from './client/repeat/RepeatRangeUncontrolledNode.ts';
+export type * from './client/resources.ts';
 export type * from './client/RootNode.ts';
 export type * from './client/SelectNode.ts';
-export type * from './client/StringNode.ts';
+export type * from './client/submission/SubmissionData.ts';
+export type * from './client/submission/SubmissionDefinition.ts';
+export type * from './client/submission/SubmissionInstanceFile.ts';
+export type * from './client/submission/SubmissionOptions.ts';
+export type * from './client/submission/SubmissionResult.ts';
+export type * from './client/submission/SubmissionState.ts';
 export type * from './client/SubtreeNode.ts';
 export type * from './client/TextRange.ts';
 export type * from './client/TriggerNode.ts';
-export type * from './client/unsupported/RangeNode.ts';
-export type * from './client/unsupported/RankNode.ts';
+export type * from './client/RankNode.ts';
 export type * from './client/unsupported/UploadNode.ts';
 export type * from './client/validation.ts';
-
-// TODO: notwithstanding potential conflicts with parallel work on `web-forms`
-// (former `ui-vue`), these are the last remaining references **outside of
-// `xforms-engine`** to anything besides /client/* and the `initializeForm`
-// entrypoint implementation. We'll refine the various `definition` types in due
-// time.
-export type {
-	AnySelectDefinition,
-	SelectDefinition,
-} from './parse/body/control/select/SelectDefinition.ts';
+export type * from './client/ValueType.ts';

package/src/instance/Group.ts

@@ -1,7 +1,12 @@
+import { XPathNodeKindKey } from '@getodk/xpath';
 import type { Accessor } from 'solid-js';
 import type { GroupDefinition, GroupNode, GroupNodeAppearances } from '../client/GroupNode.ts';
+import type { FormNodeID } from '../client/identity.ts';
+import type { SubmissionState } from '../client/submission/SubmissionState.ts';
 import type { TextRange } from '../client/TextRange.ts';
 import type { AncestorNodeValidationState } from '../client/validation.ts';
+import type { XFormsXPathElement } from '../integration/xpath/adapter/XFormsXPathNode.ts';
+import { createParentNodeSubmissionState } from '../lib/client-reactivity/submission/createParentNodeSubmissionState.ts';
 import type { ChildrenState } from '../lib/reactivity/createChildrenState.ts';
 import { createChildrenState } from '../lib/reactivity/createChildrenState.ts';
 import type { MaterializedChildren } from '../lib/reactivity/materializeCurrentStateChildren.ts';
@@ -16,25 +21,30 @@ import type { DescendantNodeSharedStateSpec } from './abstract/DescendantNode.ts
 import { DescendantNode } from './abstract/DescendantNode.ts';
 import { buildChildren } from './children.ts';
 import type { GeneralChildNode, GeneralParentNode } from './hierarchy.ts';
-import type { NodeID } from './identity.ts';
 import type { EvaluationContext } from './internal-api/EvaluationContext.ts';
-import type { SubscribableDependency } from './internal-api/SubscribableDependency.ts';
+import type { ClientReactiveSubmittableParentNode } from './internal-api/submission/ClientReactiveSubmittableParentNode.ts';
 
 // prettier-ignore
 interface GroupStateSpec extends DescendantNodeSharedStateSpec {
 	readonly label: Accessor<TextRange<'label'> | null>;
 	readonly hint: null;
-	readonly children: Accessor<readonly NodeID[]>;
+	readonly children: Accessor<readonly FormNodeID[]>;
 	readonly valueOptions: null;
 	readonly value: null;
 }
 
 export class Group
-	extends DescendantNode<GroupDefinition, GroupStateSpec, GeneralChildNode>
-	implements GroupNode, EvaluationContext, SubscribableDependency
+	extends DescendantNode<GroupDefinition, GroupStateSpec, GeneralParentNode, GeneralChildNode>
+	implements
+		GroupNode,
+		XFormsXPathElement,
+		EvaluationContext,
+		ClientReactiveSubmittableParentNode<GeneralChildNode>
 {
 	private readonly childrenState: ChildrenState<GeneralChildNode>;
 
+	override readonly [XPathNodeKindKey] = 'element';
+
 	// InstanceNode
 	protected readonly state: SharedNodeState<GroupStateSpec>;
 	protected override engineState: EngineState<GroupStateSpec>;
@@ -42,8 +52,10 @@ export class Group
 	// GroupNode
 	readonly nodeType = 'group';
 	readonly appearances: GroupNodeAppearances;
+	readonly nodeOptions = null;
 	readonly currentState: MaterializedChildren<CurrentState<GroupStateSpec>, GeneralChildNode>;
 	readonly validationState: AncestorNodeValidationState;
+	readonly submissionState: SubmissionState;
 
 	constructor(parent: GeneralParentNode, definition: GroupDefinition) {
 		super(parent, definition);
@@ -85,6 +97,7 @@ export class Group
 
 		childrenState.setChildren(buildChildren(this));
 		this.validationState = createAggregatedViolations(this, sharedStateOptions);
+		this.submissionState = createParentNodeSubmissionState(this);
 	}
 
 	getChildren(): readonly GeneralChildNode[] {

package/src/instance/InputControl.ts

@@ -0,0 +1,159 @@
+import { XPathNodeKindKey } from '@getodk/xpath';
+import type { Accessor } from 'solid-js';
+import type {
+	InputDefinition,
+	InputNode,
+	InputNodeAppearances,
+	InputNodeInputValue,
+	InputNodeOptions,
+} 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 { InputControlDefinition } from '../parse/body/control/InputControlDefinition.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 { ClientReactiveSubmittableValueNode } from './internal-api/submission/ClientReactiveSubmittableValueNode.ts';
+import type { ValidationContext } from './internal-api/ValidationContext.ts';
+import type { Root } from './Root.ts';
+
+export type AnyInputDefinition = {
+	[V in ValueType]: InputDefinition<V>;
+}[ValueType];
+
+const stringInputNodeOptions = (control: InputControlDefinition): InputNodeOptions<'string'> => ({
+	rows: control.rows,
+});
+
+const geoInputNodeOptions = (
+	control: InputControlDefinition
+): InputNodeOptions<'geopoint' | 'geoshape' | 'geotrace'> => ({
+	accuracyThreshold: control.accuracyThreshold,
+	unacceptableAccuracyThreshold: control.unacceptableAccuracyThreshold,
+});
+
+type NodeOptionsFactory<V extends ValueType> = (
+	controlDefinition: InputControlDefinition
+) => InputNodeOptions<V>;
+
+type NodeOptionsFactoryByType = {
+	[V in ValueType]: NodeOptionsFactory<V>;
+};
+
+const nodeOptionsFactoryByType: NodeOptionsFactoryByType = {
+	string: stringInputNodeOptions,
+	int: () => null,
+	boolean: () => null,
+	decimal: () => null,
+	date: () => null,
+	time: () => null,
+	dateTime: () => null,
+	geopoint: geoInputNodeOptions,
+	geotrace: geoInputNodeOptions,
+	geoshape: geoInputNodeOptions,
+	binary: () => null,
+	barcode: () => null,
+	intent: () => null,
+};
+
+interface InputControlStateSpec<V extends ValueType> extends ValueNodeStateSpec<RuntimeValue<V>> {
+	readonly label: Accessor<TextRange<'label'> | null>;
+	readonly hint: Accessor<TextRange<'hint'> | null>;
+	readonly valueOptions: 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 nodeOptions: InputNodeOptions<V>;
+	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;
+		this.nodeOptions = nodeOptionsFactoryByType[definition.valueType](definition.bodyElement);
+
+		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'>;