@getodk/xforms-engine 0.1.0 → 0.2.0

package/dist/instance/Group.d.ts

@@ -1,16 +1,16 @@
-import type { Accessor } from 'solid-js';
-import type { GroupDefinition, GroupNode } from '../client/GroupNode.ts';
-import type { TextRange } from '../index.ts';
-import type { MaterializedChildren } 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 type { DescendantNodeSharedStateSpec } from './abstract/DescendantNode.ts';
-import { DescendantNode } from './abstract/DescendantNode.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 { Accessor } from 'solid-js';
+import { GroupDefinition, GroupNode, GroupNodeAppearances } from '../client/GroupNode.ts';
+import { TextRange } from '../index.ts';
+import { MaterializedChildren } from '../lib/reactivity/materializeCurrentStateChildren.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 { DescendantNodeSharedStateSpec, DescendantNode } from './abstract/DescendantNode.ts';
+import { GeneralChildNode, GeneralParentNode } from './hierarchy.ts';
+import { NodeID } from './identity.ts';
+import { EvaluationContext } from './internal-api/EvaluationContext.ts';
+import { SubscribableDependency } from './internal-api/SubscribableDependency.ts';
+
 interface GroupStateSpec extends DescendantNodeSharedStateSpec {
     readonly label: Accessor<TextRange<'label'> | null>;
     readonly hint: null;
@@ -22,10 +22,10 @@ export declare class Group extends DescendantNode<GroupDefinition, GroupStateSpe
     private readonly childrenState;
     protected readonly state: SharedNodeState<GroupStateSpec>;
     protected engineState: EngineState<GroupStateSpec>;
-    readonly currentState: MaterializedChildren<CurrentState<GroupStateSpec>, GeneralChildNode>;
     readonly nodeType = "group";
+    readonly appearances: GroupNodeAppearances;
+    readonly currentState: MaterializedChildren<CurrentState<GroupStateSpec>, GeneralChildNode>;
     constructor(parent: GeneralParentNode, definition: GroupDefinition);
-    protected computeReference(parent: GeneralParentNode): string;
     getChildren(): readonly GeneralChildNode[];
 }
 export {};

package/dist/instance/RepeatInstance.d.ts

@@ -1,17 +1,17 @@
-import type { Accessor } from 'solid-js';
-import type { RepeatDefinition, RepeatInstanceNode } from '../client/RepeatInstanceNode.ts';
-import type { TextRange } from '../index.ts';
-import type { MaterializedChildren } 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 type { RepeatRange } from './RepeatRange.ts';
-import type { DescendantNodeSharedStateSpec } from './abstract/DescendantNode.ts';
-import { DescendantNode } from './abstract/DescendantNode.ts';
-import type { AnyChildNode, GeneralChildNode } 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 { Accessor } from 'solid-js';
+import { RepeatDefinition, RepeatInstanceNode, RepeatInstanceNodeAppearances } from '../client/RepeatInstanceNode.ts';
+import { TextRange } from '../index.ts';
+import { MaterializedChildren } from '../lib/reactivity/materializeCurrentStateChildren.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 { RepeatRange } from './RepeatRange.ts';
+import { DescendantNodeSharedStateSpec, DescendantNode } from './abstract/DescendantNode.ts';
+import { AnyChildNode, GeneralChildNode } from './hierarchy.ts';
+import { NodeID } from './identity.ts';
+import { EvaluationContext } from './internal-api/EvaluationContext.ts';
+import { SubscribableDependency } from './internal-api/SubscribableDependency.ts';
+
 export type { RepeatDefinition };
 interface RepeatInstanceStateSpec extends DescendantNodeSharedStateSpec {
     readonly label: Accessor<TextRange<'label'> | null>;
@@ -30,10 +30,34 @@ export declare class RepeatInstance extends DescendantNode<RepeatDefinition, Rep
     private readonly currentIndex;
     protected readonly state: SharedNodeState<RepeatInstanceStateSpec>;
     protected engineState: EngineState<RepeatInstanceStateSpec>;
+    /**
+     * @todo Should we special case repeat `readonly` inheritance the same way
+     * we do for `relevant`?
+     *
+     * @see {@link hasNonRelevantAncestor}
+     */
+    readonly hasReadonlyAncestor: Accessor<boolean>;
+    /**
+     * A repeat instance can inherit non-relevance, just like any other node. That
+     * inheritance is derived from the repeat instance's parent node in the
+     * primary instance XML/DOM tree (and would be semantically expected to do so
+     * even if we move away from that implementation detail).
+     *
+     * Since {@link RepeatInstance.parent} is a {@link RepeatRange}, which is a
+     * runtime data model fiction that does not exist in that hierarchy, we pass
+     * this call through, allowing the {@link RepeatRange} to check the actual
+     * primary instance parent node's relevance state.
+     *
+     * @todo Should we apply similar reasoning in {@link hasReadonlyAncestor}?
+     */
+    readonly hasNonRelevantAncestor: Accessor<boolean>;
     readonly nodeType = "repeat-instance";
+    /**
+     * @see {@link RepeatRange.appearances}
+     */
+    readonly appearances: RepeatInstanceNodeAppearances;
     readonly currentState: MaterializedChildren<CurrentState<RepeatInstanceStateSpec>, GeneralChildNode>;
     constructor(parent: RepeatRange, definition: RepeatDefinition, options: RepeatInstanceOptions);
-    protected computeReference(parent: RepeatRange): string;
     protected initializeContextNode(parentContextNode: Element, nodeName: string): Element;
     subscribe(): void;
     getChildren(): readonly GeneralChildNode[];

package/dist/instance/RepeatRange.d.ts

@@ -1,20 +1,19 @@
-import type { Accessor } from 'solid-js';
-import type { RepeatRangeNode } from '../client/RepeatRangeNode.ts';
-import type { MaterializedChildren } 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 type { RepeatSequenceDefinition } from '../model/RepeatSequenceDefinition.ts';
-import type { RepeatDefinition } from './RepeatInstance.ts';
-import { RepeatInstance } from './RepeatInstance.ts';
-import type { Root } from './Root.ts';
-import type { DescendantNodeSharedStateSpec } from './abstract/DescendantNode.ts';
-import { DescendantNode } from './abstract/DescendantNode.ts';
-import type { 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 { TextRange } from './text/TextRange.ts';
+import { Accessor } from 'solid-js';
+import { RepeatRangeNode, RepeatRangeNodeAppearances } from '../client/RepeatRangeNode.ts';
+import { MaterializedChildren } from '../lib/reactivity/materializeCurrentStateChildren.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 { RepeatRangeDefinition } from '../model/RepeatRangeDefinition.ts';
+import { RepeatDefinition, RepeatInstance } from './RepeatInstance.ts';
+import { Root } from './Root.ts';
+import { DescendantNodeSharedStateSpec, DescendantNode } from './abstract/DescendantNode.ts';
+import { GeneralParentNode } from './hierarchy.ts';
+import { NodeID } from './identity.ts';
+import { EvaluationContext } from './internal-api/EvaluationContext.ts';
+import { SubscribableDependency } from './internal-api/SubscribableDependency.ts';
+import { TextRange } from './text/TextRange.ts';
+
 interface RepeatRangeStateSpec extends DescendantNodeSharedStateSpec {
     readonly hint: null;
     readonly label: Accessor<TextRange<'label'> | null>;
@@ -22,7 +21,7 @@ interface RepeatRangeStateSpec extends DescendantNodeSharedStateSpec {
     readonly valueOptions: null;
     readonly value: null;
 }
-export declare class RepeatRange extends DescendantNode<RepeatSequenceDefinition, RepeatRangeStateSpec, RepeatInstance> implements RepeatRangeNode, EvaluationContext, SubscribableDependency {
+export declare class RepeatRange extends DescendantNode<RepeatRangeDefinition, RepeatRangeStateSpec, RepeatInstance> implements RepeatRangeNode, EvaluationContext, SubscribableDependency {
     /**
      * A repeat range doesn't have a corresponding primary instance element of its
      * own, and its instances are appended to the range's parent element. During
@@ -49,12 +48,91 @@ export declare class RepeatRange extends DescendantNode<RepeatSequenceDefinition
     private readonly childrenState;
     protected readonly state: SharedNodeState<RepeatRangeStateSpec>;
     protected engineState: EngineState<RepeatRangeStateSpec>;
+    /**
+     * @todo Should we special case repeat `readonly` state the same way
+     * we do for `relevant`?
+     *
+     * @see {@link isSelfRelevant}
+     */
+    isSelfReadonly: Accessor<boolean>;
+    private readonly emptyRangeEvaluationContext;
+    /**
+     * @see {@link isSelfRelevant}
+     */
+    private readonly isEmptyRangeSelfRelevant;
+    /**
+     * A repeat range does not exist in the primary instance tree. A `relevant`
+     * expression applies to each {@link RepeatInstance} child of the repeat
+     * range. Determining whether a repeat range itself "is relevant" isn't a
+     * concept the spec addresses, but it may be used by clients to determine
+     * whether to allow interaction with the range (e.g. by adding a repeat
+     * instance, or presenting the range's label when empty).
+     *
+     * As a naive first pass, it seems like the heuristic for this should be:
+     *
+     * 1. Does the repeat range have any repeat instance children?
+     *
+     *     - If yes, go to 2.
+     *     - If no, go to 3.
+     *
+     * 2. Does one or more of those children return `true` for the node's
+     *    `relevant` expression (i.e. is the repeat instance "self relevant")?
+     *
+     * 3. Does the relevant expression return `true` for the repeat range itself
+     *    (where, at least for now, the context of that evaluation would be the
+     *    repeat range's {@link anchorNode} to ensure correct relative expressions
+     *    resolve correctly)?
+     *
+     * @todo While (3) is proactively implemented, there isn't presently a test
+     * exercising it. It felt best for now to surface this for discussion in
+     * review to validate that it's going in the right direction.
+     *
+     * @todo While (2) **is actually tested**, the tests currently in place behave
+     * the same way with only the logic for (3), regardless of whether the repeat
+     * range actually has any repeat instance children. It's unclear (a) if that's
+     * a preferable simplification and (b) how that might affect performance (in
+     * theory it could vary depending on form structure and runtime state).
+     */
+    readonly isSelfRelevant: Accessor<boolean>;
     readonly nodeType = "repeat-range";
+    /**
+     * @todo RepeatRange*, RepeatInstance* (and RepeatTemplate*) all share the
+     * same body element, and thus all share the same definition `bodyElement`. As
+     * such, they also all share the same `appearances`. At time of writing,
+     * `web-forms` (Vue UI package) treats a `RepeatRangeNode`...
+     *
+     * - ... as a group, if the node has a label (i.e.
+     *   `<group><label/><repeat/></group>`)
+     * - ... effectively as a fragment containing only its instances, otherwise
+     *
+     * We now collapse `<group><repeat>` into `<repeat>`, and no longer treat
+     * "repeat group" as a concept (after parsing). According to the spec, these
+     * appearances **are supposed to** come from that "repeat group" in the form
+     * definition. In practice, many forms do define appearances directly on a
+     * repeat element. The engine currently produces an error if both are defined
+     * simultaneously, but otherwise makes no distinction between appearances in
+     * these form definition shapes:
+     *
+     * ```xml
+     * <group ref="/data/rep1" appearance="...">
+     *   <repeat nodeset="/data/rep1"/>
+     * </group>
+     *
+     * <group ref="/data/rep1">
+     *   <repeat nodeset="/data/rep1"/ appearance="...">
+     * </group>
+     *
+     * <repeat nodeset="/data/rep1"/ appearance="...">
+     * ```
+     *
+     * All of the above creates considerable ambiguity about where "repeat
+     * appearances" should apply, under which circumstances.
+     */
+    readonly appearances: RepeatRangeNodeAppearances;
     readonly currentState: MaterializedChildren<CurrentState<RepeatRangeStateSpec>, RepeatInstance>;
-    constructor(parent: GeneralParentNode, definition: RepeatSequenceDefinition);
+    constructor(parent: GeneralParentNode, definition: RepeatRangeDefinition);
     private getLastIndex;
     protected initializeContextNode(parentContextNode: Element): Element;
-    protected computeReference(parent: GeneralParentNode): string;
     getInstanceIndex(instance: RepeatInstance): number;
     addInstances(afterIndex?: number, count?: number, definition?: RepeatDefinition): Root;
     /**

package/dist/instance/Root.d.ts

@@ -1,20 +1,22 @@
-import type { XFormsXPathEvaluator } from '@getodk/xpath';
-import type { Accessor, Signal } from 'solid-js';
-import type { XFormDOM } from '../XFormDOM.ts';
-import type { ActiveLanguage, FormLanguage, FormLanguages } from '../client/FormLanguage.ts';
-import type { RootNode } from '../client/RootNode.ts';
-import type { MaterializedChildren } 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 type { RootDefinition } from '../model/RootDefinition.ts';
+import { XFormsXPathEvaluator } from '@getodk/xpath';
+import { Accessor, Signal } from 'solid-js';
+import { XFormDOM } from '../XFormDOM.ts';
+import { BodyClassList } from '../body/BodyDefinition.ts';
+import { ActiveLanguage, FormLanguage, FormLanguages } from '../client/FormLanguage.ts';
+import { RootNode } from '../client/RootNode.ts';
+import { MaterializedChildren } from '../lib/reactivity/materializeCurrentStateChildren.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 { RootDefinition } from '../model/RootDefinition.ts';
 import { InstanceNode } from './abstract/InstanceNode.ts';
-import type { GeneralChildNode } from './hierarchy.ts';
-import type { NodeID } from './identity.ts';
-import type { EvaluationContext, EvaluationContextRoot } from './internal-api/EvaluationContext.ts';
-import type { InstanceConfig } from './internal-api/InstanceConfig.ts';
-import type { SubscribableDependency } from './internal-api/SubscribableDependency.ts';
-import type { TranslationContext } from './internal-api/TranslationContext.ts';
+import { GeneralChildNode } from './hierarchy.ts';
+import { NodeID } from './identity.ts';
+import { EvaluationContext, EvaluationContextRoot } from './internal-api/EvaluationContext.ts';
+import { InstanceConfig } from './internal-api/InstanceConfig.ts';
+import { SubscribableDependency } from './internal-api/SubscribableDependency.ts';
+import { TranslationContext } from './internal-api/TranslationContext.ts';
+
 interface RootStateSpec {
     readonly reference: string;
     readonly readonly: boolean;
@@ -28,41 +30,25 @@ interface RootStateSpec {
     readonly activeLanguage: Signal<ActiveLanguage>;
 }
 export declare class Root extends InstanceNode<RootDefinition, RootStateSpec, GeneralChildNode> implements RootNode, EvaluationContext, EvaluationContextRoot, SubscribableDependency, TranslationContext {
-    static initialize(xformDOM: XFormDOM, definition: RootDefinition, engineConfig: InstanceConfig): Promise<Root>;
     private readonly childrenState;
+    readonly hasReadonlyAncestor: () => boolean;
+    readonly isReadonly: () => boolean;
+    readonly hasNonRelevantAncestor: () => boolean;
+    readonly isRelevant: () => boolean;
     protected readonly state: SharedNodeState<RootStateSpec>;
     protected readonly engineState: EngineState<RootStateSpec>;
     readonly nodeType = "root";
+    readonly appearances: null;
+    readonly classes: BodyClassList;
     readonly currentState: MaterializedChildren<CurrentState<RootStateSpec>, GeneralChildNode>;
     protected readonly instanceDOM: XFormDOM;
     readonly root: this;
     readonly evaluator: XFormsXPathEvaluator;
-    private readonly rootReference;
-    get contextReference(): string;
     readonly contextNode: Element;
     readonly parent: null;
     readonly languages: FormLanguages;
     get activeLanguage(): ActiveLanguage;
-    protected constructor(xformDOM: XFormDOM, definition: RootDefinition, engineConfig: InstanceConfig);
-    /**
-     * Waits until form state is fully initialized.
-     *
-     * As much as possible, all instance state computations are implemented so
-     * that they complete synchronously.
-     *
-     * There is currently one exception: because instance nodes may form
-     * computation dependencies into their descendants as well as their ancestors,
-     * there is an allowance **during form initialization only** to account for
-     * this chicken/egg scenario. Note that this allowance is intentionally,
-     * strictly limited: if form state initialization is not resolved within a
-     * single microtask tick we throw/reject.
-     *
-     * All subsequent computations are always performed synchronously (and we will
-     * use tests to validate this, by utilizing the synchronously returned `Root`
-     * state from client-facing write interfaces).
-     */
-    formStateInitialized(): Promise<void>;
-    protected computeReference(_parent: null, definition: RootDefinition): string;
+    constructor(xformDOM: XFormDOM, definition: RootDefinition, engineConfig: InstanceConfig);
     getChildren(): readonly GeneralChildNode[];
     setLanguage(language: FormLanguage): Root;
     subscribe(): void;

package/dist/instance/SelectField.d.ts

@@ -1,19 +1,19 @@
-import type { Accessor } from 'solid-js';
-import type { AnySelectDefinition } from '../body/control/select/SelectDefinition.ts';
-import type { SelectItem, SelectNode } from '../client/SelectNode.ts';
-import type { TextRange } from '../index.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 type { SimpleAtomicState } from '../lib/reactivity/types.ts';
-import type { ValueNodeDefinition } from '../model/ValueNodeDefinition.ts';
-import type { Root } from './Root.ts';
-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 { ValueContext } from './internal-api/ValueContext.ts';
+import { Accessor } from 'solid-js';
+import { AnySelectDefinition } from '../body/control/select/SelectDefinition.ts';
+import { SelectItem, SelectNode, SelectNodeAppearances } from '../client/SelectNode.ts';
+import { TextRange } from '../index.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 { SimpleAtomicState } from '../lib/reactivity/types.ts';
+import { ValueNodeDefinition } from '../model/ValueNodeDefinition.ts';
+import { Root } from './Root.ts';
+import { DescendantNodeStateSpec, DescendantNode } from './abstract/DescendantNode.ts';
+import { GeneralParentNode } from './hierarchy.ts';
+import { EvaluationContext } from './internal-api/EvaluationContext.ts';
+import { SubscribableDependency } from './internal-api/SubscribableDependency.ts';
+import { ValueContext } from './internal-api/ValueContext.ts';
+
 export interface SelectFieldDefinition extends ValueNodeDefinition {
     readonly bodyElement: AnySelectDefinition;
 }
@@ -29,13 +29,13 @@ export declare class SelectField extends DescendantNode<SelectFieldDefinition, S
     protected readonly state: SharedNodeState<SelectFieldStateSpec>;
     protected engineState: EngineState<SelectFieldStateSpec>;
     readonly nodeType = "select";
+    readonly appearances: SelectNodeAppearances;
     readonly currentState: CurrentState<SelectFieldStateSpec>;
     readonly encodeValue: (runtimeValue: readonly SelectItem[]) => string;
     readonly decodeValue: (instanceValue: string) => readonly SelectItem[];
     protected readonly getValueOptions: Accessor<readonly SelectItem[]>;
     constructor(parent: GeneralParentNode, definition: SelectFieldDefinition);
     protected getSelectItemsByValue(valueOptions?: readonly SelectItem[]): ReadonlyMap<string, SelectItem>;
-    protected computeReference(parent: GeneralParentNode): string;
     protected updateSelectedItemValues(values: readonly string[]): void;
     protected setSelectedItemValue(value: string | null): void;
     select(selectedItem: SelectItem): Root;

package/dist/instance/StringField.d.ts

@@ -1,19 +1,19 @@
-import type { Accessor } from 'solid-js';
-import type { InputDefinition } from '../body/control/InputDefinition.ts';
-import type { StringNode } from '../client/StringNode.ts';
-import type { TextRange } from '../index.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 type { SimpleAtomicState } from '../lib/reactivity/types.ts';
-import type { ValueNodeDefinition } from '../model/ValueNodeDefinition.ts';
-import type { Root } from './Root.ts';
-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 { ValueContext } from './internal-api/ValueContext.ts';
+import { Accessor } from 'solid-js';
+import { InputDefinition } from '../body/control/InputDefinition.ts';
+import { StringNode, StringNodeAppearances } from '../client/StringNode.ts';
+import { TextRange } from '../index.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 { SimpleAtomicState } from '../lib/reactivity/types.ts';
+import { ValueNodeDefinition } from '../model/ValueNodeDefinition.ts';
+import { Root } from './Root.ts';
+import { DescendantNodeStateSpec, DescendantNode } from './abstract/DescendantNode.ts';
+import { GeneralParentNode } from './hierarchy.ts';
+import { EvaluationContext } from './internal-api/EvaluationContext.ts';
+import { SubscribableDependency } from './internal-api/SubscribableDependency.ts';
+import { ValueContext } from './internal-api/ValueContext.ts';
+
 export interface StringFieldDefinition extends ValueNodeDefinition {
     readonly bodyElement: InputDefinition | null;
 }
@@ -28,11 +28,11 @@ export declare class StringField extends DescendantNode<StringFieldDefinition, S
     protected readonly state: SharedNodeState<StringFieldStateSpec>;
     protected engineState: EngineState<StringFieldStateSpec>;
     readonly nodeType = "string";
+    readonly appearances: StringNodeAppearances;
     readonly currentState: CurrentState<StringFieldStateSpec>;
     readonly encodeValue: (value: string) => string;
     readonly decodeValue: (value: string) => string;
     constructor(parent: GeneralParentNode, definition: StringFieldDefinition);
-    protected computeReference(parent: GeneralParentNode): string;
     getChildren(): readonly [];
     setValue(value: string): Root;
 }

package/dist/instance/Subtree.d.ts

@@ -1,15 +1,15 @@
-import { type Accessor } from 'solid-js';
-import type { SubtreeDefinition, SubtreeNode } from '../client/SubtreeNode.ts';
-import type { MaterializedChildren } 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 type { DescendantNodeSharedStateSpec } from './abstract/DescendantNode.ts';
-import { DescendantNode } from './abstract/DescendantNode.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 { Accessor } from 'solid-js';
+import { SubtreeDefinition, SubtreeNode } from '../client/SubtreeNode.ts';
+import { MaterializedChildren } from '../lib/reactivity/materializeCurrentStateChildren.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 { DescendantNodeSharedStateSpec, DescendantNode } from './abstract/DescendantNode.ts';
+import { GeneralChildNode, GeneralParentNode } from './hierarchy.ts';
+import { NodeID } from './identity.ts';
+import { EvaluationContext } from './internal-api/EvaluationContext.ts';
+import { SubscribableDependency } from './internal-api/SubscribableDependency.ts';
+
 interface SubtreeStateSpec extends DescendantNodeSharedStateSpec {
     readonly label: null;
     readonly hint: null;
@@ -22,9 +22,9 @@ export declare class Subtree extends DescendantNode<SubtreeDefinition, SubtreeSt
     protected readonly state: SharedNodeState<SubtreeStateSpec>;
     protected engineState: EngineState<SubtreeStateSpec>;
     readonly nodeType = "subtree";
+    readonly appearances: null;
     readonly currentState: MaterializedChildren<CurrentState<SubtreeStateSpec>, GeneralChildNode>;
     constructor(parent: GeneralParentNode, definition: SubtreeDefinition);
-    protected computeReference(parent: GeneralParentNode): string;
     getChildren(): readonly GeneralChildNode[];
 }
 export {};

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

@@ -1,17 +1,17 @@
-import type { XFormsXPathEvaluator } from '@getodk/xpath';
-import type { Accessor } from 'solid-js';
-import type { BaseNode } from '../../client/BaseNode.ts';
-import type { AnyDescendantNodeDefinition } from '../../model/DescendentNodeDefinition.ts';
-import type { AnyNodeDefinition } from '../../model/NodeDefinition.ts';
-import type { RepeatInstanceDefinition } from '../../model/RepeatInstanceDefinition.ts';
-import type { ValueNodeDefinition } from '../../model/ValueNodeDefinition.ts';
-import type { RepeatRange } from '../RepeatRange.ts';
-import type { Root } from '../Root.ts';
-import type { AnyChildNode, GeneralParentNode } from '../hierarchy.ts';
-import type { EvaluationContext } from '../internal-api/EvaluationContext.ts';
-import type { SubscribableDependency } from '../internal-api/SubscribableDependency.ts';
-import type { InstanceNodeStateSpec } from './InstanceNode.ts';
-import { InstanceNode } from './InstanceNode.ts';
+import { XFormsXPathEvaluator } from '@getodk/xpath';
+import { Accessor } from 'solid-js';
+import { BaseNode } from '../../client/BaseNode.ts';
+import { AnyDescendantNodeDefinition } from '../../model/DescendentNodeDefinition.ts';
+import { AnyNodeDefinition } from '../../model/NodeDefinition.ts';
+import { RepeatInstanceDefinition } from '../../model/RepeatInstanceDefinition.ts';
+import { ValueNodeDefinition } from '../../model/ValueNodeDefinition.ts';
+import { RepeatRange } from '../RepeatRange.ts';
+import { Root } from '../Root.ts';
+import { AnyChildNode, GeneralParentNode } from '../hierarchy.ts';
+import { EvaluationContext } from '../internal-api/EvaluationContext.ts';
+import { SubscribableDependency } from '../internal-api/SubscribableDependency.ts';
+import { InstanceNodeStateSpec, InstanceNode } from './InstanceNode.ts';
+
 export interface DescendantNodeSharedStateSpec {
     readonly reference: Accessor<string>;
     readonly readonly: Accessor<boolean>;
@@ -22,16 +22,23 @@ export type DescendantNodeStateSpec<Value = never> = InstanceNodeStateSpec<Value
 export type DescendantNodeDefinition = Extract<AnyNodeDefinition, AnyDescendantNodeDefinition>;
 export type DescendantNodeParent<Definition extends DescendantNodeDefinition> = Definition extends ValueNodeDefinition ? GeneralParentNode : Definition extends RepeatInstanceDefinition ? RepeatRange : GeneralParentNode;
 export type AnyDescendantNode = DescendantNode<DescendantNodeDefinition, DescendantNodeStateSpec<any>, any>;
+interface DescendantNodeOptions {
+    readonly computeReference?: Accessor<string>;
+}
 export declare abstract class DescendantNode<Definition extends DescendantNodeDefinition, Spec extends DescendantNodeStateSpec<any>, Child extends AnyChildNode | null = null> extends InstanceNode<Definition, Spec, Child> implements BaseNode, EvaluationContext, SubscribableDependency {
     readonly parent: DescendantNodeParent<Definition>;
     readonly definition: Definition;
+    readonly hasReadonlyAncestor: Accessor<boolean>;
+    readonly isSelfReadonly: Accessor<boolean>;
+    readonly isReadonly: Accessor<boolean>;
+    readonly hasNonRelevantAncestor: Accessor<boolean>;
+    readonly isSelfRelevant: Accessor<boolean>;
+    readonly isRelevant: Accessor<boolean>;
+    protected readonly isRequired: Accessor<boolean>;
     readonly root: Root;
     readonly evaluator: XFormsXPathEvaluator;
     readonly contextNode: Element;
-    constructor(parent: DescendantNodeParent<Definition>, definition: Definition);
-    protected computeChildStepReference(parent: DescendantNodeParent<Definition>): string;
-    protected abstract computeReference(parent: DescendantNodeParent<Definition>, definition: Definition): string;
-    protected buildSharedStateSpec(parent: DescendantNodeParent<Definition>, definition: Definition): DescendantNodeSharedStateSpec;
+    constructor(parent: DescendantNodeParent<Definition>, definition: Definition, options?: DescendantNodeOptions);
     protected createContextNode(parentContextNode: Element, nodeName: string): Element;
     /**
      * Currently expected to be overridden by...
@@ -74,3 +81,4 @@ export declare abstract class DescendantNode<Definition extends DescendantNodeDe
      */
     remove(this: AnyChildNode): void;
 }
+export {};