@getodk/xforms-engine 0.3.0 → 0.5.0

package/dist/parse/expression/abstract/TextChunkExpression.d.ts

@@ -0,0 +1,17 @@
+import { TextChunkSource } from '../../../client/TextRange.ts';
+import { AnyTextRangeDefinition } from '../../text/abstract/TextRangeDefinition.ts';
+import { TextLiteralExpression } from '../TextLiteralExpression.ts';
+import { TextOutputExpression } from '../TextOutputExpression.ts';
+import { TextReferenceExpression } from '../TextReferenceExpression.ts';
+import { TextTranslationExpression } from '../TextTranslationExpression.ts';
+import { DependentExpression } from './DependentExpression.ts';
+interface TextChunkExpressionOptions {
+    readonly isTranslated?: true;
+}
+export declare abstract class TextChunkExpression<Source extends TextChunkSource> extends DependentExpression<'string'> {
+    abstract readonly source: Source;
+    readonly stringValue?: string;
+    constructor(context: AnyTextRangeDefinition, expression: string, options?: TextChunkExpressionOptions);
+}
+export type AnyTextChunkExpression = TextLiteralExpression | TextOutputExpression | TextReferenceExpression | TextTranslationExpression;
+export {};

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

@@ -0,0 +1,38 @@
+import { DependencyContext } from '../expression/abstract/DependencyContext.ts';
+import { BindComputationExpression } from '../expression/BindComputationExpression.ts';
+import { MessageDefinition } from '../text/MessageDefinition.ts';
+import { XFormDefinition } from '../XFormDefinition.ts';
+import { BindElement } from './BindElement.ts';
+import { BindType, BindTypeDefinition } from './BindTypeDefinition.ts';
+import { ModelDefinition } from './ModelDefinition.ts';
+export declare class BindDefinition<T extends BindType = BindType> extends DependencyContext {
+    readonly form: XFormDefinition;
+    protected readonly model: ModelDefinition;
+    readonly nodeset: string;
+    readonly bindElement: BindElement;
+    readonly type: BindTypeDefinition<T>;
+    readonly parentNodeset: string | null;
+    readonly calculate: BindComputationExpression<'calculate'> | null;
+    readonly readonly: BindComputationExpression<'readonly'>;
+    readonly relevant: BindComputationExpression<'relevant'>;
+    readonly required: BindComputationExpression<'required'>;
+    /**
+     * Diverges from
+     * {@link https://github.com/getodk/javarosa/blob/059321160e6f8dbb3e81d9add61d68dd35b13cc8/dag.md | JavaRosa's},
+     * which excludes `constraint` expressions. We compute `constraint`
+     * dependencies like the other <bind> computation expressions, but explicitly
+     * ignore self-references (this is currently handled by
+     * {@link BindComputationExpression}, via its {@link DependentExpression}
+     * super class).
+     */
+    readonly constraint: BindComputationExpression<'constraint'>;
+    readonly constraintMsg: MessageDefinition<'constraintMsg'> | null;
+    readonly requiredMsg: MessageDefinition<'requiredMsg'> | null;
+    readonly saveIncomplete: BindComputationExpression<'saveIncomplete'>;
+    protected _parentBind: BindDefinition | null | undefined;
+    get parentBind(): BindDefinition | null;
+    get reference(): string;
+    get parentReference(): string | null;
+    constructor(form: XFormDefinition, model: ModelDefinition, nodeset: string, bindElement: BindElement);
+    toJSON(): Omit<this, "form" | "reference" | "toJSON" | "parentReference" | "isTranslated" | "model" | "bindElement" | "parentBind">;
+}

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

@@ -0,0 +1,20 @@
+import { BindElement } from './BindElement.ts';
+/**
+ * As specified by {@link https://getodk.github.io/xforms-spec/#bind-attributes}
+ */
+export declare const DEFAULT_BIND_TYPE = "string";
+export type DefaultBindType = typeof DEFAULT_BIND_TYPE;
+/**
+ * As specified by {@link https://getodk.github.io/xforms-spec/#data-types}
+ */
+declare const BIND_TYPES: readonly ["string", "int", "boolean", "decimal", "date", "time", "dateTime", "geopoint", "geotrace", "geoshape", "binary", "barcode", "intent"];
+type BindTypes = typeof BIND_TYPES;
+export type BindType = BindTypes[number];
+export declare class BindTypeDefinition<T extends BindType = BindType> {
+    readonly source: string | null;
+    readonly resolved: T;
+    static from<T extends BindType>(bindElement: BindElement): BindTypeDefinition<T>;
+    private constructor();
+    private constructor();
+}
+export {};

package/dist/{model → parse/model}/DescendentNodeDefinition.d.ts

@@ -2,7 +2,6 @@ import { AnyBodyElementDefinition } from '../body/BodyDefinition.ts';
 import { BindDefinition } from './BindDefinition.ts';
 import { ModelNode, NodeChildren, NodeDefaultValue, NodeDefinition, NodeDefinitionType, NodeInstances, NodeParent } from './NodeDefinition.ts';
 import { RootDefinition } from './RootDefinition.ts';
-
 export type DescendentNodeType = Exclude<NodeDefinitionType, 'root'>;
 type DescendentNodeBodyElement = AnyBodyElementDefinition;
 export declare abstract class DescendentNodeDefinition<Type extends DescendentNodeType, BodyElement extends DescendentNodeBodyElement | null = DescendentNodeBodyElement | null> implements NodeDefinition<Type> {
@@ -17,7 +16,6 @@ export declare abstract class DescendentNodeDefinition<Type extends DescendentNo
     abstract readonly nodeName: string;
     readonly root: RootDefinition;
     readonly nodeset: string;
-    readonly dependencyExpressions: ReadonlySet<string>;
     readonly isTranslated: boolean;
     constructor(parent: NodeParent<Type>, bind: BindDefinition, bodyElement: BodyElement);
 }

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

@@ -0,0 +1,8 @@
+import { SubmissionDefinition } from '../../client/submission/SubmissionDefinition.ts';
+import { XFormDOM } from '../XFormDOM.ts';
+export declare class FormSubmissionDefinition implements SubmissionDefinition {
+    readonly submissionAction: URL | null;
+    readonly submissionMethod = "post";
+    readonly encryptionKey: string | null;
+    constructor(xformDOM: XFormDOM);
+}

package/dist/parse/model/ItextTranslation/ItextTranslationDefinition.d.ts

@@ -0,0 +1,4 @@
+import { StaticDocument } from '../../../integration/xpath/static-dom/StaticDocument.ts';
+import { ItextTranslationRootDefinition } from './ItextTranslationRootDefinition.ts';
+export declare class ItextTranslationDefinition extends StaticDocument<ItextTranslationRootDefinition> {
+}

package/dist/parse/model/ItextTranslation/ItextTranslationRootDefinition.d.ts

@@ -0,0 +1,8 @@
+import { XFormsItextTranslationElement, XFORMS_KNOWN_ATTRIBUTE, XFORMS_LOCAL_NAME } from '@getodk/xpath';
+import { StaticElement } from '../../../integration/xpath/static-dom/StaticElement.ts';
+export declare class ItextTranslationRootDefinition extends StaticElement implements XFormsItextTranslationElement<ItextTranslationRootDefinition> {
+    readonly [XFORMS_LOCAL_NAME] = "translation";
+    readonly [XFORMS_KNOWN_ATTRIBUTE] = "lang";
+    getAttributeValue(localName: 'lang'): string;
+    getAttributeValue(localName: string): string | null;
+}

package/dist/parse/model/ItextTranslation/ItextTranslationsDefinition.d.ts

@@ -0,0 +1,8 @@
+import { XFormsItextTranslationMap } from '@getodk/xpath';
+import { EngineXPathNode } from '../../../integration/xpath/adapter/kind.ts';
+import { XFormDOM } from '../../XFormDOM.ts';
+import { ItextTranslationRootDefinition } from './ItextTranslationRootDefinition.ts';
+export declare class ItextTranslationsDefinition extends Map<string, ItextTranslationRootDefinition> implements XFormsItextTranslationMap<EngineXPathNode> {
+    static from(xformDOM: XFormDOM): ItextTranslationsDefinition;
+    private constructor();
+}

package/dist/{model → parse/model}/LeafNodeDefinition.d.ts

@@ -1,15 +1,16 @@
+import { ValueType } from '../../client/ValueType.ts';
 import { AnyBodyElementDefinition, ControlElementDefinition } from '../body/BodyDefinition.ts';
 import { BindDefinition } from './BindDefinition.ts';
 import { DescendentNodeDefinition } from './DescendentNodeDefinition.ts';
 import { NodeDefinition, ParentNodeDefinition } from './NodeDefinition.ts';
-
-export declare class LeafNodeDefinition extends DescendentNodeDefinition<'leaf-node', ControlElementDefinition | null> implements NodeDefinition<'leaf-node'> {
+export declare class LeafNodeDefinition<V extends ValueType = ValueType> extends DescendentNodeDefinition<'leaf-node', ControlElementDefinition | null> implements NodeDefinition<'leaf-node'> {
     readonly node: Element;
     readonly type = "leaf-node";
+    readonly valueType: V;
     readonly nodeName: string;
     readonly children: null;
     readonly instances: null;
     readonly defaultValue: string;
     constructor(parent: ParentNodeDefinition, bind: BindDefinition, bodyElement: AnyBodyElementDefinition | null, node: Element);
-    toJSON(): Omit<this, "toJSON" | "parent" | "bind" | "root" | "bodyElement">;
+    toJSON(): Omit<this, "parent" | "toJSON" | "bind" | "root" | "bodyElement">;
 }

package/dist/{model → parse/model}/ModelBindMap.d.ts

@@ -2,7 +2,6 @@ import { XFormDefinition } from '../XFormDefinition.ts';
 import { BindDefinition } from './BindDefinition.ts';
 import { BindNodeset } from './BindElement.ts';
 import { ModelDefinition } from './ModelDefinition.ts';
-
 type TopologicalSortIndex = number;
 export type SortedNodesetIndexes = ReadonlyMap<BindNodeset, TopologicalSortIndex>;
 export declare class ModelBindMap extends Map<BindNodeset, BindDefinition> {
@@ -11,6 +10,6 @@ export declare class ModelBindMap extends Map<BindNodeset, BindDefinition> {
     static fromModel(model: ModelDefinition): ModelBindMap;
     protected constructor(form: XFormDefinition, model: ModelDefinition);
     getOrCreateBindDefinition(nodeset: string): BindDefinition;
-    toJSON(): [string, BindDefinition][];
+    toJSON(): [string, BindDefinition<"string" | "boolean" | "time" | "int" | "decimal" | "date" | "dateTime" | "geopoint" | "geotrace" | "geoshape" | "binary" | "barcode" | "intent">][];
 }
 export {};

package/dist/{model → parse/model}/ModelDefinition.d.ts

@@ -1,11 +1,12 @@
 import { XFormDefinition } from '../XFormDefinition.ts';
+import { ItextTranslationsDefinition } from './ItextTranslation/ItextTranslationsDefinition.ts';
 import { ModelBindMap } from './ModelBindMap.ts';
 import { RootDefinition } from './RootDefinition.ts';
-
 export declare class ModelDefinition {
     readonly form: XFormDefinition;
     readonly binds: ModelBindMap;
     readonly root: RootDefinition;
+    readonly itextTranslations: ItextTranslationsDefinition;
     constructor(form: XFormDefinition);
-    toJSON(): Omit<this, "toJSON" | "form">;
+    toJSON(): Omit<this, "form" | "toJSON">;
 }

package/dist/{model → parse/model}/NodeDefinition.d.ts

@@ -7,7 +7,6 @@ import { AnyRepeatRangeDefinition } from './RepeatRangeDefinition.ts';
 import { RepeatTemplateDefinition } from './RepeatTemplateDefinition.ts';
 import { RootDefinition } from './RootDefinition.ts';
 import { SubtreeDefinition } from './SubtreeDefinition.ts';
-
 /**
  * Corresponds to the model/entry DOM root node, i.e.:
  *
@@ -61,7 +60,6 @@ export interface NodeDefinition<Type extends NodeDefinitionType> {
     readonly nodeName: string;
     readonly bodyElement: AnyBodyElementDefinition | RepeatElementDefinition | null;
     readonly isTranslated: boolean;
-    readonly dependencyExpressions: ReadonlySet<string>;
     readonly root: RootDefinition;
     readonly parent: NodeParent<Type>;
     readonly children: NodeChildren<Type>;

package/dist/parse/{NoteNodeDefinition.d.ts → model/NoteNodeDefinition.d.ts}

@@ -1,14 +1,13 @@
 import { AnyBodyElementDefinition } from '../body/BodyDefinition.ts';
-import { InputDefinition } from '../body/control/InputDefinition.ts';
-import { ConstantTruthyDependentExpression } from '../expression/DependentExpression.ts';
-import { BindComputation } from '../model/BindComputation.ts';
-import { BindDefinition } from '../model/BindDefinition.ts';
-import { LeafNodeDefinition } from '../model/LeafNodeDefinition.ts';
-import { ParentNodeDefinition } from '../model/NodeDefinition.ts';
-import { HintDefinition } from './text/HintDefinition.ts';
-import { LabelDefinition } from './text/LabelDefinition.ts';
-
-export type NoteReadonlyDefinition = BindComputation<'readonly'> & ConstantTruthyDependentExpression;
+import { InputControlDefinition } from '../body/control/InputControlDefinition.ts';
+import { BindComputationExpression } from '../expression/BindComputationExpression.ts';
+import { ConstantTruthyDependentExpression } from '../expression/abstract/DependentExpression.ts';
+import { HintDefinition } from '../text/HintDefinition.ts';
+import { LabelDefinition } from '../text/LabelDefinition.ts';
+import { BindDefinition } from './BindDefinition.ts';
+import { LeafNodeDefinition } from './LeafNodeDefinition.ts';
+import { ParentNodeDefinition } from './NodeDefinition.ts';
+export type NoteReadonlyDefinition = BindComputationExpression<'readonly'> & ConstantTruthyDependentExpression;
 export interface NoteBindDefinition extends BindDefinition {
     readonly readonly: NoteReadonlyDefinition;
 }
@@ -16,7 +15,7 @@ export type NoteTextDefinition = LabelDefinition | HintDefinition;
 /**
  * @package This class is used internally, both in static types and at runtime,
  * to guard and guide the distinction between instance state nodes for 'note'
- * and 'string' node types. It is intentionally package-private! The less
+ * and 'input' node types. It is intentionally package-private! The less
  * specific {@link NoteNode.definition} type, if it has any client value at all,
  * should be more than sufficient. Clients are otherwise expected to use other
  * aspects of the node's interface (such as its {@link NoteNode.nodeType} and
@@ -24,8 +23,8 @@ export type NoteTextDefinition = LabelDefinition | HintDefinition;
  */
 export declare class NoteNodeDefinition extends LeafNodeDefinition {
     readonly bind: NoteBindDefinition;
-    readonly bodyElement: InputDefinition;
+    readonly bodyElement: InputControlDefinition;
     readonly noteTextDefinition: NoteTextDefinition;
     static from(parent: ParentNodeDefinition, bind: BindDefinition, bodyElement: AnyBodyElementDefinition | null, node: Element): NoteNodeDefinition | null;
-    constructor(parent: ParentNodeDefinition, bind: NoteBindDefinition, bodyElement: InputDefinition, noteTextDefinition: NoteTextDefinition, node: Element);
+    constructor(parent: ParentNodeDefinition, bind: NoteBindDefinition, bodyElement: InputControlDefinition, noteTextDefinition: NoteTextDefinition, node: Element);
 }

package/dist/{model → parse/model}/RepeatInstanceDefinition.d.ts

@@ -2,7 +2,6 @@ import { RepeatElementDefinition } from '../body/RepeatElementDefinition.ts';
 import { DescendentNodeDefinition } from './DescendentNodeDefinition.ts';
 import { ChildNodeDefinition, NodeDefinition } from './NodeDefinition.ts';
 import { AnyRepeatRangeDefinition } from './RepeatRangeDefinition.ts';
-
 export declare class RepeatInstanceDefinition extends DescendentNodeDefinition<'repeat-instance', RepeatElementDefinition> implements NodeDefinition<'repeat-instance'> {
     readonly node: Element;
     readonly type = "repeat-instance";
@@ -11,5 +10,5 @@ export declare class RepeatInstanceDefinition extends DescendentNodeDefinition<'
     readonly instances: null;
     readonly defaultValue: null;
     constructor(range: AnyRepeatRangeDefinition, node: Element);
-    toJSON(): Omit<this, "toJSON" | "parent" | "bind" | "root" | "bodyElement">;
+    toJSON(): Omit<this, "parent" | "toJSON" | "bind" | "root" | "bodyElement">;
 }

package/dist/{model → parse/model}/RepeatRangeDefinition.d.ts

@@ -1,11 +1,10 @@
 import { RepeatElementDefinition } from '../body/RepeatElementDefinition.ts';
-import { RepeatCountControlExpression } from '../parse/expression/RepeatCountControlExpression.ts';
+import { RepeatCountControlExpression } from '../expression/RepeatCountControlExpression.ts';
 import { BindDefinition } from './BindDefinition.ts';
 import { DescendentNodeDefinition } from './DescendentNodeDefinition.ts';
 import { NodeDefinition, ParentNodeDefinition } from './NodeDefinition.ts';
 import { RepeatInstanceDefinition } from './RepeatInstanceDefinition.ts';
 import { RepeatTemplateDefinition } from './RepeatTemplateDefinition.ts';
-
 export interface ControlledRepeatRangeDefinition extends RepeatRangeDefinition {
     readonly count: RepeatCountControlExpression;
 }
@@ -26,5 +25,5 @@ export declare class RepeatRangeDefinition extends DescendentNodeDefinition<'rep
     private constructor();
     isControlled(): this is ControlledRepeatRangeDefinition;
     isUncontrolled(): this is UncontrolledRepeatRangeDefinition;
-    toJSON(): Omit<this, "toJSON" | "parent" | "bind" | "root" | "bodyElement" | "isControlled" | "isUncontrolled">;
+    toJSON(): Omit<this, "parent" | "toJSON" | "bind" | "root" | "bodyElement" | "isControlled" | "isUncontrolled">;
 }

package/dist/{model → parse/model}/RepeatTemplateDefinition.d.ts

@@ -1,9 +1,8 @@
-import { JAVAROSA_NAMESPACE_URI } from '../../../common/src/constants/xmlns.ts';
+import { JAVAROSA_NAMESPACE_URI } from '../../../../common/src/constants/xmlns.ts';
 import { RepeatElementDefinition } from '../body/RepeatElementDefinition.ts';
 import { DescendentNodeDefinition } from './DescendentNodeDefinition.ts';
 import { ChildNodeDefinition, NodeDefinition } from './NodeDefinition.ts';
 import { RepeatRangeDefinition } from './RepeatRangeDefinition.ts';
-
 interface ExplicitRepeatTemplateElement extends Element {
     getAttributeNS(namespaceURI: typeof JAVAROSA_NAMESPACE_URI, name: 'template'): string;
     getAttributeNS(namespaceURI: string | null, name: string): string | null;
@@ -24,6 +23,6 @@ export declare class RepeatTemplateDefinition extends DescendentNodeDefinition<'
     readonly instances: null;
     readonly defaultValue: null;
     protected constructor(range: RepeatRangeDefinition, templateNode: ExplicitRepeatTemplateElement);
-    toJSON(): Omit<this, "toJSON" | "parent" | "bind" | "root" | "bodyElement">;
+    toJSON(): Omit<this, "parent" | "toJSON" | "bind" | "root" | "bodyElement">;
 }
 export {};

package/dist/{model → parse/model}/RootDefinition.d.ts

@@ -1,12 +1,13 @@
-import { XFormDefinition } from '../XFormDefinition.ts';
 import { BodyClassList } from '../body/BodyDefinition.ts';
+import { XFormDefinition } from '../XFormDefinition.ts';
 import { BindDefinition } from './BindDefinition.ts';
+import { FormSubmissionDefinition } from './FormSubmissionDefinition.ts';
 import { ModelDefinition } from './ModelDefinition.ts';
 import { ChildNodeDefinition, NodeDefinition, ParentNodeDefinition } from './NodeDefinition.ts';
-
 export declare class RootDefinition implements NodeDefinition<'root'> {
     protected readonly form: XFormDefinition;
     protected readonly model: ModelDefinition;
+    readonly submission: FormSubmissionDefinition;
     readonly classes: BodyClassList;
     readonly type = "root";
     readonly bind: BindDefinition;
@@ -20,8 +21,7 @@ export declare class RootDefinition implements NodeDefinition<'root'> {
     readonly node: Element;
     readonly defaultValue: null;
     readonly isTranslated = false;
-    readonly dependencyExpressions: ReadonlySet<string>;
-    constructor(form: XFormDefinition, model: ModelDefinition, classes: BodyClassList);
+    constructor(form: XFormDefinition, model: ModelDefinition, submission: FormSubmissionDefinition, classes: BodyClassList);
     buildSubtree(parent: ParentNodeDefinition): readonly ChildNodeDefinition[];
-    toJSON(): Omit<this, "model" | "toJSON" | "form" | "bind" | "root" | "bodyElement" | "buildSubtree">;
+    toJSON(): Omit<this, "form" | "toJSON" | "bind" | "model" | "root" | "bodyElement" | "buildSubtree">;
 }

package/dist/parse/model/SecondaryInstance/SecondaryInstanceDefinition.d.ts

@@ -0,0 +1,4 @@
+import { StaticDocument } from '../../../integration/xpath/static-dom/StaticDocument.ts';
+import { SecondaryInstanceRootDefinition } from './SecondaryInstanceRootDefinition.ts';
+export declare class SecondaryInstanceDefinition extends StaticDocument<SecondaryInstanceRootDefinition> {
+}

package/dist/parse/model/SecondaryInstance/SecondaryInstanceRootDefinition.d.ts

@@ -0,0 +1,7 @@
+import { XFormsSecondaryInstanceElement, XFORMS_KNOWN_ATTRIBUTE, XFORMS_LOCAL_NAME } from '@getodk/xpath';
+import { StaticElement } from '../../../integration/xpath/static-dom/StaticElement.ts';
+import { SecondaryInstanceDefinition } from './SecondaryInstanceDefinition.ts';
+export declare class SecondaryInstanceRootDefinition extends StaticElement<SecondaryInstanceDefinition> implements XFormsSecondaryInstanceElement<StaticElement> {
+    readonly [XFORMS_LOCAL_NAME] = "instance";
+    readonly [XFORMS_KNOWN_ATTRIBUTE] = "id";
+}

package/dist/parse/model/SecondaryInstance/SecondaryInstancesDefinition.d.ts

@@ -0,0 +1,13 @@
+import { XFormsSecondaryInstanceMap } from '@getodk/xpath';
+import { EngineXPathNode } from '../../../integration/xpath/adapter/kind.ts';
+import { XFormDOM } from '../../XFormDOM.ts';
+import { SecondaryInstanceRootDefinition } from './SecondaryInstanceRootDefinition.ts';
+import { ExternalSecondaryInstanceResourceLoadOptions } from './sources/ExternalSecondaryInstanceResource.ts';
+export declare class SecondaryInstancesDefinition extends Map<string, SecondaryInstanceRootDefinition> implements XFormsSecondaryInstanceMap<EngineXPathNode> {
+    /**
+     * @package Only to be used for testing
+     */
+    static loadSync(xformDOM: XFormDOM): SecondaryInstancesDefinition;
+    static load(xformDOM: XFormDOM, options: ExternalSecondaryInstanceResourceLoadOptions): Promise<SecondaryInstancesDefinition>;
+    private constructor();
+}

package/dist/parse/model/SecondaryInstance/sources/BlankSecondaryInstanceSource.d.ts

@@ -0,0 +1,14 @@
+import { JRResourceURL } from '../../../../../../common/src/jr-resources/JRResourceURL.ts';
+import { DOMSecondaryInstanceElement } from '../../../XFormDOM.ts';
+import { SecondaryInstanceDefinition } from '../SecondaryInstanceDefinition.ts';
+import { SecondaryInstanceSource } from './SecondaryInstanceSource.ts';
+export declare class BlankSecondaryInstanceSource extends SecondaryInstanceSource<'blank'> {
+    constructor(instanceId: string, resourceURL: JRResourceURL, domElement: DOMSecondaryInstanceElement);
+    /**
+     * @todo there is really no sense in using the DOM for this, other than it was
+     * quicker/more ergonomic than constructing the requisite {@link StaticNode}
+     * structures directly. Pretty good sign those constructor signatures could
+     * use some TLC!
+     */
+    parseDefinition(): SecondaryInstanceDefinition;
+}

package/dist/parse/model/SecondaryInstance/sources/CSVExternalSecondaryInstance.d.ts

@@ -0,0 +1,22 @@
+import { SecondaryInstanceDefinition } from '../SecondaryInstanceDefinition.ts';
+import { ExternalSecondaryInstanceSource } from './ExternalSecondaryInstanceSource.ts';
+export declare class CSVExternalSecondaryInstanceSource extends ExternalSecondaryInstanceSource<'csv'> {
+    /**
+     * Based on
+     * {@link https://github.com/getodk/central-frontend/blob/42c9277709e593480d1462e28b4be5f1364532b7/src/util/csv.js#L79} (and {@link https://github.com/getodk/central-frontend/blob/42c9277709e593480d1462e28b4be5f1364532b7/src/util/csv.js#L13}).
+     *
+     * The most significant deviations at time of writing:
+     *
+     * - we have already retrieved the CSV resource, so we are parsing the raw CSV data directly.
+     * - we have no need for asynchronous/streaming parsing at this point in the
+     *   form initialization process, so we can dispense with those details of the
+     *   {@link papa | papaparse} API/config.
+     */
+    private parseCSVHeader;
+    /**
+     * Largely based on {@link https://github.com/getodk/central-frontend/blob/42c9277709e593480d1462e28b4be5f1364532b7/src/util/csv.js#L170}
+     */
+    private parseCSVRows;
+    private toItems;
+    parseDefinition(): SecondaryInstanceDefinition;
+}

package/dist/parse/model/SecondaryInstance/sources/ExternalSecondaryInstanceResource.d.ts

@@ -0,0 +1,23 @@
+import { JRResourceURL } from '../../../../../../common/src/jr-resources/JRResourceURL.ts';
+import { MissingResourceBehavior } from '../../../../client/constants.ts';
+import { FetchResource } from '../../../../client/resources.ts';
+import { FormAttachmentResource } from '../../../attachments/FormAttachmentResource.ts';
+import { ExternalSecondaryInstanceSourceFormat } from './SecondaryInstanceSource.ts';
+export interface ExternalSecondaryInstanceResourceLoadOptions {
+    readonly fetchResource: FetchResource<JRResourceURL>;
+    readonly missingResourceBehavior: MissingResourceBehavior;
+}
+type LoadedExternalSecondaryInstanceResource = {
+    [Format in ExternalSecondaryInstanceSourceFormat]: ExternalSecondaryInstanceResource<Format>;
+}[ExternalSecondaryInstanceSourceFormat];
+export declare class ExternalSecondaryInstanceResource<Format extends ExternalSecondaryInstanceSourceFormat = ExternalSecondaryInstanceSourceFormat> extends FormAttachmentResource<'secondary-instance'> {
+    readonly responseStatus: number | null;
+    readonly instanceId: string;
+    private static isMissingResource;
+    private static createBlankResource;
+    static load(instanceId: string, resourceURL: JRResourceURL, options: ExternalSecondaryInstanceResourceLoadOptions): Promise<LoadedExternalSecondaryInstanceResource>;
+    readonly format: Format;
+    readonly isBlank: boolean;
+    private constructor();
+}
+export {};

package/dist/parse/model/SecondaryInstance/sources/ExternalSecondaryInstanceSource.d.ts

@@ -0,0 +1,9 @@
+import { JRResourceURL } from '../../../../../../common/src/jr-resources/JRResourceURL.ts';
+import { DOMSecondaryInstanceElement } from '../../../XFormDOM.ts';
+import { ExternalSecondaryInstanceResource } from './ExternalSecondaryInstanceResource.ts';
+import { ExternalSecondaryInstanceSourceFormat, SecondaryInstanceSource } from './SecondaryInstanceSource.ts';
+export declare abstract class ExternalSecondaryInstanceSource<Format extends ExternalSecondaryInstanceSourceFormat = ExternalSecondaryInstanceSourceFormat> extends SecondaryInstanceSource<Format> {
+    protected readonly resource: ExternalSecondaryInstanceResource<Format>;
+    readonly resourceURL: JRResourceURL;
+    constructor(domElement: DOMSecondaryInstanceElement, resource: ExternalSecondaryInstanceResource<Format>);
+}

package/dist/parse/model/SecondaryInstance/sources/GeoJSONExternalSecondaryInstance.d.ts

@@ -0,0 +1,5 @@
+import { SecondaryInstanceDefinition } from '../SecondaryInstanceDefinition.ts';
+import { ExternalSecondaryInstanceSource } from './ExternalSecondaryInstanceSource.ts';
+export declare class GeoJSONExternalSecondaryInstanceSource extends ExternalSecondaryInstanceSource<'geojson'> {
+    parseDefinition(): SecondaryInstanceDefinition;
+}

package/dist/parse/model/SecondaryInstance/sources/InternalSecondaryInstanceSource.d.ts

@@ -0,0 +1,7 @@
+import { DOMSecondaryInstanceElement } from '../../../XFormDOM.ts';
+import { SecondaryInstanceDefinition } from '../SecondaryInstanceDefinition.ts';
+import { SecondaryInstanceSource } from './SecondaryInstanceSource.ts';
+export declare class InternalSecondaryInstanceSource extends SecondaryInstanceSource<'internal'> {
+    constructor(instanceId: string, resourceURL: null, domElement: DOMSecondaryInstanceElement);
+    parseDefinition(): SecondaryInstanceDefinition;
+}

package/dist/parse/model/SecondaryInstance/sources/SecondaryInstanceSource.d.ts

@@ -0,0 +1,13 @@
+import { JRResourceURL } from '../../../../../../common/src/jr-resources/JRResourceURL.ts';
+import { DOMSecondaryInstanceElement } from '../../../XFormDOM.ts';
+import { SecondaryInstanceDefinition } from '../SecondaryInstanceDefinition.ts';
+export type ExternalSecondaryInstanceSourceFormat = 'csv' | 'geojson' | 'xml';
+export type SecondaryInstanceSourceFormat = ExternalSecondaryInstanceSourceFormat | 'internal' | 'blank';
+export declare abstract class SecondaryInstanceSource<Format extends SecondaryInstanceSourceFormat = SecondaryInstanceSourceFormat> {
+    readonly format: Format;
+    readonly instanceId: string;
+    readonly resourceURL: JRResourceURL | null;
+    readonly domElement: DOMSecondaryInstanceElement;
+    constructor(format: Format, instanceId: string, resourceURL: JRResourceURL | null, domElement: DOMSecondaryInstanceElement);
+    abstract parseDefinition(): SecondaryInstanceDefinition;
+}

package/dist/parse/model/SecondaryInstance/sources/XMLExternalSecondaryInstanceSource.d.ts

@@ -0,0 +1,12 @@
+import { SecondaryInstanceDefinition } from '../SecondaryInstanceDefinition.ts';
+import { ExternalSecondaryInstanceSource } from './ExternalSecondaryInstanceSource.ts';
+export declare 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;
+}

package/dist/{model → parse/model}/SubtreeDefinition.d.ts

@@ -2,7 +2,6 @@ import { AnyBodyElementDefinition, AnyGroupElementDefinition } from '../body/Bod
 import { BindDefinition } from './BindDefinition.ts';
 import { DescendentNodeDefinition } from './DescendentNodeDefinition.ts';
 import { ChildNodeDefinition, NodeDefinition, ParentNodeDefinition } from './NodeDefinition.ts';
-
 export declare class SubtreeDefinition extends DescendentNodeDefinition<'subtree', AnyGroupElementDefinition | null> implements NodeDefinition<'subtree'> {
     readonly node: Element;
     readonly type = "subtree";
@@ -11,5 +10,5 @@ export declare class SubtreeDefinition extends DescendentNodeDefinition<'subtree
     readonly instances: null;
     readonly defaultValue: null;
     constructor(parent: ParentNodeDefinition, bind: BindDefinition, bodyElement: AnyBodyElementDefinition | null, node: Element);
-    toJSON(): Omit<this, "toJSON" | "parent" | "bind" | "root" | "bodyElement">;
+    toJSON(): Omit<this, "parent" | "toJSON" | "bind" | "root" | "bodyElement">;
 }

package/dist/parse/shared/parseStaticDocumentFromDOMSubtree.d.ts

@@ -0,0 +1,24 @@
+import { AnyConstructor } from '../../../../common/types/helpers.js';
+import { StaticDocument, StaticDocumentRootFactory } from '../../integration/xpath/static-dom/StaticDocument.ts';
+import { StaticElementAttributesFactory, StaticElementChildNodesFactory, StaticElement } from '../../integration/xpath/static-dom/StaticElement.ts';
+import { StaticNamedNodeOptions } from '../../integration/xpath/static-dom/StaticNamedNode.ts';
+import { StaticParentNode } from '../../integration/xpath/static-dom/StaticNode.ts';
+type ConcreteConstructor<T extends AnyConstructor> = Pick<T, keyof T>;
+export type ConcreteStaticDocumentConstructor<T extends StaticDocument<Root>, Root extends StaticElement> = ConcreteConstructor<typeof StaticDocument<Root>> & (new (rootFactory: StaticDocumentRootFactory<T, Root>) => T);
+declare const ELEMENT_NODE: 1, CDATA_SECTION_NODE: 4, TEXT_NODE: 3;
+interface StaticChildElementSource {
+    readonly domType: typeof ELEMENT_NODE;
+    readonly domNode: Element;
+}
+interface StaticChildTextSource {
+    readonly domType: typeof CDATA_SECTION_NODE | typeof TEXT_NODE;
+    readonly domNode: CharacterData;
+}
+type StaticChildNodeSource = StaticChildElementSource | StaticChildTextSource;
+export declare const toStaticChildNodeSource: (childNode: ChildNode) => StaticChildNodeSource | null;
+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;
+};
+export declare const parseStaticDocumentFromDOMSubtree: <T extends StaticDocument<Root>, Root extends StaticElement<T>>(DocumentConstructor: ConcreteStaticDocumentConstructor<T, Root>, DocumentRootConstructor: StaticElementConstructor<Root, T>, subtreeRootElement: Element) => T;
+export {};

package/dist/parse/text/HintDefinition.d.ts

@@ -1,7 +1,6 @@
-import { XFormDefinition } from '../../XFormDefinition.ts';
-import { AnyControlDefinition } from '../../body/control/ControlDefinition.ts';
+import { XFormDefinition } from '../../parse/XFormDefinition.ts';
+import { AnyControlDefinition } from '../body/control/ControlDefinition.ts';
 import { TextElementDefinition } from './abstract/TextElementDefinition.ts';
-
 export declare class HintDefinition extends TextElementDefinition<'hint'> {
     static forElement(form: XFormDefinition, owner: AnyControlDefinition): HintDefinition | null;
     readonly role = "hint";

package/dist/parse/text/ItemLabelDefinition.d.ts

@@ -1,7 +1,6 @@
-import { XFormDefinition } from '../../XFormDefinition.ts';
-import { ItemDefinition } from '../../body/control/select/ItemDefinition.ts';
+import { XFormDefinition } from '../../parse/XFormDefinition.ts';
+import { ItemDefinition } from '../body/control/select/ItemDefinition.ts';
 import { TextElementDefinition } from './abstract/TextElementDefinition.ts';
-
 export declare class ItemLabelDefinition extends TextElementDefinition<'item-label'> {
     static from(form: XFormDefinition, owner: ItemDefinition): ItemLabelDefinition | null;
     readonly role = "item-label";

package/dist/parse/text/ItemsetLabelDefinition.d.ts

@@ -1,9 +1,8 @@
-import { XFormDefinition } from '../../XFormDefinition.ts';
-import { ItemDefinition } from '../../body/control/select/ItemDefinition.ts';
-import { ItemsetDefinition } from '../../body/control/select/ItemsetDefinition.ts';
+import { XFormDefinition } from '../../parse/XFormDefinition.ts';
+import { ItemDefinition } from '../body/control/select/ItemDefinition.ts';
+import { ItemsetDefinition } from '../body/control/select/ItemsetDefinition.ts';
 import { RefAttributeChunk } from './abstract/TextElementDefinition.ts';
 import { TextRangeDefinition } from './abstract/TextRangeDefinition.ts';
-
 export type ItemLabelOwner = ItemDefinition | ItemsetDefinition;
 export declare class ItemsetLabelDefinition extends TextRangeDefinition<'item-label'> {
     static from(form: XFormDefinition, owner: ItemsetDefinition): ItemsetLabelDefinition | null;

package/dist/parse/text/LabelDefinition.d.ts

@@ -1,10 +1,9 @@
-import { XFormDefinition } from '../../XFormDefinition.ts';
-import { AnyGroupElementDefinition } from '../../body/BodyDefinition.ts';
-import { RepeatElementDefinition } from '../../body/RepeatElementDefinition.ts';
-import { AnyControlDefinition } from '../../body/control/ControlDefinition.ts';
-import { BaseGroupDefinition } from '../../body/group/BaseGroupDefinition.ts';
+import { XFormDefinition } from '../../parse/XFormDefinition.ts';
+import { AnyGroupElementDefinition } from '../../parse/body/BodyDefinition.ts';
+import { RepeatElementDefinition } from '../body/RepeatElementDefinition.ts';
+import { AnyControlDefinition } from '../body/control/ControlDefinition.ts';
+import { BaseGroupDefinition } from '../body/group/BaseGroupDefinition.ts';
 import { TextElementDefinition } from './abstract/TextElementDefinition.ts';
-
 export type LabelOwner = AnyControlDefinition | AnyGroupElementDefinition | RepeatElementDefinition;
 export declare class LabelDefinition extends TextElementDefinition<'label'> {
     static forControl(form: XFormDefinition, control: AnyControlDefinition): LabelDefinition | null;

package/dist/parse/text/MessageDefinition.d.ts

@@ -1,10 +1,9 @@
-import { 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 { BindDefinition } from '../model/BindDefinition.ts';
 import { TextBindAttributeLocalName, TextSourceNode, TextRangeDefinition } from './abstract/TextRangeDefinition.ts';
-
 export type MessageSourceNode = TextSourceNode<TextBindAttributeLocalName>;
-type MessageChunk = StaticTextChunkDefinition | TranslationChunkDefinition;
+type MessageChunk = TextLiteralExpression | TextTranslationExpression;
 export declare class MessageDefinition<Type extends TextBindAttributeLocalName> extends TextRangeDefinition<Type> {
     readonly role: Type;
     static from<Type extends TextBindAttributeLocalName>(bind: BindDefinition, type: Type): MessageDefinition<Type> | null;