@getodk/xforms-engine 0.1.0

package/dist/model/BindComputation.d.ts

@@ -0,0 +1,30 @@
+import { DependentExpression } from '../expression/DependentExpression.ts';
+import type { BindDefinition } from './BindDefinition.ts';
+declare const defaultBindComputationExpressions: {
+    readonly calculate: null;
+    readonly constraint: "true()";
+    readonly readonly: "false()";
+    readonly relevant: "true()";
+    readonly required: "false()";
+    readonly saveIncomplete: "false()";
+};
+type DefaultBindComputationExpressions = typeof defaultBindComputationExpressions;
+export type BindComputationType = keyof DefaultBindComputationExpressions;
+type BindComputationFactoryResult<Type extends BindComputationType> = DefaultBindComputationExpressions[Type] extends null ? BindComputation<Type> | null : BindComputation<Type>;
+declare const bindComputationResultTypes: {
+    readonly calculate: "string";
+    readonly constraint: "boolean";
+    readonly readonly: "boolean";
+    readonly relevant: "boolean";
+    readonly required: "boolean";
+    readonly saveIncomplete: "boolean";
+};
+type BindComputationResultTypes = typeof bindComputationResultTypes;
+export type BindComputationResultType<Computation extends BindComputationType> = BindComputationResultTypes[Computation];
+export declare class BindComputation<Computation extends BindComputationType> extends DependentExpression<BindComputationResultType<Computation>> {
+    readonly computation: Computation;
+    static forExpression<Type extends BindComputationType>(bind: BindDefinition, computation: Type): BindComputationFactoryResult<Type>;
+    readonly isDefaultExpression: boolean;
+    protected constructor(bind: BindDefinition, computation: Computation, expression: string | null);
+}
+export {};

package/dist/model/BindDefinition.d.ts

@@ -0,0 +1,31 @@
+import type { XFormDataType } from '../XFormDataType.ts';
+import type { XFormDefinition } from '../XFormDefinition.ts';
+import { DependencyContext } from '../expression/DependencyContext.ts';
+import type { DependentExpression } from '../expression/DependentExpression.ts';
+import { BindComputation } from './BindComputation.ts';
+import type { BindElement } from './BindElement.ts';
+import type { ModelDefinition } from './ModelDefinition.ts';
+export declare class BindDefinition extends DependencyContext {
+    readonly form: XFormDefinition;
+    protected readonly model: ModelDefinition;
+    readonly nodeset: string;
+    readonly bindElement: BindElement;
+    readonly bindType: string | null;
+    readonly dataType: XFormDataType;
+    readonly parentNodeset: string | null;
+    readonly calculate: BindComputation<'calculate'> | null;
+    readonly readonly: BindComputation<'readonly'>;
+    readonly relevant: BindComputation<'relevant'>;
+    readonly required: BindComputation<'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 BindComputation}, via its {@link DependentExpression} parent class).
+     */
+    readonly constraint: BindComputation<'constraint'> & DependentExpression<'boolean'>;
+    readonly saveIncomplete: BindComputation<'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, "model" | "toJSON" | "form" | "reference" | "parentReference" | "isTranslated" | "registerDependentExpression" | "dependencyExpressions" | "bindElement" | "parentBind">;
+}

package/dist/model/BindElement.d.ts

@@ -0,0 +1,6 @@
+export type BindNodeset = string;
+export interface BindElement {
+    readonly localName: 'bind';
+    getAttribute(name: 'nodeset'): BindNodeset;
+    getAttribute(name: string): string | null;
+}

package/dist/model/DescendentNodeDefinition.d.ts

@@ -0,0 +1,25 @@
+import type { AnyBodyElementDefinition } from '../body/BodyDefinition.ts';
+import type { RepeatDefinition } from '../body/RepeatDefinition.ts';
+import type { BindDefinition } from './BindDefinition.ts';
+import type { ModelNode, NodeChildren, NodeDefaultValue, NodeDefinition, NodeDefinitionType, NodeInstances, NodeParent } from './NodeDefinition.ts';
+import type { RootDefinition } from './RootDefinition.ts';
+export type DescendentNodeType = Exclude<NodeDefinitionType, 'root'>;
+type DescendentNodeBodyElement = AnyBodyElementDefinition | RepeatDefinition;
+export declare abstract class DescendentNodeDefinition<Type extends DescendentNodeType, BodyElement extends DescendentNodeBodyElement | null = DescendentNodeBodyElement | null> implements NodeDefinition<Type> {
+    readonly parent: NodeParent<Type>;
+    readonly bind: BindDefinition;
+    readonly bodyElement: BodyElement;
+    abstract readonly type: Type;
+    abstract readonly children: NodeChildren<Type>;
+    abstract readonly instances: NodeInstances<Type>;
+    abstract readonly defaultValue: NodeDefaultValue<Type>;
+    abstract readonly node: ModelNode<Type>;
+    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);
+}
+export type AnyDescendantNodeDefinition = DescendentNodeDefinition<any, any>;
+export {};

package/dist/model/ModelBindMap.d.ts

@@ -0,0 +1,15 @@
+import type { XFormDefinition } from '../XFormDefinition.ts';
+import { BindDefinition } from './BindDefinition.ts';
+import type { BindNodeset } from './BindElement.ts';
+import type { ModelDefinition } from './ModelDefinition.ts';
+type TopologicalSortIndex = number;
+export type SortedNodesetIndexes = ReadonlyMap<BindNodeset, TopologicalSortIndex>;
+export declare class ModelBindMap extends Map<BindNodeset, BindDefinition> {
+    protected readonly form: XFormDefinition;
+    protected readonly model: ModelDefinition;
+    static fromModel(model: ModelDefinition): ModelBindMap;
+    protected constructor(form: XFormDefinition, model: ModelDefinition);
+    getOrCreateBindDefinition(nodeset: string): BindDefinition;
+    toJSON(): [string, BindDefinition][];
+}
+export {};

package/dist/model/ModelDefinition.d.ts

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

package/dist/model/NodeDefinition.d.ts

@@ -0,0 +1,74 @@
+import type { AnyBodyElementDefinition } from '../body/BodyDefinition.ts';
+import type { RepeatDefinition } from '../body/RepeatDefinition.ts';
+import type { BindDefinition } from './BindDefinition.ts';
+import type { RepeatInstanceDefinition } from './RepeatInstanceDefinition.ts';
+import type { RepeatSequenceDefinition } from './RepeatSequenceDefinition.ts';
+import type { RepeatTemplateDefinition } from './RepeatTemplateDefinition.ts';
+import type { RootDefinition } from './RootDefinition.ts';
+import type { SubtreeDefinition } from './SubtreeDefinition.ts';
+import type { ValueNodeDefinition } from './ValueNodeDefinition.ts';
+/**
+ * Corresponds to the model/entry DOM root node, i.e.:
+ *
+ * - the element matching `/*` in primary instance expressions, a.k.a.
+ * - `/h:html/h:head/xf:model/xf:instance[1]/*`
+ */
+export type RootNodeType = 'root';
+/**
+ * Corresponds to a sequence of model/entry DOM subtrees which in turn
+ * corresponds to a <repeat> in the form body definition.
+ */
+export type RepeatSequenceType = 'repeat-sequence';
+/**
+ * Corresponds to a template definition for a repeat sequence, which either has
+ * an explicit `jr:template=""` attribute in the form definition or is inferred
+ * as a template from the form's first element matched by a <repeat nodeset>.
+ */
+export type RepeatTemplateType = 'repeat-template';
+/**
+ * Corresponds to a single instance of a model/entry DOM subtree which
+ * in turn corresponds to a <repeat> in the form body definition, and a
+ * 'repeat-sequence' definition.
+ */
+export type RepeatInstanceType = 'repeat-instance';
+/**
+ * Corresponds to a model/entry DOM subtree which **does not** correspond to a
+ * <repeat> in the form definition. This will typically correspond to a <group>,
+ * but this is not strictly necessary per spec (hence the distinct name).
+ */
+export type SubtreeNodeType = 'subtree';
+/**
+ * Corresponds to a model/entry DOM leaf node, i.e. one of:
+ *
+ * - An element with no child elements
+ * - Any attribute corresponding to a bind's `nodeset` expression
+ */
+export type ValueNodeType = 'value-node';
+export type NodeDefinitionType = RootNodeType | RepeatSequenceType | RepeatTemplateType | RepeatInstanceType | SubtreeNodeType | ValueNodeType;
+export type ParentNodeDefinition = RootDefinition | RepeatTemplateDefinition | RepeatInstanceDefinition | SubtreeDefinition;
+export type ChildNodeDefinition = RepeatSequenceDefinition | SubtreeDefinition | ValueNodeDefinition;
+export type ChildNodeInstanceDefinition = RepeatTemplateDefinition | RepeatInstanceDefinition | SubtreeDefinition | ValueNodeDefinition;
+export type NodeChildren<Type extends NodeDefinitionType> = Type extends ParentNodeDefinition['type'] ? readonly ChildNodeDefinition[] : null;
+export type NodeInstances<Type extends NodeDefinitionType> = Type extends 'repeat-sequence' ? readonly RepeatInstanceDefinition[] : null;
+export type NodeParent<Type extends NodeDefinitionType> = Type extends ChildNodeDefinition['type'] | ChildNodeInstanceDefinition['type'] ? ParentNodeDefinition : null;
+export type ModelNode<Type extends NodeDefinitionType> = Type extends 'repeat-sequence' ? null : Element;
+export type NodeDefaultValue<Type extends NodeDefinitionType> = Type extends 'value-node' ? string : null;
+export interface NodeDefinition<Type extends NodeDefinitionType> {
+    readonly type: Type;
+    readonly bind: BindDefinition;
+    readonly nodeset: string;
+    readonly nodeName: string;
+    readonly bodyElement: AnyBodyElementDefinition | RepeatDefinition | null;
+    readonly isTranslated: boolean;
+    readonly dependencyExpressions: ReadonlySet<string>;
+    readonly root: RootDefinition;
+    readonly parent: NodeParent<Type>;
+    readonly children: NodeChildren<Type>;
+    readonly instances: NodeInstances<Type>;
+    readonly node: ModelNode<Type>;
+    readonly defaultValue: NodeDefaultValue<Type>;
+}
+export type AnyNodeDefinition = RootDefinition | RepeatSequenceDefinition | RepeatTemplateDefinition | RepeatInstanceDefinition | SubtreeDefinition | ValueNodeDefinition;
+export type TypedNodeDefinition<Type> = Extract<AnyNodeDefinition, {
+    readonly type: Type;
+}>;

package/dist/model/RepeatInstanceDefinition.d.ts

@@ -0,0 +1,15 @@
+import { RepeatDefinition } from '../body/RepeatDefinition.ts';
+import { DescendentNodeDefinition } from './DescendentNodeDefinition.ts';
+import type { ChildNodeDefinition, NodeDefinition } from './NodeDefinition.ts';
+import type { RepeatSequenceDefinition } from './RepeatSequenceDefinition.ts';
+export declare class RepeatInstanceDefinition extends DescendentNodeDefinition<'repeat-instance', RepeatDefinition> implements NodeDefinition<'repeat-instance'> {
+    protected readonly sequence: RepeatSequenceDefinition;
+    readonly node: Element;
+    readonly type = "repeat-instance";
+    readonly nodeName: string;
+    readonly children: readonly ChildNodeDefinition[];
+    readonly instances: null;
+    readonly defaultValue: null;
+    constructor(sequence: RepeatSequenceDefinition, node: Element);
+    toJSON(): Omit<this, "toJSON" | "parent" | "bind" | "root" | "bodyElement" | "sequence">;
+}

package/dist/model/RepeatSequenceDefinition.d.ts

@@ -0,0 +1,19 @@
+import { RepeatGroupDefinition } from '../body/group/RepeatGroupDefinition.ts';
+import type { BindDefinition } from './BindDefinition.ts';
+import { DescendentNodeDefinition } from './DescendentNodeDefinition.ts';
+import type { NodeDefinition, ParentNodeDefinition } from './NodeDefinition.ts';
+import { RepeatInstanceDefinition } from './RepeatInstanceDefinition.ts';
+import { RepeatTemplateDefinition } from './RepeatTemplateDefinition.ts';
+export declare class RepeatSequenceDefinition extends DescendentNodeDefinition<'repeat-sequence', RepeatGroupDefinition> implements NodeDefinition<'repeat-sequence'> {
+    static createTemplateElement(instanceElement: Element): Element;
+    static createInstanceElement(templateElement: Element): Element;
+    readonly type = "repeat-sequence";
+    readonly template: RepeatTemplateDefinition;
+    readonly children: null;
+    readonly instances: RepeatInstanceDefinition[];
+    readonly node: null;
+    readonly nodeName: string;
+    readonly defaultValue: null;
+    constructor(parent: ParentNodeDefinition, bind: BindDefinition, bodyElement: RepeatGroupDefinition, modelNodes: readonly [Element, ...Element[]]);
+    toJSON(): Omit<this, "toJSON" | "parent" | "bind" | "root" | "bodyElement">;
+}

package/dist/model/RepeatTemplateDefinition.d.ts

@@ -0,0 +1,29 @@
+import { JAVAROSA_NAMESPACE_URI } from '../../../common/src/constants/xmlns.ts';
+import type { RepeatDefinition } from '../body/RepeatDefinition.ts';
+import { DescendentNodeDefinition } from './DescendentNodeDefinition.ts';
+import type { ChildNodeDefinition, NodeDefinition } from './NodeDefinition.ts';
+import type { RepeatSequenceDefinition } from './RepeatSequenceDefinition.ts';
+interface ExplicitRepeatTemplateElement extends Element {
+    getAttributeNS(namespaceURI: typeof JAVAROSA_NAMESPACE_URI, name: 'template'): string;
+    getAttributeNS(namespaceURI: string | null, name: string): string | null;
+    hasAttributeNS(namespaceURI: typeof JAVAROSA_NAMESPACE_URI, name: 'template'): true;
+    (namespaceURI: string | null, name: string): boolean;
+}
+interface ParsedRepeatNodes {
+    readonly template: RepeatTemplateDefinition;
+    readonly instanceNodes: readonly Element[];
+}
+export declare class RepeatTemplateDefinition extends DescendentNodeDefinition<'repeat-template', RepeatDefinition> implements NodeDefinition<'repeat-template'> {
+    protected readonly sequence: RepeatSequenceDefinition;
+    protected readonly templateNode: ExplicitRepeatTemplateElement;
+    static parseModelNodes(sequence: RepeatSequenceDefinition, modelNodes: readonly [Element, ...Element[]]): ParsedRepeatNodes;
+    readonly type = "repeat-template";
+    readonly node: Element;
+    readonly nodeName: string;
+    readonly children: readonly ChildNodeDefinition[];
+    readonly instances: null;
+    readonly defaultValue: null;
+    protected constructor(sequence: RepeatSequenceDefinition, templateNode: ExplicitRepeatTemplateElement);
+    toJSON(): Omit<this, "toJSON" | "parent" | "bind" | "root" | "bodyElement" | "sequence">;
+}
+export {};

package/dist/model/RootDefinition.d.ts

@@ -0,0 +1,24 @@
+import type { XFormDefinition } from '../XFormDefinition.ts';
+import type { BindDefinition } from './BindDefinition.ts';
+import type { ModelDefinition } from './ModelDefinition.ts';
+import type { ChildNodeDefinition, NodeDefinition, ParentNodeDefinition } from './NodeDefinition.ts';
+export declare class RootDefinition implements NodeDefinition<'root'> {
+    protected readonly form: XFormDefinition;
+    protected readonly model: ModelDefinition;
+    readonly type = "root";
+    readonly bind: BindDefinition;
+    readonly nodeset: string;
+    readonly nodeName: string;
+    readonly bodyElement: null;
+    readonly root: this;
+    readonly parent: null;
+    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);
+    buildSubtree(parent: ParentNodeDefinition): readonly ChildNodeDefinition[];
+    toJSON(): Omit<this, "model" | "toJSON" | "form" | "bind" | "root" | "bodyElement" | "buildSubtree">;
+}

package/dist/model/SubtreeDefinition.d.ts

@@ -0,0 +1,14 @@
+import type { AnyBodyElementDefinition, NonRepeatGroupElementDefinition } from '../body/BodyDefinition.ts';
+import type { BindDefinition } from './BindDefinition.ts';
+import { DescendentNodeDefinition } from './DescendentNodeDefinition.ts';
+import type { ChildNodeDefinition, NodeDefinition, ParentNodeDefinition } from './NodeDefinition.ts';
+export declare class SubtreeDefinition extends DescendentNodeDefinition<'subtree', NonRepeatGroupElementDefinition | null> implements NodeDefinition<'subtree'> {
+    readonly node: Element;
+    readonly type = "subtree";
+    readonly nodeName: string;
+    readonly children: readonly ChildNodeDefinition[];
+    readonly instances: null;
+    readonly defaultValue: null;
+    constructor(parent: ParentNodeDefinition, bind: BindDefinition, bodyElement: AnyBodyElementDefinition | null, node: Element);
+    toJSON(): Omit<this, "toJSON" | "parent" | "bind" | "root" | "bodyElement">;
+}

package/dist/model/ValueNodeDefinition.d.ts

@@ -0,0 +1,15 @@
+import type { AnyBodyElementDefinition } from '../body/BodyDefinition.ts';
+import type { AnyControlDefinition } from '../body/control/ControlDefinition.ts';
+import type { BindDefinition } from './BindDefinition.ts';
+import { DescendentNodeDefinition } from './DescendentNodeDefinition.ts';
+import type { NodeDefinition, ParentNodeDefinition } from './NodeDefinition.ts';
+export declare class ValueNodeDefinition extends DescendentNodeDefinition<'value-node', AnyControlDefinition | null> implements NodeDefinition<'value-node'> {
+    readonly node: Element;
+    readonly type = "value-node";
+    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">;
+}