@getodk/xforms-engine 0.6.0 → 0.8.0

package/src/parse/shared/parseInstanceXML.ts

@@ -0,0 +1,79 @@
+import { ErrorProductionDesignPendingError } from '../../error/ErrorProductionDesignPendingError.ts';
+import type { StaticDocument } from '../../integration/xpath/static-dom/StaticDocument.ts';
+import type { StaticNode } from '../../integration/xpath/static-dom/StaticNode.ts';
+import type { NamespaceDeclarationMap } from '../../lib/names/NamespaceDeclarationMap.ts';
+import { escapeXMLText } from '../../lib/xml-serialization.ts';
+import type { ModelDefinition } from '../model/ModelDefinition.ts';
+import type { RootDefinition } from '../model/RootDefinition.ts';
+import { parseStaticDocumentFromDOMSubtree } from './parseStaticDocumentFromDOMSubtree.ts';
+
+type WrappedInstanceXML = `<wrapped${string}</wrapped>`;
+
+const wrapInstanceXML = (model: ModelDefinition, instanceXML: string): WrappedInstanceXML => {
+	const defaultNamespace = model.root.namespaceDeclarations.get(null);
+	const defaultNamespaceURI = defaultNamespace?.declaredURI?.href;
+
+	if (defaultNamespaceURI == null) {
+		return `<wrapped>${instanceXML}</wrapped>`;
+	}
+
+	return /* xml */ `<wrapped xmlns="${escapeXMLText(defaultNamespaceURI, true)}">
+		${instanceXML}
+	</wrapped>`;
+};
+
+type AssertSoleChildElement = (element?: Element | null) => asserts element is Element;
+
+const assertSoleChildElement: AssertSoleChildElement = (element) => {
+	if (element == null) {
+		throw new ErrorProductionDesignPendingError('Expected a child element');
+	}
+
+	const { parentNode } = element;
+
+	if (parentNode == null) {
+		throw new ErrorProductionDesignPendingError('Expected element to be a child of a parent node');
+	}
+
+	if (element !== parentNode.firstElementChild || element !== parentNode.lastElementChild) {
+		throw new ErrorProductionDesignPendingError(
+			"Expected child element to be parent node's only element child."
+		);
+	}
+};
+
+const getWrappedInstanceRootElement = (xml: WrappedInstanceXML): Element => {
+	const domParser = new DOMParser();
+	const doc = domParser.parseFromString(xml, 'text/xml');
+	const { documentElement } = doc;
+	const [root] = documentElement.children;
+
+	assertSoleChildElement(root);
+
+	return root;
+};
+
+/**
+ * Parses incoming instance XML input into a {@link StaticDocument}, preserving
+ * the form definition's default namespace URI (when the instance XML does not
+ * explicitly declare a default namespace).
+ *
+ * @todo This is a hack! A proper solution will involve extending namespace
+ * resolution (i.e. probably {@link NamespaceDeclarationMap}) from
+ * {@link RootDefinition} on down throughout the instance's {@link StaticNode}
+ * tree. The same will probably be the case for parsing (XML) external secondary
+ * instances as well, so at that point we can also stop using this specialized
+ * name!
+ *
+ * @todo Aside from this being a hack, it's not very robust because it makes
+ * assumptions which are _likely but definitely not guaranteed_!
+ *
+ * - Instance XML (probably) doeesn't declare a default namespace
+ * - Instance XML **definitely** declares non-default namespaces
+ */
+export const parseInstanceXML = (model: ModelDefinition, instanceXML: string): StaticDocument => {
+	const wrappedXML = wrapInstanceXML(model, instanceXML);
+	const root = getWrappedInstanceRootElement(wrappedXML);
+
+	return parseStaticDocumentFromDOMSubtree(root);
+};

package/src/parse/shared/parseStaticDocumentFromDOMSubtree.ts

@@ -1,149 +1,64 @@
-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 { StaticAttributeOptions } from '../../integration/xpath/static-dom/StaticAttribute.ts';
+import { StaticDocument } from '../../integration/xpath/static-dom/StaticDocument.ts';
 import type {
-	StaticDocument,
-	StaticDocumentRootFactory,
-} from '../../integration/xpath/static-dom/StaticDocument.ts';
-import type {
-	StaticElementAttributesFactory,
-	StaticElementChildNodesFactory,
+	StaticElementChildOption,
 	StaticElementOptions,
 } from '../../integration/xpath/static-dom/StaticElement.ts';
-import { StaticElement } from '../../integration/xpath/static-dom/StaticElement.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);
+import type { QualifiedNameSource } from '../../lib/names/QualifiedName.ts';
 
-	return (element) => {
-		return attributes.map((attr) => {
-			return new StaticAttribute(element, attr);
-		});
+const parseNodeName = (domNode: Attr | Element): QualifiedNameSource => {
+	return {
+		namespaceURI: domNode.namespaceURI,
+		prefix: domNode.prefix,
+		localName: domNode.localName,
 	};
 };
 
-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 parseStaticElementAttributes = (domElement: Element): readonly StaticAttributeOptions[] => {
+	return Array.from(domElement.attributes).map((attr) => ({
+		name: attr,
+		value: attr.value,
+	}));
 };
 
-const domElementChildNodesFactory = (domElement: Element): StaticElementChildNodesFactory => {
-	const childNodeSources = Array.from(domElement.childNodes).flatMap(toStaticChildNodeSources);
+const { ELEMENT_NODE, CDATA_SECTION_NODE, TEXT_NODE } = Node;
 
-	return (parent) => {
-		return childNodeSources.map((domSource) => {
-			switch (domSource.domType) {
-				case ELEMENT_NODE:
-					return parseStaticElementFromDOMElement(parent, StaticElement, domSource.domNode);
+const parseStaticElementChildren = (domElement: Element): readonly StaticElementChildOption[] => {
+	return Array.from(domElement.childNodes).flatMap((child) => {
+		switch (child.nodeType) {
+			case ELEMENT_NODE:
+				return parseStaticElementOptions(child as Element);
 
-				case TEXT_NODE:
-				case CDATA_SECTION_NODE:
-					return new StaticText(parent, domSource.domNode.data);
+			case TEXT_NODE:
+			case CDATA_SECTION_NODE:
+				return (child as CharacterData).data;
 
-				default:
-					throw new UnreachableError(domSource);
-			}
-		});
-	};
+			default:
+				return [];
+		}
+	});
 };
 
-// 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: StaticElementOptions
-			): T;
+const parseStaticElementOptions = (domElement: Element): StaticElementOptions => {
+	return {
+		name: parseNodeName(domElement),
+		attributes: parseStaticElementAttributes(domElement),
+		children: parseStaticElementChildren(domElement),
 	};
-
-const parseStaticElementFromDOMElement = <
-	T extends StaticElement<Parent>,
-	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);
-	};
+interface ParseStaticDocumentFromDOMSubtreeOptions {
+	readonly nodesetPrefix?: string;
+}
+
+export const parseStaticDocumentFromDOMSubtree = (
+	subtreeRootElement: Element,
+	options: ParseStaticDocumentFromDOMSubtreeOptions = {}
+): StaticDocument => {
+	const documentRoot = parseStaticElementOptions(subtreeRootElement);
 
-	return new DocumentConstructor(rootFactory);
+	return new StaticDocument({
+		...options,
+		documentRoot,
+	});
 };

package/dist/client/EngineConfig.d.ts

@@ -1,79 +0,0 @@
-import { MissingResourceBehavior } from './constants.ts';
-import { OpaqueReactiveObjectFactory } from './OpaqueReactiveObjectFactory.ts';
-import { FetchFormAttachment, FetchResource } from './resources.ts';
-/**
- * Options provided by a client to specify certain aspects of engine runtime
- * behavior. These options will generally be intended to facilitate cooperation
- * where there is mixed responsibility between a client and the engine, or where
- * the engine may provide sensible defaults which a client could be expected to
- * override or augment.
- */
-export interface EngineConfig {
-    /**
-     * A client may specify a generic function for constructing stateful objects.
-     * The only hard requirement of this function is that it accepts an **object**
-     * and returns an object of the same shape. The engine will use this function
-     * to initialize client-facing state, and will mutate properties of the object
-     * when their corresponding state is changed.
-     *
-     * A client may use this function to provide its own implementation of
-     * reactivity with semantics like those described above. The mechanism of
-     * reactivity, if any, is at the discretion of the client. It is expected
-     * that clients providing this function will use a reactive subscribe-on-read
-     * mechanism to handle state updates conveyed by the engine.
-     */
-    readonly stateFactory?: OpaqueReactiveObjectFactory;
-    /**
-     *
-     * A client may specify an arbitrary {@link fetch}-like function for retrieving an XML XForm form
-     * definition.
-     *
-     * Notes:
-     *
-     * - This configuration will only be consuled for calls to
-     *   {@link initializeForm} with a URL referencing an XML XForm definition. It
-     *   will be ignored for calls passing an XML XForm form definition directly.
-     *
-     * - For calls to {@link initializeForm} with a URL, if this configuration is
-     *   not specified it will default to the global {@link fetch} function (if
-     *   one is defined).
-     */
-    readonly fetchFormDefinition?: FetchResource;
-    /**
-     * A client may specify an arbitrary {@link fetch}-like function to retrieve a
-     * form's attachments, i.e. any `jr:` URL referenced by the form (as specified
-     * by {@link https://getodk.github.io/xforms-spec/ | ODK XForms}).
-     *
-     * Notes:
-     *
-     * - This configuration will be consulted for all supported form attachments,
-     *   as a part of {@link initializeForm | form initialization}.
-     *
-     * - If this configuration is not specified it will default to the global
-     *   {@link fetch} function (if one is defined).
-     *
-     * This default behavior will typically result in failure to load form
-     * attachments—and in most cases this will also cause
-     * {@link initializeForm | form initialization} to fail overall—with the
-     * following exceptions:
-     *
-     * - **CLIENT-SPECIFIC:** Usage in coordination with a client-implemented
-     *   {@link https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API | Serivce Worker},
-     *   which can intercept network requests **generally**. Clients already using
-     *   a Service Worker may opt for the convenience of handling network requests
-     *   for `jr:` URLs along with any other network interception logic. Client
-     *   implementors should be warned, however, that such `jr:` URLs are not
-     *   namespaced or otherwise scoped to a particular form; such a client would
-     *   therefore inherently need to coordinate state between the Service Worker
-     *   and the main thread (or whatever other realm calls
-     *   {@link initializeForm}).
-     */
-    readonly fetchFormAttachment?: FetchFormAttachment;
-    /**
-     * @see {@link MissingResourceBehavior}
-     * @see {@link MissingResourceBehaviorDefault}
-     *
-     * @default MissingResourceBehaviorDefault
-     */
-    readonly missingResourceBehavior?: MissingResourceBehavior;
-}

package/dist/client/submission/SubmissionData.d.ts

@@ -1,7 +0,0 @@
-import { SubmissionInstanceFile, SubmissionInstanceFileName } from './SubmissionInstanceFile.ts';
-export interface SubmissionData extends FormData {
-    get(name: SubmissionInstanceFileName): SubmissionInstanceFile;
-    get(name: string): FormDataEntryValue | null;
-    has(name: SubmissionInstanceFileName): true;
-    has(name: string): boolean;
-}

package/dist/client/submission/SubmissionInstanceFile.d.ts

@@ -1,6 +0,0 @@
-import { SubmissionInstanceFileName, SubmissionInstanceFileType } from '../constants.ts';
-export type { SubmissionInstanceFileName, SubmissionInstanceFileType };
-export interface SubmissionInstanceFile extends File {
-    readonly name: SubmissionInstanceFileName;
-    readonly type: SubmissionInstanceFileType;
-}

package/dist/client/submission/SubmissionOptions.d.ts

@@ -1,23 +0,0 @@
-export type SubmissionChunkedType = 'chunked' | 'monolithic';
-interface BaseSubmissionOptions<ChunkedType extends SubmissionChunkedType> {
-    readonly chunked?: ChunkedType | undefined;
-    /**
-     * As described in the
-     * {@link https://docs.getodk.org/openrosa-form-submission/#extended-transmission-considerations | OpenRosa Form Submission API},
-     * clients may obtain this value from an OpenRosa server's
-     * `X-OpenRosa-Accept-Content-Length` header.
-     */
-    readonly maxSize?: number;
-}
-interface ChunkedSubmissionOptions extends BaseSubmissionOptions<'chunked'> {
-    readonly maxSize: number;
-}
-interface MonolithicSubmissionOptions extends BaseSubmissionOptions<'monolithic'> {
-    readonly chunked?: 'monolithic' | undefined;
-    readonly maxSize?: never;
-}
-export type SubmissionOptions<ChunkedType extends SubmissionChunkedType = 'monolithic'> = {
-    chunked: ChunkedSubmissionOptions;
-    monolithic: MonolithicSubmissionOptions;
-}[ChunkedType];
-export {};

package/dist/client/submission/SubmissionResult.d.ts

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

package/dist/client/submission/SubmissionState.d.ts

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

package/dist/client/unsupported/UnsupportedControlNode.d.ts

@@ -1,30 +0,0 @@
-import { UnknownAppearanceDefinition } from '../../parse/body/appearance/unknownAppearanceParser.ts';
-import { UploadControlDefinition } from '../../parse/body/control/UploadControlDefinition.ts';
-import { LeafNodeDefinition } from '../../parse/model/LeafNodeDefinition.ts';
-import { BaseNode, BaseNodeState } from '../BaseNode.ts';
-import { RootNode } from '../RootNode.ts';
-import { GeneralParentNode } from '../hierarchy.ts';
-import { UnsupportedControlNodeType } from '../node-types.ts';
-import { LeafNodeValidationState } from '../validation.ts';
-export interface UnsupportedControlNodeState extends BaseNodeState {
-    get children(): null;
-    get valueOptions(): unknown;
-    get value(): unknown;
-}
-export type UnsupportedControlElementDefinition = UploadControlDefinition;
-export interface UnsupportedControlDefinition extends LeafNodeDefinition {
-    readonly bodyElement: UnsupportedControlElementDefinition;
-}
-/**
- * Stub node, for form controls pending further engine support.
- */
-export interface UnsupportedControlNode extends BaseNode {
-    readonly nodeType: UnsupportedControlNodeType;
-    readonly appearances: UnknownAppearanceDefinition;
-    readonly definition: UnsupportedControlDefinition;
-    readonly root: RootNode;
-    readonly parent: GeneralParentNode;
-    readonly currentState: UnsupportedControlNodeState;
-    readonly validationState: LeafNodeValidationState;
-    setValue?(value: never): never;
-}

package/dist/client/unsupported/UploadNode.d.ts

@@ -1,9 +0,0 @@
-import { UploadControlDefinition } from '../../parse/body/control/UploadControlDefinition.ts';
-import { UnsupportedControlDefinition, UnsupportedControlNode } from './UnsupportedControlNode.ts';
-export interface UploadNodeDefinition extends UnsupportedControlDefinition {
-    readonly bodyElement: UploadControlDefinition;
-}
-export interface UploadNode extends UnsupportedControlNode {
-    readonly nodeType: 'upload';
-    readonly definition: UploadNodeDefinition;
-}

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

@@ -1,54 +0,0 @@
-import { XPathNodeKindKey } from '@getodk/xpath';
-import { Accessor } from 'solid-js';
-import { UnsupportedControlNodeType } from '../../client/node-types.ts';
-import { SubmissionState } from '../../client/submission/SubmissionState.ts';
-import { TextRange } from '../../client/TextRange.ts';
-import { UnsupportedControlDefinition, UnsupportedControlElementDefinition, UnsupportedControlNode } from '../../client/unsupported/UnsupportedControlNode.ts';
-import { AnyViolation, LeafNodeValidationState } from '../../client/validation.ts';
-import { XFormsXPathElement } from '../../integration/xpath/adapter/XFormsXPathNode.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 { UnknownAppearanceDefinition } from '../../parse/body/appearance/unknownAppearanceParser.ts';
-import { AnyUnsupportedControl, GeneralParentNode } from '../hierarchy.ts';
-import { EvaluationContext } from '../internal-api/EvaluationContext.ts';
-import { ClientReactiveSubmittableLeafNode } from '../internal-api/submission/ClientReactiveSubmittableLeafNode.ts';
-import { ValidationContext } from '../internal-api/ValidationContext.ts';
-import { ValueContext } from '../internal-api/ValueContext.ts';
-import { DescendantNode, DescendantNodeStateSpec } from './DescendantNode.ts';
-type TypedUnsupportedControlElementDefinition<Type extends UnsupportedControlNodeType> = Extract<UnsupportedControlElementDefinition, {
-    readonly type: Type;
-}>;
-interface TypedUnsupportedControlDefinition<Type extends UnsupportedControlNodeType> extends UnsupportedControlDefinition {
-    readonly bodyElement: TypedUnsupportedControlElementDefinition<Type>;
-}
-interface UnsupportedControlStateSpec extends DescendantNodeStateSpec<unknown> {
-    readonly label: Accessor<TextRange<'label'> | null>;
-    readonly hint: Accessor<TextRange<'hint'> | null>;
-    readonly children: null;
-    readonly value: SimpleAtomicState<unknown>;
-    readonly valueOptions: never;
-}
-export declare abstract class UnsupportedControl<Type extends UnsupportedControlNodeType> extends DescendantNode<TypedUnsupportedControlDefinition<Type>, UnsupportedControlStateSpec, GeneralParentNode, null> implements UnsupportedControlNode, XFormsXPathElement, EvaluationContext, ValidationContext, ValueContext<unknown>, ClientReactiveSubmittableLeafNode<unknown> {
-    private readonly validation;
-    protected readonly state: SharedNodeState<UnsupportedControlStateSpec>;
-    readonly [XPathNodeKindKey] = "element";
-    protected readonly engineState: EngineState<UnsupportedControlStateSpec>;
-    abstract readonly nodeType: Type;
-    readonly appearances: UnknownAppearanceDefinition;
-    readonly nodeOptions: null;
-    readonly currentState: CurrentState<UnsupportedControlStateSpec>;
-    get validationState(): LeafNodeValidationState;
-    readonly submissionState: SubmissionState;
-    abstract readonly contextNode: AnyUnsupportedControl & this;
-    readonly encodeValue: (instanceValue: unknown) => string;
-    readonly decodeValue: (instanceValue: unknown) => unknown;
-    constructor(parent: GeneralParentNode, definition: TypedUnsupportedControlDefinition<Type>);
-    getXPathValue(): string;
-    getViolation(): AnyViolation | null;
-    isBlank(): boolean;
-    getChildren(): readonly [];
-    setValue(_: never): never;
-}
-export {};

package/dist/instance/index.d.ts

@@ -1,8 +0,0 @@
-import { RootNode } from '../client/RootNode.ts';
-import { InitializeFormOptions as BaseInitializeFormOptions, FormResource } from '../client/index.ts';
-import { InstanceConfig } from './internal-api/InstanceConfig.ts';
-interface InitializeFormOptions extends BaseInitializeFormOptions {
-    readonly config: Partial<InstanceConfig>;
-}
-export declare const initializeForm: (input: FormResource, options?: Partial<InitializeFormOptions>) => Promise<RootNode>;
-export {};

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

@@ -1,23 +0,0 @@
-import { EngineXPathNode } from '../../integration/xpath/adapter/kind.ts';
-import { ReactiveScope } from '../../lib/reactivity/scope.ts';
-import { BindComputationExpression } from '../../parse/expression/BindComputationExpression.ts';
-import { EvaluationContext } from './EvaluationContext.ts';
-export type InstanceValue = string;
-interface ValueContextDefinitionBind {
-    readonly calculate: BindComputationExpression<'calculate'> | null;
-    readonly readonly: BindComputationExpression<'readonly'>;
-}
-export interface ValueContextDefinition {
-    readonly bind: ValueContextDefinitionBind;
-    readonly defaultValue: InstanceValue;
-}
-export interface ValueContext<RuntimeValue> extends EvaluationContext {
-    readonly scope: ReactiveScope;
-    readonly definition: ValueContextDefinition;
-    readonly contextNode: EngineXPathNode & this;
-    isReadonly(): boolean;
-    isRelevant(): boolean;
-    readonly encodeValue: (this: unknown, runtimeValue: RuntimeValue) => InstanceValue;
-    readonly decodeValue: (this: unknown, instanceValue: InstanceValue) => RuntimeValue;
-}
-export {};

package/dist/instance/internal-api/submission/ClientReactiveSubmittableInstance.d.ts

@@ -1,14 +0,0 @@
-import { SubmissionDefinition } from '../../../client/submission/SubmissionDefinition.ts';
-import { AncestorNodeValidationState } from '../../../client/validation.ts';
-import { Root } from '../../Root.ts';
-import { ClientReactiveSubmittableParentNode, ClientReactiveSubmittableParentNodeDefinition } from './ClientReactiveSubmittableParentNode.ts';
-interface ClientReactiveSubmittableInstanceDefinition extends ClientReactiveSubmittableParentNodeDefinition {
-    readonly submission: SubmissionDefinition;
-}
-export interface ClientReactiveSubmittableInstance extends ClientReactiveSubmittableParentNode<Root> {
-    readonly definition: ClientReactiveSubmittableInstanceDefinition;
-    readonly root: Root;
-    readonly parent: null;
-    readonly validationState: AncestorNodeValidationState;
-}
-export {};