@getodk/xforms-engine 0.8.0 → 0.10.0

package/dist/instance/SelectControl.d.ts

@@ -22,6 +22,7 @@ interface SelectControlStateSpec extends ValueNodeStateSpec<readonly string[]> {
     readonly label: Accessor<TextRange<'label'> | null>;
     readonly hint: Accessor<TextRange<'hint'> | null>;
     readonly valueOptions: Accessor<SelectValueOptions>;
+    readonly isSelectWithImages: Accessor<boolean>;
 }
 export declare class SelectControl extends ValueNode<'string', SelectDefinition<'string'>, readonly string[], readonly string[]> implements SelectNode, XFormsXPathElement, EvaluationContext, ValidationContext, ClientReactiveSerializableValueNode {
     static from(parent: GeneralParentNode, instanceNode: StaticLeafElement | null, definition: SelectDefinition): SelectControl;

package/dist/instance/text/TextRange.d.ts

@@ -1,10 +1,20 @@
+import { JRResourceURL } from '../../../../common/src/jr-resources/JRResourceURL.ts';
 import { TextRange as ClientTextRange, TextChunk, TextOrigin, TextRole } from '../../client/TextRange.ts';
+export interface MediaSources {
+    image?: JRResourceURL;
+    video?: JRResourceURL;
+    audio?: JRResourceURL;
+}
 export declare class TextRange<Role extends TextRole, Origin extends TextOrigin> implements ClientTextRange<Role, Origin> {
     readonly origin: Origin;
     readonly role: Role;
     protected readonly chunks: readonly TextChunk[];
+    protected readonly mediaSources?: MediaSources | undefined;
     [Symbol.iterator](): Generator<TextChunk, void, unknown>;
     get formatted(): Record<PropertyKey, unknown>;
     get asString(): string;
-    constructor(origin: Origin, role: Role, chunks: readonly TextChunk[]);
+    get imageSource(): JRResourceURL | undefined;
+    get audioSource(): JRResourceURL | undefined;
+    get videoSource(): JRResourceURL | undefined;
+    constructor(origin: Origin, role: Role, chunks: readonly TextChunk[], mediaSources?: MediaSources | undefined);
 }

package/dist/integration/xpath/adapter/traversal.d.ts

@@ -1,6 +1,6 @@
 import { EngineXPathAttribute, EngineXPathDocument, EngineXPathElement, EngineXPathNode, EngineXPathParentNode, XFormsXPathChildNode } from './kind.ts';
 export declare const getContainingEngineXPathDocument: (node: EngineXPathNode) => EngineXPathDocument;
-export declare const getEngineXPathAttributes: (node: EngineXPathNode) => Iterable<EngineXPathAttribute>;
+export declare const getEngineXPathAttributes: (node: EngineXPathNode) => readonly EngineXPathAttribute[];
 /**
  * @todo We've now laid most of the groundwork necessary to implement this
  * properly. At time of writing it has still been deferred because:
@@ -14,7 +14,7 @@ export declare const getEngineXPathAttributes: (node: EngineXPathNode) => Iterab
  * it throw? It might be nice to be alerted if the assumptions in point 2 above
  * are somehow wrong (or become wrong).
  */
-export declare const getNamespaceDeclarations: () => Iterable<never>;
+export declare const getNamespaceDeclarations: () => readonly [];
 export declare const getParentNode: (node: EngineXPathNode) => EngineXPathParentNode | null;
 export declare const getChildNodes: (node: EngineXPathNode) => readonly XFormsXPathChildNode[];
 export declare const getChildElements: (node: EngineXPathNode) => readonly EngineXPathElement[];

package/dist/lib/codecs/DateValueCodec.d.ts

@@ -0,0 +1,7 @@
+import { Temporal } from 'temporal-polyfill';
+import { ValueCodec } from './ValueCodec.ts';
+export type DatetimeRuntimeValue = Temporal.PlainDate | null;
+export type DatetimeInputValue = Date | Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime | string | null;
+export declare class DateValueCodec extends ValueCodec<'date', DatetimeRuntimeValue, DatetimeInputValue> {
+    constructor();
+}

package/dist/lib/codecs/getSharedValueCodec.d.ts

@@ -1,4 +1,5 @@
 import { ValueType } from '../../client/ValueType.ts';
+import { DatetimeInputValue, DatetimeRuntimeValue } from './DateValueCodec.ts';
 import { DecimalInputValue, DecimalRuntimeValue } from './DecimalValueCodec.ts';
 import { GeopointInputValue, GeopointRuntimeValue } from './Geopoint/Geopoint.ts';
 import { IntInputValue, IntRuntimeValue } from './IntValueCodec.ts';
@@ -8,7 +9,7 @@ interface RuntimeValuesByType {
     readonly int: IntRuntimeValue;
     readonly decimal: DecimalRuntimeValue;
     readonly boolean: string;
-    readonly date: string;
+    readonly date: DatetimeRuntimeValue;
     readonly time: string;
     readonly dateTime: string;
     readonly geopoint: GeopointRuntimeValue;
@@ -24,7 +25,7 @@ interface RuntimeInputValuesByType {
     readonly int: IntInputValue;
     readonly decimal: DecimalInputValue;
     readonly boolean: string;
-    readonly date: string;
+    readonly date: DatetimeInputValue;
     readonly time: string;
     readonly dateTime: string;
     readonly geopoint: GeopointInputValue;

package/dist/lib/reactivity/text/createTextRange.d.ts

@@ -5,8 +5,7 @@ import { TextRange } from '../../../instance/text/TextRange.ts';
 import { TextRangeDefinition } from '../../../parse/text/abstract/TextRangeDefinition.ts';
 type ComputedFormTextRange<Role extends TextRole> = Accessor<TextRange<Role, 'form'>>;
 /**
- * Creates a text range (e.g. label or hint) from the provided definition,
- * reactive to:
+ * Creates a text range (e.g. label or hint) from the provided definition, reactive to:
  *
  * - The form's current language (e.g. `<label ref="jr:itext('text-id')" />`)
  * - Direct `<output>` references within the label's children

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

@@ -0,0 +1,16 @@
+import { TextChunkSource } from '../../client/TextRange.ts';
+import { AnyTextRangeDefinition } from '../text/abstract/TextRangeDefinition.ts';
+import { DependentExpression } from './abstract/DependentExpression.ts';
+interface TextChunkExpressionOptions {
+    readonly isTranslated?: true;
+}
+export declare class TextChunkExpression<T extends 'nodes' | 'string'> extends DependentExpression<T> {
+    readonly source: TextChunkSource;
+    readonly stringValue: string;
+    constructor(context: AnyTextRangeDefinition, resultType: T, expression: string, source: TextChunkSource, options?: TextChunkExpressionOptions, literalValue?: string);
+    static fromLiteral(context: AnyTextRangeDefinition, stringValue: string): TextChunkExpression<'string'>;
+    static fromReference(context: AnyTextRangeDefinition, ref: string): TextChunkExpression<'string'>;
+    static fromOutput(context: AnyTextRangeDefinition, element: Element): TextChunkExpression<'string'> | null;
+    static fromTranslation(context: AnyTextRangeDefinition, maybeExpression: string): TextChunkExpression<'nodes'> | null;
+}
+export {};

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

@@ -1,12 +1,10 @@
 import { XFormDefinition } from '../../parse/XFormDefinition.ts';
-import { ItemDefinition } from '../body/control/ItemDefinition.ts';
 import { ItemsetDefinition } from '../body/control/ItemsetDefinition.ts';
-import { RefAttributeChunk } from './abstract/TextElementDefinition.ts';
+import { TextChunkExpression } from '../expression/TextChunkExpression.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;
     readonly role = "item-label";
-    readonly chunks: readonly [RefAttributeChunk];
+    readonly chunks: ReadonlyArray<TextChunkExpression<'nodes' | 'string'>>;
     private constructor();
 }

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

@@ -1,14 +1,10 @@
-import { TextLiteralExpression } from '../expression/TextLiteralExpression.ts';
-import { TextTranslationExpression } from '../expression/TextTranslationExpression.ts';
+import { TextChunkExpression } from '../expression/TextChunkExpression.ts';
 import { BindDefinition } from '../model/BindDefinition.ts';
-import { TextBindAttributeLocalName, TextSourceNode, TextRangeDefinition } from './abstract/TextRangeDefinition.ts';
-export type MessageSourceNode = TextSourceNode<TextBindAttributeLocalName>;
-type MessageChunk = TextLiteralExpression | TextTranslationExpression;
+import { TextBindAttributeLocalName, TextRangeDefinition } from './abstract/TextRangeDefinition.ts';
 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;
-    readonly chunks: readonly [MessageChunk];
+    readonly chunks: ReadonlyArray<TextChunkExpression<'nodes' | 'string'>>;
     private constructor();
 }
 export type AnyMessageDefinition = MessageDefinition<TextBindAttributeLocalName>;
-export {};

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

@@ -1,21 +1,15 @@
 import { ElementTextRole } from '../../../client/TextRange.ts';
 import { XFormDefinition } from '../../../parse/XFormDefinition.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';
-import { TextTranslationExpression } from '../../expression/TextTranslationExpression.ts';
+import { TextChunkExpression } from '../../expression/TextChunkExpression.ts';
 import { HintDefinition } from '../HintDefinition.ts';
 import { ItemLabelDefinition } from '../ItemLabelDefinition.ts';
 import { ItemsetLabelDefinition } from '../ItemsetLabelDefinition.ts';
 import { LabelDefinition, LabelOwner } from '../LabelDefinition.ts';
 import { TextSourceNode, TextRangeDefinition } from './TextRangeDefinition.ts';
-export type RefAttributeChunk = TextReferenceExpression | TextTranslationExpression;
-type TextElementChildChunk = TextOutputExpression | TextLiteralExpression;
-type TextElementChunks = readonly [RefAttributeChunk] | readonly TextElementChildChunk[];
 type TextElementOwner = ItemDefinition | LabelOwner;
 export declare abstract class TextElementDefinition<Role extends ElementTextRole> extends TextRangeDefinition<Role> {
-    readonly chunks: TextElementChunks;
+    readonly chunks: ReadonlyArray<TextChunkExpression<'nodes' | 'string'>>;
     constructor(form: XFormDefinition, owner: TextElementOwner, sourceNode: TextSourceNode<Role>);
 }
 export type AnyTextElementDefinition = HintDefinition | ItemLabelDefinition | ItemsetLabelDefinition | LabelDefinition;

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

@@ -2,7 +2,7 @@ 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 { AnyTextChunkExpression } from '../../expression/abstract/TextChunkExpression.ts';
+import { TextChunkExpression } from '../../expression/TextChunkExpression.ts';
 import { AnyMessageDefinition } from '../MessageDefinition.ts';
 import { AnyTextElementDefinition } from './TextElementDefinition.ts';
 export type TextBindAttributeLocalName = 'constraintMsg' | 'requiredMsg';
@@ -22,7 +22,7 @@ export declare abstract class TextRangeDefinition<Role extends TextRole> extends
     abstract readonly role: Role;
     readonly parentReference: string | null;
     readonly reference: string | null;
-    abstract readonly chunks: readonly AnyTextChunkExpression[];
+    abstract readonly chunks: ReadonlyArray<TextChunkExpression<'nodes' | 'string'>>;
     get isTranslated(): boolean;
     set isTranslated(value: true);
     protected constructor(form: XFormDefinition, ownerContext: DependencyContext, sourceNode: TextSourceNode<Role>);