@getodk/xforms-engine 0.5.0 → 0.6.0

package/src/lib/reactivity/{createSelectItems.ts → createItemCollection.ts}

@@ -1,21 +1,26 @@
 import { UpsertableMap } from '@getodk/common/lib/collections/UpsertableMap.ts';
 import type { Accessor } from 'solid-js';
 import { createMemo } from 'solid-js';
+import type { ActiveLanguage } from '../../client/FormLanguage.ts';
+import type { SelectItem } from '../../client/SelectNode.ts';
+import type { RankItem } from '../../client/RankNode.ts';
 import type { TextRange as ClientTextRange } from '../../client/TextRange.ts';
-import type { ActiveLanguage, SelectItem } from '../../index.ts';
 import type { EvaluationContext } from '../../instance/internal-api/EvaluationContext.ts';
 import type { TranslationContext } from '../../instance/internal-api/TranslationContext.ts';
-import type { SelectField } from '../../instance/SelectField.ts';
+import type { SelectControl } from '../../instance/SelectControl.ts';
+import type { RankControl } from '../../instance/RankControl.ts';
 import { TextChunk } from '../../instance/text/TextChunk.ts';
 import { TextRange } from '../../instance/text/TextRange.ts';
 import type { EngineXPathNode } from '../../integration/xpath/adapter/kind.ts';
 import type { EngineXPathEvaluator } from '../../integration/xpath/EngineXPathEvaluator.ts';
-import type { ItemDefinition } from '../../parse/body/control/select/ItemDefinition.ts';
-import type { ItemsetDefinition } from '../../parse/body/control/select/ItemsetDefinition.ts';
+import type { ItemDefinition } from '../../parse/body/control/ItemDefinition.ts';
+import type { ItemsetDefinition } from '../../parse/body/control/ItemsetDefinition.ts';
 import { createComputedExpression } from './createComputedExpression.ts';
 import type { ReactiveScope } from './scope.ts';
 import { createTextRange } from './text/createTextRange.ts';
 
+export type ItemCollectionControl = RankControl | SelectControl;
+type Item = RankItem | SelectItem;
 type DerivedItemLabel = ClientTextRange<'item-label', 'form-derived'>;
 
 const derivedItemLabel = (context: TranslationContext, value: string): DerivedItemLabel => {
@@ -24,7 +29,7 @@ const derivedItemLabel = (context: TranslationContext, value: string): DerivedIt
 	return new TextRange('form-derived', 'item-label', [chunk]);
 };
 
-const createSelectItemLabel = (
+const createItemLabel = (
 	context: EvaluationContext,
 	definition: ItemDefinition
 ): Accessor<ClientTextRange<'item-label'>> => {
@@ -37,14 +42,14 @@ const createSelectItemLabel = (
 	return createTextRange(context, 'item-label', label);
 };
 
-const createTranslatedStaticSelectItems = (
-	selectField: SelectField,
+const createTranslatedStaticItems = (
+	control: ItemCollectionControl,
 	items: readonly ItemDefinition[]
-): Accessor<readonly SelectItem[]> => {
-	return selectField.scope.runTask(() => {
+): Accessor<readonly Item[]> => {
+	return control.scope.runTask(() => {
 		const labeledItems = items.map((item) => {
 			const { value } = item;
-			const label = createSelectItemLabel(selectField, item);
+			const label = createItemLabel(control, item);
 
 			return () => ({
 				value,
@@ -66,18 +71,18 @@ class ItemsetItemEvaluationContext implements EvaluationContext {
 	readonly getActiveLanguage: Accessor<ActiveLanguage>;
 
 	constructor(
-		selectField: SelectField,
+		control: ItemCollectionControl,
 		readonly contextNode: EngineXPathNode
 	) {
-		this.isAttached = selectField.isAttached;
-		this.scope = selectField.scope;
-		this.evaluator = selectField.evaluator;
-		this.contextReference = selectField.contextReference;
-		this.getActiveLanguage = selectField.getActiveLanguage;
+		this.isAttached = control.isAttached;
+		this.scope = control.scope;
+		this.evaluator = control.evaluator;
+		this.contextReference = control.contextReference;
+		this.getActiveLanguage = control.getActiveLanguage;
 	}
 }
 
-const createSelectItemsetItemLabel = (
+const createItemsetItemLabel = (
 	context: EvaluationContext,
 	definition: ItemsetDefinition,
 	itemValue: Accessor<string>
@@ -99,11 +104,11 @@ interface ItemsetItem {
 }
 
 const createItemsetItems = (
-	selectField: SelectField,
+	control: ItemCollectionControl,
 	itemset: ItemsetDefinition
 ): Accessor<readonly ItemsetItem[]> => {
-	return selectField.scope.runTask(() => {
-		const itemNodes = createComputedExpression(selectField, itemset.nodes, {
+	return control.scope.runTask(() => {
+		const itemNodes = createComputedExpression(control, itemset.nodes, {
 			defaultValue: [],
 		});
 		const itemsCache = new UpsertableMap<EngineXPathNode, ItemsetItem>();
@@ -111,11 +116,11 @@ const createItemsetItems = (
 		return createMemo(() => {
 			return itemNodes().map((itemNode) => {
 				return itemsCache.upsert(itemNode, () => {
-					const context = new ItemsetItemEvaluationContext(selectField, itemNode);
+					const context = new ItemsetItemEvaluationContext(control, itemNode);
 					const value = createComputedExpression(context, itemset.value, {
 						defaultValue: '',
 					});
-					const label = createSelectItemsetItemLabel(context, itemset, value);
+					const label = createItemsetItemLabel(context, itemset, value);
 
 					return {
 						label,
@@ -128,11 +133,11 @@ const createItemsetItems = (
 };
 
 const createItemset = (
-	selectField: SelectField,
+	control: ItemCollectionControl,
 	itemset: ItemsetDefinition
-): Accessor<readonly SelectItem[]> => {
-	return selectField.scope.runTask(() => {
-		const itemsetItems = createItemsetItems(selectField, itemset);
+): Accessor<readonly Item[]> => {
+	return control.scope.runTask(() => {
+		const itemsetItems = createItemsetItems(control, itemset);
 
 		return createMemo(() => {
 			return itemsetItems().map((item) => {
@@ -146,23 +151,23 @@ const createItemset = (
 };
 
 /**
- * Creates a reactive computation of a {@link SelectField}'s
- * {@link SelectItem}s, in support of the field's `valueOptions`.
+ * Creates a reactive computation of a {@link ItemCollectionControl}'s
+ * {@link Item}s, in support of the field's `valueOptions`.
  *
- * - Selects defined with static `<item>`s will compute to an corresponding
+ * - The control defined with static `<item>`s will compute to an corresponding
  *   static list of items.
- * - Selects defined with a computed `<itemset>` will compute to a reactive list
+ * - The control defined with a computed `<itemset>` will compute to a reactive list
  *   of items.
- * - Items of both will produce {@link SelectItem.label | labels} reactive to
+ * - Items of both will produce {@link ItemType.label | labels} reactive to
  *   their appropriate dependencies (whether relative to the itemset item node,
  *   referencing a form's `itext` translations, etc).
  */
-export const createSelectItems = (selectField: SelectField): Accessor<readonly SelectItem[]> => {
-	const { items, itemset } = selectField.definition.bodyElement;
+export const createItemCollection = (control: ItemCollectionControl): Accessor<readonly Item[]> => {
+	const { items, itemset } = control.definition.bodyElement;
 
-	if (itemset == null) {
-		return createTranslatedStaticSelectItems(selectField, items);
+	if (itemset != null) {
+		return createItemset(control, itemset);
 	}
 
-	return createItemset(selectField, itemset);
+	return createTranslatedStaticItems(control, items);
 };

package/src/lib/xml-serialization.ts

@@ -1,3 +1,6 @@
+import type { NamespaceDeclarationMap } from './names/NamespaceDeclarationMap.ts';
+import type { QualifiedName } from './names/QualifiedName.ts';
+
 declare const ESCAPED_XML_TEXT_BRAND: unique symbol;
 
 export type EscapedXMLText = string & { readonly [ESCAPED_XML_TEXT_BRAND]: true };
@@ -75,22 +78,86 @@ export const escapeXMLText = <Text extends string>(
 		: (out as EscapedXMLText);
 };
 
-const serializeElementXML = (nodeName: string, children: string): string => {
+interface SerializableElementAttribute {
+	serializeAttributeXML(): string;
+}
+
+interface ElementXMLSerializationOptions {
+	readonly namespaceDeclarations?: NamespaceDeclarationMap;
+	readonly attributes?: readonly SerializableElementAttribute[];
+}
+
+const serializeElementNamespaceDeclarationXML = (
+	namespaceDeclarations?: NamespaceDeclarationMap
+): string => {
+	if (namespaceDeclarations == null) {
+		return '';
+	}
+
+	return Array.from(namespaceDeclarations.values())
+		.map((namespaceDeclaration) => {
+			return namespaceDeclaration.serializeNamespaceDeclarationXML({
+				omitDefaultNamespace: true,
+			});
+		})
+		.join('');
+};
+
+const serializeElementAttributeXML = (
+	attributes?: readonly SerializableElementAttribute[]
+): string => {
+	if (attributes == null) {
+		return '';
+	}
+
+	return attributes
+		.map((attribute) => {
+			return attribute.serializeAttributeXML();
+		})
+		.join('');
+};
+
+const serializeElementXML = (
+	qualifiedName: QualifiedName,
+	children: string,
+	options: ElementXMLSerializationOptions = {}
+): string => {
+	// See JSDoc for the `getPrefixedName` method. If we find we do actually need
+	// custom element (subtree) prefix resolution, we'd uncomment the argument
+	// below. (Either way, at time of writing the affected tests pass where
+	// expected when the option is passed. It's omitted on the presumption that it
+	// would be redundant, since the nodes being serialized are already resolved
+	// with the same set of namespace declarations which would affect them.)
+	//
+	// prettier-ignore
+	const nodeName = qualifiedName.getPrefixedName(
+		// options.namespaceDeclarations
+	);
+	const namespaceDeclarations = serializeElementNamespaceDeclarationXML(
+		options.namespaceDeclarations
+	);
+	const attributes = serializeElementAttributeXML(options.attributes);
+	const prefix = `<${nodeName}${namespaceDeclarations}${attributes}`;
+
 	if (children === '') {
-		return `<${nodeName}/>`;
+		return `${prefix}/>`;
 	}
 
-	// TODO: attributes
-	return `<${nodeName}>${children}</${nodeName}>`;
+	return `${prefix}>${children}</${nodeName}>`;
 };
 
 export const serializeParentElementXML = (
-	nodeName: string,
-	serializedChildren: readonly string[]
+	qualifiedName: QualifiedName,
+	serializedChildren: readonly string[],
+	options?: ElementXMLSerializationOptions
 ): string => {
-	return serializeElementXML(nodeName, serializedChildren.join(''));
+	return serializeElementXML(qualifiedName, serializedChildren.join(''), options);
 };
 
-export const serializeLeafElementXML = (nodeName: string, xmlValue: EscapedXMLText): string => {
-	return serializeElementXML(nodeName, xmlValue.normalize());
+export const serializeLeafElementXML = (
+	qualifiedName: QualifiedName,
+	xmlValue: EscapedXMLText,
+	options?: ElementXMLSerializationOptions
+): string => {
+	return serializeElementXML(qualifiedName, xmlValue.normalize(), options);
 };

package/src/parse/XFormDOM.ts

@@ -1,4 +1,9 @@
-import { XFORMS_NAMESPACE_URI, XMLNS_NAMESPACE_URI } from '@getodk/common/constants/xmlns.ts';
+import {
+	JAVAROSA_NAMESPACE_URI,
+	OPENROSA_XFORMS_NAMESPACE_URI,
+	XFORMS_NAMESPACE_URI,
+	XMLNS_NAMESPACE_URI,
+} from '@getodk/common/constants/xmlns.ts';
 import type {
 	KnownAttributeLocalNamedElement,
 	LocalNamedElement,
@@ -7,6 +12,118 @@ import { DefaultEvaluator } from '@getodk/xpath';
 
 interface DOMBindElement extends KnownAttributeLocalNamedElement<'bind', 'nodeset'> {}
 
+const getMetaElement = (primaryInstanceRoot: Element): Element | null => {
+	for (const child of primaryInstanceRoot.children) {
+		const { localName, namespaceURI } = child;
+
+		if (
+			(namespaceURI === OPENROSA_XFORMS_NAMESPACE_URI || namespaceURI === XFORMS_NAMESPACE_URI) &&
+			localName === 'meta'
+		) {
+			return child;
+		}
+	}
+
+	return null;
+};
+
+const getMetaChildElement = (meta: Element | null, localName: string): Element | null => {
+	if (meta == null) {
+		return null;
+	}
+
+	const { namespaceURI } = meta;
+
+	for (const child of meta.children) {
+		if (child.localName === localName && child.namespaceURI === namespaceURI) {
+			return child;
+		}
+	}
+
+	return null;
+};
+
+const getQualifiedName = (
+	contextNode: Node,
+	namespaceURI: string | null,
+	localName: string
+): string => {
+	const prefix = contextNode.lookupPrefix(namespaceURI);
+
+	if (prefix == null) {
+		return localName;
+	}
+
+	return `${prefix}:${localName}`;
+};
+
+const createNamespacedChildElement = (
+	parent: Element,
+	namespaceURI: string | null,
+	localName: string
+): Element => {
+	const qualifiedName = getQualifiedName(parent, namespaceURI, localName);
+	const child = parent.ownerDocument.createElementNS(namespaceURI, qualifiedName);
+
+	parent.append(child);
+
+	return child;
+};
+
+const setNamespacedAttributeValue = (
+	element: Element,
+	namespaceURI: string | null,
+	localName: string,
+	value: string
+) => {
+	const qualifiedName = getQualifiedName(element, namespaceURI, localName);
+
+	element.setAttributeNS(namespaceURI, qualifiedName, value);
+};
+
+const createDefaultInstanceIDBinding = (
+	model: Element,
+	primaryInstanceRoot: Element,
+	meta: Element,
+	instanceID: Element
+): DOMBindElement => {
+	const bind = createNamespacedChildElement(model, model.namespaceURI, 'bind');
+	const nodeset = `/${primaryInstanceRoot.nodeName}/${meta.nodeName}/${instanceID.nodeName}`;
+
+	bind.setAttribute('nodeset', nodeset);
+	setNamespacedAttributeValue(bind, JAVAROSA_NAMESPACE_URI, 'preload', 'uid');
+
+	return bind as DOMBindElement;
+};
+
+const normalizeDefaultMetaBindings = (
+	model: Element,
+	primaryInstanceRoot: Element,
+	binds: readonly DOMBindElement[]
+): readonly DOMBindElement[] => {
+	let meta = getMetaElement(primaryInstanceRoot);
+	let instanceID = getMetaChildElement(meta, 'instanceID');
+
+	if (meta == null) {
+		meta = createNamespacedChildElement(primaryInstanceRoot, OPENROSA_XFORMS_NAMESPACE_URI, 'meta');
+	}
+
+	if (instanceID == null) {
+		instanceID = createNamespacedChildElement(meta, meta.namespaceURI, 'instanceID');
+
+		const instanceIDBinding = createDefaultInstanceIDBinding(
+			model,
+			primaryInstanceRoot,
+			meta,
+			instanceID
+		);
+
+		return [...binds, instanceIDBinding];
+	}
+
+	return binds;
+};
+
 export interface DOMItextTranslationElement
 	extends KnownAttributeLocalNamedElement<'translation', 'lang'> {}
 
@@ -238,23 +355,6 @@ export class XFormDOM {
 		const html = evaluator.evaluateNonNullElement('/h:html', {
 			contextNode: xformDocument,
 		});
-
-		let body = evaluator.evaluateNonNullElement('./h:body', {
-			contextNode: html,
-		});
-		let normalizedXML: string;
-
-		if (options.isNormalized) {
-			normalizedXML = sourceXML;
-		} else {
-			body = normalizeXFormBody(body);
-
-			// TODO: if we keep doing normalization this way long term (or using the DOM
-			// for parsing long term, for that matter!), we should measure this. And we
-			// should measure against XMLSerializer while we're at it!
-			normalizedXML = xformDocument.documentElement.outerHTML;
-		}
-
 		const head = evaluator.evaluateNonNullElement('./h:head', {
 			contextNode: html,
 		});
@@ -264,9 +364,12 @@ export class XFormDOM {
 		const model = evaluator.evaluateNonNullElement('./xf:model', {
 			contextNode: head,
 		});
-		const binds = evaluator.evaluateNodes<DOMBindElement>('./xf:bind[@nodeset]', {
-			contextNode: model,
-		});
+		let binds: readonly DOMBindElement[] = evaluator.evaluateNodes<DOMBindElement>(
+			'./xf:bind[@nodeset]',
+			{
+				contextNode: model,
+			}
+		);
 
 		const instances = evaluator.evaluateNodes<DOMInstanceElement>('./xf:instance', {
 			contextNode: model,
@@ -292,6 +395,23 @@ export class XFormDOM {
 			}
 		);
 
+		let body = evaluator.evaluateNonNullElement('./h:body', {
+			contextNode: html,
+		});
+		let normalizedXML: string;
+
+		if (options.isNormalized) {
+			normalizedXML = sourceXML;
+		} else {
+			body = normalizeXFormBody(body);
+			binds = normalizeDefaultMetaBindings(model, primaryInstanceRoot, binds);
+
+			// TODO: if we keep doing normalization this way long term (or using the DOM
+			// for parsing long term, for that matter!), we should measure this. And we
+			// should measure against XMLSerializer while we're at it!
+			normalizedXML = xformDocument.documentElement.outerHTML;
+		}
+
 		this.normalizedXML = normalizedXML;
 		this.xformDocument = xformDocument;
 		this.html = html;

package/src/parse/XFormDefinition.ts

@@ -24,10 +24,7 @@ export class XFormDefinition {
 		this.xformDocument = xformDocument;
 		this.id = id;
 		this.title = title.textContent ?? '';
-
-		// TODO: highly unlikely primary instance root will need a namespace prefix
-		// but noting it just in case there is such weird usage...
-		this.rootReference = `/${primaryInstanceRoot.localName}`;
+		this.rootReference = `/${primaryInstanceRoot.nodeName}`;
 
 		this.body = new BodyDefinition(this);
 		this.model = new ModelDefinition(this);

package/src/parse/body/BodyDefinition.ts

@@ -6,8 +6,8 @@ import { ControlDefinition } from './control/ControlDefinition.ts';
 import { InputControlDefinition } from './control/InputControlDefinition.ts';
 import { RangeControlDefinition } from './control/RangeControlDefinition.ts';
 import { RankControlDefinition } from './control/RankControlDefinition.ts';
-import type { AnySelectDefinition } from './control/select/SelectDefinition.ts';
-import { SelectDefinition } from './control/select/SelectDefinition.ts';
+import type { AnySelectControlDefinition } from './control/SelectControlDefinition.ts';
+import { SelectControlDefinition } from './control/SelectControlDefinition.ts';
 import { TriggerControlDefinition } from './control/TriggerControlDefinition.ts';
 import { UploadControlDefinition } from './control/UploadControlDefinition.ts';
 import { LogicalGroupDefinition } from './group/LogicalGroupDefinition.ts';
@@ -24,7 +24,7 @@ export interface BodyElementParentContext {
 
 // prettier-ignore
 export type ControlElementDefinition =
-	| AnySelectDefinition
+	| AnySelectControlDefinition
 	| InputControlDefinition
 	| RangeControlDefinition
 	| RankControlDefinition
@@ -48,7 +48,7 @@ const BodyElementDefinitionConstructors = [
 	PresentationGroupDefinition,
 	StructuralGroupDefinition,
 	InputControlDefinition,
-	SelectDefinition,
+	SelectControlDefinition,
 	RangeControlDefinition,
 	RankControlDefinition,
 	TriggerControlDefinition,

package/src/parse/body/appearance/rangeAppearanceParser.ts

@@ -0,0 +1,11 @@
+import type { ParsedTokenList } from '../../../lib/TokenListParser.ts';
+import { TokenListParser } from '../../../lib/TokenListParser.ts';
+
+export const rangeAppearanceParser = new TokenListParser([
+	'no-ticks',
+	'picker',
+	'rating',
+	'vertical',
+]);
+
+export type RangeAppearanceDefinition = ParsedTokenList<typeof rangeAppearanceParser>;

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

@@ -2,6 +2,7 @@ import type { XFormDefinition } from '../../XFormDefinition.ts';
 import type { InputAppearanceDefinition } from '../appearance/inputAppearanceParser.ts';
 import { inputAppearanceParser } from '../appearance/inputAppearanceParser.ts';
 import type { BodyElementParentContext } from '../BodyDefinition.ts';
+import { parseToFloat, parseToInteger } from '../../../lib/number-parsers.ts';
 import { ControlDefinition } from './ControlDefinition.ts';
 
 export class InputControlDefinition extends ControlDefinition<'input'> {
@@ -11,10 +12,18 @@ export class InputControlDefinition extends ControlDefinition<'input'> {
 
 	readonly type = 'input';
 	readonly appearances: InputAppearanceDefinition;
+	readonly rows: number | null;
+	readonly accuracyThreshold: number | null;
+	readonly unacceptableAccuracyThreshold: number | null;
 
 	constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element) {
 		super(form, parent, element);
 
 		this.appearances = inputAppearanceParser.parseFrom(element, 'appearance');
+		this.rows = parseToInteger(element.getAttribute('rows'));
+		this.accuracyThreshold = parseToFloat(element.getAttribute('accuracyThreshold'));
+		this.unacceptableAccuracyThreshold = parseToFloat(
+			element.getAttribute('unacceptableAccuracyThreshold')
+		);
 	}
 }

package/src/parse/body/control/{select/ItemDefinition.ts → ItemDefinition.ts}

@@ -1,8 +1,10 @@
-import { getValueElement, type ItemElement } from '../../../../lib/dom/query.ts';
-import { ItemLabelDefinition } from '../../../text/ItemLabelDefinition.ts';
-import type { XFormDefinition } from '../../../XFormDefinition.ts';
-import { BodyElementDefinition } from '../../BodyElementDefinition.ts';
-import type { AnySelectDefinition } from './SelectDefinition.ts';
+import type { ItemElement } from '../../../lib/dom/query.ts';
+import { getValueElement } from '../../../lib/dom/query.ts';
+import { ItemLabelDefinition } from '../../text/ItemLabelDefinition.ts';
+import type { XFormDefinition } from '../../XFormDefinition.ts';
+import { BodyElementDefinition } from '../BodyElementDefinition.ts';
+import type { AnySelectControlDefinition } from './SelectControlDefinition.ts';
+import { RankControlDefinition } from './RankControlDefinition.ts';
 
 export class ItemDefinition extends BodyElementDefinition<'item'> {
 	override readonly category = 'support';
@@ -13,7 +15,7 @@ export class ItemDefinition extends BodyElementDefinition<'item'> {
 
 	constructor(
 		form: XFormDefinition,
-		override readonly parent: AnySelectDefinition,
+		override readonly parent: AnySelectControlDefinition | RankControlDefinition,
 		element: ItemElement
 	) {
 		const valueElement = getValueElement(element);

package/src/parse/body/control/{select/ItemsetDefinition.ts → ItemsetDefinition.ts}

@@ -1,11 +1,13 @@
-import { getValueElement, type ItemsetElement } from '../../../../lib/dom/query.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 { AnySelectDefinition } from './SelectDefinition.ts';
+import type { ItemsetElement } from '../../../lib/dom/query.ts';
+import { getValueElement } from '../../../lib/dom/query.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';
 
 export class ItemsetDefinition extends BodyElementDefinition<'itemset'> {
 	override readonly category = 'support';
@@ -19,7 +21,7 @@ export class ItemsetDefinition extends BodyElementDefinition<'itemset'> {
 
 	constructor(
 		form: XFormDefinition,
-		override readonly parent: AnySelectDefinition,
+		override readonly parent: AnySelectControlDefinition | RankControlDefinition,
 		element: ItemsetElement
 	) {
 		super(form, parent, element);