@getodk/xforms-engine 0.13.0 → 0.15.0

package/dist/lib/xml-serialization.d.ts

@@ -1,3 +1,5 @@
+import { GeneralChildNode } from '../client/hierarchy.ts';
+import { Attribute } from '../instance/Attribute.ts';
 import { NamespaceDeclarationMap } from './names/NamespaceDeclarationMap.ts';
 import { QualifiedName } from './names/QualifiedName.ts';
 declare const ESCAPED_XML_TEXT_BRAND: unique symbol;
@@ -38,13 +40,7 @@ export type EscapedXMLText = string & {
  *   reconsider this assumption.
  */
 export declare const escapeXMLText: <Text extends string>(text: Exclude<Text, EscapedXMLText>, attr?: boolean) => EscapedXMLText;
-interface SerializableElementAttribute {
-    serializeAttributeXML(): string;
-}
-interface ElementXMLSerializationOptions {
-    readonly namespaceDeclarations?: NamespaceDeclarationMap;
-    readonly attributes?: readonly SerializableElementAttribute[];
-}
-export declare const serializeParentElementXML: (qualifiedName: QualifiedName, serializedChildren: readonly string[], options?: ElementXMLSerializationOptions) => string;
-export declare const serializeLeafElementXML: (qualifiedName: QualifiedName, xmlValue: EscapedXMLText, options?: ElementXMLSerializationOptions) => string;
+export declare const serializeAttributeXML: (qualifiedName: QualifiedName, xmlValue: EscapedXMLText) => string;
+export declare const serializeParentElementXML: (qualifiedName: QualifiedName, children: readonly GeneralChildNode[], attributes: readonly Attribute[], namespaceDeclarations?: NamespaceDeclarationMap) => string;
+export declare const serializeLeafElementXML: (qualifiedName: QualifiedName, xmlValue: EscapedXMLText, namespaceDeclarations?: NamespaceDeclarationMap) => string;
 export {};

package/dist/parse/XFormDOM.d.ts

@@ -29,7 +29,7 @@ export declare class XFormDOM {
     readonly secondaryInstanceElements: readonly DOMSecondaryInstanceElement[];
     readonly body: Element;
     protected constructor(sourceXML: string, options: XFormDOMOptions);
-    toJSON(): Omit<this, "head" | "html" | "title" | "toJSON" | "model" | "primaryInstance" | "primaryInstanceRoot" | "xformDocument"> & {
+    toJSON(): Omit<this, "head" | "html" | "title" | "toJSON" | "primaryInstance" | "model" | "primaryInstanceRoot" | "xformDocument"> & {
         xformDocument: string;
         html: string;
         head: string;

package/dist/parse/body/BodyDefinition.d.ts

@@ -7,9 +7,7 @@ import { RankControlDefinition } from './control/RankControlDefinition.ts';
 import { AnySelectControlDefinition } from './control/SelectControlDefinition.ts';
 import { TriggerControlDefinition } from './control/TriggerControlDefinition.ts';
 import { UploadControlDefinition } from './control/UploadControlDefinition.ts';
-import { LogicalGroupDefinition } from './group/LogicalGroupDefinition.ts';
-import { PresentationGroupDefinition } from './group/PresentationGroupDefinition.ts';
-import { StructuralGroupDefinition } from './group/StructuralGroupDefinition.ts';
+import { GroupElementDefinition } from './GroupElementDefinition.ts';
 import { RepeatElementDefinition } from './RepeatElementDefinition.ts';
 import { UnsupportedBodyElementDefinition } from './UnsupportedBodyElementDefinition.ts';
 export interface BodyElementParentContext {
@@ -18,14 +16,10 @@ export interface BodyElementParentContext {
     readonly element: Element;
 }
 export type ControlElementDefinition = AnySelectControlDefinition | InputControlDefinition | RangeControlDefinition | RankControlDefinition | TriggerControlDefinition | UploadControlDefinition;
-type SupportedBodyElementDefinition = RepeatElementDefinition | LogicalGroupDefinition | PresentationGroupDefinition | StructuralGroupDefinition | ControlElementDefinition;
+type SupportedBodyElementDefinition = ControlElementDefinition | GroupElementDefinition | RepeatElementDefinition;
 export type AnyBodyElementDefinition = SupportedBodyElementDefinition | UnsupportedBodyElementDefinition;
 export type BodyElementDefinitionArray = readonly AnyBodyElementDefinition[];
 export type AnyBodyElementType = AnyBodyElementDefinition['type'];
-export type AnyGroupElementDefinition = Extract<AnyBodyElementDefinition, {
-    readonly type: `${string}-group`;
-}>;
-export declare const groupElementDefinition: (element: AnyBodyElementDefinition) => AnyGroupElementDefinition | null;
 export type AnyControlElementDefinition = Extract<AnyBodyElementDefinition, {
     readonly category: 'control';
 }>;

package/dist/parse/body/GroupElementDefinition.d.ts

@@ -0,0 +1,22 @@
+import { LabelDefinition } from '../text/LabelDefinition.ts';
+import { XFormDefinition } from '../XFormDefinition.ts';
+import { StructureElementAppearanceDefinition } from './appearance/structureElementAppearanceParser.ts';
+import { BodyElementDefinitionArray, BodyElementParentContext } from './BodyDefinition.ts';
+import { BodyElementDefinition } from './BodyElementDefinition.ts';
+/**
+ * As per the spec: https://getodk.github.io/xforms-spec/#groups
+ *
+ * A group combines elements together.
+ * The group can have a label, and if so is referred to as a "presentation group".
+ * The group can have a ref, and if so is referred to as a "logical group".
+ */
+export declare class GroupElementDefinition extends BodyElementDefinition<'group'> {
+    readonly category = "structure";
+    readonly type = "group";
+    readonly children: BodyElementDefinitionArray;
+    readonly reference: string | null;
+    readonly appearances: StructureElementAppearanceDefinition;
+    readonly label: LabelDefinition | null;
+    static isCompatible(localName: string): boolean;
+    constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element);
+}

package/dist/parse/body/control/ItemsetDefinition.d.ts

@@ -1,4 +1,6 @@
+import { StaticElement } from '../../../integration/xpath/static-dom/StaticElement.ts';
 import { ItemsetElement } from '../../../lib/dom/query.ts';
+import { DependentExpression } from '../../expression/abstract/DependentExpression.ts';
 import { ItemsetNodesetExpression } from '../../expression/ItemsetNodesetExpression.ts';
 import { ItemsetValueExpression } from '../../expression/ItemsetValueExpression.ts';
 import { ItemsetLabelDefinition } from '../../text/ItemsetLabelDefinition.ts';
@@ -15,4 +17,5 @@ export declare class ItemsetDefinition extends BodyElementDefinition<'itemset'>
     readonly nodes: ItemsetNodesetExpression;
     readonly value: ItemsetValueExpression;
     constructor(form: XFormDefinition, parent: AnySelectControlDefinition | RankControlDefinition, element: ItemsetElement);
+    getPropertiesExpressions(propertiesNodes: StaticElement[]): Array<DependentExpression<'string'>>;
 }

package/dist/parse/expression/ItemPropertyExpression.d.ts

@@ -0,0 +1,6 @@
+import { StaticElement } from '../../integration/xpath/static-dom/StaticElement.ts';
+import { DependentExpression } from './abstract/DependentExpression.ts';
+export declare class ItemPropertyExpression extends DependentExpression<'string'> {
+    static from(propertiesNodes: StaticElement[]): ItemPropertyExpression[];
+    constructor(propertyName: string);
+}

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

@@ -0,0 +1,22 @@
+import { StaticAttribute } from '../../integration/xpath/static-dom/StaticAttribute.ts';
+import { NamespaceDeclarationMap, NamedNodeDefinition } from '../../lib/names/NamespaceDeclarationMap.ts';
+import { QualifiedName } from '../../lib/names/QualifiedName.ts';
+import { BindDefinition } from './BindDefinition.ts';
+import { NodeDefinition } from './NodeDefinition.ts';
+import { RootDefinition } from './RootDefinition.ts';
+export declare class AttributeDefinition extends NodeDefinition<'attribute'> implements NamedNodeDefinition {
+    readonly template: StaticAttribute;
+    private readonly serializedXML;
+    readonly value: string;
+    readonly type = "attribute";
+    readonly namespaceDeclarations: NamespaceDeclarationMap;
+    readonly bodyElement: null;
+    readonly root: RootDefinition;
+    readonly isTranslated: boolean;
+    readonly parent: null;
+    readonly children: null;
+    readonly attributes: null;
+    readonly qualifiedName: QualifiedName;
+    constructor(root: RootDefinition, bind: BindDefinition, template: StaticAttribute);
+    serializeAttributeXML(): string;
+}

package/dist/parse/model/{RootAttributeMap.d.ts → AttributeDefinitionMap.d.ts}

@@ -1,14 +1,8 @@
 import { StaticElement } from '../../integration/xpath/static-dom/StaticElement.ts';
 import { QualifiedName } from '../../lib/names/QualifiedName.ts';
-import { RootAttributeDefinition } from './RootAttributeDefinition.ts';
-import { RootDefinition } from './RootDefinition.ts';
+import { AttributeDefinition } from './AttributeDefinition.ts';
+import { ModelDefinition } from './ModelDefinition.ts';
 /**
- * @todo This can be trivially expanded to a narrowly general case when we
- * prioritize work to
- * {@link https://github.com/getodk/web-forms/issues/285 | support attributes}
- * (as modeled form nodes on par with elements). It's been deferred here to
- * avoid expanding scope of an already fairly large yak shave.
- *
  * @todo There's a **much more expansive** general case just waiting for a good
  * opportuntity to prioritize it. E.g. a `NamedNodeMap<T>`, where T is any
  * generalized concept of a named node. This expansive generalization would have
@@ -18,7 +12,7 @@ import { RootDefinition } from './RootDefinition.ts';
  *
  * @see {@link QualifiedName} for more detail.
  */
-export declare class RootAttributeMap extends Map<QualifiedName, RootAttributeDefinition> {
-    static from(root: RootDefinition, instanceNode: StaticElement): RootAttributeMap;
+export declare class AttributeDefinitionMap extends Map<QualifiedName, AttributeDefinition> {
+    static from(model: ModelDefinition, instanceNode: StaticElement): AttributeDefinitionMap;
     private constructor();
 }

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

@@ -1,16 +1,20 @@
 import { StaticElement } from '../../integration/xpath/static-dom/StaticElement.ts';
 import { NamespaceDeclarationMap } from '../../lib/names/NamespaceDeclarationMap.ts';
 import { QualifiedName } from '../../lib/names/QualifiedName.ts';
-import { AnyBodyElementDefinition, AnyGroupElementDefinition } from '../body/BodyDefinition.ts';
+import { AnyBodyElementDefinition } from '../body/BodyDefinition.ts';
+import { GroupElementDefinition } from '../body/GroupElementDefinition.ts';
+import { AttributeDefinitionMap } from './AttributeDefinitionMap.ts';
 import { BindDefinition } from './BindDefinition.ts';
 import { DescendentNodeDefinition } from './DescendentNodeDefinition.ts';
+import { ModelDefinition } from './ModelDefinition.ts';
 import { ChildNodeDefinition, ParentNodeDefinition } from './NodeDefinition.ts';
-export declare class SubtreeDefinition extends DescendentNodeDefinition<'subtree', AnyGroupElementDefinition | null> {
+export declare class GroupDefinition extends DescendentNodeDefinition<'group', GroupElementDefinition | null> {
     readonly template: StaticElement;
-    readonly type = "subtree";
+    readonly type = "group";
     readonly namespaceDeclarations: NamespaceDeclarationMap;
     readonly qualifiedName: QualifiedName;
     readonly children: readonly ChildNodeDefinition[];
-    constructor(parent: ParentNodeDefinition, bind: BindDefinition, bodyElement: AnyBodyElementDefinition | null, template: StaticElement);
+    readonly attributes: AttributeDefinitionMap;
+    constructor(model: ModelDefinition, parent: ParentNodeDefinition, bind: BindDefinition, bodyElement: AnyBodyElementDefinition | null, template: StaticElement);
     toJSON(): Omit<this, "parent" | "toJSON" | "bind" | "root" | "bodyElement">;
 }

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

@@ -13,6 +13,7 @@ export declare class LeafNodeDefinition<V extends ValueType = ValueType> extends
     readonly namespaceDeclarations: NamespaceDeclarationMap;
     readonly qualifiedName: QualifiedName;
     readonly children: null;
+    readonly attributes: null;
     constructor(parent: ParentNodeDefinition, bind: BindDefinition, bodyElement: AnyBodyElementDefinition | null, template: StaticLeafElement);
     toJSON(): Omit<this, "parent" | "toJSON" | "bind" | "root" | "bodyElement">;
 }

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

@@ -1,13 +1,16 @@
+import { StaticAttribute } from '../../integration/xpath/static-dom/StaticAttribute.ts';
 import { StaticElement } from '../../integration/xpath/static-dom/StaticElement.ts';
 import { NamedSubtreeDefinition, NamespaceDeclarationMap } from '../../lib/names/NamespaceDeclarationMap.ts';
 import { QualifiedName } from '../../lib/names/QualifiedName.ts';
 import { AnyBodyElementDefinition } from '../body/BodyDefinition.ts';
 import { RepeatElementDefinition } from '../body/RepeatElementDefinition.ts';
+import { AttributeDefinition } from './AttributeDefinition.ts';
+import { AttributeDefinitionMap } from './AttributeDefinitionMap.ts';
 import { BindDefinition } from './BindDefinition.ts';
+import { GroupDefinition } from './GroupDefinition.ts';
 import { LeafNodeDefinition } from './LeafNodeDefinition.ts';
 import { AnyRepeatDefinition } from './RepeatDefinition.ts';
 import { RootDefinition } from './RootDefinition.ts';
-import { SubtreeDefinition } from './SubtreeDefinition.ts';
 /**
  * Corresponds to a model instance root node, i.e.:
  *
@@ -27,10 +30,9 @@ export type RootNodeType = 'root';
 export type RepeatType = 'repeat';
 /**
  * Corresponds to a model instance 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).
+ * <repeat> in the form definition.
  */
-export type SubtreeNodeType = 'subtree';
+export type GroupNodeType = 'group';
 /**
  * Corresponds to a model instance leaf node, i.e. one of:
  *
@@ -38,9 +40,10 @@ export type SubtreeNodeType = 'subtree';
  * - Any attribute corresponding to a bind's `nodeset` expression
  */
 export type LeafNodeType = 'leaf-node';
-export type NodeDefinitionType = RootNodeType | RepeatType | SubtreeNodeType | LeafNodeType;
-export type ParentNodeDefinition = RootDefinition | AnyRepeatDefinition | SubtreeDefinition;
-export type ChildNodeDefinition = AnyRepeatDefinition | LeafNodeDefinition | SubtreeDefinition;
+export type AttributeNodeType = 'attribute';
+export type NodeDefinitionType = RootNodeType | RepeatType | GroupNodeType | LeafNodeType | AttributeNodeType;
+export type ParentNodeDefinition = RootDefinition | AnyRepeatDefinition | GroupDefinition;
+export type ChildNodeDefinition = AnyRepeatDefinition | GroupDefinition | LeafNodeDefinition;
 export declare abstract class NodeDefinition<Type extends NodeDefinitionType> implements NamedSubtreeDefinition {
     readonly bind: BindDefinition;
     abstract readonly type: Type;
@@ -50,9 +53,10 @@ export declare abstract class NodeDefinition<Type extends NodeDefinitionType> im
     abstract readonly isTranslated: boolean;
     abstract readonly root: RootDefinition;
     abstract readonly parent: ParentNodeDefinition | null;
-    abstract readonly template: StaticElement;
+    abstract readonly template: StaticAttribute | StaticElement;
     abstract readonly children: readonly ChildNodeDefinition[] | null;
+    abstract readonly attributes: AttributeDefinitionMap | null;
     readonly nodeset: string;
     constructor(bind: BindDefinition);
 }
-export type AnyNodeDefinition = RootDefinition | AnyRepeatDefinition | SubtreeDefinition | LeafNodeDefinition;
+export type AnyNodeDefinition = RootDefinition | AnyRepeatDefinition | GroupDefinition | LeafNodeDefinition | AttributeDefinition;

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

@@ -3,8 +3,10 @@ import { NamespaceDeclarationMap } from '../../lib/names/NamespaceDeclarationMap
 import { QualifiedName } from '../../lib/names/QualifiedName.ts';
 import { RepeatElementDefinition } from '../body/RepeatElementDefinition.ts';
 import { RepeatCountControlExpression } from '../expression/RepeatCountControlExpression.ts';
+import { AttributeDefinitionMap } from './AttributeDefinitionMap.ts';
 import { BindDefinition } from './BindDefinition.ts';
 import { DescendentNodeDefinition } from './DescendentNodeDefinition.ts';
+import { ModelDefinition } from './ModelDefinition.ts';
 import { ChildNodeDefinition, ParentNodeDefinition } from './NodeDefinition.ts';
 export type RepeatInstanceNodes = readonly [StaticElement, ...StaticElement[]];
 export interface ControlledRepeatDefinition extends RepeatDefinition {
@@ -18,7 +20,7 @@ export interface UncontrolledRepeatDefinition extends RepeatDefinition {
  * "repeat", as defined by a form, where those concepts include:
  *
  * - A {@link RepeatElementDefinition}—corresponding to a `<repeat>` {@link https://getodk.github.io/xforms-spec/#body-elements | body element}—which is associated with the nodeset referencing the "repeat template" and
- *   all "repeat instances" (see below points describing both concepts in more detail). The presence of such a body element determines whether to produce a repeat definition (rather than e.g. a {@link SubtreeDefinition}).
+ *   all "repeat instances" (see below points describing both concepts in more detail). The presence of such a body element determines whether to produce a repeat definition (rather than e.g. a {@link GroupDefinition}).
  *
  * - A "repeat template", defined by a form either
  *   explicitly,
@@ -46,13 +48,14 @@ export interface UncontrolledRepeatDefinition extends RepeatDefinition {
  * associated with a defined repeat.
  */
 export declare class RepeatDefinition extends DescendentNodeDefinition<'repeat', RepeatElementDefinition> {
-    static from(parent: ParentNodeDefinition, bind: BindDefinition, bodyElement: RepeatElementDefinition, instanceNodes: RepeatInstanceNodes): AnyRepeatDefinition;
+    static from(model: ModelDefinition, parent: ParentNodeDefinition, bind: BindDefinition, bodyElement: RepeatElementDefinition, instanceNodes: RepeatInstanceNodes): AnyRepeatDefinition;
     readonly type = "repeat";
     readonly children: readonly ChildNodeDefinition[];
     readonly count: RepeatCountControlExpression | null;
     readonly template: StaticElement;
     readonly namespaceDeclarations: NamespaceDeclarationMap;
     readonly qualifiedName: QualifiedName;
+    readonly attributes: AttributeDefinitionMap;
     private constructor();
     isControlled(): this is ControlledRepeatDefinition;
     isUncontrolled(): this is UncontrolledRepeatDefinition;

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

@@ -3,9 +3,9 @@ import { NamespaceDeclarationMap } from '../../lib/names/NamespaceDeclarationMap
 import { QualifiedName } from '../../lib/names/QualifiedName.ts';
 import { BodyClassList } from '../body/BodyDefinition.ts';
 import { XFormDefinition } from '../XFormDefinition.ts';
+import { AttributeDefinitionMap } from './AttributeDefinitionMap.ts';
 import { ModelDefinition } from './ModelDefinition.ts';
 import { ChildNodeDefinition, ParentNodeDefinition, NodeDefinition } from './NodeDefinition.ts';
-import { RootAttributeMap } from './RootAttributeMap.ts';
 import { SubmissionDefinition } from './SubmissionDefinition.ts';
 export declare class RootDefinition extends NodeDefinition<'root'> {
     protected readonly form: XFormDefinition;
@@ -19,10 +19,10 @@ export declare class RootDefinition extends NodeDefinition<'root'> {
     readonly parent: null;
     readonly template: StaticElement;
     readonly namespaceDeclarations: NamespaceDeclarationMap;
-    readonly attributes: RootAttributeMap;
+    readonly attributes: AttributeDefinitionMap;
     readonly children: readonly ChildNodeDefinition[];
     readonly isTranslated = false;
     constructor(form: XFormDefinition, model: ModelDefinition, submission: SubmissionDefinition, classes: BodyClassList);
     buildSubtree(parent: ParentNodeDefinition, node: StaticElement): readonly ChildNodeDefinition[];
-    toJSON(): Omit<this, "form" | "toJSON" | "bind" | "root" | "model" | "bodyElement" | "buildSubtree">;
+    toJSON(): Omit<this, "form" | "toJSON" | "bind" | "model" | "root" | "bodyElement" | "buildSubtree">;
 }

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

@@ -1,14 +1,13 @@
 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 { GroupElementDefinition } from '../body/GroupElementDefinition.ts';
+import { RepeatElementDefinition } from '../body/RepeatElementDefinition.ts';
 import { TextElementDefinition } from './abstract/TextElementDefinition.ts';
-export type LabelOwner = AnyControlDefinition | AnyGroupElementDefinition | RepeatElementDefinition;
+export type LabelOwner = AnyControlDefinition | GroupElementDefinition | RepeatElementDefinition;
 export declare class LabelDefinition extends TextElementDefinition<'label'> {
     static forControl(form: XFormDefinition, control: AnyControlDefinition): LabelDefinition | null;
     static forRepeatGroup(form: XFormDefinition, repeat: RepeatElementDefinition): LabelDefinition | null;
-    static forGroup(form: XFormDefinition, group: BaseGroupDefinition<any>): LabelDefinition | null;
+    static forGroup(form: XFormDefinition, group: GroupElementDefinition): LabelDefinition | null;
     readonly role = "label";
     private constructor();
 }