@getodk/xforms-engine 0.3.0 → 0.5.0

package/src/parse/model/SecondaryInstance/sources/XMLExternalSecondaryInstanceSource.ts

@@ -0,0 +1,32 @@
+import { XFORMS_NAMESPACE_URI } from '@getodk/common/constants/xmlns.ts';
+import { parseStaticDocumentFromDOMSubtree } from '../../../shared/parseStaticDocumentFromDOMSubtree.ts';
+import { SecondaryInstanceDefinition } from '../SecondaryInstanceDefinition.ts';
+import { SecondaryInstanceRootDefinition } from '../SecondaryInstanceRootDefinition.ts';
+import { ExternalSecondaryInstanceSource } from './ExternalSecondaryInstanceSource.ts';
+import type { InternalSecondaryInstanceSource } from './InternalSecondaryInstanceSource.ts';
+
+export class XMLExternalSecondaryInstanceSource extends ExternalSecondaryInstanceSource<'xml'> {
+	/**
+	 * Note: this logic is a superset of the logic in
+	 * {@link InternalSecondaryInstanceSource.parseDefinition}. That subset is so
+	 * trivial/already sufficiently abstracted that it doesn't really make a lot
+	 * of sense to abstract further, but it might be worth considering if both
+	 * method implementations grow their responsibilities in the same ways.
+	 */
+	parseDefinition(): SecondaryInstanceDefinition {
+		const xmlDocument = this.domElement.ownerDocument.implementation.createDocument(
+			XFORMS_NAMESPACE_URI,
+			'instance'
+		);
+		const instanceElement = xmlDocument.documentElement;
+
+		instanceElement.setAttribute('id', this.instanceId);
+		instanceElement.innerHTML = this.resource.data;
+
+		return parseStaticDocumentFromDOMSubtree(
+			SecondaryInstanceDefinition,
+			SecondaryInstanceRootDefinition,
+			instanceElement
+		);
+	}
+}

package/src/parse/shared/parseStaticDocumentFromDOMSubtree.ts

@@ -0,0 +1,149 @@
+import { UnreachableError } from '@getodk/common/lib/error/UnreachableError.ts';
+import type { AnyConstructor } from '@getodk/common/types/helpers.js';
+import { StaticAttribute } from '../../integration/xpath/static-dom/StaticAttribute.ts';
+import type {
+	StaticDocument,
+	StaticDocumentRootFactory,
+} from '../../integration/xpath/static-dom/StaticDocument.ts';
+import type {
+	StaticElementAttributesFactory,
+	StaticElementChildNodesFactory,
+} from '../../integration/xpath/static-dom/StaticElement.ts';
+import { StaticElement } from '../../integration/xpath/static-dom/StaticElement.ts';
+import type { StaticNamedNodeOptions } from '../../integration/xpath/static-dom/StaticNamedNode.ts';
+import type { StaticParentNode } from '../../integration/xpath/static-dom/StaticNode.ts';
+import { StaticText } from '../../integration/xpath/static-dom/StaticText.ts';
+
+type ConcreteConstructor<T extends AnyConstructor> = Pick<T, keyof T>;
+
+// prettier-ignore
+export type ConcreteStaticDocumentConstructor<
+	T extends StaticDocument<Root>,
+	Root extends StaticElement,
+> =
+	& ConcreteConstructor<typeof StaticDocument<Root>>
+	& (new (rootFactory: StaticDocumentRootFactory<T, Root>) => T);
+
+const domElementAttributesFactory = (domElement: Element): StaticElementAttributesFactory => {
+	const attributes = Array.from(domElement.attributes);
+
+	return (element) => {
+		return attributes.map((attr) => {
+			return new StaticAttribute(element, attr);
+		});
+	};
+};
+
+const { ELEMENT_NODE, CDATA_SECTION_NODE, TEXT_NODE } = Node;
+
+interface StaticChildElementSource {
+	readonly domType: typeof ELEMENT_NODE;
+	readonly domNode: Element;
+}
+
+interface StaticChildTextSource {
+	readonly domType: typeof CDATA_SECTION_NODE | typeof TEXT_NODE;
+	readonly domNode: CharacterData;
+}
+
+// prettier-ignore
+type StaticChildNodeSource =
+	| StaticChildElementSource
+	| StaticChildTextSource;
+
+export const toStaticChildNodeSource = (childNode: ChildNode): StaticChildNodeSource | null => {
+	const domType = childNode.nodeType;
+
+	switch (domType) {
+		case ELEMENT_NODE:
+			return {
+				domType,
+				domNode: childNode as Element,
+			};
+
+		case TEXT_NODE:
+			return {
+				domType,
+				domNode: childNode as Text,
+			};
+
+		case CDATA_SECTION_NODE:
+			return {
+				domType,
+				domNode: childNode as CDATASection,
+			};
+
+		default:
+			return null;
+	}
+};
+
+const toStaticChildNodeSources = (childNode: ChildNode): StaticChildNodeSource | readonly [] => {
+	return toStaticChildNodeSource(childNode) ?? [];
+};
+
+const domElementChildNodesFactory = (domElement: Element): StaticElementChildNodesFactory => {
+	const childNodeSources = Array.from(domElement.childNodes).flatMap(toStaticChildNodeSources);
+
+	return (parent) => {
+		return childNodeSources.map((domSource) => {
+			switch (domSource.domType) {
+				case ELEMENT_NODE:
+					return parseStaticElementFromDOMElement(parent, StaticElement, domSource.domNode);
+
+				case TEXT_NODE:
+				case CDATA_SECTION_NODE:
+					return new StaticText(parent, domSource.domNode.data);
+
+				default:
+					throw new UnreachableError(domSource);
+			}
+		});
+	};
+};
+
+// prettier-ignore
+export type StaticElementConstructor<
+	T extends StaticElement<Parent>,
+	Parent extends StaticParentNode = StaticParentNode
+> =
+	& ConcreteConstructor<typeof StaticElement>
+	& {
+			readonly prototype: T;
+
+			new (
+				parent: Parent,
+				attributesFactory: StaticElementAttributesFactory,
+				childNodesFactory: StaticElementChildNodesFactory,
+				options: StaticNamedNodeOptions
+			): T;
+	};
+
+const parseStaticElementFromDOMElement = <
+	T extends StaticElement,
+	Parent extends StaticParentNode = StaticParentNode,
+>(
+	parent: Parent,
+	ElementConstructor: StaticElementConstructor<T, Parent>,
+	domElement: Element
+): T => {
+	const attributesFactory = domElementAttributesFactory(domElement);
+	const childNodesFactory = domElementChildNodesFactory(domElement);
+
+	return new ElementConstructor(parent, attributesFactory, childNodesFactory, domElement);
+};
+
+export const parseStaticDocumentFromDOMSubtree = <
+	T extends StaticDocument<Root>,
+	Root extends StaticElement<T>,
+>(
+	DocumentConstructor: ConcreteStaticDocumentConstructor<T, Root>,
+	DocumentRootConstructor: StaticElementConstructor<Root, T>,
+	subtreeRootElement: Element
+): T => {
+	const rootFactory: StaticDocumentRootFactory<T, Root> = (parent) => {
+		return parseStaticElementFromDOMElement(parent, DocumentRootConstructor, subtreeRootElement);
+	};
+
+	return new DocumentConstructor(rootFactory);
+};

package/src/parse/text/HintDefinition.ts

@@ -1,7 +1,7 @@
 import type { LocalNamedElement } from '@getodk/common/types/dom.ts';
-import type { XFormDefinition } from '../../XFormDefinition.ts';
-import type { AnyControlDefinition } from '../../body/control/ControlDefinition.ts';
 import { getHintElement } from '../../lib/dom/query.ts';
+import type { XFormDefinition } from '../../parse/XFormDefinition.ts';
+import type { AnyControlDefinition } from '../body/control/ControlDefinition.ts';
 import { TextElementDefinition } from './abstract/TextElementDefinition.ts';
 
 interface HintElement extends LocalNamedElement<'hint'> {}

package/src/parse/text/ItemLabelDefinition.ts

@@ -1,7 +1,7 @@
 import type { LocalNamedElement } from '@getodk/common/types/dom.ts';
-import type { XFormDefinition } from '../../XFormDefinition.ts';
-import type { ItemDefinition } from '../../body/control/select/ItemDefinition.ts';
 import { getLabelElement } from '../../lib/dom/query.ts';
+import type { XFormDefinition } from '../../parse/XFormDefinition.ts';
+import type { ItemDefinition } from '../body/control/select/ItemDefinition.ts';
 import { TextElementDefinition } from './abstract/TextElementDefinition.ts';
 
 interface LabelElement extends LocalNamedElement<'label'> {}

package/src/parse/text/ItemsetLabelDefinition.ts

@@ -1,10 +1,10 @@
 import type { LocalNamedElement } from '@getodk/common/types/dom.ts';
-import type { XFormDefinition } from '../../XFormDefinition.ts';
-import type { ItemDefinition } from '../../body/control/select/ItemDefinition.ts';
-import type { ItemsetDefinition } from '../../body/control/select/ItemsetDefinition.ts';
 import { getLabelElement } from '../../lib/dom/query.ts';
-import { ReferenceChunkDefinition } from './ReferenceChunkDefinition.ts';
-import { TranslationChunkDefinition } from './TranslationChunkDefinition.ts';
+import type { XFormDefinition } from '../../parse/XFormDefinition.ts';
+import type { ItemDefinition } from '../body/control/select/ItemDefinition.ts';
+import type { ItemsetDefinition } from '../body/control/select/ItemsetDefinition.ts';
+import { TextReferenceExpression } from '../expression/TextReferenceExpression.ts';
+import { TextTranslationExpression } from '../expression/TextTranslationExpression.ts';
 import type { RefAttributeChunk } from './abstract/TextElementDefinition.ts';
 import { TextRangeDefinition } from './abstract/TextRangeDefinition.ts';
 
@@ -36,8 +36,8 @@ export class ItemsetLabelDefinition extends TextRangeDefinition<'item-label'> {
 		}
 
 		const refChunk =
-			TranslationChunkDefinition.from(this, refExpression) ??
-			ReferenceChunkDefinition.from(this, refExpression);
+			TextTranslationExpression.from(this, refExpression) ??
+			TextReferenceExpression.from(this, refExpression);
 
 		this.chunks = [refChunk];
 	}

package/src/parse/text/LabelDefinition.ts

@@ -1,10 +1,10 @@
 import type { LocalNamedElement } from '@getodk/common/types/dom.ts';
-import type { XFormDefinition } from '../../XFormDefinition.ts';
-import type { AnyGroupElementDefinition } from '../../body/BodyDefinition.ts';
-import type { RepeatElementDefinition } from '../../body/RepeatElementDefinition.ts';
-import type { AnyControlDefinition } from '../../body/control/ControlDefinition.ts';
-import type { BaseGroupDefinition } from '../../body/group/BaseGroupDefinition.ts';
 import { getLabelElement, getRepeatGroupLabelElement } from '../../lib/dom/query.ts';
+import type { XFormDefinition } from '../../parse/XFormDefinition.ts';
+import type { AnyGroupElementDefinition } from '../../parse/body/BodyDefinition.ts';
+import type { RepeatElementDefinition } from '../body/RepeatElementDefinition.ts';
+import type { AnyControlDefinition } from '../body/control/ControlDefinition.ts';
+import type { BaseGroupDefinition } from '../body/group/BaseGroupDefinition.ts';
 import { TextElementDefinition } from './abstract/TextElementDefinition.ts';
 
 // prettier-ignore

package/src/parse/text/MessageDefinition.ts

@@ -1,7 +1,7 @@
 import { JAVAROSA_NAMESPACE_URI } from '@getodk/common/constants/xmlns.ts';
-import type { BindDefinition } from '../../model/BindDefinition.ts';
-import { StaticTextChunkDefinition } from './StaticTextChunkDefinition.ts';
-import { TranslationChunkDefinition } from './TranslationChunkDefinition.ts';
+import { TextLiteralExpression } from '../expression/TextLiteralExpression.ts';
+import { TextTranslationExpression } from '../expression/TextTranslationExpression.ts';
+import type { BindDefinition } from '../model/BindDefinition.ts';
 import type { TextBindAttributeLocalName, TextSourceNode } from './abstract/TextRangeDefinition.ts';
 import { TextRangeDefinition } from './abstract/TextRangeDefinition.ts';
 
@@ -9,8 +9,8 @@ export type MessageSourceNode = TextSourceNode<TextBindAttributeLocalName>;
 
 // prettier-ignore
 type MessageChunk =
-	| StaticTextChunkDefinition
-	| TranslationChunkDefinition;
+	| TextLiteralExpression
+	| TextTranslationExpression;
 
 export class MessageDefinition<
 	Type extends TextBindAttributeLocalName,
@@ -38,8 +38,8 @@ export class MessageDefinition<
 		super(bind.form, bind, null);
 
 		const chunk: MessageChunk =
-			TranslationChunkDefinition.fromMessage(this, message) ??
-			StaticTextChunkDefinition.from(this, message);
+			TextTranslationExpression.fromMessage(this, message) ??
+			TextLiteralExpression.from(this, message);
 
 		this.chunks = [chunk];
 	}

package/src/parse/text/abstract/TextElementDefinition.ts

@@ -1,28 +1,28 @@
 import { isElementNode, isTextNode } from '@getodk/common/lib/dom/predicates.ts';
-import type { XFormDefinition } from '../../../XFormDefinition.ts';
-import type { ItemDefinition } from '../../../body/control/select/ItemDefinition.ts';
 import type { ElementTextRole } from '../../../client/TextRange.ts';
+import type { XFormDefinition } from '../../../parse/XFormDefinition.ts';
+import type { ItemDefinition } from '../../body/control/select/ItemDefinition.ts';
+import { TextLiteralExpression } from '../../expression/TextLiteralExpression.ts';
+import { TextOutputExpression } from '../../expression/TextOutputExpression.ts';
+import { TextReferenceExpression } from '../../expression/TextReferenceExpression.ts';
+import { TextTranslationExpression } from '../../expression/TextTranslationExpression.ts';
 import { parseNodesetReference } from '../../xpath/reference-parsing.ts';
 import type { HintDefinition } from '../HintDefinition.ts';
 import type { ItemLabelDefinition } from '../ItemLabelDefinition.ts';
 import type { ItemsetLabelDefinition } from '../ItemsetLabelDefinition.ts';
 import type { LabelDefinition, LabelOwner } from '../LabelDefinition.ts';
-import { OutputChunkDefinition } from '../OutputChunkDefinition.ts';
-import { ReferenceChunkDefinition } from '../ReferenceChunkDefinition.ts';
-import { StaticTextChunkDefinition } from '../StaticTextChunkDefinition.ts';
-import { TranslationChunkDefinition } from '../TranslationChunkDefinition.ts';
 import type { TextSourceNode } from './TextRangeDefinition.ts';
 import { TextRangeDefinition } from './TextRangeDefinition.ts';
 
 // prettier-ignore
 export type RefAttributeChunk =
-	| ReferenceChunkDefinition
-	| TranslationChunkDefinition;
+	| TextReferenceExpression
+	| TextTranslationExpression;
 
 // prettier-ignore
 type TextElementChildChunk =
-	| OutputChunkDefinition
-	| StaticTextChunkDefinition;
+	| TextOutputExpression
+	| TextLiteralExpression;
 
 // prettier-ignore
 type TextElementChunks =
@@ -45,19 +45,19 @@ export abstract class TextElementDefinition<
 		if (refExpression == null) {
 			this.chunks = Array.from(sourceNode.childNodes).flatMap((childNode) => {
 				if (isElementNode(childNode)) {
-					return OutputChunkDefinition.from(context, childNode) ?? [];
+					return TextOutputExpression.from(context, childNode) ?? [];
 				}
 
 				if (isTextNode(childNode)) {
-					return StaticTextChunkDefinition.from(context, childNode.data);
+					return TextLiteralExpression.from(context, childNode.data);
 				}
 
 				return [];
 			});
 		} else {
 			const refChunk =
-				TranslationChunkDefinition.from(context, refExpression) ??
-				ReferenceChunkDefinition.from(context, refExpression);
+				TextTranslationExpression.from(context, refExpression) ??
+				TextReferenceExpression.from(context, refExpression);
 			this.chunks = [refChunk];
 		}
 	}

package/src/parse/text/abstract/TextRangeDefinition.ts

@@ -1,10 +1,9 @@
 import type { LocalNamedElement } from '@getodk/common/types/dom.ts';
-import type { XFormDefinition } from '../../../XFormDefinition.ts';
 import type { TextRole } from '../../../client/TextRange.ts';
-import { DependencyContext } from '../../../expression/DependencyContext.ts';
-import type { AnyDependentExpression } from '../../../expression/DependentExpression.ts';
+import type { XFormDefinition } from '../../../parse/XFormDefinition.ts';
+import { DependencyContext } from '../../expression/abstract/DependencyContext.ts';
+import type { AnyTextChunkExpression } from '../../expression/abstract/TextChunkExpression.ts';
 import type { AnyMessageDefinition } from '../MessageDefinition.ts';
-import type { AnyTextChunkDefinition } from './TextChunkDefinition.ts';
 import type { AnyTextElementDefinition } from './TextElementDefinition.ts';
 
 export type TextBindAttributeLocalName = 'constraintMsg' | 'requiredMsg';
@@ -25,7 +24,7 @@ export abstract class TextRangeDefinition<Role extends TextRole> extends Depende
 	readonly parentReference: string | null;
 	readonly reference: string | null;
 
-	abstract readonly chunks: readonly AnyTextChunkDefinition[];
+	abstract readonly chunks: readonly AnyTextChunkExpression[];
 
 	override get isTranslated(): boolean {
 		return (
@@ -52,11 +51,6 @@ export abstract class TextRangeDefinition<Role extends TextRole> extends Depende
 		this.parentReference = ownerContext.parentReference;
 	}
 
-	override registerDependentExpression(expression: AnyDependentExpression): void {
-		this.ownerContext.registerDependentExpression(expression);
-		super.registerDependentExpression(expression);
-	}
-
 	toJSON(): object {
 		const { form, ownerContext, ...rest } = this;
 

package/src/parse/xpath/semantic-analysis.ts

@@ -9,7 +9,9 @@ import type {
 	FilterPathExprNode,
 	FunctionCallNode,
 	FunctionNameNode,
+	LocalPartNode,
 	NumberNode,
+	PrefixNode,
 	RelativeLocationPathNode,
 	StringLiteralNode,
 } from '@getodk/xpath/static/grammar/SyntaxNode.js';
@@ -464,3 +466,30 @@ export const isConstantTruthyExpression = (
 			throw new UnreachableError(syntaxNode);
 	}
 };
+
+interface QualifiedNameExpression {
+	readonly prefix: string;
+	readonly localPart: string;
+}
+
+export const parseQualifiedNameExpression = (
+	expression: string
+): QualifiedNameExpression | null => {
+	const { rootNode } = expressionParser.parse(expression);
+	const syntaxNode = findTypedPrincipalExpressionNode(['prefixed_name'], rootNode);
+
+	if (syntaxNode == null) {
+		return null;
+	}
+
+	const [prefixNode, localPartNode, ...rest] = syntaxNode.children;
+
+	prefixNode satisfies PrefixNode;
+	localPartNode satisfies LocalPartNode;
+	rest satisfies readonly [];
+
+	return {
+		prefix: prefixNode.text,
+		localPart: localPartNode.text,
+	};
+};

package/dist/XFormDOM.d.ts

@@ -1,32 +0,0 @@
-import { XFormsXPathEvaluator } from '@getodk/xpath';
-
-interface XFormDOMNormalizationOptions {
-    readonly isNormalized: boolean;
-}
-export declare class XFormDOM {
-    protected readonly sourceXML: string;
-    static from(sourceXML: string): XFormDOM;
-    protected readonly normalizedXML: string;
-    readonly rootEvaluator: XFormsXPathEvaluator;
-    readonly primaryInstanceEvaluator: XFormsXPathEvaluator;
-    readonly xformDocument: XMLDocument;
-    readonly html: Element;
-    readonly head: Element;
-    readonly title: Element;
-    readonly model: Element;
-    readonly primaryInstance: Element;
-    readonly primaryInstanceRoot: Element;
-    readonly body: Element;
-    protected constructor(sourceXML: string, options: XFormDOMNormalizationOptions);
-    createInstance(): XFormDOM;
-    toJSON(): Omit<this, "xformDocument" | "html" | "rootEvaluator" | "primaryInstanceEvaluator" | "head" | "title" | "model" | "primaryInstance" | "primaryInstanceRoot" | "createInstance" | "toJSON"> & {
-        xformDocument: string;
-        html: string;
-        head: string;
-        title: string;
-        model: string;
-        primaryInstance: string;
-        primaryInstanceRoot: string;
-    };
-}
-export {};

package/dist/XFormDataType.d.ts

@@ -1,27 +0,0 @@
-import { CollectionValues } from '../../common/types/collections/CollectionValues.ts';
-
-/**
- * Like JavaRosa. Presumably for explicit types which aren't impelemnted?
- */
-declare const UNSUPPORTED_DATA_TYPE = "UNSUPPORTED";
-export type UnsupportedDataType = typeof UNSUPPORTED_DATA_TYPE;
-/**
- * Like JavaRosa. Presumably for e.g. groups with explicit binds (`relevant` etc)?
- */
-declare const NULL_DATA_TYPE = "NULL";
-export type NullDataType = typeof NULL_DATA_TYPE;
-/**
- * As in ODK XForms Spec.
- *
- * TODO: it's unclear why JavaRosa's `DataType` hews closely to the spec, but
- * has certain differences (e.g. string -> TEXT, int -> INTEGER). It's also
- * not immediately clear how additive types like CHOICE and MULTIPLE_ITEMS
- * square with the underlying spec types.
- */
-export declare const XFORM_SPEC_DATA_TYPES: readonly ["string", "int", "boolean", "decimal", "date", "time", "dateTime", "geopoint", "geotrace", "geoshape", "binary", "barcode", "intent"];
-export type XFormSpecDataType = CollectionValues<typeof XFORM_SPEC_DATA_TYPES>;
-export type XFormDataType = NullDataType | UnsupportedDataType | XFormSpecDataType;
-declare const DEFAULT_XFORM_DATA_TYPE = "string";
-export type DefaultXFormDataType = typeof DEFAULT_XFORM_DATA_TYPE;
-export declare const bindDataType: (bindType: string | null) => XFormDataType;
-export {};

package/dist/body/appearance/inputAppearanceParser.d.ts

@@ -1,4 +0,0 @@
-import { TokenListParser, ParsedTokenList } from '../../lib/TokenListParser.ts';
-
-export declare const inputAppearanceParser: TokenListParser<"multiline" | "numbers" | "url" | "thousand-sep" | "no-calendar" | "month-year" | "year" | "ethiopian" | "coptic" | "islamic" | "bikram-sambat" | "myanmar" | "persian" | "placement-map" | "maps" | "hidden-answer" | "annotate" | "draw" | "signature" | "new-front" | "new" | "front" | "printer" | "masked", "multiline" | "numbers" | "url" | "thousand-sep" | "no-calendar" | "month-year" | "year" | "ethiopian" | "coptic" | "islamic" | "bikram-sambat" | "myanmar" | "persian" | "placement-map" | "maps" | "hidden-answer" | "annotate" | "draw" | "signature" | "new-front" | "new" | "front" | "printer" | "masked">;
-export type InputAppearanceDefinition = ParsedTokenList<typeof inputAppearanceParser>;

package/dist/client/StringNode.d.ts

@@ -1,47 +0,0 @@
-import { InputDefinition } from '../body/control/InputDefinition.ts';
-import { LeafNodeDefinition } from '../model/LeafNodeDefinition.ts';
-import { BaseNode, BaseNodeState } from './BaseNode.ts';
-import { NodeAppearances } from './NodeAppearances.ts';
-import { RootNode } from './RootNode.ts';
-import { GeneralParentNode } from './hierarchy.ts';
-import { LeafNodeValidationState } from './validation.ts';
-
-export interface StringNodeState extends BaseNodeState {
-    get children(): null;
-    get valueOptions(): null;
-    /**
-     * Reflects the current value of a {@link StringNode}. This value may be
-     * populated when a form is loaded, and it may be updated by certain
-     * computations defined by the form. It may also be updated by a client, using
-     * the {@link StringNode.setValue} method.
-     */
-    get value(): string;
-}
-export interface StringDefinition extends LeafNodeDefinition {
-    readonly bodyElement: InputDefinition;
-}
-export type StringNodeAppearances = NodeAppearances<StringDefinition>;
-/**
- * A node which can be assigned a string/text value. A string node **MAY**
- * correspond to form field defined as an XForms `<input>`, which a user-facing
- * client would likely present for a user to fill. It may not correspond to an
- * `<input>`, or necessarily have any presentational implications for a client
- * (for instance if the node is bound to an XForms `calculate` expression).
- */
-export interface StringNode extends BaseNode {
-    readonly nodeType: 'string';
-    readonly appearances: StringNodeAppearances;
-    readonly definition: StringDefinition;
-    readonly root: RootNode;
-    readonly parent: GeneralParentNode;
-    readonly currentState: StringNodeState;
-    readonly validationState: LeafNodeValidationState;
-    /**
-     * For use by a client to update the value of a string node.
-     *
-     * @todo [how] should we express write restrictions to a client? E.g. what
-     * happens when a string node is readonly, and a client attempts to call this
-     * method?
-     */
-    setValue(value: string): RootNode;
-}

package/dist/expression/DependencyContext.d.ts

@@ -1,13 +0,0 @@
-import { AnyDependentExpression } from './DependentExpression.ts';
-
-export declare abstract class DependencyContext {
-    abstract get parentReference(): string | null;
-    abstract get reference(): string | null;
-    protected readonly dependentExpressions: Set<AnyDependentExpression>;
-    protected dependencyExpressionsCache: ReadonlySet<string> | null;
-    get dependencyExpressions(): ReadonlySet<string>;
-    get isTranslated(): boolean;
-    set isTranslated(value: true);
-    protected _isTranslated: boolean;
-    registerDependentExpression(expression: AnyDependentExpression): void;
-}

package/dist/instance/StringField.d.ts

@@ -1,45 +0,0 @@
-import { Accessor } from 'solid-js';
-import { InputDefinition } from '../body/control/InputDefinition.ts';
-import { StringNode, StringNodeAppearances } from '../client/StringNode.ts';
-import { TextRange } from '../client/TextRange.ts';
-import { AnyViolation, LeafNodeValidationState } from '../client/validation.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 { LeafNodeDefinition } from '../model/LeafNodeDefinition.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 { ValidationContext } from './internal-api/ValidationContext.ts';
-import { ValueContext } from './internal-api/ValueContext.ts';
-
-export interface StringFieldDefinition extends LeafNodeDefinition {
-    readonly bodyElement: InputDefinition;
-}
-interface StringFieldStateSpec extends DescendantNodeStateSpec<string> {
-    readonly label: Accessor<TextRange<'label'> | null>;
-    readonly hint: Accessor<TextRange<'hint'> | null>;
-    readonly children: null;
-    readonly value: SimpleAtomicState<string>;
-    readonly valueOptions: null;
-}
-export declare class StringField extends DescendantNode<StringFieldDefinition, StringFieldStateSpec, null> implements StringNode, EvaluationContext, SubscribableDependency, ValidationContext, ValueContext<string> {
-    private readonly validation;
-    protected readonly state: SharedNodeState<StringFieldStateSpec>;
-    protected engineState: EngineState<StringFieldStateSpec>;
-    readonly nodeType = "string";
-    readonly appearances: StringNodeAppearances;
-    readonly currentState: CurrentState<StringFieldStateSpec>;
-    get validationState(): LeafNodeValidationState;
-    readonly encodeValue: (value: string) => string;
-    readonly decodeValue: (value: string) => string;
-    constructor(parent: GeneralParentNode, definition: StringFieldDefinition);
-    getViolation(): AnyViolation | null;
-    isBlank(): boolean;
-    getChildren(): readonly [];
-    setValue(value: string): Root;
-}
-export {};

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

@@ -1,60 +0,0 @@
-import { ReactiveScope } from '../../lib/reactivity/scope.ts';
-
-/**
- * Provides a common interface to explicitly establish a reactive subscription
- * to a form node, regardless of which node-specific details might trigger
- * reactive updates. This is primarily intended for use in coordination with a
- * node's {@link EvaluationContext} interface, so that computed expression
- * evaluations can be re-executed when their dependencies update, without
- * requiring a given evaluation to handle node-specific logic to determine
- * when/whether updates have occurred.
- *
- * @example Given a form with these bindings:
- *
- * ```xml
- * <bind nodeset="/data/field-1" />
- * <bind nodeset="/data/field-2" type="int" />
- * <bind nodeset="/data/group-a" relevant="/data/field-1 != ''" />
- * <bind nodeset="/data/group-a/field-a-1" calculate="/data/field-2 * 2" />
- * ```
- *
- * The field `/data/group-a/field-a-1`'s calculate has two dependencies:
- *
- * - `/data-field-2` (explicit)
- * - `/data/group-a` (implicit: non-relevance is inherited)
- *
- * (This is an oversimplification, but it helps to illustrate the concept.)
- *
- * The first dependency's subscription is clearly concerned with that leaf
- * node's value. In which case, that node's `subscribe` method should react to
- * updates to its value (e.g. its `currentState.value` or the internal reactive
- * representation thereof).
- *
- * Whereas the second dependency has no value (no parent nodes do); instead, the
- * subscription would be concerned with that node's relevance. In which case,
- * that node's `subscribe` method should react to updates to its relevance state
- * (e.g. its `currentState.relevant` or the internal reactive represeentation
- * thereof).
- *
- * @example Given a form with:
- *
- * ```xml
- * <!-- model -->
- * <bind nodeset="/data/repeat-a/field-a-1" calculate="position(..)" />
- * <!-- body -->
- * <repeat nodeset="/data/repeat-a" />
- * ```
- *
- * The field `/data/repeat-a/field-a-1` has a dependency on its containing
- * repeat instance. That node also doesn't have a value, and here the dynamic
- * aspect of the dependency is the node's current position. Here the node's
- * `subscribe` method should react to changes in its position (likely indirectly
- * by reading its `contextReference`).
- *
- * @see {@link EvaluationContext}
- * @see {@link EvaluationContext.contextReference}
- */
-export interface SubscribableDependency {
-    readonly scope: ReactiveScope;
-    readonly subscribe: VoidFunction;
-}