@getodk/xforms-engine 0.14.0 → 0.16.0

package/src/lib/client-reactivity/instance-state/createTemplatedNodeInstanceState.ts

@@ -1,11 +1,7 @@
 import type { InstanceState } from '../../../client/serialization/InstanceState.ts';
-import { TemplatedNodeAttributeSerializationError } from '../../../error/TemplatedNodeAttributeSerializationError.ts';
 import type { ClientReactiveSerializableTemplatedNode } from '../../../instance/internal-api/serialization/ClientReactiveSerializableTemplatedNode.ts';
 import { serializeParentElementXML } from '../../xml-serialization.ts';
 
-/**
- * @see {@link TemplatedNodeAttributeSerializationError}
- */
 export const createTemplatedNodeInstanceState = (
 	node: ClientReactiveSerializableTemplatedNode
 ): InstanceState => {
@@ -15,17 +11,11 @@ export const createTemplatedNodeInstanceState = (
 				return '';
 			}
 
-			const serializedChildren = node.currentState.children.map((child) => {
-				return child.instanceState.instanceXML;
-			});
-
-			const { attributes } = node.currentState;
-
-			if (attributes != null) {
-				throw new TemplatedNodeAttributeSerializationError();
-			}
-
-			return serializeParentElementXML(node.definition.qualifiedName, serializedChildren);
+			return serializeParentElementXML(
+				node.definition.qualifiedName,
+				node.currentState.children,
+				node.currentState.attributes
+			);
 		},
 	};
 };

package/src/lib/client-reactivity/instance-state/createValueNodeInstanceState.ts

@@ -14,8 +14,9 @@ export const createValueNodeInstanceState = (
 			}
 
 			const xmlValue = escapeXMLText(node.currentState.instanceValue);
+			const attributes = node.currentState.attributes;
 
-			return serializeLeafElementXML(qualifiedName, xmlValue);
+			return serializeLeafElementXML(qualifiedName, xmlValue, attributes);
 		},
 	};
 };

package/src/lib/client-reactivity/instance-state/prepareInstancePayload.ts

@@ -208,6 +208,7 @@ export const prepareInstancePayload = <PayloadType extends InstancePayloadType>(
 	instanceRoot: ClientReactiveSerializableInstance,
 	options: PrepareInstancePayloadOptions<PayloadType>
 ): InstancePayload<PayloadType> => {
+	instanceRoot.root.parent.model.triggerXformsRevalidateListeners();
 	const validation = validateInstance(instanceRoot);
 	const submissionMeta = instanceRoot.definition.submission;
 	const instanceFile = new InstanceFile(instanceRoot);

package/src/lib/codecs/NoteCodec.ts

@@ -10,7 +10,7 @@ export type NoteRuntimeValue<V extends ValueType> =
 // prettier-ignore
 export type NoteInputValue<V extends ValueType> =
 	| RuntimeInputValue<V>
-	| RuntimeValue<V>
+	| RuntimeValue<V> // eslint-disable-line @typescript-eslint/no-redundant-type-constituents
 	| null;
 
 export class NoteCodec<V extends ValueType> extends ValueCodec<

package/src/lib/codecs/items/SingleValueItemCodec.ts

@@ -12,9 +12,7 @@ export type SingleValueSelectRuntimeValues =
  * @see {@link encodeValueFactory}
  */
 // prettier-ignore
-type SingleValueSelectCodecValues =
-	| SingleValueSelectRuntimeValues
-	| readonly string[];
+type SingleValueSelectCodecValues = readonly string[];
 
 /**
  * @todo This is more permissive than it should be, allowing an array of any

package/src/lib/names/NamespaceDeclarationMap.ts

@@ -11,7 +11,7 @@ type NamedNodeDefinitionMap = ReadonlyMap<QualifiedName, NamedNodeDefinition>;
 export interface NamedSubtreeDefinition extends NamedNodeDefinition {
 	readonly namespaceDeclarations: NamespaceDeclarationMap;
 	readonly parent: NamedSubtreeDefinition | null;
-	readonly attributes?: NamedNodeDefinitionMap;
+	readonly attributes: NamedNodeDefinitionMap | null;
 }
 
 /**

package/src/lib/reactivity/createAttributeState.ts

@@ -0,0 +1,51 @@
+import type { Accessor, Setter, Signal } from 'solid-js';
+import { createSignal } from 'solid-js';
+import type { Attribute } from '../../instance/Attribute.ts';
+import type { ReactiveScope } from './scope.ts';
+
+export interface AttributeState {
+	readonly attributes: Signal<readonly Attribute[]>;
+	readonly getAttributes: Accessor<readonly Attribute[]>;
+	readonly setAttributes: Setter<readonly Attribute[]>;
+}
+
+/**
+ * Creates attributes state suitable for all node types
+ *
+ * The produced {@link AttributeState.attributes} (and its get/set convenience
+ * methods) signal is intended to be used to store the engine's attribute state,
+ * and update that state when appropriate.
+ */
+export const createAttributeState = (scope: ReactiveScope): AttributeState => {
+	return scope.runTask(() => {
+		const baseState = createSignal<readonly Attribute[]>([]);
+		const [getAttributes, baseSetAttributes] = baseState;
+
+		type AttributeSetterCallback = (prev: readonly Attribute[]) => readonly Attribute[];
+		type AttributeOrSetterCallback = AttributeSetterCallback | readonly Attribute[];
+
+		const setAttributes: Setter<readonly Attribute[]> = (
+			valueOrSetterCallback: AttributeOrSetterCallback
+		) => {
+			let setterCallback: AttributeSetterCallback;
+
+			if (typeof valueOrSetterCallback === 'function') {
+				setterCallback = valueOrSetterCallback;
+			} else {
+				setterCallback = (_) => valueOrSetterCallback;
+			}
+
+			return baseSetAttributes((prev) => {
+				return setterCallback(prev);
+			});
+		};
+
+		const attributes: Signal<readonly Attribute[]> = [getAttributes, setAttributes];
+
+		return {
+			attributes,
+			getAttributes,
+			setAttributes,
+		};
+	});
+};

package/src/lib/reactivity/createInstanceValueState.ts

@@ -1,24 +1,35 @@
 import type { Signal } from 'solid-js';
 import { createComputed, createMemo, createSignal, untrack } from 'solid-js';
+import type { AttributeContext } from '../../instance/internal-api/AttributeContext.ts';
 import type { InstanceValueContext } from '../../instance/internal-api/InstanceValueContext.ts';
+import { ActionComputationExpression } from '../../parse/expression/ActionComputationExpression.ts';
 import type { BindComputationExpression } from '../../parse/expression/BindComputationExpression.ts';
+import { ActionDefinition } from '../../parse/model/ActionDefinition.ts';
+import type { AnyBindPreloadDefinition } from '../../parse/model/BindPreloadDefinition.ts';
+import { XFORM_EVENT } from '../../parse/model/Event.ts';
 import { createComputedExpression } from './createComputedExpression.ts';
 import type { SimpleAtomicState, SimpleAtomicStateSetter } from './types.ts';
 
-const isInstanceFirstLoad = (context: InstanceValueContext) => {
+const REPEAT_INDEX_REGEX = /([^[]*)(\[[0-9]+\])/g;
+
+type ValueContext = AttributeContext | InstanceValueContext;
+
+const isInstanceFirstLoad = (context: ValueContext) => {
 	return context.rootDocument.initializationMode === 'create';
 };
 
+const isAddingRepeatChild = (context: ValueContext) => {
+	return context.rootDocument.isAttached();
+};
+
 /**
  * Special case, does not correspond to any event.
- *
- * @see {@link shouldPreloadUID}
  */
-const isEditInitialLoad = (context: InstanceValueContext) => {
+const isEditInitialLoad = (context: ValueContext) => {
 	return context.rootDocument.initializationMode === 'edit';
 };
 
-const getInitialValue = (context: InstanceValueContext): string => {
+const getInitialValue = (context: ValueContext): string => {
 	const sourceNode = context.instanceNode ?? context.definition.template;
 
 	return context.decodeInstanceValue(sourceNode.value);
@@ -36,7 +47,7 @@ type RelevantValueState = SimpleAtomicState<string>;
  *   node/context's relevance is restored
  */
 const createRelevantValueState = (
-	context: InstanceValueContext,
+	context: ValueContext,
 	baseValueState: BaseValueState
 ): RelevantValueState => {
 	return context.scope.runTask(() => {
@@ -59,7 +70,7 @@ const createRelevantValueState = (
  * (client/user) writes when the field is in a `readonly` state.
  */
 const guardDownstreamReadonlyWrites = (
-	context: InstanceValueContext,
+	context: ValueContext,
 	baseState: SimpleAtomicState<string>
 ): SimpleAtomicState<string> => {
 	const { readonly } = context.definition.bind;
@@ -83,47 +94,86 @@ const guardDownstreamReadonlyWrites = (
 	return [getValue, setValue];
 };
 
-/**
- * Per {@link https://getodk.github.io/xforms-spec/#preload-attributes:~:text=concatenation%20of%20%E2%80%98uuid%3A%E2%80%99%20and%20uuid()}
- */
-const PRELOAD_UID_EXPRESSION = 'concat("uuid:", uuid())';
-
 /**
  * @todo It feels increasingly awkward to keep piling up preload stuff here, but it won't stay that way for long. In the meantime, this seems like the best way to express the cases where `preload="uid"` should be effective, i.e.:
  *
  * - When an instance is first loaded ({@link isInstanceFirstLoad})
  * - When an instance is initially loaded for editing ({@link isEditInitialLoad})
  */
-const shouldPreloadUID = (context: InstanceValueContext) => {
+const isLoading = (context: ValueContext) => {
 	return isInstanceFirstLoad(context) || isEditInitialLoad(context);
 };
 
-/**
- * @todo This is a temporary one-off, until we support the full range of
- * {@link https://getodk.github.io/xforms-spec/#preload-attributes | preloads}.
- *
- * @todo ALSO, IMPORTANTLY(!): the **call site** for this function is
- * semantically where we would expect to trigger a
- * {@link https://getodk.github.io/xforms-spec/#event:odk-instance-first-load | odk-instance-first-load event},
- * _and compute_ preloads semantically associated with that event.
- */
-const setPreloadUIDValue = (
-	context: InstanceValueContext,
-	valueState: RelevantValueState
-): void => {
+const setValueIfPreloadDefined = (
+	context: ValueContext,
+	setValue: SimpleAtomicStateSetter<string>,
+	preload: AnyBindPreloadDefinition
+) => {
+	const value = preload.getValue(context);
+	if (value) {
+		setValue(value);
+	}
+};
+
+const postloadValue = (
+	context: ValueContext,
+	setValue: SimpleAtomicStateSetter<string>,
+	preload: AnyBindPreloadDefinition
+) => {
+	const ref = context.contextReference();
+	context.definition.model.registerXformsRevalidateListener(ref, () => {
+		setValueIfPreloadDefined(context, setValue, preload);
+	});
+};
+
+const preloadValue = (context: ValueContext, setValue: SimpleAtomicStateSetter<string>): void => {
 	const { preload } = context.definition.bind;
+	if (!preload) {
+		return;
+	}
 
-	if (preload?.type !== 'uid' || !shouldPreloadUID(context)) {
+	if (preload.event === XFORM_EVENT.xformsRevalidate) {
+		postloadValue(context, setValue, preload);
 		return;
 	}
 
-	const preloadUIDValue = context.evaluator.evaluateString(PRELOAD_UID_EXPRESSION, {
+	if (isLoading(context)) {
+		setValueIfPreloadDefined(context, setValue, preload);
+	}
+};
+
+const referencesCurrentNode = (context: ValueContext, ref: string): boolean => {
+	const nodes = context.evaluator.evaluateNodes(ref, {
 		contextNode: context.contextNode,
 	});
+	if (nodes.length > 1) {
+		throw new Error(
+			'You are trying to target a repeated field. Currently you may only target a field in a specific repeat instance. XPath nodeset has more than one node.'
+		);
+	}
+	return nodes.includes(context.contextNode);
+};
 
-	const [, setValue] = valueState;
-
-	setValue(preloadUIDValue);
+// Replaces the unbound repeat references in source and ref, with references
+// bound to the repeat instace of the context.
+const bindToRepeatInstance = (
+	context: ValueContext,
+	action: ActionDefinition
+): { source: string | undefined; ref: string } => {
+	let source = action.source;
+	let ref = action.ref;
+	if (source) {
+		const contextRef = context.contextReference();
+		for (const part of contextRef.matchAll(REPEAT_INDEX_REGEX)) {
+			const unbound = part[1] + '/';
+			if (source.includes(unbound)) {
+				const bound = part[0] + '/';
+				source = source.replace(unbound, bound);
+				ref = ref.replace(unbound, bound);
+			}
+		}
+	}
+	return { source, ref };
 };
 
 /**
@@ -131,30 +181,78 @@ const setPreloadUIDValue = (
  * computations to the provided value setter, on initialization and any
  * subsequent reactive update.
  *
- * @see {@link setPreloadUIDValue} for important details about spec ordering of
+ * @see {@link preloadValue} for important details about spec ordering of
  * events and computations.
  */
 const createCalculation = (
-	context: InstanceValueContext,
+	context: ValueContext,
 	setRelevantValue: SimpleAtomicStateSetter<string>,
-	calculateDefinition: BindComputationExpression<'calculate'>
+	computation: ActionComputationExpression<'string'> | BindComputationExpression<'calculate'>
 ): void => {
-	context.scope.runTask(() => {
-		const calculate = createComputedExpression(context, calculateDefinition, {
-			defaultValue: '',
-		});
-
-		createComputed(() => {
-			if (context.isAttached() && context.isRelevant()) {
-				const calculated = calculate();
-				const value = context.decodeInstanceValue(calculated);
+	const calculate = createComputedExpression(context, computation);
+	createComputed(() => {
+		if (context.isAttached() && context.isRelevant()) {
+			const calculated = calculate();
+			const value = context.decodeInstanceValue(calculated);
+			setRelevantValue(value);
+		}
+	});
+};
 
-				setRelevantValue(value);
+const createValueChangedCalculation = (
+	context: ValueContext,
+	setRelevantValue: SimpleAtomicStateSetter<string>,
+	action: ActionDefinition
+): void => {
+	const { source, ref } = bindToRepeatInstance(context, action);
+	if (!source) {
+		// no element to listen to
+		return;
+	}
+	let previous = '';
+	const sourceElementExpression = new ActionComputationExpression('string', source);
+	const calculateValueSource = createComputedExpression(context, sourceElementExpression); // registers listener
+	createComputed(() => {
+		if (context.isAttached() && context.isRelevant()) {
+			const valueSource = calculateValueSource();
+			if (previous !== valueSource) {
+				// only update if value has changed
+				if (referencesCurrentNode(context, ref)) {
+					const calc = context.evaluator.evaluateString(action.computation.expression, context);
+					const value = context.decodeInstanceValue(calc);
+					setRelevantValue(value);
+				}
 			}
-		});
+			previous = valueSource;
+		}
 	});
 };
 
+const registerAction = (
+	context: ValueContext,
+	setValue: SimpleAtomicStateSetter<string>,
+	action: ActionDefinition
+) => {
+	if (action.events.includes(XFORM_EVENT.odkInstanceFirstLoad)) {
+		if (isInstanceFirstLoad(context)) {
+			createCalculation(context, setValue, action.computation);
+		}
+	}
+	if (action.events.includes(XFORM_EVENT.odkInstanceLoad)) {
+		if (!isAddingRepeatChild(context)) {
+			createCalculation(context, setValue, action.computation);
+		}
+	}
+	if (action.events.includes(XFORM_EVENT.odkNewRepeat)) {
+		if (isAddingRepeatChild(context)) {
+			createCalculation(context, setValue, action.computation);
+		}
+	}
+	if (action.events.includes(XFORM_EVENT.xformsValueChanged)) {
+		createValueChangedCalculation(context, setValue, action);
+	}
+};
+
 export type InstanceValueState = SimpleAtomicState<string>;
 
 /**
@@ -168,25 +266,26 @@ export type InstanceValueState = SimpleAtomicState<string>;
  *   nodes defined with one
  * - prevents downstream writes to nodes in a readonly state
  */
-export const createInstanceValueState = (context: InstanceValueContext): InstanceValueState => {
+export const createInstanceValueState = (context: ValueContext): InstanceValueState => {
 	return context.scope.runTask(() => {
 		const initialValue = getInitialValue(context);
 		const baseValueState = createSignal(initialValue);
 		const relevantValueState = createRelevantValueState(context, baseValueState);
 
-		/**
-		 * @see {@link setPreloadUIDValue} for important details about spec ordering of events and computations.
-		 */
-		setPreloadUIDValue(context, relevantValueState);
+		const [, setValue] = relevantValueState;
 
-		const { calculate } = context.definition.bind;
+		preloadValue(context, setValue);
 
+		const { calculate } = context.definition.bind;
 		if (calculate != null) {
-			const [, setValue] = relevantValueState;
-
 			createCalculation(context, setValue, calculate);
 		}
 
+		const action = context.definition.model.actions.get(context.contextReference());
+		if (action) {
+			registerAction(context, setValue, action);
+		}
+
 		return guardDownstreamReadonlyWrites(context, relevantValueState);
 	});
 };

package/src/lib/reactivity/node-state/createSharedNodeState.ts

@@ -13,10 +13,10 @@ import { isComputedPropertySpec, isMutablePropertySpec } from './createSpecified
 // prettier-ignore
 type MutableKeyOf<Spec extends StateSpec> = {
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	[K in string & keyof Spec]: Spec[K] extends MutablePropertySpec<any>
+	[K in Extract<keyof Spec, string>]: Spec[K] extends MutablePropertySpec<any>
 		? K
 		: never;
-}[string & keyof Spec];
+}[Extract<keyof Spec, string>];
 
 type SetEnginePropertyState<Spec extends StateSpec> = <K extends MutableKeyOf<Spec>>(
 	key: K,

package/src/lib/xml-serialization.ts

@@ -1,3 +1,5 @@
+import type { GeneralChildNode } from '../client/hierarchy.ts';
+import type { Attribute } from '../instance/Attribute.ts';
 import type { NamespaceDeclarationMap } from './names/NamespaceDeclarationMap.ts';
 import type { QualifiedName } from './names/QualifiedName.ts';
 
@@ -78,15 +80,6 @@ export const escapeXMLText = <Text extends string>(
 		: (out as EscapedXMLText);
 };
 
-interface SerializableElementAttribute {
-	serializeAttributeXML(): string;
-}
-
-interface ElementXMLSerializationOptions {
-	readonly namespaceDeclarations?: NamespaceDeclarationMap;
-	readonly attributes?: readonly SerializableElementAttribute[];
-}
-
 const serializeElementNamespaceDeclarationXML = (
 	namespaceDeclarations?: NamespaceDeclarationMap
 ): string => {
@@ -103,24 +96,11 @@ const serializeElementNamespaceDeclarationXML = (
 		.join('');
 };
 
-const serializeElementAttributeXML = (
-	attributes?: readonly SerializableElementAttribute[]
-): string => {
-	if (attributes == null) {
-		return '';
-	}
-
-	return attributes
-		.map((attribute) => {
-			return attribute.serializeAttributeXML();
-		})
-		.join('');
-};
-
 const serializeElementXML = (
 	qualifiedName: QualifiedName,
 	children: string,
-	options: ElementXMLSerializationOptions = {}
+	attributes: string,
+	namespaceDeclarations?: NamespaceDeclarationMap
 ): string => {
 	// See JSDoc for the `getPrefixedName` method. If we find we do actually need
 	// custom element (subtree) prefix resolution, we'd uncomment the argument
@@ -133,11 +113,9 @@ const serializeElementXML = (
 	const nodeName = qualifiedName.getPrefixedName(
 		// options.namespaceDeclarations
 	);
-	const namespaceDeclarations = serializeElementNamespaceDeclarationXML(
-		options.namespaceDeclarations
-	);
-	const attributes = serializeElementAttributeXML(options.attributes);
-	const prefix = `<${nodeName}${namespaceDeclarations}${attributes}`;
+	const serializedNamespaceDeclarations =
+		serializeElementNamespaceDeclarationXML(namespaceDeclarations);
+	const prefix = `<${nodeName}${serializedNamespaceDeclarations}${attributes}`;
 
 	if (children === '') {
 		return `${prefix}/>`;
@@ -146,18 +124,44 @@ const serializeElementXML = (
 	return `${prefix}>${children}</${nodeName}>`;
 };
 
+export const serializeAttributeXML = (
+	qualifiedName: QualifiedName,
+	xmlValue: EscapedXMLText
+): string => {
+	const nodeName = qualifiedName.getPrefixedName();
+	return ` ${nodeName}="${xmlValue.normalize()}"`;
+};
+
 export const serializeParentElementXML = (
 	qualifiedName: QualifiedName,
-	serializedChildren: readonly string[],
-	options?: ElementXMLSerializationOptions
+	children: readonly GeneralChildNode[],
+	attributes: readonly Attribute[],
+	namespaceDeclarations?: NamespaceDeclarationMap
 ): string => {
-	return serializeElementXML(qualifiedName, serializedChildren.join(''), options);
+	const serializedChildren = children.map((child) => child.instanceState.instanceXML).join('');
+	const serializedAttributes = attributes
+		.map((attribute) => attribute.instanceState.instanceXML)
+		.join('');
+	return serializeElementXML(
+		qualifiedName,
+		serializedChildren,
+		serializedAttributes,
+		namespaceDeclarations
+	);
 };
 
 export const serializeLeafElementXML = (
 	qualifiedName: QualifiedName,
 	xmlValue: EscapedXMLText,
-	options?: ElementXMLSerializationOptions
+	attributes: readonly Attribute[],
+	namespaceDeclarations?: NamespaceDeclarationMap
 ): string => {
-	return serializeElementXML(qualifiedName, xmlValue.normalize(), options);
+	const serializedAttributes =
+		attributes?.map((attribute) => attribute.instanceState.instanceXML).join('') ?? '';
+	return serializeElementXML(
+		qualifiedName,
+		xmlValue.normalize(),
+		serializedAttributes,
+		namespaceDeclarations
+	);
 };

package/src/parse/XFormDOM.ts

@@ -11,6 +11,7 @@ import type {
 import { DefaultEvaluator } from '@getodk/xpath';
 
 interface DOMBindElement extends KnownAttributeLocalNamedElement<'bind', 'nodeset'> {}
+interface DOMSetValueElement extends KnownAttributeLocalNamedElement<'setvalue', 'event'> {}
 
 const getMetaElement = (primaryInstanceRoot: Element): Element | null => {
 	for (const child of primaryInstanceRoot.children) {
@@ -336,6 +337,7 @@ export class XFormDOM {
 
 	readonly model: Element;
 	readonly binds: readonly DOMBindElement[];
+	readonly setValues: readonly DOMSetValueElement[];
 	readonly primaryInstance: Element;
 	readonly primaryInstanceRoot: Element;
 
@@ -368,6 +370,12 @@ export class XFormDOM {
 				contextNode: model,
 			}
 		);
+		const setValues: readonly DOMSetValueElement[] = evaluator.evaluateNodes<DOMSetValueElement>(
+			'./xf:setvalue[@event]',
+			{
+				contextNode: model,
+			}
+		);
 
 		const instances = evaluator.evaluateNodes<DOMInstanceElement>('./xf:instance', {
 			contextNode: model,
@@ -417,6 +425,7 @@ export class XFormDOM {
 		this.title = title;
 		this.model = model;
 		this.binds = binds;
+		this.setValues = setValues;
 		this.primaryInstance = primaryInstance;
 		this.primaryInstanceRoot = primaryInstanceRoot;
 		this.itextTranslationElements = itextTranslationElements;

package/src/parse/body/GroupElementDefinition.ts

@@ -39,8 +39,8 @@ export class GroupElementDefinition extends BodyElementDefinition<'group'> {
 			return childName !== 'label';
 		});
 
-		this.children = this.body.getChildElementDefinitions(form, this, element, childElements);
 		this.reference = parseNodesetReference(parent, element, 'ref');
+		this.children = this.body.getChildElementDefinitions(form, this, element, childElements);
 		this.appearances = structureElementAppearanceParser.parseFrom(element, 'appearance');
 		this.label = LabelDefinition.forGroup(form, this);
 	}

package/src/parse/body/control/InputControlDefinition.ts

@@ -1,8 +1,8 @@
+import { parseToFloat, parseToInteger } from '../../../lib/number-parsers.ts';
 import type { XFormDefinition } from '../../XFormDefinition.ts';
 import type { InputAppearanceDefinition } from '../appearance/inputAppearanceParser.ts';
 import { inputAppearanceParser } from '../appearance/inputAppearanceParser.ts';
 import type { BodyElementParentContext } from '../BodyDefinition.ts';
-import { parseToFloat, parseToInteger } from '../../../lib/number-parsers.ts';
 import { ControlDefinition } from './ControlDefinition.ts';
 
 export class InputControlDefinition extends ControlDefinition<'input'> {

package/src/parse/expression/ActionComputationExpression.ts

@@ -0,0 +1,12 @@
+import {
+	DependentExpression,
+	type DependentExpressionResultType,
+} from './abstract/DependentExpression.ts';
+
+export class ActionComputationExpression<
+	Type extends DependentExpressionResultType,
+> extends DependentExpression<Type> {
+	constructor(resultType: Type, expression: string) {
+		super(resultType, expression);
+	}
+}