@getodk/xforms-engine 0.4.0 → 0.6.0

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

@@ -1,26 +1,29 @@
+import { NamespaceDeclarationMap } from '../../lib/names/NamespaceDeclarationMap.ts';
+import { QualifiedName } from '../../lib/names/QualifiedName.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'> {
+import { ChildNodeDefinition, ParentNodeDefinition, NodeDefinition } from './NodeDefinition.ts';
+import { RootAttributeMap } from './RootAttributeMap.ts';
+export declare class RootDefinition extends NodeDefinition<'root'> {
     protected readonly form: XFormDefinition;
     protected readonly model: ModelDefinition;
+    readonly submission: FormSubmissionDefinition;
     readonly classes: BodyClassList;
     readonly type = "root";
-    readonly bind: BindDefinition;
-    readonly nodeset: string;
-    readonly nodeName: string;
+    readonly qualifiedName: QualifiedName;
     readonly bodyElement: null;
     readonly root: this;
     readonly parent: null;
+    readonly namespaceDeclarations: NamespaceDeclarationMap;
+    readonly attributes: RootAttributeMap;
     readonly children: readonly ChildNodeDefinition[];
     readonly instances: null;
     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, "form" | "toJSON" | "bind" | "model" | "root" | "bodyElement" | "buildSubtree">;
+    toJSON(): Omit<this, "form" | "bind" | "model" | "toJSON" | "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/parse/model/SubtreeDefinition.d.ts

@@ -1,14 +1,17 @@
+import { NamespaceDeclarationMap } from '../../lib/names/NamespaceDeclarationMap.ts';
+import { QualifiedName } from '../../lib/names/QualifiedName.ts';
 import { AnyBodyElementDefinition, AnyGroupElementDefinition } from '../body/BodyDefinition.ts';
 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'> {
+import { ChildNodeDefinition, ParentNodeDefinition } from './NodeDefinition.ts';
+export declare class SubtreeDefinition extends DescendentNodeDefinition<'subtree', AnyGroupElementDefinition | null> {
     readonly node: Element;
     readonly type = "subtree";
-    readonly nodeName: string;
+    readonly namespaceDeclarations: NamespaceDeclarationMap;
+    readonly qualifiedName: QualifiedName;
     readonly children: readonly ChildNodeDefinition[];
     readonly instances: null;
     readonly defaultValue: null;
     constructor(parent: ParentNodeDefinition, bind: BindDefinition, bodyElement: AnyBodyElementDefinition | null, node: Element);
-    toJSON(): Omit<this, "parent" | "toJSON" | "bind" | "root" | "bodyElement">;
+    toJSON(): Omit<this, "parent" | "bind" | "toJSON" | "root" | "bodyElement">;
 }

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

@@ -0,0 +1,23 @@
+import { AnyConstructor } from '../../../../common/types/helpers.js';
+import { StaticDocument, StaticDocumentRootFactory } from '../../integration/xpath/static-dom/StaticDocument.ts';
+import { StaticElementAttributesFactory, StaticElementChildNodesFactory, StaticElementOptions, StaticElement } from '../../integration/xpath/static-dom/StaticElement.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: StaticElementOptions): 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/ItemLabelDefinition.d.ts

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

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

@@ -1,6 +1,6 @@
 import { XFormDefinition } from '../../parse/XFormDefinition.ts';
-import { ItemDefinition } from '../body/control/select/ItemDefinition.ts';
-import { ItemsetDefinition } from '../body/control/select/ItemsetDefinition.ts';
+import { ItemDefinition } from '../body/control/ItemDefinition.ts';
+import { ItemsetDefinition } from '../body/control/ItemsetDefinition.ts';
 import { RefAttributeChunk } from './abstract/TextElementDefinition.ts';
 import { TextRangeDefinition } from './abstract/TextRangeDefinition.ts';
 export type ItemLabelOwner = ItemDefinition | ItemsetDefinition;

package/dist/parse/text/abstract/TextElementDefinition.d.ts

@@ -1,6 +1,6 @@
 import { ElementTextRole } from '../../../client/TextRange.ts';
 import { XFormDefinition } from '../../../parse/XFormDefinition.ts';
-import { ItemDefinition } from '../../body/control/select/ItemDefinition.ts';
+import { ItemDefinition } from '../../body/control/ItemDefinition.ts';
 import { TextLiteralExpression } from '../../expression/TextLiteralExpression.ts';
 import { TextOutputExpression } from '../../expression/TextOutputExpression.ts';
 import { TextReferenceExpression } from '../../expression/TextReferenceExpression.ts';

package/dist/parse/text/abstract/TextRangeDefinition.d.ts

@@ -2,7 +2,6 @@ import { LocalNamedElement } from '../../../../../common/types/dom.ts';
 import { TextRole } from '../../../client/TextRange.ts';
 import { XFormDefinition } from '../../../parse/XFormDefinition.ts';
 import { DependencyContext } from '../../expression/abstract/DependencyContext.ts';
-import { AnyDependentExpression } from '../../expression/abstract/DependentExpression.ts';
 import { AnyTextChunkExpression } from '../../expression/abstract/TextChunkExpression.ts';
 import { AnyMessageDefinition } from '../MessageDefinition.ts';
 import { AnyTextElementDefinition } from './TextElementDefinition.ts';
@@ -27,7 +26,6 @@ export declare abstract class TextRangeDefinition<Role extends TextRole> extends
     get isTranslated(): boolean;
     set isTranslated(value: true);
     protected constructor(form: XFormDefinition, ownerContext: DependencyContext, sourceNode: TextSourceNode<Role>);
-    registerDependentExpression(expression: AnyDependentExpression): void;
     toJSON(): object;
 }
 export type AnyTextRangeDefinition = AnyMessageDefinition | AnyTextElementDefinition;

package/dist/parse/xpath/semantic-analysis.d.ts

@@ -65,9 +65,7 @@ export declare const findLocationPathSubExpressionNodes: (syntaxNode: AnySyntaxN
  * expression is any {@link PathExpressionNode} syntax type.
  */
 export declare const getPathExpressionNode: (expression: string) => PathExpressionNode | null;
-type BrandedExpression<Expression extends string, Brand extends symbol> = Expression & {
-    readonly [K in Brand]: true;
-};
+type BrandedExpression<Expression extends string, Brand extends symbol> = Expression & Readonly<Record<Brand, true>>;
 declare const CONSTANT_EXPRESSION: unique symbol;
 type CONSTANT_EXPRESSION = typeof CONSTANT_EXPRESSION;
 /**
@@ -94,4 +92,9 @@ export type ConstantTruthyExpression = BrandedExpression<ConstantExpression, CON
  * @see {@link ConstantTruthyExpression}
  */
 export declare const isConstantTruthyExpression: (expression: string) => expression is ConstantTruthyExpression;
+interface QualifiedNameExpression {
+    readonly prefix: string;
+    readonly localPart: string;
+}
+export declare const parseQualifiedNameExpression: (expression: string) => QualifiedNameExpression | null;
 export {};