@getodk/xforms-engine 0.2.0 → 0.4.0

package/src/lib/reactivity/validation/createValidation.ts

@@ -0,0 +1,196 @@
+import type { Accessor } from 'solid-js';
+import { createMemo } from 'solid-js';
+import type { OpaqueReactiveObjectFactory } from '../../../client/OpaqueReactiveObjectFactory.ts';
+import type {
+	TextRange as ClientTextRange,
+	ValidationTextRole,
+} from '../../../client/TextRange.ts';
+import { VALIDATION_TEXT } from '../../../client/constants.ts';
+import type {
+	AnyViolation,
+	ConditionSatisfied,
+	ConditionValidation,
+	ConditionViolation,
+	ValidationCondition,
+} from '../../../client/validation.ts';
+import type { ValidationContext } from '../../../instance/internal-api/ValidationContext.ts';
+import { TextChunk } from '../../../instance/text/TextChunk.ts';
+import { TextRange } from '../../../instance/text/TextRange.ts';
+import type { MessageDefinition } from '../../../parse/text/MessageDefinition.ts';
+import { createComputedExpression } from '../createComputedExpression.ts';
+import type {
+	SharedNodeState,
+	SharedNodeStateOptions,
+} from '../node-state/createSharedNodeState.ts';
+import { createSharedNodeState } from '../node-state/createSharedNodeState.ts';
+import type { ReactiveScope } from '../scope.ts';
+import { createTextRange } from '../text/createTextRange.ts';
+
+type EngineViolationMessage<Role extends ValidationTextRole> = ClientTextRange<Role, 'engine'>;
+
+const engineViolationMessage = <Role extends ValidationTextRole>(
+	context: ValidationContext,
+	role: Role
+): Accessor<EngineViolationMessage<Role>> => {
+	const messageText = VALIDATION_TEXT[role];
+	const chunk = new TextChunk(context.root, 'literal', messageText);
+	const message = new TextRange('engine', role, [chunk]);
+
+	return () => message;
+};
+
+const createViolationMessage = <Role extends ValidationTextRole>(
+	context: ValidationContext,
+	role: Role,
+	definition: MessageDefinition<Role> | null
+) => {
+	if (definition == null) {
+		return engineViolationMessage(context, role);
+	}
+
+	return createTextRange(context, role, definition);
+};
+
+// prettier-ignore
+type ComputedConditionValidation<
+	Condition extends ValidationCondition
+> = Accessor<ConditionValidation<Condition>>;
+
+const constraintValid = (): ConditionSatisfied<'constraint'> => {
+	return {
+		condition: 'constraint',
+		valid: true,
+		message: null,
+	};
+};
+
+const createConstraintValidation = (
+	context: ValidationContext
+): ComputedConditionValidation<'constraint'> => {
+	return context.scope.runTask(() => {
+		const { constraint, constraintMsg } = context.definition.bind;
+
+		if (constraint == null) {
+			return constraintValid;
+		}
+
+		const isValid = createComputedExpression(context, constraint, {
+			arbitraryDependencies: [context],
+		});
+
+		const message = createViolationMessage(context, 'constraintMsg', constraintMsg);
+
+		return createMemo(() => {
+			if (!context.isRelevant() || context.isBlank() || isValid()) {
+				return constraintValid();
+			}
+
+			return {
+				condition: 'constraint',
+				valid: false,
+				message: message(),
+			} as const;
+		});
+	});
+};
+
+const requiredValid = (): ConditionSatisfied<'required'> => {
+	return {
+		condition: 'required',
+		valid: true,
+		message: null,
+	};
+};
+
+const createRequiredValidation = (
+	context: ValidationContext
+): ComputedConditionValidation<'required'> => {
+	return context.scope.runTask(() => {
+		const { required, requiredMsg } = context.definition.bind;
+
+		if (required.isDefaultExpression) {
+			return requiredValid;
+		}
+
+		const isValid = () => {
+			if (context.isRequired()) {
+				return !context.isBlank();
+			}
+
+			return true;
+		};
+
+		const message = createViolationMessage(context, 'requiredMsg', requiredMsg);
+
+		return createMemo(() => {
+			if (!context.isRelevant() || isValid()) {
+				return requiredValid();
+			}
+
+			return {
+				condition: 'required',
+				valid: false,
+				message: message(),
+			} as const;
+		});
+	});
+};
+
+type OptionalViolation<Condition extends ValidationCondition> =
+	Accessor<ConditionViolation<Condition> | null>;
+
+const createComputedViolation = <Condition extends ValidationCondition>(
+	scope: ReactiveScope,
+	validateCondition: ComputedConditionValidation<Condition>
+): OptionalViolation<Condition> => {
+	return scope.runTask(() => {
+		return createMemo(() => {
+			const validation = validateCondition();
+
+			if (validation.valid) {
+				return null;
+			}
+
+			return validation;
+		});
+	});
+};
+
+type ComputedViolation = Accessor<AnyViolation | null>;
+
+interface ValidationStateSpec {
+	readonly constraint: ComputedConditionValidation<'constraint'>;
+	readonly required: ComputedConditionValidation<'required'>;
+	readonly violation: ComputedViolation;
+}
+
+export type SharedValidationState = SharedNodeState<ValidationStateSpec>;
+
+interface ValidationStateOptions<Factory extends OpaqueReactiveObjectFactory>
+	extends SharedNodeStateOptions<Factory, ValidationStateSpec> {}
+
+export const createValidationState = <Factory extends OpaqueReactiveObjectFactory>(
+	context: ValidationContext,
+	options: ValidationStateOptions<Factory>
+): SharedValidationState => {
+	const { scope } = context;
+
+	return scope.runTask(() => {
+		const constraint = createConstraintValidation(context);
+		const constraintViolation = createComputedViolation(scope, constraint);
+		const required = createRequiredValidation(context);
+		const requiredViolation = createComputedViolation(scope, required);
+
+		const violation = createMemo(() => {
+			return constraintViolation() ?? requiredViolation();
+		});
+
+		const spec: ValidationStateSpec = {
+			constraint,
+			required,
+			violation,
+		};
+
+		return createSharedNodeState(scope, spec, options);
+	});
+};

package/src/{XFormDataType.ts → parse/XFormDataType.ts}

@@ -10,9 +10,7 @@ export type UnsupportedDataType = typeof UNSUPPORTED_DATA_TYPE;
 /**
  * Like JavaRosa. Presumably for e.g. groups with explicit binds (`relevant` etc)?
  */
-const NULL_DATA_TYPE = 'NULL';
-
-export type NullDataType = typeof NULL_DATA_TYPE;
+export type NullDataType = 'NULL';
 
 /**
  * As in ODK XForms Spec.

package/src/{XFormDefinition.ts → parse/XFormDefinition.ts}

@@ -1,6 +1,6 @@
-import { XFormDOM } from './XFormDOM.ts';
-import { BodyDefinition } from './body/BodyDefinition.ts';
+import { BodyDefinition } from '../parse/body/BodyDefinition.ts';
 import { ModelDefinition } from './model/ModelDefinition.ts';
+import { XFormDOM } from './XFormDOM.ts';
 
 export class XFormDefinition {
 	readonly xformDOM: XFormDOM;

package/src/{body → parse/body}/BodyDefinition.ts

@@ -1,18 +1,23 @@
-import type { XFormDefinition } from '../XFormDefinition.ts';
-import { DependencyContext } from '../expression/DependencyContext.ts';
-import type { ParsedTokenList } from '../lib/TokenListParser.ts';
-import { TokenListParser } from '../lib/TokenListParser.ts';
-import { RepeatElementDefinition } from './RepeatElementDefinition.ts';
-import { UnsupportedBodyElementDefinition } from './UnsupportedBodyElementDefinition.ts';
+import type { ParsedTokenList } from '../../lib/TokenListParser.ts';
+import { TokenListParser } from '../../lib/TokenListParser.ts';
+import type { XFormDefinition } from '../../parse/XFormDefinition.ts';
+import { DependencyContext } from '../expression/abstract/DependencyContext.ts';
 import { ControlDefinition } from './control/ControlDefinition.ts';
 import { InputDefinition } from './control/InputDefinition.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 { TriggerControlDefinition } from './control/TriggerControlDefinition.ts';
+import { UploadControlDefinition } from './control/UploadControlDefinition.ts';
 import { LogicalGroupDefinition } from './group/LogicalGroupDefinition.ts';
 import { PresentationGroupDefinition } from './group/PresentationGroupDefinition.ts';
 import { StructuralGroupDefinition } from './group/StructuralGroupDefinition.ts';
+import { RepeatElementDefinition } from './RepeatElementDefinition.ts';
+import { UnsupportedBodyElementDefinition } from './UnsupportedBodyElementDefinition.ts';
 
 export interface BodyElementParentContext {
+	readonly body: BodyDefinition;
 	readonly reference: string | null;
 	readonly element: Element;
 }
@@ -20,7 +25,11 @@ export interface BodyElementParentContext {
 // prettier-ignore
 export type ControlElementDefinition =
 	| AnySelectDefinition
-	| InputDefinition;
+	| InputDefinition
+	| RangeControlDefinition
+	| RankControlDefinition
+	| TriggerControlDefinition
+	| UploadControlDefinition;
 
 type SupportedBodyElementDefinition =
 	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
@@ -40,6 +49,10 @@ const BodyElementDefinitionConstructors = [
 	StructuralGroupDefinition,
 	InputDefinition,
 	SelectDefinition,
+	RangeControlDefinition,
+	RankControlDefinition,
+	TriggerControlDefinition,
+	UploadControlDefinition,
 ] as const satisfies readonly BodyElementDefinitionConstructor[];
 
 export type AnyBodyElementDefinition =
@@ -145,25 +158,8 @@ const bodyClassParser = new TokenListParser(['pages' /*, 'theme-grid' */]);
 
 export type BodyClassList = ParsedTokenList<typeof bodyClassParser>;
 
-export class BodyDefinition extends DependencyContext {
-	static getChildElementDefinitions(
-		form: XFormDefinition,
-		parent: BodyElementParentContext,
-		parentElement: Element,
-		children: readonly Element[] = Array.from(parentElement.children)
-	): readonly AnyBodyElementDefinition[] {
-		return Array.from(children).map((element) => {
-			const { localName } = element;
-
-			for (const Constructor of BodyElementDefinitionConstructors) {
-				if (Constructor.isCompatible(localName, element)) {
-					return new Constructor(form, parent, element);
-				}
-			}
-
-			return new UnsupportedBodyElementDefinition(form, parent, element);
-		});
-	}
+export class BodyDefinition extends DependencyContext implements BodyElementParentContext {
+	readonly body: BodyDefinition;
 
 	readonly element: Element;
 
@@ -196,12 +192,14 @@ export class BodyDefinition extends DependencyContext {
 	constructor(protected readonly form: XFormDefinition) {
 		super();
 
+		this.body = this;
+
 		const { body: element } = form.xformDOM;
 
 		this.reference = form.rootReference;
 		this.element = element;
 		this.classes = bodyClassParser.parseFrom(element, 'class');
-		this.elements = BodyDefinition.getChildElementDefinitions(form, this, element);
+		this.elements = this.getChildElementDefinitions(form, this, element);
 		this.elementsByReference = new BodyElementMap(this.elements);
 	}
 
@@ -209,6 +207,25 @@ export class BodyDefinition extends DependencyContext {
 		return this.elementsByReference.get(reference) ?? null;
 	}
 
+	getChildElementDefinitions(
+		form: XFormDefinition,
+		parent: BodyElementParentContext,
+		parentElement: Element,
+		children: readonly Element[] = Array.from(parentElement.children)
+	): readonly AnyBodyElementDefinition[] {
+		return Array.from(children).map((element) => {
+			const { localName } = element;
+
+			for (const Constructor of BodyElementDefinitionConstructors) {
+				if (Constructor.isCompatible(localName, element)) {
+					return new Constructor(form, parent, element);
+				}
+			}
+
+			return new UnsupportedBodyElementDefinition(form, parent, element);
+		});
+	}
+
 	toJSON() {
 		const { form, ...rest } = this;
 

package/src/{body → parse/body}/BodyElementDefinition.ts

@@ -1,8 +1,9 @@
+import { DependencyContext } from '../expression/abstract/DependencyContext.ts';
+import type { HintDefinition } from '../text/HintDefinition.ts';
+import type { ItemLabelDefinition } from '../text/ItemLabelDefinition.ts';
+import type { LabelDefinition } from '../text/LabelDefinition.ts';
 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';
+import type { BodyDefinition, BodyElementParentContext } from './BodyDefinition.ts';
 
 /**
  * These category names roughly correspond to each of the ODK XForms spec's
@@ -11,7 +12,10 @@ import type { LabelDefinition } from './text/LabelDefinition.ts';
  */
 type BodyElementCategory = 'control' | 'structure' | 'support' | 'UNSUPPORTED';
 
-export abstract class BodyElementDefinition<Type extends string> extends DependencyContext {
+export abstract class BodyElementDefinition<Type extends string>
+	extends DependencyContext
+	implements BodyElementParentContext
+{
 	// eslint-disable-next-line @typescript-eslint/ban-ts-comment
 	// @ts-ignore
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -19,10 +23,12 @@ export abstract class BodyElementDefinition<Type extends string> extends Depende
 		throw new Error('Must be overridden by BodyElementDefinition subclass');
 	}
 
+	readonly body: BodyDefinition;
+
 	abstract readonly category: BodyElementCategory;
 	abstract readonly type: Type;
 	readonly hint: HintDefinition | null = null;
-	readonly label: LabelDefinition | null = null;
+	readonly label: ItemLabelDefinition | LabelDefinition | null = null;
 
 	readonly reference: string | null = null;
 	readonly parentReference: string | null;
@@ -33,6 +39,7 @@ export abstract class BodyElementDefinition<Type extends string> extends Depende
 		readonly element: Element
 	) {
 		super();
+		this.body = parent.body;
 		this.parentReference = parent.reference;
 	}
 

package/src/{body → parse/body}/RepeatElementDefinition.ts

@@ -1,11 +1,14 @@
 import { JAVAROSA_NAMESPACE_URI } from '@getodk/common/constants/xmlns.ts';
 import type { XFormDefinition } from '../XFormDefinition.ts';
-import type { BodyElementDefinitionArray, BodyElementParentContext } from './BodyDefinition.ts';
-import { BodyDefinition } from './BodyDefinition.ts';
+import type {
+	BodyElementDefinitionArray,
+	BodyElementParentContext,
+} from '../body/BodyDefinition.ts';
+import { LabelDefinition } from '../text/LabelDefinition.ts';
+import { parseNodesetReference } from '../xpath/reference-parsing.ts';
 import { BodyElementDefinition } from './BodyElementDefinition.ts';
 import type { StructureElementAppearanceDefinition } from './appearance/structureElementAppearanceParser.ts';
 import { structureElementAppearanceParser } from './appearance/structureElementAppearanceParser.ts';
-import { LabelDefinition } from './text/LabelDefinition.ts';
 
 export class RepeatElementDefinition extends BodyElementDefinition<'repeat'> {
 	static override isCompatible(localName: string): boolean {
@@ -18,11 +21,8 @@ export class RepeatElementDefinition extends BodyElementDefinition<'repeat'> {
 	readonly appearances: StructureElementAppearanceDefinition;
 	override readonly label: LabelDefinition | null;
 
-	// TODO: this will fall into the growing category of non-`BindExpression`
-	// cases which have roughly the same design story.
 	readonly countExpression: string | null;
-
-	readonly isFixedCount: boolean;
+	readonly noAddRemoveExpression: string | null;
 
 	readonly children: BodyElementDefinitionArray;
 
@@ -31,7 +31,7 @@ export class RepeatElementDefinition extends BodyElementDefinition<'repeat'> {
 
 		this.label = LabelDefinition.forRepeatGroup(form, this);
 
-		const reference = element.getAttribute('nodeset');
+		const reference = parseNodesetReference(parent, element, 'nodeset');
 
 		if (reference == null) {
 			throw new Error('Invalid repeat: missing `nodeset` reference');
@@ -40,26 +40,16 @@ export class RepeatElementDefinition extends BodyElementDefinition<'repeat'> {
 		this.reference = reference;
 		this.appearances = structureElementAppearanceParser.parseFrom(element, 'appearance');
 		this.countExpression = element.getAttributeNS(JAVAROSA_NAMESPACE_URI, 'count');
+		this.noAddRemoveExpression = element.getAttributeNS(JAVAROSA_NAMESPACE_URI, 'noAddRemove');
 
 		const childElements = Array.from(element.children).filter((childElement) => {
 			const { localName } = childElement;
 
 			return localName !== 'label' && localName !== 'group-label';
 		});
-		const children = BodyDefinition.getChildElementDefinitions(form, this, element, childElements);
+		const children = this.body.getChildElementDefinitions(form, this, element, childElements);
 
 		this.children = children;
-
-		// Spec says this can be either `true()` or `false()`. That said, it
-		// could also presumably be `true ( )` or whatever.
-		const noAddRemove =
-			element
-				.getAttributeNS(JAVAROSA_NAMESPACE_URI, 'noAddRemove')
-				?.trim()
-				.replaceAll(/\s+/g, '') ?? 'false()';
-
-		// TODO: **probably** safe to disregard anything else?
-		this.isFixedCount = noAddRemove === 'true()';
 	}
 
 	override toJSON() {

package/src/{body → parse/body}/appearance/inputAppearanceParser.ts

@@ -1,4 +1,4 @@
-import { TokenListParser, type ParsedTokenList } from '../../lib/TokenListParser.ts';
+import { TokenListParser, type ParsedTokenList } from '../../../lib/TokenListParser.ts';
 
 export const inputAppearanceParser = new TokenListParser([
 	'multiline',

package/src/{body → parse/body}/appearance/selectAppearanceParser.ts

@@ -1,4 +1,4 @@
-import { TokenListParser, type ParsedTokenList } from '../../lib/TokenListParser.ts';
+import { TokenListParser, type ParsedTokenList } from '../../../lib/TokenListParser.ts';
 
 export const selectAppearanceParser = new TokenListParser(
 	[

package/src/{body → parse/body}/appearance/structureElementAppearanceParser.ts

@@ -1,4 +1,4 @@
-import { TokenListParser, type ParsedTokenList } from '../../lib/TokenListParser.ts';
+import { TokenListParser, type ParsedTokenList } from '../../../lib/TokenListParser.ts';
 
 export const structureElementAppearanceParser = new TokenListParser(['field-list', 'table-list']);
 

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

@@ -0,0 +1,5 @@
+import { TokenListParser, type ParsedTokenList } from '../../../lib/TokenListParser.ts';
+
+export const unknownAppearanceParser = new TokenListParser();
+
+export type UnknownAppearanceDefinition = ParsedTokenList<typeof unknownAppearanceParser>;

package/src/{body → parse/body}/control/ControlDefinition.ts

@@ -1,9 +1,10 @@
+import type { ParsedTokenList } from '../../../lib/TokenListParser.ts';
+import { HintDefinition } from '../../text/HintDefinition.ts';
+import { LabelDefinition } from '../../text/LabelDefinition.ts';
 import type { XFormDefinition } from '../../XFormDefinition.ts';
-import type { ParsedTokenList } from '../../lib/TokenListParser.ts';
+import { parseNodesetReference } from '../../xpath/reference-parsing.ts';
 import type { BodyElementParentContext } from '../BodyDefinition.ts';
 import { BodyElementDefinition } from '../BodyElementDefinition.ts';
-import { HintDefinition } from '../text/HintDefinition.ts';
-import { LabelDefinition } from '../text/LabelDefinition.ts';
 
 // prettier-ignore
 type ControlType =
@@ -30,7 +31,7 @@ export abstract class ControlDefinition<
 	constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element) {
 		super(form, parent, element);
 
-		const reference = element.getAttribute('ref');
+		const reference = parseNodesetReference(parent, element, 'ref');
 
 		if (reference == null) {
 			throw new Error(`Invalid control: missing ref attribute`);

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

@@ -0,0 +1,26 @@
+import type { XFormDefinition } from '../../XFormDefinition.ts';
+import {
+	unknownAppearanceParser,
+	type UnknownAppearanceDefinition,
+} from '../appearance/unknownAppearanceParser.ts';
+import type { BodyElementParentContext } from '../BodyDefinition.ts';
+import { ControlDefinition } from './ControlDefinition.ts';
+
+export class RangeControlDefinition extends ControlDefinition<'range'> {
+	static override isCompatible(localName: string): boolean {
+		return localName === 'range';
+	}
+
+	readonly type = 'range';
+	readonly appearances: UnknownAppearanceDefinition;
+
+	constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element) {
+		super(form, parent, element);
+
+		this.appearances = unknownAppearanceParser.parseFrom(element, 'appearance');
+	}
+
+	override toJSON(): object {
+		return {};
+	}
+}

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

@@ -0,0 +1,27 @@
+import { ODK_NAMESPACE_URI } from '@getodk/common/constants/xmlns.ts';
+import type { XFormDefinition } from '../../XFormDefinition.ts';
+import {
+	unknownAppearanceParser,
+	type UnknownAppearanceDefinition,
+} from '../appearance/unknownAppearanceParser.ts';
+import type { BodyElementParentContext } from '../BodyDefinition.ts';
+import { ControlDefinition } from './ControlDefinition.ts';
+
+export class RankControlDefinition extends ControlDefinition<'rank'> {
+	static override isCompatible(localName: string, element: Element): boolean {
+		return localName === 'rank' && element.namespaceURI === ODK_NAMESPACE_URI;
+	}
+
+	readonly type = 'rank';
+	readonly appearances: UnknownAppearanceDefinition;
+
+	constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element) {
+		super(form, parent, element);
+
+		this.appearances = unknownAppearanceParser.parseFrom(element, 'appearance');
+	}
+
+	override toJSON(): object {
+		return {};
+	}
+}

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

@@ -0,0 +1,26 @@
+import type { XFormDefinition } from '../../XFormDefinition.ts';
+import {
+	unknownAppearanceParser,
+	type UnknownAppearanceDefinition,
+} from '../appearance/unknownAppearanceParser.ts';
+import type { BodyElementParentContext } from '../BodyDefinition.ts';
+import { ControlDefinition } from './ControlDefinition.ts';
+
+export class TriggerControlDefinition extends ControlDefinition<'trigger'> {
+	static override isCompatible(localName: string): boolean {
+		return localName === 'trigger';
+	}
+
+	readonly type = 'trigger';
+	readonly appearances: UnknownAppearanceDefinition;
+
+	constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element) {
+		super(form, parent, element);
+
+		this.appearances = unknownAppearanceParser.parseFrom(element, 'appearance');
+	}
+
+	override toJSON(): object {
+		return {};
+	}
+}

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

@@ -0,0 +1,26 @@
+import type { XFormDefinition } from '../../XFormDefinition.ts';
+import {
+	unknownAppearanceParser,
+	type UnknownAppearanceDefinition,
+} from '../appearance/unknownAppearanceParser.ts';
+import type { BodyElementParentContext } from '../BodyDefinition.ts';
+import { ControlDefinition } from './ControlDefinition.ts';
+
+export class UploadControlDefinition extends ControlDefinition<'upload'> {
+	static override isCompatible(localName: string): boolean {
+		return localName === 'upload';
+	}
+
+	readonly type = 'upload';
+	readonly appearances: UnknownAppearanceDefinition;
+
+	constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element) {
+		super(form, parent, element);
+
+		this.appearances = unknownAppearanceParser.parseFrom(element, 'appearance');
+	}
+
+	override toJSON(): object {
+		return {};
+	}
+}

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

@@ -1,14 +1,14 @@
-import { getValueElement, type ItemElement } from '../../../lib/dom/query.ts';
+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 { LabelDefinition } from '../../text/LabelDefinition.ts';
 import type { AnySelectDefinition } from './SelectDefinition.ts';
 
 export class ItemDefinition extends BodyElementDefinition<'item'> {
 	override readonly category = 'support';
 	override readonly type = 'item';
 
-	override readonly label: LabelDefinition | null;
+	override readonly label: ItemLabelDefinition | null;
 	readonly value: string;
 
 	constructor(
@@ -25,7 +25,7 @@ export class ItemDefinition extends BodyElementDefinition<'item'> {
 
 		super(form, parent, element);
 
-		this.label = LabelDefinition.forItem(form, this);
+		this.label = ItemLabelDefinition.from(form, this);
 		this.value = value;
 	}
 }