@getodk/xforms-engine 0.5.0 → 0.6.0

package/src/parse/model/RangeNodeDefinition.ts

@@ -0,0 +1,118 @@
+import type { ValueType } from '../../client/ValueType.ts';
+import { ErrorProductionDesignPendingError } from '../../error/ErrorProductionDesignPendingError.ts';
+import type { RuntimeValue, SharedValueCodec } from '../../lib/codecs/getSharedValueCodec.ts';
+import { getSharedValueCodec } from '../../lib/codecs/getSharedValueCodec.ts';
+import type {
+	RangeControlBoundsDefinition,
+	RangeControlDefinition,
+} from '../body/control/RangeControlDefinition.ts';
+import type { BindDefinition } from './BindDefinition.ts';
+import { LeafNodeDefinition } from './LeafNodeDefinition.ts';
+import type { ParentNodeDefinition } from './NodeDefinition.ts';
+
+const RANGE_VALUE_TYPES = ['decimal', 'int'] as const;
+
+export type RangeValueType = (typeof RANGE_VALUE_TYPES)[number];
+
+type AssertedRangeValueType<V extends ValueType> = Extract<V, RangeValueType>;
+
+type AssertRangeBindDefinition = <V extends ValueType>(
+	bind: BindDefinition<V>
+) => asserts bind is BindDefinition<AssertedRangeValueType<V>>;
+
+const assertRangeBindDefinition: AssertRangeBindDefinition = (bind) => {
+	if (!RANGE_VALUE_TYPES.includes(bind.type.resolved as RangeValueType)) {
+		throw new ErrorProductionDesignPendingError(
+			`Expected range to have bind type "decimal" or "int", got: ${bind.type.resolved}`
+		);
+	}
+};
+
+export interface RangeLeafNodeDefinition<V extends ValueType = ValueType>
+	extends LeafNodeDefinition<V> {
+	readonly bodyElement: RangeControlDefinition;
+}
+
+const decodeBoundsValue = <V extends ValueType>(
+	codec: SharedValueCodec<V>,
+	value: string
+): NonNullable<RuntimeValue<V>> => {
+	const decoded = codec.decodeValue(value);
+
+	if (decoded == null) {
+		throw new ErrorProductionDesignPendingError(
+			`Failed to decode bounds value (encoded as ${JSON.stringify(value)})`
+		);
+	}
+
+	return decoded;
+};
+
+class RangeNodeBoundsDefinition<V extends RangeValueType = RangeValueType> {
+	static from<V extends RangeValueType>(
+		bounds: RangeControlBoundsDefinition,
+		bind: BindDefinition<V>
+	): RangeNodeBoundsDefinition<V> {
+		const type = bind.type.resolved;
+		const codec = getSharedValueCodec(type);
+		const min = decodeBoundsValue(codec, bounds.start);
+		const max = decodeBoundsValue(codec, bounds.end);
+		const step = decodeBoundsValue(codec, bounds.step);
+
+		return new this(min, max, step);
+	}
+
+	constructor(
+		readonly min: NonNullable<RuntimeValue<V>>,
+		readonly max: NonNullable<RuntimeValue<V>>,
+		readonly step: NonNullable<RuntimeValue<V>>
+	) {}
+}
+
+/**
+ * @todo We should really consider making `LeafNodeDefinition` an abstract base
+ * class, and each node's definition an explicit concrete subclass of that. It
+ * would simplify a lot of things, reduce redundancy (and drift!) between
+ * various like `*Definition` types, and allow us to reason more clearly about
+ * what parse-product-input is used to construct each primary instance node.
+ * Furthermore, it would give us a great deal more flexibility to revisit some
+ * of the weaker parts of our current data model (e.g. splitting up selects).
+ *
+ * I explored this refactor as part of the prerequisite work to support range
+ * controls. I eventually backed out because it involved more churn than I felt
+ * comfortable with, but I do think we should keep an eye out for other
+ * opportunities to take on the churn.
+ */
+export class RangeNodeDefinition<V extends RangeValueType = RangeValueType>
+	extends LeafNodeDefinition<V>
+	implements RangeLeafNodeDefinition<V>
+{
+	static from<V extends ValueType>(
+		parent: ParentNodeDefinition,
+		bind: BindDefinition<V>,
+		bodyElement: RangeControlDefinition,
+		node: Element
+	): RangeNodeDefinition<Extract<V, RangeValueType>> {
+		assertRangeBindDefinition(bind);
+
+		return new this(parent, bind, bodyElement, node);
+	}
+
+	readonly bounds: RangeNodeBoundsDefinition<V>;
+
+	private constructor(
+		parent: ParentNodeDefinition,
+		override readonly bind: BindDefinition<V>,
+		override readonly bodyElement: RangeControlDefinition,
+		node: Element
+	) {
+		super(parent, bind, bodyElement, node);
+
+		this.bounds = RangeNodeBoundsDefinition.from(bodyElement.bounds, bind);
+	}
+}
+
+// prettier-ignore
+export type AnyRangeNodeDefinition =
+	| RangeNodeDefinition<'decimal'>
+	| RangeNodeDefinition<'int'>;

package/src/parse/model/RepeatInstanceDefinition.ts

@@ -1,15 +1,18 @@
+import { NamespaceDeclarationMap } from '../../lib/names/NamespaceDeclarationMap.ts';
+import { QualifiedName } from '../../lib/names/QualifiedName.ts';
 import { RepeatElementDefinition } from '../body/RepeatElementDefinition.ts';
 import { DescendentNodeDefinition } from './DescendentNodeDefinition.ts';
-import type { ChildNodeDefinition, NodeDefinition } from './NodeDefinition.ts';
+import type { ChildNodeDefinition } from './NodeDefinition.ts';
 import type { AnyRepeatRangeDefinition } from './RepeatRangeDefinition.ts';
 
-export class RepeatInstanceDefinition
-	extends DescendentNodeDefinition<'repeat-instance', RepeatElementDefinition>
-	implements NodeDefinition<'repeat-instance'>
-{
+export class RepeatInstanceDefinition extends DescendentNodeDefinition<
+	'repeat-instance',
+	RepeatElementDefinition
+> {
 	readonly type = 'repeat-instance';
 
-	readonly nodeName: string;
+	readonly namespaceDeclarations: NamespaceDeclarationMap;
+	readonly qualifiedName: QualifiedName;
 	readonly children: readonly ChildNodeDefinition[];
 	readonly instances = null;
 	readonly defaultValue = null;
@@ -22,7 +25,8 @@ export class RepeatInstanceDefinition
 
 		super(parent, bind, bodyElement);
 
-		this.nodeName = range.nodeName;
+		this.qualifiedName = new QualifiedName(node);
+		this.namespaceDeclarations = new NamespaceDeclarationMap(this);
 		this.children = root.buildSubtree(this);
 	}
 

package/src/parse/model/RepeatRangeDefinition.ts

@@ -1,8 +1,10 @@
+import { NamespaceDeclarationMap } from '../../lib/names/NamespaceDeclarationMap.ts';
+import { QualifiedName } from '../../lib/names/QualifiedName.ts';
 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 { NodeDefinition, ParentNodeDefinition } from './NodeDefinition.ts';
+import type { ParentNodeDefinition } from './NodeDefinition.ts';
 import { RepeatInstanceDefinition } from './RepeatInstanceDefinition.ts';
 import { RepeatTemplateDefinition } from './RepeatTemplateDefinition.ts';
 
@@ -29,10 +31,10 @@ const assertRepeatRangeDefinitionUnion: AssertRepeatRangeDefinitionUnion = (_def
 	// tautologically true!
 };
 
-export class RepeatRangeDefinition
-	extends DescendentNodeDefinition<'repeat-range', RepeatElementDefinition>
-	implements NodeDefinition<'repeat-range'>
-{
+export class RepeatRangeDefinition extends DescendentNodeDefinition<
+	'repeat-range',
+	RepeatElementDefinition
+> {
 	static from(
 		parent: ParentNodeDefinition,
 		bind: BindDefinition,
@@ -54,7 +56,8 @@ export class RepeatRangeDefinition
 	readonly count: RepeatCountControlExpression | null;
 
 	readonly node = null;
-	readonly nodeName: string;
+	readonly namespaceDeclarations: NamespaceDeclarationMap;
+	readonly qualifiedName: QualifiedName;
 	readonly defaultValue = null;
 
 	private constructor(
@@ -68,7 +71,8 @@ export class RepeatRangeDefinition
 		const { template, instanceNodes } = RepeatTemplateDefinition.parseModelNodes(this, modelNodes);
 
 		this.template = template;
-		this.nodeName = template.nodeName;
+		this.qualifiedName = template.qualifiedName;
+		this.namespaceDeclarations = new NamespaceDeclarationMap(this);
 		this.count = RepeatCountControlExpression.from(bodyElement, instanceNodes.length);
 
 		assertRepeatRangeDefinitionUnion(this);

package/src/parse/model/RepeatTemplateDefinition.ts

@@ -1,8 +1,10 @@
 import { JAVAROSA_NAMESPACE_URI } from '@getodk/common/constants/xmlns.ts';
+import { NamespaceDeclarationMap } from '../../lib/names/NamespaceDeclarationMap.ts';
+import { QualifiedName } from '../../lib/names/QualifiedName.ts';
 import type { RepeatElementDefinition } from '../body/RepeatElementDefinition.ts';
 import { BindDefinition } from './BindDefinition.ts';
 import { DescendentNodeDefinition } from './DescendentNodeDefinition.ts';
-import type { ChildNodeDefinition, NodeDefinition } from './NodeDefinition.ts';
+import type { ChildNodeDefinition } from './NodeDefinition.ts';
 import type { RepeatRangeDefinition } from './RepeatRangeDefinition.ts';
 
 const repeatTemplates = new WeakMap<BindDefinition, RepeatTemplateDefinition>();
@@ -72,10 +74,10 @@ interface ParsedRepeatNodes {
 	readonly instanceNodes: readonly Element[];
 }
 
-export class RepeatTemplateDefinition
-	extends DescendentNodeDefinition<'repeat-template', RepeatElementDefinition>
-	implements NodeDefinition<'repeat-template'>
-{
+export class RepeatTemplateDefinition extends DescendentNodeDefinition<
+	'repeat-template',
+	RepeatElementDefinition
+> {
 	static parseModelNodes(
 		range: RepeatRangeDefinition,
 		modelNodes: readonly [Element, ...Element[]]
@@ -115,7 +117,8 @@ export class RepeatTemplateDefinition
 	readonly type = 'repeat-template';
 
 	readonly node: Element;
-	readonly nodeName: string;
+	readonly namespaceDeclarations: NamespaceDeclarationMap;
+	readonly qualifiedName: QualifiedName;
 	readonly children: readonly ChildNodeDefinition[];
 	readonly instances = null;
 	readonly defaultValue = null;
@@ -133,7 +136,8 @@ export class RepeatTemplateDefinition
 		node.removeAttributeNS(JAVAROSA_NAMESPACE_URI, 'template');
 
 		this.node = node;
-		this.nodeName = node.localName;
+		this.qualifiedName = new QualifiedName(node);
+		this.namespaceDeclarations = new NamespaceDeclarationMap(this);
 		this.children = root.buildSubtree(this);
 	}
 

package/src/parse/model/RootAttributeDefinition.ts

@@ -0,0 +1,45 @@
+import { XMLNS_NAMESPACE_URI } from '@getodk/common/constants/xmlns.ts';
+import type { NamedNodeDefinition } from '../../lib/names/NamespaceDeclarationMap.ts';
+import { QualifiedName } from '../../lib/names/QualifiedName.ts';
+import { escapeXMLText } from '../../lib/xml-serialization.ts';
+import type { RootDefinition } from './RootDefinition.ts';
+
+interface RootAttributeSource {
+	readonly namespaceURI: string | null;
+	readonly nodeName: string;
+	readonly prefix: string | null;
+	readonly localName: string;
+	readonly value: string;
+}
+
+/**
+ * @todo This class is named and typed to emphasize its intentionally narrow
+ * usage and purpose. It **intentionally** avoids addressing the much broader
+ * set of concerns around modeling attributes in primary instance/submissions.
+ */
+export class RootAttributeDefinition implements NamedNodeDefinition {
+	private readonly serializedXML: string;
+
+	readonly parent: RootDefinition;
+	readonly qualifiedName: QualifiedName;
+	readonly value: string;
+
+	constructor(root: RootDefinition, source: RootAttributeSource) {
+		const { namespaceURI, nodeName, value } = source;
+
+		this.parent = root;
+		this.qualifiedName = new QualifiedName(source);
+		this.value = value;
+
+		// We serialize namespace declarations separately
+		if (namespaceURI === XMLNS_NAMESPACE_URI) {
+			this.serializedXML = '';
+		} else {
+			this.serializedXML = ` ${nodeName}="${escapeXMLText(value, true)}"`;
+		}
+	}
+
+	serializeAttributeXML(): string {
+		return this.serializedXML;
+	}
+}

package/src/parse/model/RootAttributeMap.ts

@@ -0,0 +1,44 @@
+import { XMLNS_NAMESPACE_URI } from '@getodk/common/constants/xmlns.ts';
+import type { QualifiedName } from '../../lib/names/QualifiedName.ts';
+import { RootAttributeDefinition } from './RootAttributeDefinition.ts';
+import type { RootDefinition } from './RootDefinition.ts';
+
+const isNonNamespaceDeclarationDOMAttr = (domAttr: Attr) => {
+	return domAttr.namespaceURI !== XMLNS_NAMESPACE_URI;
+};
+
+/**
+ * @todo This can be trivially expanded to a narrowly general case when we
+ * prioritize work to
+ * {@link https://github.com/getodk/web-forms/issues/285 | support attributes}
+ * (as modeled form nodes on par with elements). It's been deferred here to
+ * avoid expanding scope of an already fairly large yak shave.
+ *
+ * @todo There's a **much more expansive** general case just waiting for a good
+ * opportuntity to prioritize it. E.g. a `NamedNodeMap<T>`, where T is any
+ * generalized concept of a named node. This expansive generalization would have
+ * a ton of value in a variety of known performance optimization
+ * targets/solutions (i.e. optimizing the most redundant, suboptimal, frequently
+ * performed aspects of any typical XPath expression in a typical XForm).
+ *
+ * @see {@link QualifiedName} for more detail.
+ */
+export class RootAttributeMap extends Map<QualifiedName, RootAttributeDefinition> {
+	static from(root: RootDefinition, domRootSourceElement: Element) {
+		const domAttrs = Array.from(domRootSourceElement.attributes);
+		const nonNamespaceDeclarationDOMAttrs = domAttrs.filter(isNonNamespaceDeclarationDOMAttr);
+		const attributes = nonNamespaceDeclarationDOMAttrs.map((source) => {
+			return new RootAttributeDefinition(root, source);
+		});
+
+		return new this(attributes);
+	}
+
+	private constructor(attributes: readonly RootAttributeDefinition[]) {
+		super(
+			attributes.map((attribute) => {
+				return [attribute.qualifiedName, attribute];
+			})
+		);
+	}
+}

package/src/parse/model/RootDefinition.ts

@@ -1,26 +1,26 @@
+import { NamespaceDeclarationMap } from '../../lib/names/NamespaceDeclarationMap.ts';
+import { QualifiedName } from '../../lib/names/QualifiedName.ts';
 import type { BodyClassList } from '../body/BodyDefinition.ts';
 import type { XFormDefinition } from '../XFormDefinition.ts';
-import type { BindDefinition } from './BindDefinition.ts';
 import type { FormSubmissionDefinition } from './FormSubmissionDefinition.ts';
 import { LeafNodeDefinition } from './LeafNodeDefinition.ts';
 import type { ModelDefinition } from './ModelDefinition.ts';
-import type {
-	ChildNodeDefinition,
-	NodeDefinition,
-	ParentNodeDefinition,
-} from './NodeDefinition.ts';
+import type { ChildNodeDefinition, ParentNodeDefinition } from './NodeDefinition.ts';
+import { NodeDefinition } from './NodeDefinition.ts';
 import { NoteNodeDefinition } from './NoteNodeDefinition.ts';
+import { RangeNodeDefinition } from './RangeNodeDefinition.ts';
 import { RepeatRangeDefinition } from './RepeatRangeDefinition.ts';
+import { RootAttributeMap } from './RootAttributeMap.ts';
 import { SubtreeDefinition } from './SubtreeDefinition.ts';
 
-export class RootDefinition implements NodeDefinition<'root'> {
+export class RootDefinition extends NodeDefinition<'root'> {
 	readonly type = 'root';
-	readonly bind: BindDefinition;
-	readonly nodeset: string;
-	readonly nodeName: string;
+	readonly qualifiedName: QualifiedName;
 	readonly bodyElement = null;
 	readonly root = this;
 	readonly parent = null;
+	readonly namespaceDeclarations: NamespaceDeclarationMap;
+	readonly attributes: RootAttributeMap;
 	readonly children: readonly ChildNodeDefinition[];
 	readonly instances = null;
 	readonly node: Element;
@@ -34,29 +34,26 @@ export class RootDefinition implements NodeDefinition<'root'> {
 		readonly submission: FormSubmissionDefinition,
 		readonly classes: BodyClassList
 	) {
+		const { primaryInstanceRoot } = form.xformDOM;
+		const qualifiedName = new QualifiedName(primaryInstanceRoot);
+		const nodeName = qualifiedName.getPrefixedName();
+
 		// TODO: theoretically the pertinent step in the bind's `nodeset` *could* be
 		// namespaced. It also may make more sense to determine the root nodeset
 		// earlier (i.e. in the appropriate definition class).
-		//
-		// TODO: while it's unlikely a form actually defines a <bind> for the root,
-		// if it did, bind nodesets are not yet normalized, so `/root` may currently
-		// be defined as `/ root` (or even `/ *` or any other valid expression
-		// resolving to the root).
-		const { primaryInstanceRoot } = form.xformDOM;
-		const { localName: rootNodeName } = primaryInstanceRoot;
-
-		this.nodeName = rootNodeName;
-
-		const nodeset = `/${rootNodeName}`;
+		const nodeset = `/${nodeName}`;
 		const bind = model.binds.get(nodeset);
 
 		if (bind == null) {
 			throw new Error('Missing root node bind definition');
 		}
 
-		this.bind = bind;
-		this.nodeset = nodeset;
+		super(bind);
+
+		this.qualifiedName = qualifiedName;
 		this.node = primaryInstanceRoot;
+		this.attributes = RootAttributeMap.from(this, primaryInstanceRoot);
+		this.namespaceDeclarations = new NamespaceDeclarationMap(this);
 		this.children = this.buildSubtree(this);
 	}
 
@@ -70,13 +67,13 @@ export class RootDefinition implements NodeDefinition<'root'> {
 		const childrenByName = new Map<string, [Element, ...Element[]]>();
 
 		for (const child of node.children) {
-			const { localName } = child;
+			const { nodeName } = child;
 
-			let elements = childrenByName.get(localName);
+			let elements = childrenByName.get(nodeName);
 
 			if (elements == null) {
 				elements = [child];
-				childrenByName.set(localName, elements);
+				childrenByName.set(nodeName, elements);
 			} else {
 				// TODO: check if previous element exists, was it previous element
 				// sibling. Highly likely this should otherwise fail!
@@ -84,8 +81,8 @@ export class RootDefinition implements NodeDefinition<'root'> {
 			}
 		}
 
-		return Array.from(childrenByName).map(([localName, children]) => {
-			const nodeset = `${parentNodeset}/${localName}`;
+		return Array.from(childrenByName).map(([nodeName, children]) => {
+			const nodeset = `${parentNodeset}/${nodeName}`;
 			const bind = binds.getOrCreateBindDefinition(nodeset);
 			const bodyElement = body.getBodyElement(nodeset);
 			const [firstChild, ...restChildren] = children;
@@ -102,6 +99,10 @@ export class RootDefinition implements NodeDefinition<'root'> {
 			const isLeafNode = element.childElementCount === 0;
 
 			if (isLeafNode) {
+				if (bodyElement?.type === 'range') {
+					return RangeNodeDefinition.from(parent, bind, bodyElement, element);
+				}
+
 				return (
 					NoteNodeDefinition.from(parent, bind, bodyElement, element) ??
 					new LeafNodeDefinition(parent, bind, bodyElement, element)

package/src/parse/model/SecondaryInstance/sources/GeoJSONExternalSecondaryInstance.ts

@@ -305,6 +305,7 @@ class GeoJSONSecondaryInstanceFeaturePropertyElement extends StaticElement {
 		const { id = propertiesId } = feature;
 
 		if (id !== undefined) {
+			// eslint-disable-next-line @typescript-eslint/no-base-to-string -- Intentional fallback, we don't know what this is and it could be any permutation of JSON
 			yield new this(parent, 'id', String(id));
 		}
 

package/src/parse/model/SubtreeDefinition.ts

@@ -1,22 +1,21 @@
+import { NamespaceDeclarationMap } from '../../lib/names/NamespaceDeclarationMap.ts';
+import { QualifiedName } from '../../lib/names/QualifiedName.ts';
 import type {
 	AnyBodyElementDefinition,
 	AnyGroupElementDefinition,
 } from '../body/BodyDefinition.ts';
 import type { BindDefinition } from './BindDefinition.ts';
 import { DescendentNodeDefinition } from './DescendentNodeDefinition.ts';
-import type {
-	ChildNodeDefinition,
-	NodeDefinition,
-	ParentNodeDefinition,
-} from './NodeDefinition.ts';
-
-export class SubtreeDefinition
-	extends DescendentNodeDefinition<'subtree', AnyGroupElementDefinition | null>
-	implements NodeDefinition<'subtree'>
-{
+import type { ChildNodeDefinition, ParentNodeDefinition } from './NodeDefinition.ts';
+
+export class SubtreeDefinition extends DescendentNodeDefinition<
+	'subtree',
+	AnyGroupElementDefinition | null
+> {
 	readonly type = 'subtree';
 
-	readonly nodeName: string;
+	readonly namespaceDeclarations: NamespaceDeclarationMap;
+	readonly qualifiedName: QualifiedName;
 	readonly children: readonly ChildNodeDefinition[];
 	readonly instances = null;
 	readonly defaultValue = null;
@@ -38,7 +37,8 @@ export class SubtreeDefinition
 
 		const { root } = parent;
 
-		this.nodeName = node.localName;
+		this.qualifiedName = new QualifiedName(node);
+		this.namespaceDeclarations = new NamespaceDeclarationMap(this);
 		this.children = root.buildSubtree(this);
 	}
 

package/src/parse/shared/parseStaticDocumentFromDOMSubtree.ts

@@ -8,9 +8,9 @@ import type {
 import type {
 	StaticElementAttributesFactory,
 	StaticElementChildNodesFactory,
+	StaticElementOptions,
 } from '../../integration/xpath/static-dom/StaticElement.ts';
 import { StaticElement } from '../../integration/xpath/static-dom/StaticElement.ts';
-import type { StaticNamedNodeOptions } from '../../integration/xpath/static-dom/StaticNamedNode.ts';
 import type { StaticParentNode } from '../../integration/xpath/static-dom/StaticNode.ts';
 import { StaticText } from '../../integration/xpath/static-dom/StaticText.ts';
 
@@ -115,12 +115,12 @@ export type StaticElementConstructor<
 				parent: Parent,
 				attributesFactory: StaticElementAttributesFactory,
 				childNodesFactory: StaticElementChildNodesFactory,
-				options: StaticNamedNodeOptions
+				options: StaticElementOptions
 			): T;
 	};
 
 const parseStaticElementFromDOMElement = <
-	T extends StaticElement,
+	T extends StaticElement<Parent>,
 	Parent extends StaticParentNode = StaticParentNode,
 >(
 	parent: Parent,

package/src/parse/text/ItemLabelDefinition.ts

@@ -1,7 +1,7 @@
 import type { LocalNamedElement } from '@getodk/common/types/dom.ts';
 import { getLabelElement } from '../../lib/dom/query.ts';
 import type { XFormDefinition } from '../../parse/XFormDefinition.ts';
-import type { ItemDefinition } from '../body/control/select/ItemDefinition.ts';
+import type { ItemDefinition } from '../body/control/ItemDefinition.ts';
 import { TextElementDefinition } from './abstract/TextElementDefinition.ts';
 
 interface LabelElement extends LocalNamedElement<'label'> {}

package/src/parse/text/ItemsetLabelDefinition.ts

@@ -1,8 +1,8 @@
 import type { LocalNamedElement } from '@getodk/common/types/dom.ts';
 import { getLabelElement } from '../../lib/dom/query.ts';
 import type { XFormDefinition } from '../../parse/XFormDefinition.ts';
-import type { ItemDefinition } from '../body/control/select/ItemDefinition.ts';
-import type { ItemsetDefinition } from '../body/control/select/ItemsetDefinition.ts';
+import type { ItemDefinition } from '../body/control/ItemDefinition.ts';
+import type { ItemsetDefinition } from '../body/control/ItemsetDefinition.ts';
 import { TextReferenceExpression } from '../expression/TextReferenceExpression.ts';
 import { TextTranslationExpression } from '../expression/TextTranslationExpression.ts';
 import type { RefAttributeChunk } from './abstract/TextElementDefinition.ts';

package/src/parse/text/abstract/TextElementDefinition.ts

@@ -1,7 +1,7 @@
 import { isElementNode, isTextNode } from '@getodk/common/lib/dom/predicates.ts';
 import type { ElementTextRole } from '../../../client/TextRange.ts';
 import type { XFormDefinition } from '../../../parse/XFormDefinition.ts';
-import type { ItemDefinition } from '../../body/control/select/ItemDefinition.ts';
+import type { ItemDefinition } from '../../body/control/ItemDefinition.ts';
 import { TextLiteralExpression } from '../../expression/TextLiteralExpression.ts';
 import { TextOutputExpression } from '../../expression/TextOutputExpression.ts';
 import { TextReferenceExpression } from '../../expression/TextReferenceExpression.ts';

package/src/parse/xpath/semantic-analysis.ts

@@ -396,9 +396,10 @@ const findConstantExpressionNode = (expression: string): ConstantExpressionSynta
 	}
 };
 
-type BrandedExpression<Expression extends string, Brand extends symbol> = Expression & {
-	readonly [K in Brand]: true;
-};
+// prettier-ignore
+type BrandedExpression<Expression extends string, Brand extends symbol> =
+	& Expression
+	& Readonly<Record<Brand, true>>;
 
 const CONSTANT_EXPRESSION = Symbol('CONSTANT_EXPRESSION');
 type CONSTANT_EXPRESSION = typeof CONSTANT_EXPRESSION;

package/dist/client/unsupported/RangeNode.d.ts

@@ -1,9 +0,0 @@
-import { RangeControlDefinition } from '../../parse/body/control/RangeControlDefinition.ts';
-import { UnsupportedControlDefinition, UnsupportedControlNode } from './UnsupportedControlNode.ts';
-export interface RangeNodeDefinition extends UnsupportedControlDefinition {
-    readonly bodyElement: RangeControlDefinition;
-}
-export interface RangeNode extends UnsupportedControlNode {
-    readonly nodeType: 'range';
-    readonly definition: RangeNodeDefinition;
-}

package/dist/client/unsupported/RankNode.d.ts

@@ -1,9 +0,0 @@
-import { RankControlDefinition } from '../../parse/body/control/RankControlDefinition.ts';
-import { UnsupportedControlDefinition, UnsupportedControlNode } from './UnsupportedControlNode.ts';
-export interface RankNodeDefinition extends UnsupportedControlDefinition {
-    readonly bodyElement: RankControlDefinition;
-}
-export interface RankNode extends UnsupportedControlNode {
-    readonly nodeType: 'rank';
-    readonly definition: RankNodeDefinition;
-}

package/dist/instance/SelectField.d.ts

@@ -1,58 +0,0 @@
-import { XPathNodeKindKey } from '@getodk/xpath';
-import { Accessor } from 'solid-js';
-import { SelectItem, SelectNode, SelectNodeAppearances } from '../client/SelectNode.ts';
-import { TextRange } from '../client/TextRange.ts';
-import { SubmissionState } from '../client/submission/SubmissionState.ts';
-import { AnyViolation, LeafNodeValidationState } from '../client/validation.ts';
-import { XFormsXPathElement } from '../integration/xpath/adapter/XFormsXPathNode.ts';
-import { CurrentState } from '../lib/reactivity/node-state/createCurrentState.ts';
-import { EngineState } from '../lib/reactivity/node-state/createEngineState.ts';
-import { SharedNodeState } from '../lib/reactivity/node-state/createSharedNodeState.ts';
-import { SimpleAtomicState } from '../lib/reactivity/types.ts';
-import { AnySelectDefinition } from '../parse/body/control/select/SelectDefinition.ts';
-import { LeafNodeDefinition } from '../parse/model/LeafNodeDefinition.ts';
-import { Root } from './Root.ts';
-import { DescendantNodeStateSpec, DescendantNode } from './abstract/DescendantNode.ts';
-import { GeneralParentNode } from './hierarchy.ts';
-import { EvaluationContext } from './internal-api/EvaluationContext.ts';
-import { ValidationContext } from './internal-api/ValidationContext.ts';
-import { ValueContext } from './internal-api/ValueContext.ts';
-import { ClientReactiveSubmittableLeafNode } from './internal-api/submission/ClientReactiveSubmittableLeafNode.ts';
-export interface SelectFieldDefinition extends LeafNodeDefinition {
-    readonly bodyElement: AnySelectDefinition;
-}
-interface SelectFieldStateSpec extends DescendantNodeStateSpec<readonly SelectItem[]> {
-    readonly label: Accessor<TextRange<'label'> | null>;
-    readonly hint: Accessor<TextRange<'hint'> | null>;
-    readonly children: null;
-    readonly value: SimpleAtomicState<readonly SelectItem[]>;
-    readonly valueOptions: Accessor<readonly SelectItem[]>;
-}
-export declare class SelectField extends DescendantNode<SelectFieldDefinition, SelectFieldStateSpec, GeneralParentNode, null> implements SelectNode, XFormsXPathElement, EvaluationContext, ValidationContext, ValueContext<readonly SelectItem[]>, ClientReactiveSubmittableLeafNode<readonly SelectItem[]> {
-    private readonly selectExclusive;
-    private readonly validation;
-    readonly [XPathNodeKindKey] = "element";
-    protected readonly state: SharedNodeState<SelectFieldStateSpec>;
-    protected engineState: EngineState<SelectFieldStateSpec>;
-    readonly nodeType = "select";
-    readonly appearances: SelectNodeAppearances;
-    readonly currentState: CurrentState<SelectFieldStateSpec>;
-    get validationState(): LeafNodeValidationState;
-    readonly submissionState: SubmissionState;
-    readonly contextNode: this;
-    readonly encodeValue: (runtimeValue: readonly SelectItem[]) => string;
-    readonly decodeValue: (instanceValue: string) => readonly SelectItem[];
-    protected readonly getValueOptions: Accessor<readonly SelectItem[]>;
-    protected readonly getValue: Accessor<readonly SelectItem[]>;
-    constructor(parent: GeneralParentNode, definition: SelectFieldDefinition);
-    protected getSelectItemsByValue(valueOptions?: readonly SelectItem[]): ReadonlyMap<string, SelectItem>;
-    protected updateSelectedItemValues(values: readonly string[]): void;
-    protected setSelectedItemValue(value: string | null): void;
-    getXPathValue(): string;
-    select(selectedItem: SelectItem): Root;
-    deselect(deselectedItem: SelectItem): Root;
-    getChildren(): readonly [];
-    getViolation(): AnyViolation | null;
-    isBlank(): boolean;
-}
-export {};