@getodk/xforms-engine 0.1.0

package/README.md

@@ -0,0 +1,44 @@
+# @getodk/xforms-engine
+
+Implementation of the [ODK XForms specification](https://getodk.github.io/xforms-spec/)'s data model and computation logic. This package does not handle presentation or user interaction. Those aspects of forms are meant to be handled by a client. Presently, those clients are:
+
+- [`@getodk/web-forms`](../web-forms)
+- [`@getodk/ui-solid`](../ui-solid)
+
+## Install
+
+Install with `npm` (or the equivalent command for your preferred package manager):
+
+```sh
+npm install @getodk/xforms-engine
+```
+
+## Development
+
+> [!NOTE]
+> All commands should be run from the root of the monorepo, not this package's subdirectory.
+
+Test commands:
+
+```sh
+# Single run
+yarn workspace @getodk/xforms-engine test-node:jsdom
+yarn workspace @getodk/xforms-engine test-browser:chromium
+yarn workspace @getodk/xforms-engine test-browser:firefox
+yarn workspace @getodk/xforms-engine test-browser:webkit
+
+# Watch mode (convenient during development)
+yarn workspace @getodk/xforms-engine test-watch:jsdom
+yarn workspace @getodk/xforms-engine test-watch:chromium
+yarn workspace @getodk/xforms-engine test-watch:firefox
+yarn workspace @getodk/xforms-engine test-watch:webkit
+```
+
+## Supported/tested environments
+
+- Browsers (latest versions):
+  - Chrome/Chromium-based browsers (tested only in Chromium)
+  - Firefox
+  - Safari/WebKit (tested in WebKit directly)
+- Non-browser runtimes with a DOM compatibility environement:
+  - Node (current/LTS; tested with [jsdom](https://github.com/jsdom/jsdom)). Server-side rendering of forms is not presently supported or targeted beyond testing, though it may be considered in the future. Inclusion of Node in the automated test suites helps us to keep this option open.

package/dist/.vite/manifest.json

@@ -0,0 +1,7 @@
+{
+  "src/index.ts": {
+    "file": "solid.js",
+    "src": "src/index.ts",
+    "isEntry": true
+  }
+}

package/dist/XFormDOM.d.ts

@@ -0,0 +1,31 @@
+import { XFormsXPathEvaluator } from '@getodk/xpath';
+interface XFormDOMNormalizationOptions {
+    readonly isNormalized: boolean;
+}
+export declare class XFormDOM {
+    protected readonly sourceXML: string;
+    static from(sourceXML: string): XFormDOM;
+    protected readonly normalizedXML: string;
+    readonly rootEvaluator: XFormsXPathEvaluator;
+    readonly primaryInstanceEvaluator: XFormsXPathEvaluator;
+    readonly xformDocument: XMLDocument;
+    readonly html: Element;
+    readonly head: Element;
+    readonly title: Element;
+    readonly model: Element;
+    readonly primaryInstance: Element;
+    readonly primaryInstanceRoot: Element;
+    readonly body: Element;
+    protected constructor(sourceXML: string, options: XFormDOMNormalizationOptions);
+    createInstance(): XFormDOM;
+    toJSON(): Omit<this, "xformDocument" | "html" | "rootEvaluator" | "primaryInstanceEvaluator" | "head" | "title" | "model" | "primaryInstance" | "primaryInstanceRoot" | "createInstance" | "toJSON"> & {
+        xformDocument: string;
+        html: string;
+        head: string;
+        title: string;
+        model: string;
+        primaryInstance: string;
+        primaryInstanceRoot: string;
+    };
+}
+export {};

package/dist/XFormDataType.d.ts

@@ -0,0 +1,26 @@
+import type { CollectionValues } from '../../common/types/collections/CollectionValues.ts';
+/**
+ * Like JavaRosa. Presumably for explicit types which aren't impelemnted?
+ */
+declare const UNSUPPORTED_DATA_TYPE = "UNSUPPORTED";
+export type UnsupportedDataType = typeof UNSUPPORTED_DATA_TYPE;
+/**
+ * Like JavaRosa. Presumably for e.g. groups with explicit binds (`relevant` etc)?
+ */
+declare const NULL_DATA_TYPE = "NULL";
+export type NullDataType = typeof NULL_DATA_TYPE;
+/**
+ * As in ODK XForms Spec.
+ *
+ * TODO: it's unclear why JavaRosa's `DataType` hews closely to the spec, but
+ * has certain differences (e.g. string -> TEXT, int -> INTEGER). It's also
+ * not immediately clear how additive types like CHOICE and MULTIPLE_ITEMS
+ * square with the underlying spec types.
+ */
+export declare const XFORM_SPEC_DATA_TYPES: readonly ["string", "int", "boolean", "decimal", "date", "time", "dateTime", "geopoint", "geotrace", "geoshape", "binary", "barcode", "intent"];
+export type XFormSpecDataType = CollectionValues<typeof XFORM_SPEC_DATA_TYPES>;
+export type XFormDataType = NullDataType | UnsupportedDataType | XFormSpecDataType;
+declare const DEFAULT_XFORM_DATA_TYPE = "string";
+export type DefaultXFormDataType = typeof DEFAULT_XFORM_DATA_TYPE;
+export declare const bindDataType: (bindType: string | null) => XFormDataType;
+export {};

package/dist/XFormDefinition.d.ts

@@ -0,0 +1,14 @@
+import { XFormDOM } from './XFormDOM.ts';
+import { BodyDefinition } from './body/BodyDefinition.ts';
+import { ModelDefinition } from './model/ModelDefinition.ts';
+export declare class XFormDefinition {
+    readonly sourceXML: string;
+    readonly xformDOM: XFormDOM;
+    readonly xformDocument: XMLDocument;
+    readonly id: string;
+    readonly title: string;
+    readonly rootReference: string;
+    readonly body: BodyDefinition;
+    readonly model: ModelDefinition;
+    constructor(sourceXML: string);
+}

package/dist/body/BodyDefinition.d.ts

@@ -0,0 +1,52 @@
+import type { XFormDefinition } from '../XFormDefinition.ts';
+import { DependencyContext } from '../expression/DependencyContext.ts';
+import { UnsupportedBodyElementDefinition } from './UnsupportedBodyElementDefinition.ts';
+import { InputDefinition } from './control/InputDefinition.ts';
+import type { AnySelectDefinition } from './control/select/SelectDefinition.ts';
+import { LogicalGroupDefinition } from './group/LogicalGroupDefinition.ts';
+import { PresentationGroupDefinition } from './group/PresentationGroupDefinition.ts';
+import { RepeatGroupDefinition } from './group/RepeatGroupDefinition.ts';
+import { StructuralGroupDefinition } from './group/StructuralGroupDefinition.ts';
+export interface BodyElementParentContext {
+    readonly reference: string | null;
+    readonly element: Element;
+}
+type SupportedBodyElementDefinition = RepeatGroupDefinition | LogicalGroupDefinition | PresentationGroupDefinition | StructuralGroupDefinition | InputDefinition | AnySelectDefinition;
+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 type NonRepeatGroupElementDefinition = Exclude<AnyGroupElementDefinition, {
+    readonly type: 'repeat-group';
+}>;
+export declare const groupElementDefinition: (element: AnyBodyElementDefinition) => AnyGroupElementDefinition | null;
+export type AnyControlElementDefinition = Extract<AnyBodyElementDefinition, {
+    readonly category: 'control';
+}>;
+export declare const controlElementDefinition: (element: AnyBodyElementDefinition) => AnyControlElementDefinition | null;
+type BodyElementReference = string;
+declare class BodyElementMap extends Map<BodyElementReference, AnyBodyElementDefinition> {
+    constructor(elements: BodyElementDefinitionArray);
+    protected mapElementsByReference(elements: BodyElementDefinitionArray): void;
+    set(reference: BodyElementReference, element: AnyBodyElementDefinition): this;
+    getBodyElementType(reference: BodyElementReference): AnyBodyElementType | null;
+    toJSON(): {
+        [k: string]: AnyBodyElementDefinition;
+    };
+}
+export declare class BodyDefinition extends DependencyContext {
+    protected readonly form: XFormDefinition;
+    static getChildElementDefinitions(form: XFormDefinition, parent: BodyElementParentContext, parentElement: Element, children?: readonly Element[]): readonly AnyBodyElementDefinition[];
+    readonly element: Element;
+    readonly elements: readonly AnyBodyElementDefinition[];
+    protected readonly elementsByReference: BodyElementMap;
+    readonly parentReference: null;
+    readonly reference: string;
+    constructor(form: XFormDefinition);
+    getBodyElement(reference: string): AnyBodyElementDefinition | null;
+    getRepeatGroup(reference: string): RepeatGroupDefinition | null;
+    toJSON(): Omit<this, "toJSON" | "form" | "isTranslated" | "registerDependentExpression" | "dependencyExpressions" | "getBodyElement" | "getRepeatGroup">;
+}
+export {};

package/dist/body/BodyElementDefinition.d.ts

@@ -0,0 +1,32 @@
+import type { XFormDefinition } from '../XFormDefinition.ts';
+import { DependencyContext } from '../expression/DependencyContext.ts';
+import type { BodyElementParentContext } from './BodyDefinition.ts';
+import type { HintDefinition } from './text/HintDefinition.ts';
+import type { LabelDefinition } from './text/LabelDefinition.ts';
+/**
+ * These category names roughly correspond to each of the ODK XForms spec's
+ * {@link https://getodk.github.io/xforms-spec/#body-elements | Body Elements}
+ * tables.
+ */
+type BodyElementCategory = 'control' | 'structure' | 'support' | 'UNSUPPORTED';
+export declare abstract class BodyElementDefinition<Type extends string> extends DependencyContext {
+    protected readonly form: XFormDefinition;
+    readonly parent: BodyElementParentContext;
+    readonly element: Element;
+    static isCompatible(localName: string, element: Element): boolean;
+    abstract readonly category: BodyElementCategory;
+    abstract readonly type: Type;
+    readonly hint: HintDefinition | null;
+    readonly label: LabelDefinition | null;
+    readonly reference: string | null;
+    readonly parentReference: string | null;
+    protected constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element);
+    toJSON(): object;
+}
+type BodyElementDefinitionClass = Pick<typeof BodyElementDefinition, keyof typeof BodyElementDefinition>;
+export type BodyElementDefinitionConstructor = BodyElementDefinitionClass & (new (form: XFormDefinition, element: Element) => BodyElementDefinition<any>);
+type BodyElementDefinitionInstance = InstanceType<BodyElementDefinitionConstructor>;
+export type TypedBodyElementDefinition<Type extends string> = Extract<BodyElementDefinitionInstance, {
+    readonly type: Type;
+}>;
+export {};

package/dist/body/RepeatDefinition.d.ts

@@ -0,0 +1,15 @@
+import type { XFormDefinition } from '../XFormDefinition.ts';
+import type { BodyElementDefinitionArray } from './BodyDefinition.ts';
+import { BodyElementDefinition } from './BodyElementDefinition.ts';
+import type { RepeatGroupDefinition } from './group/RepeatGroupDefinition.ts';
+export declare class RepeatDefinition extends BodyElementDefinition<'repeat'> {
+    readonly groupDefinition: RepeatGroupDefinition;
+    readonly category = "structure";
+    readonly type = "repeat";
+    readonly reference: string;
+    readonly countExpression: string | null;
+    readonly isFixedCount: boolean;
+    readonly children: BodyElementDefinitionArray;
+    constructor(form: XFormDefinition, groupDefinition: RepeatGroupDefinition, element: Element);
+    toJSON(): Omit<this, "toJSON" | "form" | "parent" | "isTranslated" | "registerDependentExpression" | "dependencyExpressions" | "groupDefinition">;
+}

package/dist/body/UnsupportedBodyElementDefinition.d.ts

@@ -0,0 +1,10 @@
+import type { XFormDefinition } from '../XFormDefinition.ts';
+import type { BodyElementParentContext } from './BodyDefinition.ts';
+import { BodyElementDefinition } from './BodyElementDefinition.ts';
+export declare class UnsupportedBodyElementDefinition extends BodyElementDefinition<'UNSUPPORTED'> {
+    static isCompatible(): boolean;
+    readonly category = "UNSUPPORTED";
+    readonly type = "UNSUPPORTED";
+    readonly reference: null;
+    constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element);
+}

package/dist/body/control/ControlDefinition.d.ts

@@ -0,0 +1,16 @@
+import type { XFormDefinition } from '../../XFormDefinition.ts';
+import type { BodyElementParentContext } from '../BodyDefinition.ts';
+import { BodyElementDefinition } from '../BodyElementDefinition.ts';
+import { HintDefinition } from '../text/HintDefinition.ts';
+import { LabelDefinition } from '../text/LabelDefinition.ts';
+type ControlType = 'input' | 'range' | 'rank' | 'select' | 'select1' | 'trigger' | 'upload';
+export declare abstract class ControlDefinition<Type extends ControlType> extends BodyElementDefinition<Type> {
+    readonly category = "control";
+    abstract readonly type: Type;
+    readonly reference: string;
+    readonly label: LabelDefinition | null;
+    readonly hint: HintDefinition | null;
+    constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element);
+}
+export type AnyControlDefinition = ControlDefinition<any>;
+export {};

package/dist/body/control/InputDefinition.d.ts

@@ -0,0 +1,5 @@
+import { ControlDefinition } from './ControlDefinition.ts';
+export declare class InputDefinition extends ControlDefinition<'input'> {
+    static isCompatible(localName: string): boolean;
+    readonly type = "input";
+}

package/dist/body/control/select/ItemDefinition.d.ts

@@ -0,0 +1,13 @@
+import { type ItemElement } from '../../../lib/dom/query.ts';
+import type { XFormDefinition } from '../../../XFormDefinition.ts';
+import { BodyElementDefinition } from '../../BodyElementDefinition.ts';
+import { LabelDefinition } from '../../text/LabelDefinition.ts';
+import type { AnySelectDefinition } from './SelectDefinition.ts';
+export declare class ItemDefinition extends BodyElementDefinition<'item'> {
+    readonly parent: AnySelectDefinition;
+    readonly category = "support";
+    readonly type = "item";
+    readonly label: LabelDefinition | null;
+    readonly value: string;
+    constructor(form: XFormDefinition, parent: AnySelectDefinition, element: ItemElement);
+}

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

@@ -0,0 +1,16 @@
+import { type ItemsetElement } from '../../../lib/dom/query.ts';
+import type { XFormDefinition } from '../../../XFormDefinition.ts';
+import { BodyElementDefinition } from '../../BodyElementDefinition.ts';
+import { LabelDefinition } from '../../text/LabelDefinition.ts';
+import { ItemsetNodesetExpression } from './ItemsetNodesetExpression.ts';
+import { ItemsetValueExpression } from './ItemsetValueExpression.ts';
+import type { AnySelectDefinition } from './SelectDefinition.ts';
+export declare class ItemsetDefinition extends BodyElementDefinition<'itemset'> {
+    readonly category = "support";
+    readonly type = "itemset";
+    readonly reference: string;
+    readonly label: LabelDefinition | null;
+    readonly nodes: ItemsetNodesetExpression;
+    readonly value: ItemsetValueExpression;
+    constructor(form: XFormDefinition, select: AnySelectDefinition, element: ItemsetElement);
+}

package/dist/body/control/select/ItemsetNodesetContext.d.ts

@@ -0,0 +1,11 @@
+import { DependencyContext } from '../../../expression/DependencyContext.ts';
+import type { AnyDependentExpression } from '../../../expression/DependentExpression.ts';
+import type { ItemsetDefinition } from './ItemsetDefinition.ts';
+export declare class ItemsetNodesetContext extends DependencyContext {
+    protected readonly itemset: ItemsetDefinition;
+    readonly parentReference: null;
+    readonly reference: string;
+    constructor(itemset: ItemsetDefinition, nodesetExpression: string);
+    set isTranslated(value: true);
+    registerDependentExpression(expression: AnyDependentExpression): void;
+}

package/dist/body/control/select/ItemsetNodesetExpression.d.ts

@@ -0,0 +1,5 @@
+import { DependentExpression } from '../../../expression/DependentExpression.ts';
+import type { ItemsetDefinition } from './ItemsetDefinition.ts';
+export declare class ItemsetNodesetExpression extends DependentExpression<'nodes'> {
+    constructor(itemset: ItemsetDefinition, nodesetExpression: string);
+}

package/dist/body/control/select/ItemsetValueExpression.d.ts

@@ -0,0 +1,6 @@
+import { DependentExpression } from '../../../expression/DependentExpression.ts';
+import type { ItemsetDefinition } from './ItemsetDefinition.ts';
+export declare class ItemsetValueExpression extends DependentExpression<'string'> {
+    readonly itemset: ItemsetDefinition;
+    constructor(itemset: ItemsetDefinition, expression: string);
+}

package/dist/body/control/select/SelectDefinition.d.ts

@@ -0,0 +1,23 @@
+import type { CollectionValues } from '../../../../../common/types/collections/CollectionValues.ts';
+import type { LocalNamedElement } from '../../../../../common/types/dom.ts';
+import type { XFormDefinition } from '../../../XFormDefinition.ts';
+import type { AnyBodyElementDefinition, BodyElementParentContext } from '../../BodyDefinition.ts';
+import { ControlDefinition } from '../ControlDefinition.ts';
+import { ItemDefinition } from './ItemDefinition.ts';
+import { ItemsetDefinition } from './ItemsetDefinition.ts';
+declare const selectLocalNames: Set<"select" | "rank" | "select1">;
+export type SelectType = CollectionValues<typeof selectLocalNames>;
+export interface SelectElement extends LocalNamedElement<SelectType> {
+}
+export declare class SelectDefinition<Type extends SelectType> extends ControlDefinition<Type> {
+    static isCompatible(localName: string, element: Element): boolean;
+    static isSelect(element: AnyBodyElementDefinition): element is AnySelectDefinition;
+    readonly type: Type;
+    readonly element: SelectElement;
+    readonly itemset: ItemsetDefinition | null;
+    readonly items: readonly ItemDefinition[];
+    constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element);
+    toJSON(): {};
+}
+export type AnySelectDefinition = SelectDefinition<SelectType>;
+export {};

package/dist/body/group/BaseGroupDefinition.d.ts

@@ -0,0 +1,46 @@
+import type { XFormDefinition } from '../../XFormDefinition.ts';
+import { type BodyElementDefinitionArray, type BodyElementParentContext } from '../BodyDefinition.ts';
+import { BodyElementDefinition } from '../BodyElementDefinition.ts';
+import { LabelDefinition } from '../text/LabelDefinition.ts';
+/**
+ * These type names are derived from **and expand upon** the language used in
+ * the ODK XForms spec to describe various group usage. Whereas the spec
+ * language allows for a group to be described as more than one case, the intent
+ * here is to establish exclusive naming which may or may not compound. As such:
+ *
+ * - `logical-group`, per spec language, is a group with a `ref`; its usage here
+ *   differs from the spec language in that it _may_ have a `<label>` child but
+ *   is not also treated as a `presentation-group` (which is only used for
+ *   groups which do not have a `ref`)
+ * - `presentation-group` is a group with a `<label>` child; its usage here
+ *   differs from the spec language in that `presentation-group` does **not**
+ *   have a `ref`
+ * - `repeat-group` is not mentioned by the spec; it is an extension of
+ *   `logical-group`, wherein its `ref` is the same as its immediate `<repeat>`
+ *   child's `nodeset` (usage of each attribute is normalized during
+ *   initialization, in {@link XFormDOM})
+ * - `structural-group` is any `<group>` element which does not satisfy any of
+ *   the other usage scenarios; this isn't exactly the terminology used, but is
+ *   the most closely fitting name for the concept where the other sceanarios
+ *   do not apply
+ *
+ * A more succinct decision tree:
+ *
+ * - `<group ref="$ref"><repeat nodeset="$ref">` -> `repeat-group`, else
+ * - `<group ref="$ref">` -> `logical-group`, else
+ * - `<group><label>` -> `presentation-group`, else
+ * - `<group>` -> `structural-group`
+ */
+export type GroupType = 'logical-group' | 'presentation-group' | 'repeat-group' | 'structural-group';
+export declare abstract class BaseGroupDefinition<Type extends GroupType> extends BodyElementDefinition<Type> {
+    private static groupTypes;
+    protected static getGroupType(localName: string, element: Element): GroupType | null;
+    readonly category = "structure";
+    readonly children: BodyElementDefinitionArray;
+    readonly reference: string | null;
+    readonly label: LabelDefinition | null;
+    constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element, children?: BodyElementDefinitionArray);
+    getChildren(element: Element): BodyElementDefinitionArray;
+}
+export declare const repeatGroup: <T extends BaseGroupDefinition<any>>(groupDefinition: T) => Extract<T, BaseGroupDefinition<"repeat-group">> | null;
+export declare const nonRepeatGroup: <T extends BaseGroupDefinition<any>>(groupDefinition: T) => Exclude<T, BaseGroupDefinition<"repeat-group">> | null;

package/dist/body/group/LogicalGroupDefinition.d.ts

@@ -0,0 +1,6 @@
+import { BaseGroupDefinition } from './BaseGroupDefinition.ts';
+export declare class LogicalGroupDefinition extends BaseGroupDefinition<'logical-group'> {
+    static isCompatible(localName: string, element: Element): boolean;
+    readonly type = "logical-group";
+}
+export type LogicalGroupDefinitionClass = typeof LogicalGroupDefinition;

package/dist/body/group/PresentationGroupDefinition.d.ts

@@ -0,0 +1,11 @@
+import type { XFormDefinition } from '../../XFormDefinition.ts';
+import type { BodyElementParentContext } from '../BodyDefinition.ts';
+import { LabelDefinition } from '../text/LabelDefinition.ts';
+import { BaseGroupDefinition } from './BaseGroupDefinition.ts';
+export declare class PresentationGroupDefinition extends BaseGroupDefinition<'presentation-group'> {
+    static isCompatible(localName: string, element: Element): boolean;
+    readonly type = "presentation-group";
+    readonly label: LabelDefinition;
+    constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element);
+}
+export type PresentationGroupDefinitionClass = typeof PresentationGroupDefinition;

package/dist/body/group/RepeatGroupDefinition.d.ts

@@ -0,0 +1,12 @@
+import type { XFormDefinition } from '../../XFormDefinition.ts';
+import type { BodyElementDefinitionArray, BodyElementParentContext } from '../BodyDefinition.ts';
+import { RepeatDefinition } from '../RepeatDefinition.ts';
+import { BaseGroupDefinition } from './BaseGroupDefinition.ts';
+export declare class RepeatGroupDefinition extends BaseGroupDefinition<'repeat-group'> {
+    static isCompatible(localName: string, element: Element): boolean;
+    readonly type = "repeat-group";
+    readonly repeat: RepeatDefinition;
+    get repeatChildren(): BodyElementDefinitionArray;
+    constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element);
+}
+export type RepeatGroupDefinitionClass = typeof RepeatGroupDefinition;

package/dist/body/group/StructuralGroupDefinition.d.ts

@@ -0,0 +1,6 @@
+import { BaseGroupDefinition } from './BaseGroupDefinition.ts';
+export declare class StructuralGroupDefinition extends BaseGroupDefinition<'structural-group'> {
+    static isCompatible(localName: string, element: Element): boolean;
+    readonly type = "structural-group";
+}
+export type StructuralGroupDefinitionClass = typeof StructuralGroupDefinition;

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

@@ -0,0 +1,11 @@
+import type { XFormDefinition } from '../../XFormDefinition.ts';
+import type { AnyControlDefinition } from '../control/ControlDefinition.ts';
+import type { TextElement } from './TextElementDefinition.ts';
+import { TextElementDefinition } from './TextElementDefinition.ts';
+export interface HintElement extends TextElement {
+    readonly localName: 'hint';
+}
+export declare class HintDefinition extends TextElementDefinition<'hint'> {
+    static forElement(form: XFormDefinition, definition: AnyControlDefinition): HintDefinition | null;
+    readonly type = "hint";
+}

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

@@ -0,0 +1,20 @@
+import type { XFormDefinition } from '../../XFormDefinition.ts';
+import type { AnyControlDefinition } from '../control/ControlDefinition.ts';
+import type { ItemDefinition } from '../control/select/ItemDefinition.ts';
+import type { ItemsetDefinition } from '../control/select/ItemsetDefinition.ts';
+import type { BaseGroupDefinition } from '../group/BaseGroupDefinition.ts';
+import type { TextElement, TextElementOwner } from './TextElementDefinition.ts';
+import { TextElementDefinition } from './TextElementDefinition.ts';
+export interface LabelElement extends TextElement {
+    readonly localName: 'label';
+}
+type StaticLabelContext = Exclude<TextElementOwner, ItemsetDefinition>;
+export declare class LabelDefinition extends TextElementDefinition<'label'> {
+    protected static staticDefinition(form: XFormDefinition, definition: StaticLabelContext): LabelDefinition | null;
+    static forControl(form: XFormDefinition, control: AnyControlDefinition): LabelDefinition | null;
+    static forGroup(form: XFormDefinition, group: BaseGroupDefinition<any>): LabelDefinition | null;
+    static forItem(form: XFormDefinition, item: ItemDefinition): LabelDefinition | null;
+    static forItemset(form: XFormDefinition, itemset: ItemsetDefinition): LabelDefinition | null;
+    readonly type = "label";
+}
+export {};

package/dist/body/text/TextElementDefinition.d.ts

@@ -0,0 +1,32 @@
+import type { XFormDefinition } from '../../XFormDefinition.ts';
+import { type AnyDependentExpression } from '../../expression/DependentExpression.ts';
+import type { AnyGroupElementDefinition } from '../BodyDefinition.ts';
+import { BodyElementDefinition } from '../BodyElementDefinition.ts';
+import type { InputDefinition } from '../control/InputDefinition.ts';
+import type { ItemDefinition } from '../control/select/ItemDefinition.ts';
+import type { ItemsetDefinition } from '../control/select/ItemsetDefinition.ts';
+import type { AnySelectDefinition } from '../control/select/SelectDefinition.ts';
+import { TextElementOutputPart } from './TextElementOutputPart.ts';
+import { TextElementReferencePart } from './TextElementReferencePart.ts';
+import { TextElementStaticPart } from './TextElementStaticPart.ts';
+export type TextElementType = 'hint' | 'label';
+export interface TextElement extends Element {
+    readonly localName: TextElementType;
+}
+export type TextElementOwner = AnyGroupElementDefinition | AnySelectDefinition | InputDefinition | ItemDefinition | ItemsetDefinition;
+export type TextElementChild = TextElementOutputPart | TextElementStaticPart;
+export declare abstract class TextElementDefinition<Type extends TextElementType> extends BodyElementDefinition<Type> {
+    readonly owner: TextElementOwner;
+    readonly category = "support";
+    abstract readonly type: Type;
+    readonly reference: string | null;
+    readonly parentReference: string | null;
+    readonly referenceExpression: TextElementReferencePart | null;
+    readonly children: readonly TextElementChild[];
+    get isTranslated(): boolean;
+    set isTranslated(value: true);
+    protected constructor(form: XFormDefinition, owner: TextElementOwner, element: TextElement);
+    registerDependentExpression(expression: AnyDependentExpression): void;
+    toJSON(): object;
+}
+export type AnyTextElementDefinition = TextElementDefinition<TextElementType>;

package/dist/body/text/TextElementOutputPart.d.ts

@@ -0,0 +1,12 @@
+import type { AnyTextElementDefinition } from './TextElementDefinition.ts';
+import { TextElementPart } from './TextElementPart.ts';
+interface OutputElement extends Element {
+    readonly localName: 'output';
+    getAttribute(name: 'value'): string;
+    getAttribute(name: string): string | null;
+}
+export declare class TextElementOutputPart extends TextElementPart<'output'> {
+    static from(context: AnyTextElementDefinition, element: Element): TextElementOutputPart | null;
+    protected constructor(context: AnyTextElementDefinition, element: OutputElement);
+}
+export {};

package/dist/body/text/TextElementPart.d.ts

@@ -0,0 +1,12 @@
+import { DependentExpression } from '../../expression/DependentExpression.ts';
+import type { AnyTextElementDefinition } from './TextElementDefinition.ts';
+import type { TextElementOutputPart } from './TextElementOutputPart.ts';
+import type { TextElementReferencePart } from './TextElementReferencePart.ts';
+import type { TextElementStaticPart } from './TextElementStaticPart.ts';
+export type TextElementPartType = 'output' | 'reference' | 'static';
+export declare abstract class TextElementPart<Type extends TextElementPartType> extends DependentExpression<'string'> {
+    readonly type: Type;
+    readonly stringValue?: string;
+    constructor(type: Type, context: AnyTextElementDefinition, expression: string);
+}
+export type AnyTextElementPart = TextElementOutputPart | TextElementReferencePart | TextElementStaticPart;

package/dist/body/text/TextElementReferencePart.d.ts

@@ -0,0 +1,6 @@
+import type { AnyTextElementDefinition, TextElement } from './TextElementDefinition.ts';
+import { TextElementPart } from './TextElementPart.ts';
+export declare class TextElementReferencePart extends TextElementPart<'reference'> {
+    static from(context: AnyTextElementDefinition, element: TextElement): TextElementReferencePart | null;
+    protected constructor(context: AnyTextElementDefinition, expression: string);
+}

package/dist/body/text/TextElementStaticPart.d.ts

@@ -0,0 +1,6 @@
+import type { AnyTextElementDefinition } from './TextElementDefinition.ts';
+import { TextElementPart } from './TextElementPart.ts';
+export declare class TextElementStaticPart extends TextElementPart<'static'> {
+    readonly stringValue: string;
+    constructor(context: AnyTextElementDefinition, node: Text);
+}