@getodk/xforms-engine 0.12.0 → 0.14.0

package/src/parse/body/GroupElementDefinition.ts

@@ -0,0 +1,47 @@
+import { LabelDefinition } from '../text/LabelDefinition.ts';
+import type { XFormDefinition } from '../XFormDefinition.ts';
+import { parseNodesetReference } from '../xpath/reference-parsing.ts';
+import type { StructureElementAppearanceDefinition } from './appearance/structureElementAppearanceParser.ts';
+import { structureElementAppearanceParser } from './appearance/structureElementAppearanceParser.ts';
+import {
+	type BodyElementDefinitionArray,
+	type 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 class GroupElementDefinition extends BodyElementDefinition<'group'> {
+	override readonly category = 'structure';
+	override readonly type = 'group';
+
+	readonly children: BodyElementDefinitionArray;
+
+	override readonly reference: string | null;
+	readonly appearances: StructureElementAppearanceDefinition;
+	override readonly label: LabelDefinition | null;
+
+	static override isCompatible(localName: string): boolean {
+		return localName === 'group';
+	}
+
+	constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element) {
+		super(form, parent, element);
+
+		const childElements = Array.from(element.children).filter((child) => {
+			const childName = child.localName;
+
+			return childName !== 'label';
+		});
+
+		this.children = this.body.getChildElementDefinitions(form, this, element, childElements);
+		this.reference = parseNodesetReference(parent, element, 'ref');
+		this.appearances = structureElementAppearanceParser.parseFrom(element, 'appearance');
+		this.label = LabelDefinition.forGroup(form, this);
+	}
+}

package/src/parse/body/control/ItemsetDefinition.ts

@@ -1,13 +1,16 @@
+import type { StaticElement } from '../../../integration/xpath/static-dom/StaticElement.ts';
 import type { ItemsetElement } from '../../../lib/dom/query.ts';
 import { getValueElement } from '../../../lib/dom/query.ts';
+import { DependentExpression } from '../../expression/abstract/DependentExpression.ts';
+import { ItemPropertyExpression } from '../../expression/ItemPropertyExpression.ts';
 import { ItemsetNodesetExpression } from '../../expression/ItemsetNodesetExpression.ts';
 import { ItemsetValueExpression } from '../../expression/ItemsetValueExpression.ts';
 import { ItemsetLabelDefinition } from '../../text/ItemsetLabelDefinition.ts';
 import type { XFormDefinition } from '../../XFormDefinition.ts';
 import { parseNodesetReference } from '../../xpath/reference-parsing.ts';
 import { BodyElementDefinition } from '../BodyElementDefinition.ts';
-import type { AnySelectControlDefinition } from './SelectControlDefinition.ts';
 import { RankControlDefinition } from './RankControlDefinition.ts';
+import type { AnySelectControlDefinition } from './SelectControlDefinition.ts';
 
 export class ItemsetDefinition extends BodyElementDefinition<'itemset'> {
 	override readonly category = 'support';
@@ -28,7 +31,7 @@ export class ItemsetDefinition extends BodyElementDefinition<'itemset'> {
 
 		const nodesetExpression = parseNodesetReference(parent, element, 'nodeset');
 
-		this.nodes = new ItemsetNodesetExpression(this, nodesetExpression);
+		this.nodes = new ItemsetNodesetExpression(nodesetExpression);
 		this.reference = nodesetExpression;
 
 		const valueElement = getValueElement(element);
@@ -52,4 +55,8 @@ export class ItemsetDefinition extends BodyElementDefinition<'itemset'> {
 		this.value = new ItemsetValueExpression(this, valueExpression);
 		this.label = ItemsetLabelDefinition.from(form, this);
 	}
+
+	getPropertiesExpressions(propertiesNodes: StaticElement[]): Array<DependentExpression<'string'>> {
+		return ItemPropertyExpression.from(propertiesNodes);
+	}
 }

package/src/parse/expression/BindComputationExpression.ts

@@ -47,18 +47,15 @@ export class BindComputationExpression<
 			return null as BindComputationFactoryResult<Type>;
 		}
 
-		return new this(bind, computation, expression);
+		return new this(computation, expression);
 	}
 
 	readonly isDefaultExpression: boolean;
 
 	protected constructor(
-		bind: BindDefinition,
 		readonly computation: Computation,
 		expression: string | null
 	) {
-		const ignoreContextReference = computation === 'constraint';
-
 		let isDefaultExpression: boolean;
 		let resolvedExpression: string;
 
@@ -75,9 +72,7 @@ export class BindComputationExpression<
 			resolvedExpression = expression;
 		}
 
-		super(bind, bindComputationResultTypes[computation], resolvedExpression, {
-			ignoreContextReference,
-		});
+		super(bindComputationResultTypes[computation], resolvedExpression);
 
 		this.isDefaultExpression = isDefaultExpression;
 	}

package/src/parse/expression/ItemPropertyExpression.ts

@@ -0,0 +1,12 @@
+import type { StaticElement } from '../../integration/xpath/static-dom/StaticElement.ts';
+import { DependentExpression } from './abstract/DependentExpression.ts';
+
+export class ItemPropertyExpression extends DependentExpression<'string'> {
+	static from(propertiesNodes: StaticElement[]) {
+		return propertiesNodes.map((node: StaticElement) => new this(node.qualifiedName.localName));
+	}
+
+	constructor(propertyName: string) {
+		super('string', propertyName);
+	}
+}

package/src/parse/expression/ItemsetNodesetExpression.ts

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

package/src/parse/expression/ItemsetValueExpression.ts

@@ -6,6 +6,6 @@ export class ItemsetValueExpression extends DependentExpression<'string'> {
 		readonly itemset: ItemsetDefinition,
 		expression: string
 	) {
-		super(itemset, 'string', expression);
+		super('string', expression);
 	}
 }

package/src/parse/expression/RepeatCountControlExpression.ts

@@ -23,7 +23,7 @@ export class RepeatCountControlExpression extends DependentExpression<'number'>
 		const { countExpression, noAddRemoveExpression } = bodyElement;
 
 		if (countExpression != null) {
-			return new this(bodyElement, countExpression);
+			return new this(countExpression);
 		}
 
 		if (noAddRemoveExpression != null && isConstantTruthyExpression(noAddRemoveExpression)) {
@@ -32,13 +32,13 @@ export class RepeatCountControlExpression extends DependentExpression<'number'>
 			// repeat's template.
 			const fixedCountExpression = String(Math.max(initialCount, 1));
 
-			return new this(bodyElement, fixedCountExpression);
+			return new this(fixedCountExpression);
 		}
 
 		return null;
 	}
 
-	private constructor(context: RepeatElementDefinition, expression: string) {
-		super(context, 'number', expression);
+	private constructor(expression: string) {
+		super('number', expression);
 	}
 }

package/src/parse/expression/TextChunkExpression.ts

@@ -1,11 +1,14 @@
+import type {
+	JRResourceURLString,
+	ResourceType,
+} from '@getodk/common/jr-resources/JRResourceURL.ts';
 import type { KnownAttributeLocalNamedElement } from '@getodk/common/types/dom.ts';
 import type { TextChunkSource } from '../../client/TextRange.ts';
-import type { AnyTextRangeDefinition } from '../text/abstract/TextRangeDefinition.ts';
-import { isTranslationExpression } from '../xpath/semantic-analysis.ts';
+import { getTranslationExpression } from '../xpath/semantic-analysis.ts';
 import { DependentExpression } from './abstract/DependentExpression.ts';
 
 interface TextChunkExpressionOptions {
-	readonly isTranslated?: true;
+	readonly type?: ResourceType;
 }
 
 interface OutputElement extends KnownAttributeLocalNamedElement<'output', 'value'> {}
@@ -18,59 +21,46 @@ export class TextChunkExpression<T extends 'nodes' | 'string'> extends Dependent
 	readonly source: TextChunkSource;
 	// Set for the literal source, blank otherwise
 	readonly stringValue: string;
+	readonly resourceType: ResourceType | null;
 
 	constructor(
-		context: AnyTextRangeDefinition,
 		resultType: T,
 		expression: string,
 		source: TextChunkSource,
-		options: TextChunkExpressionOptions = {},
-		literalValue = ''
+		literalValue = '',
+		options: TextChunkExpressionOptions = {}
 	) {
-		super(context, resultType, expression, {
-			semanticDependencies: {
-				translations: options.isTranslated,
-			},
-			ignoreContextReference: true,
-		});
+		super(resultType, expression);
 
+		this.resourceType = options.type ?? null;
 		this.source = source;
 		this.stringValue = literalValue;
 	}
 
-	static fromLiteral(
-		context: AnyTextRangeDefinition,
-		stringValue: string
-	): TextChunkExpression<'string'> {
-		return new TextChunkExpression(context, 'string', 'null', 'literal', {}, stringValue);
+	static fromLiteral(stringValue: string): TextChunkExpression<'string'> {
+		return new TextChunkExpression('string', 'null', 'literal', stringValue);
 	}
 
-	static fromReference(
-		context: AnyTextRangeDefinition,
-		ref: string
-	): TextChunkExpression<'string'> {
-		return new TextChunkExpression(context, 'string', ref, 'reference');
+	static fromReference(ref: string): TextChunkExpression<'string'> {
+		return new TextChunkExpression('string', ref, 'reference');
 	}
 
-	static fromOutput(
-		context: AnyTextRangeDefinition,
-		element: Element
-	): TextChunkExpression<'string'> | null {
+	static fromOutput(element: Element): TextChunkExpression<'string'> | null {
 		if (!isOutputElement(element)) {
 			return null;
 		}
 
-		return new TextChunkExpression(context, 'string', element.getAttribute('value'), 'output');
+		return new TextChunkExpression('string', element.getAttribute('value'), 'output');
 	}
 
-	static fromTranslation(
-		context: AnyTextRangeDefinition,
-		maybeExpression: string
-	): TextChunkExpression<'nodes'> | null {
-		if (isTranslationExpression(maybeExpression)) {
-			return new TextChunkExpression(context, 'nodes', maybeExpression, 'translation', {
-				isTranslated: true,
-			});
+	static fromResource(url: JRResourceURLString, type: ResourceType): TextChunkExpression<'string'> {
+		return new TextChunkExpression('string', 'null', 'literal', url, { type });
+	}
+
+	static fromTranslation(maybeExpression: string): TextChunkExpression<'nodes'> | null {
+		const translationExpression = getTranslationExpression(maybeExpression);
+		if (translationExpression) {
+			return new TextChunkExpression('nodes', translationExpression, 'translation');
 		}
 
 		return null;

package/src/parse/expression/abstract/DependentExpression.ts

@@ -3,12 +3,7 @@ import type {
 	ConstantExpression,
 	ConstantTruthyExpression,
 } from '../../xpath/semantic-analysis.ts';
-import {
-	isConstantExpression,
-	isConstantTruthyExpression,
-	isTranslationExpression,
-} from '../../xpath/semantic-analysis.ts';
-import type { DependencyContext } from './DependencyContext.ts';
+import { isConstantExpression, isConstantTruthyExpression } from '../../xpath/semantic-analysis.ts';
 
 const evaluatorMethodsByResultType = {
 	boolean: 'evaluateBoolean',
@@ -28,22 +23,6 @@ export type DependentExpressionResult<Type extends DependentExpressionResultType
 	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;
@@ -60,10 +39,8 @@ export abstract class DependentExpression<Type extends DependentExpressionResult
 	readonly constantTruthyExpression: ConstantTruthyExpression | null;
 
 	constructor(
-		context: DependencyContext,
 		readonly resultType: Type,
-		readonly expression: string,
-		options: DependentExpressionOptions = {}
+		readonly expression: string
 	) {
 		if (resultType === 'boolean' && isConstantTruthyExpression(expression)) {
 			this.constantTruthyExpression = expression;
@@ -77,19 +54,6 @@ export abstract class DependentExpression<Type extends DependentExpressionResult
 		}
 
 		this.evaluatorMethod = evaluatorMethodsByResultType[resultType];
-
-		const {
-			semanticDependencies = {
-				translations: false,
-			},
-		} = options;
-
-		const isTranslated = semanticDependencies.translations && isTranslationExpression(expression);
-
-		if (isTranslated) {
-			this.isTranslated = true;
-			context.isTranslated = true;
-		}
 	}
 
 	isConstantExpression(): this is ConstantDependentExpression<Type> {

package/src/parse/model/{SubtreeDefinition.ts → GroupDefinition.ts}

@@ -1,19 +1,17 @@
 import type { StaticElement } from '../../integration/xpath/static-dom/StaticElement.ts';
 import { NamespaceDeclarationMap } from '../../lib/names/NamespaceDeclarationMap.ts';
 import { QualifiedName } from '../../lib/names/QualifiedName.ts';
-import type {
-	AnyBodyElementDefinition,
-	AnyGroupElementDefinition,
-} from '../body/BodyDefinition.ts';
+import type { AnyBodyElementDefinition } from '../body/BodyDefinition.ts';
+import type { GroupElementDefinition } from '../body/GroupElementDefinition.ts';
 import type { BindDefinition } from './BindDefinition.ts';
 import { DescendentNodeDefinition } from './DescendentNodeDefinition.ts';
 import type { ChildNodeDefinition, ParentNodeDefinition } from './NodeDefinition.ts';
 
-export class SubtreeDefinition extends DescendentNodeDefinition<
-	'subtree',
-	AnyGroupElementDefinition | null
+export class GroupDefinition extends DescendentNodeDefinition<
+	'group',
+	GroupElementDefinition | null
 > {
-	readonly type = 'subtree';
+	readonly type = 'group';
 
 	readonly namespaceDeclarations: NamespaceDeclarationMap;
 	readonly qualifiedName: QualifiedName;

package/src/parse/model/ModelDefinition.ts

@@ -1,7 +1,10 @@
+import type { ActiveLanguage } from '../../client/FormLanguage.ts';
 import { ErrorProductionDesignPendingError } from '../../error/ErrorProductionDesignPendingError.ts';
 import type { StaticDocument } from '../../integration/xpath/static-dom/StaticDocument.ts';
+import { TextChunkExpression } from '../expression/TextChunkExpression.ts';
 import { parseStaticDocumentFromDOMSubtree } from '../shared/parseStaticDocumentFromDOMSubtree.ts';
 import type { XFormDefinition } from '../XFormDefinition.ts';
+import { generateItextChunks, type ChunkExpressionsByItextId } from './generateItextChunks.ts';
 import { ItextTranslationsDefinition } from './ItextTranslationsDefinition.ts';
 import { ModelBindMap } from './ModelBindMap.ts';
 import type { AnyNodeDefinition } from './NodeDefinition.ts';
@@ -16,6 +19,7 @@ export class ModelDefinition {
 	readonly nodes: NodeDefinitionMap;
 	readonly instance: StaticDocument;
 	readonly itextTranslations: ItextTranslationsDefinition;
+	readonly itextChunks: Map<string, ChunkExpressionsByItextId>;
 
 	constructor(readonly form: XFormDefinition) {
 		const submission = new SubmissionDefinition(form.xformDOM);
@@ -27,6 +31,7 @@ export class ModelDefinition {
 		this.root = new RootDefinition(form, this, submission, form.body.classes);
 		this.nodes = nodeDefinitionMap(this.root);
 		this.itextTranslations = ItextTranslationsDefinition.from(form.xformDOM);
+		this.itextChunks = generateItextChunks(form.xformDOM.itextTranslationElements);
 	}
 
 	getNodeDefinition(nodeset: string): AnyNodeDefinition {
@@ -54,4 +59,12 @@ export class ModelDefinition {
 
 		return rest;
 	}
+
+	getTranslationChunks(
+		itextId: string,
+		activeLanguage: ActiveLanguage
+	): ReadonlyArray<TextChunkExpression<'string'>> {
+		const languageMap = this.itextChunks.get(activeLanguage.language);
+		return languageMap?.get(itextId) ?? [];
+	}
 }

package/src/parse/model/NodeDefinition.ts

@@ -7,10 +7,10 @@ import type { QualifiedName } from '../../lib/names/QualifiedName.ts';
 import type { AnyBodyElementDefinition } from '../body/BodyDefinition.ts';
 import type { RepeatElementDefinition } from '../body/RepeatElementDefinition.ts';
 import type { BindDefinition } from './BindDefinition.ts';
+import type { GroupDefinition } from './GroupDefinition.ts';
 import type { LeafNodeDefinition } from './LeafNodeDefinition.ts';
 import type { AnyRepeatDefinition } from './RepeatDefinition.ts';
 import type { RootDefinition } from './RootDefinition.ts';
-import type { SubtreeDefinition } from './SubtreeDefinition.ts';
 
 /**
  * Corresponds to a model instance root node, i.e.:
@@ -33,10 +33,9 @@ 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:
@@ -51,7 +50,7 @@ export type NodeDefinitionType =
 	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
 	| RootNodeType
 	| RepeatType
-	| SubtreeNodeType
+	| GroupNodeType
 	| LeafNodeType;
 
 // prettier-ignore
@@ -59,13 +58,13 @@ export type ParentNodeDefinition =
 	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
 	| RootDefinition
 	| AnyRepeatDefinition
-	| SubtreeDefinition;
+	| GroupDefinition;
 
 // prettier-ignore
 export type ChildNodeDefinition =
 	| AnyRepeatDefinition
-	| LeafNodeDefinition
-	| SubtreeDefinition;
+	| GroupDefinition
+	| LeafNodeDefinition;
 
 export abstract class NodeDefinition<Type extends NodeDefinitionType>
 	implements NamedSubtreeDefinition
@@ -92,5 +91,5 @@ export type AnyNodeDefinition =
 	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
 	| RootDefinition
 	| AnyRepeatDefinition
-	| SubtreeDefinition
+	| GroupDefinition
 	| LeafNodeDefinition;

package/src/parse/model/RepeatDefinition.ts

@@ -21,9 +21,9 @@ import type { RepeatElementDefinition } from '../body/RepeatElementDefinition.ts
 import { RepeatCountControlExpression } from '../expression/RepeatCountControlExpression.ts';
 import type { BindDefinition } from './BindDefinition.ts';
 import { DescendentNodeDefinition } from './DescendentNodeDefinition.ts';
+import type { GroupDefinition } from './GroupDefinition.ts';
 import type { ChildNodeDefinition, ParentNodeDefinition } from './NodeDefinition.ts';
 import type { RootDefinition } from './RootDefinition.ts';
-import type { SubtreeDefinition } from './SubtreeDefinition.ts';
 
 interface JavaRosaNamespaceURI extends NamespaceURL {
 	readonly href: JAVAROSA_NAMESPACE_URI;
@@ -284,7 +284,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,

package/src/parse/model/RootDefinition.ts

@@ -3,6 +3,7 @@ import { NamespaceDeclarationMap } from '../../lib/names/NamespaceDeclarationMap
 import { QualifiedName } from '../../lib/names/QualifiedName.ts';
 import type { BodyClassList } from '../body/BodyDefinition.ts';
 import type { XFormDefinition } from '../XFormDefinition.ts';
+import { GroupDefinition } from './GroupDefinition.ts';
 import { LeafNodeDefinition } from './LeafNodeDefinition.ts';
 import type { ModelDefinition } from './ModelDefinition.ts';
 import type { ChildNodeDefinition, ParentNodeDefinition } from './NodeDefinition.ts';
@@ -12,7 +13,6 @@ import { RangeNodeDefinition } from './RangeNodeDefinition.ts';
 import { RepeatDefinition } from './RepeatDefinition.ts';
 import { RootAttributeMap } from './RootAttributeMap.ts';
 import type { SubmissionDefinition } from './SubmissionDefinition.ts';
-import { SubtreeDefinition } from './SubtreeDefinition.ts';
 
 export class RootDefinition extends NodeDefinition<'root'> {
 	readonly type = 'root';
@@ -107,7 +107,7 @@ export class RootDefinition extends NodeDefinition<'root'> {
 				);
 			}
 
-			return new SubtreeDefinition(parent, bind, bodyElement, element);
+			return new GroupDefinition(parent, bind, bodyElement, element);
 		});
 	}
 

package/src/parse/model/generateItextChunks.ts

@@ -0,0 +1,61 @@
+import {
+	isResourceType,
+	type JRResourceURLString,
+	type ResourceType,
+} from '@getodk/common/jr-resources/JRResourceURL.ts';
+import { isElementNode, isTextNode } from '@getodk/common/lib/dom/predicates.ts';
+import { TextChunkExpression } from '../expression/TextChunkExpression.ts';
+import type { DOMItextTranslationElement } from '../XFormDOM.ts';
+
+const generateChunk = (node: Node): TextChunkExpression<'string'> | null => {
+	if (isElementNode(node)) {
+		return TextChunkExpression.fromOutput(node);
+	}
+	if (isTextNode(node)) {
+		const formAttribute = node.parentElement!.getAttribute('form') as ResourceType;
+		if (isResourceType(formAttribute)) {
+			return TextChunkExpression.fromResource(node.data as JRResourceURLString, formAttribute);
+		}
+		return TextChunkExpression.fromLiteral(node.data);
+	}
+	return null;
+};
+
+const generateChunksForValues = (valueElement: ChildNode): Array<TextChunkExpression<'string'>> => {
+	return Array.from(valueElement.childNodes)
+		.map((node) => generateChunk(node))
+		.filter((chunk) => chunk !== null);
+};
+
+const generateChunksForTranslation = (
+	textElement: Element
+): Array<TextChunkExpression<'string'>> => {
+	return Array.from(textElement.childNodes).flatMap((valueElement) =>
+		generateChunksForValues(valueElement)
+	);
+};
+
+const generateChunksForLanguage = (
+	translationElement: DOMItextTranslationElement
+): Map<string, ReadonlyArray<TextChunkExpression<'string'>>> => {
+	return new Map(
+		Array.from(translationElement.children).map((textElement) => {
+			const itextId = textElement.getAttribute('id');
+			return [itextId!, generateChunksForTranslation(textElement)] as const;
+		})
+	);
+};
+
+export interface ChunkExpressionsByItextId
+	extends Map<string, ReadonlyArray<TextChunkExpression<'string'>>> {}
+
+export const generateItextChunks = (
+	translationElements: readonly DOMItextTranslationElement[]
+): Map<string, ChunkExpressionsByItextId> => {
+	return new Map(
+		translationElements.map((translationElement) => {
+			const lang = translationElement.getAttribute('lang');
+			return [lang, generateChunksForLanguage(translationElement)] as const;
+		})
+	);
+};

package/src/parse/text/ItemsetLabelDefinition.ts

@@ -30,11 +30,11 @@ export class ItemsetLabelDefinition extends TextRangeDefinition<'item-label'> {
 			throw new Error('<itemset><label> missing ref attribute');
 		}
 
-		const expression = TextChunkExpression.fromTranslation(this, refExpression);
-		if (expression != null) {
-			this.chunks = [expression];
+		const translationChunk = TextChunkExpression.fromTranslation(refExpression);
+		if (translationChunk) {
+			this.chunks = [translationChunk];
 		} else {
-			this.chunks = [TextChunkExpression.fromReference(this, refExpression)];
+			this.chunks = [TextChunkExpression.fromReference(refExpression)];
 		}
 	}
 }

package/src/parse/text/LabelDefinition.ts

@@ -1,16 +1,15 @@
 import type { LocalNamedElement } from '@getodk/common/types/dom.ts';
 import { getLabelElement, getRepeatGroupLabelElement } from '../../lib/dom/query.ts';
 import type { XFormDefinition } from '../../parse/XFormDefinition.ts';
-import type { AnyGroupElementDefinition } from '../../parse/body/BodyDefinition.ts';
-import type { RepeatElementDefinition } from '../body/RepeatElementDefinition.ts';
 import type { AnyControlDefinition } from '../body/control/ControlDefinition.ts';
-import type { BaseGroupDefinition } from '../body/group/BaseGroupDefinition.ts';
+import type { GroupElementDefinition } from '../body/GroupElementDefinition.ts';
+import type { RepeatElementDefinition } from '../body/RepeatElementDefinition.ts';
 import { TextElementDefinition } from './abstract/TextElementDefinition.ts';
 
 // prettier-ignore
 export type LabelOwner =
 	| AnyControlDefinition
-	| AnyGroupElementDefinition
+	| GroupElementDefinition
 	| RepeatElementDefinition;
 
 interface LabelElement extends LocalNamedElement<'label'> {}
@@ -39,11 +38,7 @@ export class LabelDefinition extends TextElementDefinition<'label'> {
 		return new this(form, repeat, repeatGroupLabel);
 	}
 
-	static forGroup(
-		form: XFormDefinition,
-		// eslint-disable-next-line @typescript-eslint/no-explicit-any
-		group: BaseGroupDefinition<any>
-	): LabelDefinition | null {
+	static forGroup(form: XFormDefinition, group: GroupElementDefinition): LabelDefinition | null {
 		const labelElement = getLabelElement(group.element);
 
 		if (labelElement == null) {

package/src/parse/text/MessageDefinition.ts

@@ -29,11 +29,11 @@ export class MessageDefinition<
 	) {
 		super(bind.form, bind, null);
 
-		const expression = TextChunkExpression.fromTranslation(this, message);
-		if (expression != null) {
-			this.chunks = [expression];
+		const translationChunk = TextChunkExpression.fromTranslation(message);
+		if (translationChunk) {
+			this.chunks = [translationChunk];
 		} else {
-			this.chunks = [TextChunkExpression.fromLiteral(this, message)];
+			this.chunks = [TextChunkExpression.fromLiteral(message)];
 		}
 	}
 }