@getodk/xforms-engine 0.14.0 → 0.16.0

package/dist/instance/Attribute.d.ts

@@ -0,0 +1,64 @@
+import { XPathNodeKindKey } from '@getodk/xpath';
+import { Accessor } from 'solid-js';
+import { AttributeNode } from '../client/AttributeNode.ts';
+import { ActiveLanguage, InstanceState, NullValidationState } from '../client/index.ts';
+import { XFormsXPathAttribute } from '../integration/xpath/adapter/XFormsXPathNode.ts';
+import { EngineXPathEvaluator } from '../integration/xpath/EngineXPathEvaluator.ts';
+import { StaticAttribute } from '../integration/xpath/static-dom/StaticAttribute.ts';
+import { RuntimeInputValue, RuntimeValue } from '../lib/codecs/getSharedValueCodec.ts';
+import { RuntimeValueSetter, RuntimeValueState } from '../lib/codecs/ValueCodec.ts';
+import { CurrentState } from '../lib/reactivity/node-state/createCurrentState.ts';
+import { EngineState } from '../lib/reactivity/node-state/createEngineState.ts';
+import { SharedNodeState } from '../lib/reactivity/node-state/createSharedNodeState.ts';
+import { ReactiveScope } from '../lib/reactivity/scope.ts';
+import { SimpleAtomicState } from '../lib/reactivity/types.ts';
+import { AttributeDefinition } from '../parse/model/AttributeDefinition.ts';
+import { AnyChildNode, AnyNode } from './hierarchy.ts';
+import { AttributeContext } from './internal-api/AttributeContext.ts';
+import { InstanceConfig } from './internal-api/InstanceConfig.ts';
+import { DecodeInstanceValue } from './internal-api/InstanceValueContext.ts';
+import { ClientReactiveSerializableAttributeNode } from './internal-api/serialization/ClientReactiveSerializableAttributeNode.ts';
+import { PrimaryInstance } from './PrimaryInstance.ts';
+import { Root } from './Root.ts';
+export interface AttributeStateSpec {
+    readonly value: SimpleAtomicState<string>;
+    readonly instanceValue: Accessor<string>;
+    readonly relevant: Accessor<boolean>;
+}
+export declare class Attribute implements AttributeNode, ClientReactiveSerializableAttributeNode, AttributeContext, XFormsXPathAttribute {
+    readonly owner: AnyNode;
+    readonly definition: AttributeDefinition;
+    readonly instanceNode: StaticAttribute;
+    readonly [XPathNodeKindKey] = "attribute";
+    protected readonly state: SharedNodeState<AttributeStateSpec>;
+    protected readonly engineState: EngineState<AttributeStateSpec>;
+    readonly validationState: NullValidationState;
+    readonly nodeType = "attribute";
+    readonly currentState: CurrentState<AttributeStateSpec>;
+    readonly instanceState: InstanceState;
+    readonly appearances: null;
+    readonly nodeOptions: null;
+    readonly valueType: string;
+    readonly decodeInstanceValue: DecodeInstanceValue;
+    protected readonly getInstanceValue: Accessor<string>;
+    protected readonly valueState: RuntimeValueState<RuntimeValue<'string'>>;
+    protected readonly setValueState: RuntimeValueSetter<RuntimeInputValue<'string'>>;
+    readonly evaluator: EngineXPathEvaluator;
+    readonly getActiveLanguage: Accessor<ActiveLanguage>;
+    readonly contextNode: AnyNode;
+    readonly scope: ReactiveScope;
+    readonly rootDocument: PrimaryInstance;
+    readonly instanceConfig: InstanceConfig;
+    readonly root: Root;
+    readonly isRelevant: Accessor<boolean>;
+    readonly isAttached: Accessor<boolean>;
+    readonly isReadonly: Accessor<boolean>;
+    readonly hasReadonlyAncestor: Accessor<boolean>;
+    readonly hasNonRelevantAncestor: Accessor<boolean>;
+    readonly contextReference: () => string;
+    constructor(owner: AnyNode, definition: AttributeDefinition, instanceNode: StaticAttribute);
+    setValue(value: string): Root;
+    getChildren(): readonly [];
+    getXPathChildNodes(): readonly AnyChildNode[];
+    getXPathValue(): string;
+}

package/dist/instance/Group.d.ts

@@ -12,6 +12,7 @@ import { CurrentState } from '../lib/reactivity/node-state/createCurrentState.ts
 import { EngineState } from '../lib/reactivity/node-state/createEngineState.ts';
 import { SharedNodeState } from '../lib/reactivity/node-state/createSharedNodeState.ts';
 import { DescendantNodeSharedStateSpec, DescendantNode } from './abstract/DescendantNode.ts';
+import { Attribute } from './Attribute.ts';
 import { GeneralChildNode, GeneralParentNode } from './hierarchy.ts';
 import { EvaluationContext } from './internal-api/EvaluationContext.ts';
 import { ClientReactiveSerializableParentNode } from './internal-api/serialization/ClientReactiveSerializableParentNode.ts';
@@ -19,6 +20,7 @@ interface GroupStateSpec extends DescendantNodeSharedStateSpec {
     readonly label: Accessor<TextRange<'label'> | null>;
     readonly hint: null;
     readonly children: Accessor<readonly FormNodeID[]>;
+    readonly attributes: Accessor<readonly Attribute[]>;
     readonly valueOptions: null;
     readonly value: null;
 }

package/dist/instance/InputControl.d.ts

@@ -10,6 +10,7 @@ import { CurrentState } from '../lib/reactivity/node-state/createCurrentState.ts
 import { EngineState } from '../lib/reactivity/node-state/createEngineState.ts';
 import { SharedNodeState } from '../lib/reactivity/node-state/createSharedNodeState.ts';
 import { ValueNode, ValueNodeStateSpec } from './abstract/ValueNode.ts';
+import { Attribute } from './Attribute.ts';
 import { GeneralParentNode } from './hierarchy.ts';
 import { EvaluationContext } from './internal-api/EvaluationContext.ts';
 import { ClientReactiveSerializableValueNode } from './internal-api/serialization/ClientReactiveSerializableValueNode.ts';
@@ -21,6 +22,7 @@ export type AnyInputDefinition = {
 interface InputControlStateSpec<V extends ValueType> extends ValueNodeStateSpec<RuntimeValue<V>> {
     readonly label: Accessor<TextRange<'label'> | null>;
     readonly hint: Accessor<TextRange<'hint'> | null>;
+    readonly attributes: Accessor<readonly Attribute[]>;
     readonly valueOptions: null;
 }
 export declare class InputControl<V extends ValueType = ValueType> extends ValueNode<V, InputDefinition<V>, RuntimeValue<V>, RuntimeInputValue<V>> implements InputNode<V>, XFormsXPathElement, EvaluationContext, ValidationContext, ClientReactiveSerializableValueNode {

package/dist/instance/PrimaryInstance.d.ts

@@ -21,6 +21,7 @@ import { RootDefinition } from '../parse/model/RootDefinition.ts';
 import { SecondaryInstancesDefinition } from '../parse/model/SecondaryInstance/SecondaryInstancesDefinition.ts';
 import { InstanceNode } from './abstract/InstanceNode.ts';
 import { InstanceAttachmentsState } from './attachments/InstanceAttachmentsState.ts';
+import { Attribute } from './Attribute.ts';
 import { InitialInstanceState } from './input/InitialInstanceState.ts';
 import { EvaluationContext } from './internal-api/EvaluationContext.ts';
 import { InstanceConfig } from './internal-api/InstanceConfig.ts';
@@ -36,6 +37,7 @@ interface PrimaryInstanceStateSpec {
     readonly label: null;
     readonly hint: null;
     readonly children: Accessor<readonly FormNodeID[]>;
+    readonly attributes: Accessor<readonly Attribute[]>;
     readonly valueOptions: null;
     readonly value: null;
     readonly activeLanguage: Accessor<ActiveLanguage>;

package/dist/instance/Root.d.ts

@@ -15,6 +15,7 @@ import { SharedNodeState } from '../lib/reactivity/node-state/createSharedNodeSt
 import { BodyClassList } from '../parse/body/BodyDefinition.ts';
 import { RootDefinition } from '../parse/model/RootDefinition.ts';
 import { DescendantNode } from './abstract/DescendantNode.ts';
+import { Attribute } from './Attribute.ts';
 import { GeneralChildNode } from './hierarchy.ts';
 import { EvaluationContext } from './internal-api/EvaluationContext.ts';
 import { ClientReactiveSerializableParentNode } from './internal-api/serialization/ClientReactiveSerializableParentNode.ts';
@@ -28,6 +29,7 @@ interface RootStateSpec {
     readonly label: null;
     readonly hint: null;
     readonly children: Accessor<readonly FormNodeID[]>;
+    readonly attributes: Accessor<readonly Attribute[]>;
     readonly valueOptions: null;
     readonly value: null;
     readonly activeLanguage: Accessor<ActiveLanguage>;

package/dist/instance/UploadControl.d.ts

@@ -12,6 +12,7 @@ import { EngineState } from '../lib/reactivity/node-state/createEngineState.ts';
 import { SharedNodeState } from '../lib/reactivity/node-state/createSharedNodeState.ts';
 import { SimpleAtomicState } from '../lib/reactivity/types.ts';
 import { UnknownAppearanceDefinition } from '../parse/body/appearance/unknownAppearanceParser.ts';
+import { Attribute } from './Attribute.ts';
 import { Root } from './Root.ts';
 import { DescendantNodeStateSpec, DescendantNode } from './abstract/DescendantNode.ts';
 import { InstanceAttachmentRuntimeValue } from './attachments/InstanceAttachment.ts';
@@ -28,6 +29,7 @@ interface UploadControlStateSpec extends DescendantNodeStateSpec<InstanceAttachm
     readonly label: Accessor<TextRange<'label'> | null>;
     readonly hint: Accessor<TextRange<'hint'> | null>;
     readonly children: null;
+    readonly attributes: Accessor<readonly Attribute[]>;
     readonly valueOptions: null;
     readonly value: SimpleAtomicState<InstanceAttachmentRuntimeValue>;
     readonly instanceValue: Accessor<InstanceAttachmentFileName>;

package/dist/instance/abstract/InstanceNode.d.ts

@@ -10,6 +10,7 @@ import { ActiveLanguage, TextRange } from '../../index.ts';
 import { EngineXPathEvaluator } from '../../integration/xpath/EngineXPathEvaluator.ts';
 import { XFormsXPathPrimaryInstanceNode, XFormsXPathPrimaryInstanceNodeKind } from '../../integration/xpath/adapter/XFormsXPathNode.ts';
 import { PrimaryInstanceXPathNode } from '../../integration/xpath/adapter/kind.ts';
+import { StaticAttribute } from '../../integration/xpath/static-dom/StaticAttribute.ts';
 import { StaticDocument } from '../../integration/xpath/static-dom/StaticDocument.ts';
 import { StaticElement } from '../../integration/xpath/static-dom/StaticElement.ts';
 import { CurrentState } from '../../lib/reactivity/node-state/createCurrentState.ts';
@@ -18,6 +19,7 @@ import { SharedNodeState } from '../../lib/reactivity/node-state/createSharedNod
 import { ReactiveScope } from '../../lib/reactivity/scope.ts';
 import { SimpleAtomicState } from '../../lib/reactivity/types.ts';
 import { AnyNodeDefinition } from '../../parse/model/NodeDefinition.ts';
+import { Attribute } from '../Attribute.ts';
 import { PrimaryInstance } from '../PrimaryInstance.ts';
 import { Root } from '../Root.ts';
 import { AnyChildNode, AnyParentNode } from '../hierarchy.ts';
@@ -36,6 +38,7 @@ export interface InstanceNodeStateSpec<Value = never> {
     readonly label: Accessor<TextRange<'label'> | null> | null;
     readonly hint: Accessor<TextRange<'hint'> | null> | null;
     readonly children: Accessor<readonly FormNodeID[]> | null;
+    readonly attributes: Accessor<readonly Attribute[]> | null;
     readonly valueOptions: InstanceNodeValueOptionsStateSpec;
     readonly value: Signal<Value> | SimpleAtomicState<Value> | null;
 }
@@ -59,7 +62,7 @@ export interface InstanceNodeOptions {
 export declare abstract class InstanceNode<Definition extends AnyNodeDefinition, Spec extends InstanceNodeStateSpec<any>, Parent extends AnyParentNode | null, Child extends AnyChildNode | null = null> implements BaseEngineNode, XFormsXPathPrimaryInstanceNode, EvaluationContext {
     readonly instanceConfig: InstanceConfig;
     readonly parent: Parent;
-    readonly instanceNode: StaticDocument | StaticElement | null;
+    readonly instanceNode: StaticAttribute | StaticDocument | StaticElement | null;
     readonly definition: Definition;
     protected abstract readonly state: SharedNodeState<Spec>;
     protected abstract readonly engineState: EngineState<Spec>;
@@ -106,7 +109,7 @@ export declare abstract class InstanceNode<Definition extends AnyNodeDefinition,
      * constrain) their more specific `this` type.
      */
     readonly contextNode: PrimaryInstanceXPathNode;
-    constructor(instanceConfig: InstanceConfig, parent: Parent, instanceNode: StaticDocument | StaticElement | null, definition: Definition, options?: InstanceNodeOptions);
+    constructor(instanceConfig: InstanceConfig, parent: Parent, instanceNode: StaticAttribute | StaticDocument | StaticElement | null, definition: Definition, options?: InstanceNodeOptions);
     /** @package */
     isPrimaryInstance(): this is PrimaryInstance;
     /** @package */

package/dist/instance/abstract/ValueNode.d.ts

@@ -14,6 +14,7 @@ import { SharedNodeState } from '../../lib/reactivity/node-state/createSharedNod
 import { SimpleAtomicState } from '../../lib/reactivity/types.ts';
 import { SharedValidationState } from '../../lib/reactivity/validation/createValidation.ts';
 import { LeafNodeDefinition } from '../../parse/model/LeafNodeDefinition.ts';
+import { Attribute } from '../Attribute.ts';
 import { GeneralParentNode } from '../hierarchy.ts';
 import { EvaluationContext } from '../internal-api/EvaluationContext.ts';
 import { DecodeInstanceValue, InstanceValueContext } from '../internal-api/InstanceValueContext.ts';
@@ -23,6 +24,7 @@ import { DescendantNodeStateSpec, DescendantNode } from './DescendantNode.ts';
 export type ValueNodeDefinition<V extends ValueType> = LeafNodeDefinition<V>;
 export interface ValueNodeStateSpec<RuntimeValue> extends DescendantNodeStateSpec<RuntimeValue> {
     readonly children: null;
+    readonly attributes: Accessor<readonly Attribute[]>;
     readonly value: SimpleAtomicState<RuntimeValue>;
     readonly instanceValue: Accessor<string>;
 }

package/dist/instance/attachments/buildAttributes.d.ts

@@ -0,0 +1,7 @@
+import { Attribute } from '../Attribute';
+import { AnyNode } from '../hierarchy.ts';
+import { InputControl } from '../InputControl.ts';
+import { ModelValue } from '../ModelValue.ts';
+import { Note } from '../Note.ts';
+import { RangeControl } from '../RangeControl.ts';
+export declare function buildAttributes(owner: AnyNode | InputControl<any> | ModelValue<any> | Note<any> | RangeControl<any>): Attribute[];

package/dist/instance/internal-api/AttributeContext.d.ts

@@ -0,0 +1,35 @@
+import { Accessor } from 'solid-js';
+import { FormInstanceInitializationMode } from '../../client/index.ts';
+import { StaticAttribute } from '../../integration/xpath/static-dom/StaticAttribute.ts';
+import { ReactiveScope } from '../../lib/reactivity/scope.ts';
+import { BindComputationExpression } from '../../parse/expression/BindComputationExpression.ts';
+import { AnyBindPreloadDefinition } from '../../parse/model/BindPreloadDefinition.ts';
+import { ModelDefinition } from '../../parse/model/ModelDefinition.ts';
+import { EvaluationContext } from './EvaluationContext.ts';
+import { InstanceConfig } from './InstanceConfig.ts';
+export interface InstanceAttributeContextDocument {
+    readonly initializationMode: FormInstanceInitializationMode;
+    readonly isAttached: Accessor<boolean>;
+}
+export type DecodeInstanceValue = (value: string) => string;
+interface InstanceAttributeContextDefinitionBind {
+    readonly preload: AnyBindPreloadDefinition | null;
+    readonly calculate: BindComputationExpression<'calculate'> | null;
+    readonly readonly: BindComputationExpression<'readonly'>;
+}
+export interface InstanceAttributeContextDefinition {
+    readonly bind: InstanceAttributeContextDefinitionBind;
+    readonly template: StaticAttribute;
+    readonly model: ModelDefinition;
+}
+export interface AttributeContext extends EvaluationContext {
+    readonly scope: ReactiveScope;
+    readonly rootDocument: InstanceAttributeContextDocument;
+    readonly definition: InstanceAttributeContextDefinition;
+    readonly instanceNode: StaticAttribute;
+    readonly instanceConfig: InstanceConfig;
+    readonly decodeInstanceValue: DecodeInstanceValue;
+    isReadonly(): boolean;
+    isRelevant(): boolean;
+}
+export {};

package/dist/instance/internal-api/InstanceConfig.d.ts

@@ -1,4 +1,5 @@
 import { InstanceAttachmentFileNameFactory } from '../../client/attachments/InstanceAttachmentsConfig.ts';
+import { PreloadProperties } from '../../client/form/FormInstanceConfig.ts';
 import { OpaqueReactiveObjectFactory } from '../../client/OpaqueReactiveObjectFactory.ts';
 export interface InstanceConfig {
     /**
@@ -6,4 +7,5 @@ export interface InstanceConfig {
      */
     readonly clientStateFactory: OpaqueReactiveObjectFactory;
     readonly computeAttachmentName: InstanceAttachmentFileNameFactory;
+    readonly preloadProperties: PreloadProperties;
 }

package/dist/instance/internal-api/InstanceValueContext.d.ts

@@ -1,11 +1,15 @@
+import { Accessor } from 'solid-js';
 import { FormInstanceInitializationMode } from '../../client/index.ts';
 import { StaticLeafElement } from '../../integration/xpath/static-dom/StaticElement.ts';
 import { ReactiveScope } from '../../lib/reactivity/scope.ts';
 import { BindComputationExpression } from '../../parse/expression/BindComputationExpression.ts';
 import { AnyBindPreloadDefinition } from '../../parse/model/BindPreloadDefinition.ts';
+import { ModelDefinition } from '../../parse/model/ModelDefinition.ts';
 import { EvaluationContext } from './EvaluationContext.ts';
+import { InstanceConfig } from './InstanceConfig.ts';
 export interface InstanceValueContextDocument {
     readonly initializationMode: FormInstanceInitializationMode;
+    readonly isAttached: Accessor<boolean>;
 }
 export type DecodeInstanceValue = (value: string) => string;
 interface InstanceValueContextDefinitionBind {
@@ -16,12 +20,14 @@ interface InstanceValueContextDefinitionBind {
 export interface InstanceValueContextDefinition {
     readonly bind: InstanceValueContextDefinitionBind;
     readonly template: StaticLeafElement;
+    readonly model: ModelDefinition;
 }
 export interface InstanceValueContext extends EvaluationContext {
     readonly scope: ReactiveScope;
     readonly rootDocument: InstanceValueContextDocument;
     readonly definition: InstanceValueContextDefinition;
     readonly instanceNode: StaticLeafElement | null;
+    readonly instanceConfig: InstanceConfig;
     readonly decodeInstanceValue: DecodeInstanceValue;
     isReadonly(): boolean;
     isRelevant(): boolean;

package/dist/instance/internal-api/serialization/ClientReactiveSerializableAttributeNode.d.ts

@@ -0,0 +1,15 @@
+import { InstanceState } from '../../../client/serialization/InstanceState.ts';
+import { QualifiedName } from '../../../lib/names/QualifiedName.ts';
+export type SerializedInstanceValue = string;
+interface ClientReactiveSerializableAttributeNodeCurrentState {
+    get instanceValue(): SerializedInstanceValue;
+}
+interface ClientReactiveSerializableAttributeNodeDefinition {
+    readonly qualifiedName: QualifiedName;
+}
+export interface ClientReactiveSerializableAttributeNode {
+    readonly definition: ClientReactiveSerializableAttributeNodeDefinition;
+    readonly currentState: ClientReactiveSerializableAttributeNodeCurrentState;
+    readonly instanceState: InstanceState;
+}
+export {};

package/dist/instance/internal-api/serialization/ClientReactiveSerializableParentNode.d.ts

@@ -1,11 +1,13 @@
 import { InstanceState } from '../../../client/serialization/InstanceState.ts';
 import { QualifiedName } from '../../../lib/names/QualifiedName.ts';
+import { Attribute } from '../../Attribute.ts';
 export interface ClientReactiveSerializableChildNode {
     readonly instanceState: InstanceState;
 }
 export interface ClientReactiveSerializableParentNodeCurrentState<Child extends ClientReactiveSerializableChildNode> {
     get relevant(): boolean;
     get children(): readonly Child[];
+    get attributes(): readonly Attribute[];
 }
 export interface ClientReactiveSerializableParentNodeDefinition {
     readonly qualifiedName: QualifiedName;

package/dist/instance/internal-api/serialization/ClientReactiveSerializableTemplatedNode.d.ts

@@ -1,9 +1,9 @@
 import { StaticElement } from '../../../integration/xpath/static-dom/StaticElement.ts';
+import { Attribute } from '../../Attribute.ts';
 import { GeneralChildNode } from '../../hierarchy.ts';
 import { ClientReactiveSerializableParentNode, ClientReactiveSerializableParentNodeCurrentState, ClientReactiveSerializableParentNodeDefinition } from './ClientReactiveSerializableParentNode.ts';
 export interface ClientReactiveSerializableTemplatedNodeCurrentState extends ClientReactiveSerializableParentNodeCurrentState<GeneralChildNode> {
-    /** @see {@link TemplatedNodeAttributeSerializationError} */
-    get attributes(): unknown;
+    get attributes(): readonly Attribute[];
 }
 export interface ClientReactiveSerializableTemplatedNodeDefinition extends ClientReactiveSerializableParentNodeDefinition {
     readonly template: StaticElement;

package/dist/instance/internal-api/serialization/ClientReactiveSerializableValueNode.d.ts

@@ -1,5 +1,7 @@
 import { InstanceState } from '../../../client/serialization/InstanceState.ts';
 import { QualifiedName } from '../../../lib/names/QualifiedName.ts';
+import { BindDefinition } from '../../../parse/model/BindDefinition.ts';
+import { Attribute } from '../../Attribute.ts';
 import { ClientReactiveSerializableChildNode, ClientReactiveSerializableParentNode } from './ClientReactiveSerializableParentNode.ts';
 export type SerializedInstanceValue = string;
 interface ClientReactiveSerializableValueNodeCurrentState {
@@ -8,9 +10,11 @@ interface ClientReactiveSerializableValueNodeCurrentState {
      * @todo Consider moving into {@link InstanceState}
      */
     get instanceValue(): SerializedInstanceValue;
+    get attributes(): readonly Attribute[];
 }
 interface ClientReactiveSerializableValueNodeDefinition {
     readonly qualifiedName: QualifiedName;
+    readonly bind: BindDefinition;
 }
 export interface ClientReactiveSerializableValueNode {
     readonly definition: ClientReactiveSerializableValueNodeDefinition;

package/dist/instance/repeat/BaseRepeatRange.d.ts

@@ -9,6 +9,7 @@ import { TextRange } from '../../client/TextRange.ts';
 import { AncestorNodeValidationState } from '../../client/validation.ts';
 import { XFormsXPathNodeRange, XFormsXPathNodeRangeKind } from '../../integration/xpath/adapter/XFormsXPathNode.ts';
 import { StaticElement } from '../../integration/xpath/static-dom/StaticElement.ts';
+import { AttributeState } from '../../lib/reactivity/createAttributeState.ts';
 import { ChildrenState } from '../../lib/reactivity/createChildrenState.ts';
 import { MaterializedChildren } from '../../lib/reactivity/materializeCurrentStateChildren.ts';
 import { CurrentState } from '../../lib/reactivity/node-state/createCurrentState.ts';
@@ -16,6 +17,7 @@ import { EngineState } from '../../lib/reactivity/node-state/createEngineState.t
 import { SharedNodeState } from '../../lib/reactivity/node-state/createSharedNodeState.ts';
 import { ControlledRepeatDefinition } from '../../parse/model/RepeatDefinition.ts';
 import { DescendantNodeSharedStateSpec, DescendantNode } from '../abstract/DescendantNode.ts';
+import { Attribute } from '../Attribute.ts';
 import { GeneralParentNode } from '../hierarchy.ts';
 import { EvaluationContext } from '../internal-api/EvaluationContext.ts';
 import { ClientReactiveSerializableParentNode } from '../internal-api/serialization/ClientReactiveSerializableParentNode.ts';
@@ -24,12 +26,14 @@ interface RepeatRangeStateSpec extends DescendantNodeSharedStateSpec {
     readonly hint: null;
     readonly label: Accessor<TextRange<'label'> | null>;
     readonly children: Accessor<readonly FormNodeID[]>;
+    readonly attributes: Accessor<readonly Attribute[]>;
     readonly valueOptions: null;
     readonly value: null;
 }
 type BaseRepeatRangeNodeType<Definition extends AnyRepeatDefinition> = Definition extends ControlledRepeatDefinition ? 'repeat-range:controlled' : 'repeat-range:uncontrolled';
 export declare abstract class BaseRepeatRange<Definition extends AnyRepeatDefinition> extends DescendantNode<Definition, RepeatRangeStateSpec, GeneralParentNode, RepeatInstance> implements BaseRepeatRangeNode, XFormsXPathNodeRange, EvaluationContext, ClientReactiveSerializableParentNode<RepeatInstance> {
     protected readonly childrenState: ChildrenState<RepeatInstance>;
+    protected readonly attributeState: AttributeState;
     /**
      * A repeat range doesn't have a corresponding primary instance element of its
      * own. It is represented in the following ways:
@@ -114,5 +118,6 @@ export declare abstract class BaseRepeatRange<Definition extends AnyRepeatDefini
     protected addChildren(afterIndex: number, instanceNodes: readonly StaticElement[]): readonly RepeatInstance[];
     protected removeChildren(startIndex: number, count: number): readonly RepeatInstance[];
     getChildren(): readonly RepeatInstance[];
+    getAttributes(): readonly Attribute[];
 }
 export {};

package/dist/instance/repeat/RepeatInstance.d.ts

@@ -12,14 +12,14 @@ import { CurrentState } from '../../lib/reactivity/node-state/createCurrentState
 import { EngineState } from '../../lib/reactivity/node-state/createEngineState.ts';
 import { SharedNodeState } from '../../lib/reactivity/node-state/createSharedNodeState.ts';
 import { DescendantNodeSharedStateSpec, DescendantNode } from '../abstract/DescendantNode.ts';
+import { Attribute } from '../Attribute.ts';
 import { GeneralChildNode, RepeatRange } from '../hierarchy.ts';
 import { EvaluationContext } from '../internal-api/EvaluationContext.ts';
 import { ClientReactiveSerializableTemplatedNode } from '../internal-api/serialization/ClientReactiveSerializableTemplatedNode.ts';
 interface RepeatInstanceStateSpec extends DescendantNodeSharedStateSpec {
     readonly label: Accessor<TextRange<'label'> | null>;
     readonly hint: null;
-    /** @see {@link TemplatedNodeAttributeSerializationError} */
-    readonly attributes: null;
+    readonly attributes: Accessor<readonly Attribute[]>;
     readonly children: Accessor<readonly FormNodeID[]>;
     readonly valueOptions: null;
     readonly value: null;

package/dist/integration/xpath/adapter/XFormsXPathNode.d.ts

@@ -56,11 +56,11 @@ export type XPathNamedNodeKind = XPathElementKind | XPathAttributeKind;
 export interface XFormsXPathNamedNode extends XFormsXPathNode {
     readonly [XPathNodeKindKey]: XPathNamedNodeKind;
 }
-export type XFormsXPathDescendantNodeKind = XFormsXPathNodeRangeKind | XPathElementKind | XPathTextKind | XPathCommentKind;
+export type XFormsXPathDescendantNodeKind = XFormsXPathNodeRangeKind | XPathElementKind | XPathTextKind | XPathCommentKind | XPathAttributeKind;
 export interface XFormsXPathDescendantNode extends XFormsXPathNode {
     readonly [XPathNodeKindKey]: XFormsXPathDescendantNodeKind;
 }
-export type XFormsXPathPrimaryInstanceNodeKind = XPathDocumentKind | XFormsXPathNodeRangeKind | XPathElementKind | XPathTextKind;
+export type XFormsXPathPrimaryInstanceNodeKind = XPathDocumentKind | XFormsXPathNodeRangeKind | XPathElementKind | XPathAttributeKind | XPathTextKind;
 export interface XFormsXPathPrimaryInstanceNode extends XFormsXPathNode {
     readonly [XPathNodeKindKey]: XFormsXPathPrimaryInstanceNodeKind;
 }

package/dist/lib/client-reactivity/instance-state/createAttributeNodeInstanceState.d.ts

@@ -0,0 +1,3 @@
+import { InstanceState } from '../../../client/serialization/InstanceState.ts';
+import { ClientReactiveSerializableAttributeNode } from '../../../instance/internal-api/serialization/ClientReactiveSerializableAttributeNode.ts';
+export declare const createAttributeNodeInstanceState: (node: ClientReactiveSerializableAttributeNode) => InstanceState;

package/dist/lib/client-reactivity/instance-state/createTemplatedNodeInstanceState.d.ts

@@ -1,6 +1,3 @@
 import { InstanceState } from '../../../client/serialization/InstanceState.ts';
 import { ClientReactiveSerializableTemplatedNode } from '../../../instance/internal-api/serialization/ClientReactiveSerializableTemplatedNode.ts';
-/**
- * @see {@link TemplatedNodeAttributeSerializationError}
- */
 export declare const createTemplatedNodeInstanceState: (node: ClientReactiveSerializableTemplatedNode) => InstanceState;

package/dist/lib/codecs/items/SingleValueItemCodec.d.ts

@@ -4,7 +4,7 @@ export type SingleValueSelectRuntimeValues = readonly [] | readonly [string];
 /**
  * @see {@link encodeValueFactory}
  */
-type SingleValueSelectCodecValues = SingleValueSelectRuntimeValues | readonly string[];
+type SingleValueSelectCodecValues = readonly string[];
 /**
  * Value codec implementation for `<select1>` controls.
  *

package/dist/lib/names/NamespaceDeclarationMap.d.ts

@@ -7,7 +7,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;
 }
 /**
  * @todo This is a bit of a code style experiment! Responsive to

package/dist/lib/reactivity/createAttributeState.d.ts

@@ -0,0 +1,16 @@
+import { Accessor, Setter, Signal } from 'solid-js';
+import { Attribute } from '../../instance/Attribute.ts';
+import { 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 declare const createAttributeState: (scope: ReactiveScope) => AttributeState;

package/dist/lib/reactivity/createInstanceValueState.d.ts

@@ -1,5 +1,7 @@
+import { AttributeContext } from '../../instance/internal-api/AttributeContext.ts';
 import { InstanceValueContext } from '../../instance/internal-api/InstanceValueContext.ts';
 import { SimpleAtomicState } from './types.ts';
+type ValueContext = AttributeContext | InstanceValueContext;
 export type InstanceValueState = SimpleAtomicState<string>;
 /**
  * Provides a consistent interface for value nodes of any type which:
@@ -12,4 +14,5 @@ export type InstanceValueState = SimpleAtomicState<string>;
  *   nodes defined with one
  * - prevents downstream writes to nodes in a readonly state
  */
-export declare const createInstanceValueState: (context: InstanceValueContext) => InstanceValueState;
+export declare const createInstanceValueState: (context: ValueContext) => InstanceValueState;
+export {};

package/dist/lib/reactivity/node-state/createSharedNodeState.d.ts

@@ -5,8 +5,8 @@ import { CurrentState } from './createCurrentState.ts';
 import { EngineState } from './createEngineState.ts';
 import { MutablePropertySpec, SpecifiedState, StateSpec } from './createSpecifiedState.ts';
 type MutableKeyOf<Spec extends StateSpec> = {
-    [K in string & keyof Spec]: Spec[K] extends MutablePropertySpec<any> ? K : never;
-}[string & keyof Spec];
+    [K in Extract<keyof Spec, string>]: Spec[K] extends MutablePropertySpec<any> ? K : never;
+}[Extract<keyof Spec, string>];
 type SetEnginePropertyState<Spec extends StateSpec> = <K extends MutableKeyOf<Spec>>(key: K, newValue: SpecifiedState<Spec>[K]) => SpecifiedState<Spec>[K];
 export interface SharedNodeState<Spec extends StateSpec> {
     readonly spec: Spec;

package/dist/lib/xml-serialization.d.ts

@@ -1,3 +1,5 @@
+import { GeneralChildNode } from '../client/hierarchy.ts';
+import { Attribute } from '../instance/Attribute.ts';
 import { NamespaceDeclarationMap } from './names/NamespaceDeclarationMap.ts';
 import { QualifiedName } from './names/QualifiedName.ts';
 declare const ESCAPED_XML_TEXT_BRAND: unique symbol;
@@ -38,13 +40,7 @@ export type EscapedXMLText = string & {
  *   reconsider this assumption.
  */
 export declare const escapeXMLText: <Text extends string>(text: Exclude<Text, EscapedXMLText>, attr?: boolean) => EscapedXMLText;
-interface SerializableElementAttribute {
-    serializeAttributeXML(): string;
-}
-interface ElementXMLSerializationOptions {
-    readonly namespaceDeclarations?: NamespaceDeclarationMap;
-    readonly attributes?: readonly SerializableElementAttribute[];
-}
-export declare const serializeParentElementXML: (qualifiedName: QualifiedName, serializedChildren: readonly string[], options?: ElementXMLSerializationOptions) => string;
-export declare const serializeLeafElementXML: (qualifiedName: QualifiedName, xmlValue: EscapedXMLText, options?: ElementXMLSerializationOptions) => string;
+export declare const serializeAttributeXML: (qualifiedName: QualifiedName, xmlValue: EscapedXMLText) => string;
+export declare const serializeParentElementXML: (qualifiedName: QualifiedName, children: readonly GeneralChildNode[], attributes: readonly Attribute[], namespaceDeclarations?: NamespaceDeclarationMap) => string;
+export declare const serializeLeafElementXML: (qualifiedName: QualifiedName, xmlValue: EscapedXMLText, attributes: readonly Attribute[], namespaceDeclarations?: NamespaceDeclarationMap) => string;
 export {};

package/dist/parse/XFormDOM.d.ts

@@ -1,6 +1,8 @@
 import { KnownAttributeLocalNamedElement } from '../../../common/types/dom.ts';
 interface DOMBindElement extends KnownAttributeLocalNamedElement<'bind', 'nodeset'> {
 }
+interface DOMSetValueElement extends KnownAttributeLocalNamedElement<'setvalue', 'event'> {
+}
 export interface DOMItextTranslationElement extends KnownAttributeLocalNamedElement<'translation', 'lang'> {
 }
 export interface DOMSecondaryInstanceElement extends KnownAttributeLocalNamedElement<'instance', 'id'> {
@@ -23,13 +25,14 @@ export declare class XFormDOM {
     readonly title: Element;
     readonly model: Element;
     readonly binds: readonly DOMBindElement[];
+    readonly setValues: readonly DOMSetValueElement[];
     readonly primaryInstance: Element;
     readonly primaryInstanceRoot: Element;
     readonly itextTranslationElements: readonly DOMItextTranslationElement[];
     readonly secondaryInstanceElements: readonly DOMSecondaryInstanceElement[];
     readonly body: Element;
     protected constructor(sourceXML: string, options: XFormDOMOptions);
-    toJSON(): Omit<this, "head" | "html" | "title" | "toJSON" | "model" | "primaryInstance" | "primaryInstanceRoot" | "xformDocument"> & {
+    toJSON(): Omit<this, "head" | "html" | "title" | "toJSON" | "primaryInstance" | "model" | "primaryInstanceRoot" | "xformDocument"> & {
         xformDocument: string;
         html: string;
         head: string;

package/dist/parse/expression/ActionComputationExpression.d.ts

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

package/dist/parse/model/ActionDefinition.d.ts

@@ -0,0 +1,15 @@
+import { ActionComputationExpression } from '../expression/ActionComputationExpression.ts';
+import { XFormEvent } from './Event.ts';
+import { ModelDefinition } from './ModelDefinition.ts';
+export declare class ActionDefinition {
+    readonly element: Element;
+    static getRef(model: ModelDefinition, setValueElement: Element): string | null;
+    static getValue(element: Element): string;
+    static isKnownEvent: (event: XFormEvent) => event is XFormEvent;
+    static getEvents(element: Element): XFormEvent[];
+    readonly ref: string;
+    readonly events: XFormEvent[];
+    readonly computation: ActionComputationExpression<'string'>;
+    readonly source: string | undefined;
+    constructor(model: ModelDefinition, element: Element, source?: string);
+}

package/dist/parse/model/AttributeDefinition.d.ts

@@ -0,0 +1,24 @@
+import { StaticAttribute } from '../../integration/xpath/static-dom/StaticAttribute.ts';
+import { NamespaceDeclarationMap, NamedNodeDefinition } from '../../lib/names/NamespaceDeclarationMap.ts';
+import { QualifiedName } from '../../lib/names/QualifiedName.ts';
+import { BindDefinition } from './BindDefinition.ts';
+import { ModelDefinition } from './ModelDefinition.ts';
+import { NodeDefinition } from './NodeDefinition.ts';
+import { RootDefinition } from './RootDefinition.ts';
+export declare class AttributeDefinition extends NodeDefinition<'attribute'> implements NamedNodeDefinition {
+    readonly model: ModelDefinition;
+    readonly template: StaticAttribute;
+    private readonly serializedXML;
+    readonly value: string;
+    readonly type = "attribute";
+    readonly namespaceDeclarations: NamespaceDeclarationMap;
+    readonly bodyElement: null;
+    readonly root: RootDefinition;
+    readonly isTranslated: boolean;
+    readonly parent: null;
+    readonly children: null;
+    readonly attributes: null;
+    readonly qualifiedName: QualifiedName;
+    constructor(model: ModelDefinition, bind: BindDefinition, template: StaticAttribute);
+    serializeAttributeXML(): string;
+}