@getodk/xforms-engine 0.11.0 → 0.13.0

package/dist/instance/RankControl.d.ts

@@ -1,4 +1,4 @@
-import { XPathNodeKindKey } from '@getodk/xpath';
+import { XPathChoiceNode, XPathNodeKindKey } from '@getodk/xpath';
 import { Accessor } from 'solid-js';
 import { RankDefinition, RankNode, RankValueOptions } from '../client/RankNode.ts';
 import { TextRange } from '../client/TextRange.ts';
@@ -23,7 +23,7 @@ interface RankControlStateSpec extends ValueNodeStateSpec<readonly string[]> {
     readonly hint: Accessor<TextRange<'hint'> | null>;
     readonly valueOptions: Accessor<RankValueOptions>;
 }
-export declare class RankControl extends ValueNode<'string', RankDefinition<'string'>, readonly string[], readonly string[]> implements RankNode, XFormsXPathElement, EvaluationContext, ValidationContext, ClientReactiveSerializableValueNode {
+export declare class RankControl extends ValueNode<'string', RankDefinition<'string'>, readonly string[], readonly string[]> implements RankNode, XFormsXPathElement, EvaluationContext, ValidationContext, ClientReactiveSerializableValueNode, XPathChoiceNode {
     static from(parent: GeneralParentNode, instanceNode: StaticLeafElement | null, definition: RankDefinition): RankControl;
     private readonly mapOptionsByValue;
     protected readonly getInstanceValue: Accessor<string>;
@@ -37,5 +37,6 @@ export declare class RankControl extends ValueNode<'string', RankDefinition<'str
     private constructor();
     getValueLabel(value: string): TextRange<'item-label'> | null;
     setValues(valuesInOrder: readonly string[]): Root;
+    getChoiceName(value: string): string | null;
 }
 export {};

package/dist/instance/SelectControl.d.ts

@@ -1,4 +1,4 @@
-import { XPathNodeKindKey } from '@getodk/xpath';
+import { XPathChoiceNode, XPathNodeKindKey } from '@getodk/xpath';
 import { Accessor } from 'solid-js';
 import { SelectDefinition, SelectItem, SelectNode, SelectNodeAppearances, SelectValueOptions } from '../client/SelectNode.ts';
 import { TextRange } from '../client/TextRange.ts';
@@ -24,7 +24,7 @@ interface SelectControlStateSpec extends ValueNodeStateSpec<readonly string[]> {
     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 {
+export declare class SelectControl extends ValueNode<'string', SelectDefinition<'string'>, readonly string[], readonly string[]> implements SelectNode, XFormsXPathElement, EvaluationContext, ValidationContext, ClientReactiveSerializableValueNode, XPathChoiceNode {
     static from(parent: GeneralParentNode, instanceNode: StaticLeafElement | null, definition: SelectDefinition): SelectControl;
     private readonly mapOptionsByValue;
     protected readonly getInstanceValue: Accessor<string>;
@@ -64,5 +64,6 @@ export declare class SelectControl extends ValueNode<'string', SelectDefinition<
     isSelected(value: string): boolean;
     selectValue(value: string | null): Root;
     selectValues(values: readonly string[]): Root;
+    getChoiceName(value: string): string | null;
 }
 export {};

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

@@ -4,8 +4,8 @@ import { ItemsetValueExpression } from '../../expression/ItemsetValueExpression.
 import { ItemsetLabelDefinition } from '../../text/ItemsetLabelDefinition.ts';
 import { XFormDefinition } from '../../XFormDefinition.ts';
 import { BodyElementDefinition } from '../BodyElementDefinition.ts';
-import { AnySelectControlDefinition } from './SelectControlDefinition.ts';
 import { RankControlDefinition } from './RankControlDefinition.ts';
+import { AnySelectControlDefinition } from './SelectControlDefinition.ts';
 export declare class ItemsetDefinition extends BodyElementDefinition<'itemset'> {
     readonly parent: AnySelectControlDefinition | RankControlDefinition;
     readonly category = "support";

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

@@ -25,6 +25,6 @@ export declare class BindComputationExpression<Computation extends BindComputati
     readonly computation: Computation;
     static forComputation<Type extends BindComputationType>(bind: BindDefinition, computation: Type): BindComputationFactoryResult<Type>;
     readonly isDefaultExpression: boolean;
-    protected constructor(bind: BindDefinition, computation: Computation, expression: string | null);
+    protected constructor(computation: Computation, expression: string | null);
 }
 export {};

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

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

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

@@ -1,16 +1,18 @@
+import { JRResourceURLString, ResourceType } from '../../../../common/src/jr-resources/JRResourceURL.ts';
 import { TextChunkSource } from '../../client/TextRange.ts';
-import { AnyTextRangeDefinition } from '../text/abstract/TextRangeDefinition.ts';
 import { DependentExpression } from './abstract/DependentExpression.ts';
 interface TextChunkExpressionOptions {
-    readonly isTranslated?: true;
+    readonly type?: ResourceType;
 }
 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;
+    readonly resourceType: ResourceType | null;
+    constructor(resultType: T, expression: string, source: TextChunkSource, literalValue?: string, options?: TextChunkExpressionOptions);
+    static fromLiteral(stringValue: string): TextChunkExpression<'string'>;
+    static fromReference(ref: string): TextChunkExpression<'string'>;
+    static fromOutput(element: Element): TextChunkExpression<'string'> | null;
+    static fromResource(url: JRResourceURLString, type: ResourceType): TextChunkExpression<'string'>;
+    static fromTranslation(maybeExpression: string): TextChunkExpression<'nodes'> | null;
 }
 export {};

package/dist/parse/expression/abstract/DependentExpression.d.ts

@@ -1,6 +1,5 @@
 import { EngineXPathEvaluator } from '../../../integration/xpath/EngineXPathEvaluator.ts';
 import { ConstantExpression, ConstantTruthyExpression } from '../../xpath/semantic-analysis.ts';
-import { DependencyContext } from './DependencyContext.ts';
 declare const evaluatorMethodsByResultType: {
     readonly boolean: "evaluateBoolean";
     readonly nodes: "evaluateNodes";
@@ -11,19 +10,6 @@ type EvaluatorMethodsByResultType = typeof evaluatorMethodsByResultType;
 export type DependentExpressionResultType = keyof EvaluatorMethodsByResultType;
 export type DependentExpressionEvaluatorMethod<Type extends DependentExpressionResultType> = EvaluatorMethodsByResultType[Type];
 export type DependentExpressionResult<Type extends DependentExpressionResultType> = ReturnType<EngineXPathEvaluator[DependentExpressionEvaluatorMethod<Type>]>;
-interface SemanticDependencyOptions {
-    /**
-     * @default false
-     */
-    readonly translations?: boolean | undefined;
-}
-interface DependentExpressionOptions {
-    /**
-     * @default false
-     */
-    readonly ignoreContextReference?: boolean;
-    readonly semanticDependencies?: SemanticDependencyOptions;
-}
 export interface ConstantDependentExpression<Type extends DependentExpressionResultType> extends DependentExpression<Type> {
     readonly expression: ConstantExpression;
 }
@@ -37,7 +23,7 @@ export declare abstract class DependentExpression<Type extends DependentExpressi
     readonly evaluatorMethod: DependentExpressionEvaluatorMethod<Type>;
     readonly constantExpression: ConstantExpression | null;
     readonly constantTruthyExpression: ConstantTruthyExpression | null;
-    constructor(context: DependencyContext, resultType: Type, expression: string, options?: DependentExpressionOptions);
+    constructor(resultType: Type, expression: string);
     isConstantExpression(): this is ConstantDependentExpression<Type>;
     isConstantTruthyExpression(): this is ConstantTruthyDependentExpression;
     toString(): string | null;

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

@@ -1,5 +1,8 @@
+import { ActiveLanguage } from '../../client/FormLanguage.ts';
 import { StaticDocument } from '../../integration/xpath/static-dom/StaticDocument.ts';
+import { TextChunkExpression } from '../expression/TextChunkExpression.ts';
 import { XFormDefinition } from '../XFormDefinition.ts';
+import { ChunkExpressionsByItextId } from './generateItextChunks.ts';
 import { ItextTranslationsDefinition } from './ItextTranslationsDefinition.ts';
 import { ModelBindMap } from './ModelBindMap.ts';
 import { AnyNodeDefinition } from './NodeDefinition.ts';
@@ -12,8 +15,10 @@ export declare class ModelDefinition {
     readonly nodes: NodeDefinitionMap;
     readonly instance: StaticDocument;
     readonly itextTranslations: ItextTranslationsDefinition;
+    readonly itextChunks: Map<string, ChunkExpressionsByItextId>;
     constructor(form: XFormDefinition);
     getNodeDefinition(nodeset: string): AnyNodeDefinition;
     getRootDefinition(instance: StaticDocument): RootDefinition;
-    toJSON(): Omit<this, "form" | "toJSON" | "getNodeDefinition" | "getRootDefinition">;
+    toJSON(): Omit<this, "form" | "toJSON" | "getNodeDefinition" | "getRootDefinition" | "getTranslationChunks">;
+    getTranslationChunks(itextId: string, activeLanguage: ActiveLanguage): ReadonlyArray<TextChunkExpression<'string'>>;
 }

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

@@ -0,0 +1,5 @@
+import { TextChunkExpression } from '../expression/TextChunkExpression.ts';
+import { DOMItextTranslationElement } from '../XFormDOM.ts';
+export interface ChunkExpressionsByItextId extends Map<string, ReadonlyArray<TextChunkExpression<'string'>>> {
+}
+export declare const generateItextChunks: (translationElements: readonly DOMItextTranslationElement[]) => Map<string, ChunkExpressionsByItextId>;

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

@@ -11,6 +11,7 @@ export type TranslationExpression = LocalNamedFunctionCallLiteral<'itext'>;
  * arbitrary expression may call `jr:itext`.
  */
 export declare const isTranslationExpression: (expression: string) => expression is TranslationExpression;
+export declare const getTranslationExpression: (expression: string) => string | null;
 /**
  * Predicate to determine if a FilterPathExpr (as currently produced by
  * `tree-sitter-xpath`) is one of: