@getodk/xforms-engine 0.1.1 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getodk/xforms-engine",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "license": "Apache-2.0",
   "description": "XForms engine for ODK Web Forms",
   "type": "module",
@@ -29,8 +29,8 @@
     "README.md"
   ],
   "engines": {
-    "node": "^18.20.3 || ^20.13.1 || ^22.2.0",
-    "yarn": "1.22.19"
+    "node": "^18.20.4 || ^20.15.1 || ^22.4.1",
+    "yarn": "1.22.22"
   },
   "scripts": {
     "build": "npm-run-all -nl build:*",
@@ -54,26 +54,25 @@
     "test:types": "tsc --project ./tsconfig.json --emitDeclarationOnly false --noEmit"
   },
   "dependencies": {
-    "solid-js": "^1.8.17"
+    "solid-js": "^1.8.18"
   },
   "devDependencies": {
-    "@babel/core": "^7.24.6",
-    "@getodk/tree-sitter-xpath": "0.1.1",
-    "@getodk/xpath": "0.1.1",
-    "@playwright/test": "^1.44.1",
-    "@vitest/browser": "^1.6.0",
+    "@babel/core": "^7.24.8",
+    "@getodk/tree-sitter-xpath": "0.1.2",
+    "@getodk/xpath": "0.2.0",
+    "@playwright/test": "^1.45.1",
+    "@vitest/browser": "^2.0.2",
     "babel-plugin-transform-jsbi-to-bigint": "^1.4.0",
     "http-server": "^14.1.1",
-    "jsdom": "^24.0.0",
-    "typedoc": "^0.25.13",
-    "unplugin-fonts": "^1.1.1",
-    "vite": "^5.2.11",
+    "jsdom": "^24.1.0",
+    "typedoc": "^0.26.4",
+    "vite": "^5.3.3",
     "vite-plugin-dts": "^3.9.1",
     "vite-plugin-no-bundle": "^4.0.0",
-    "vitest": "^1.6.0"
+    "vitest": "^2.0.2"
   },
   "peerDependencies": {
-    "solid-js": "^1.8.17"
+    "solid-js": "^1.8.18"
   },
   "peerDependenciesMeta": {
     "solid-js": {

package/src/XFormDOM.ts

@@ -1,4 +1,4 @@
-import { XFORMS_NAMESPACE_URI } from '@getodk/common/constants/xmlns.ts';
+import { XFORMS_NAMESPACE_URI, XMLNS_NAMESPACE_URI } from '@getodk/common/constants/xmlns.ts';
 import { XFormsXPathEvaluator } from '@getodk/xpath';
 
 const domParser = new DOMParser();
@@ -41,7 +41,83 @@ const normalizeBodyRefNodesetAttributes = (body: Element): void => {
 	}
 };
 
-const normalizeRepeatGroups = (xformDocument: XMLDocument, body: Element): void => {
+const normalizeRepeatGroupAttributes = (group: Element, repeat: Element): void => {
+	for (const groupAttribute of group.attributes) {
+		const { localName, namespaceURI, nodeName, value } = groupAttribute;
+
+		if (
+			// Don't propagate namespace declarations (which appear as attributes in
+			// the browser/XML DOM, either named `xmlns` or with an `xmlns` prefix,
+			// always in the XMLNS namespace).
+			namespaceURI === XMLNS_NAMESPACE_URI ||
+			// Don't propagate `ref`, it has been normalized as `nodeset` on the
+			// repeat element.
+			localName === 'ref' ||
+			// TODO: this accommodates tests of this normalization process, where
+			// certain nodes of interest are given an `id` attribute, and looked up
+			// for the purpose of asserting what was normalized about them. It's
+			// unclear if there's a generally expected behavior around the attribute.
+			localName === 'id'
+		) {
+			continue;
+		}
+
+		// TODO: The `appearance` attribute is propagated from
+		// `<group appearance><repeat>` to `<repeat appearance>`. But we presently
+		// bail if both elements define the attribute.
+		//
+		// The spec is clear that the attribute is only supported on `<group>` and
+		// control elements, which would suggest it should not be present on a
+		// `<repeat>` element directly. But many form fixtures (in e.g. Enketo)
+		// do have `<repeat apperance>`.
+		//
+		// It may be reasonable to relax this by:
+		//
+		// - Detecting if they share the same appearances, treated as a no-op.
+		//
+		// - Assume they're both meant to apply, and concatenate.
+		if (
+			localName === 'appearance' &&
+			namespaceURI === XFORMS_NAMESPACE_URI &&
+			repeat.hasAttribute(localName)
+		) {
+			const ref = group.getAttribute('ref');
+
+			throw new Error(
+				`Failed to normalize conflicting "appearances" attribute of group/repeat "${ref}"`
+			);
+		}
+
+		repeat.setAttributeNS(namespaceURI, nodeName, value);
+	}
+};
+
+const normalizeRepeatGroupLabel = (group: Element, repeat: Element): void => {
+	const groupLabel = Array.from(group.children).find((child) => {
+		return child.localName === 'label';
+	});
+
+	if (groupLabel == null) {
+		return;
+	}
+
+	const repeatLabel = groupLabel.cloneNode(true) as Element;
+
+	repeatLabel.setAttribute('form-definition-source', 'repeat-group');
+
+	repeat.prepend(repeatLabel);
+
+	groupLabel.remove();
+};
+
+const unwrapRepeatGroup = (group: Element, repeat: Element): void => {
+	normalizeRepeatGroupAttributes(group, repeat);
+	normalizeRepeatGroupLabel(group, repeat);
+
+	group.replaceWith(repeat);
+};
+
+const normalizeRepeatGroups = (body: Element): void => {
 	const repeats = body.querySelectorAll('repeat');
 
 	for (const repeat of repeats) {
@@ -63,11 +139,8 @@ const normalizeRepeatGroups = (xformDocument: XMLDocument, body: Element): void
 			}
 		}
 
-		if (group == null) {
-			group = xformDocument.createElementNS(XFORMS_NAMESPACE_URI, 'group');
-			group.setAttribute('ref', repeatNodeset);
-			repeat.before(group);
-			group.append(repeat);
+		if (group != null) {
+			unwrapRepeatGroup(group, repeat);
 		}
 	}
 };
@@ -113,7 +186,7 @@ const parseNormalizedXForm = (
 		normalizedXML = sourceXML;
 	} else {
 		normalizeBodyRefNodesetAttributes(body);
-		normalizeRepeatGroups(xformDocument, body);
+		normalizeRepeatGroups(body);
 
 		normalizedXML = html.outerHTML;
 	}

package/src/body/BodyDefinition.ts

@@ -1,5 +1,8 @@
 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 { ControlDefinition } from './control/ControlDefinition.ts';
 import { InputDefinition } from './control/InputDefinition.ts';
@@ -7,7 +10,6 @@ import type { AnySelectDefinition } from './control/select/SelectDefinition.ts';
 import { SelectDefinition } from './control/select/SelectDefinition.ts';
 import { LogicalGroupDefinition } from './group/LogicalGroupDefinition.ts';
 import { PresentationGroupDefinition } from './group/PresentationGroupDefinition.ts';
-import { RepeatGroupDefinition } from './group/RepeatGroupDefinition.ts';
 import { StructuralGroupDefinition } from './group/StructuralGroupDefinition.ts';
 
 export interface BodyElementParentContext {
@@ -15,20 +17,24 @@ export interface BodyElementParentContext {
 	readonly element: Element;
 }
 
+// prettier-ignore
+export type ControlElementDefinition =
+	| AnySelectDefinition
+	| InputDefinition;
+
 type SupportedBodyElementDefinition =
 	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
-	| RepeatGroupDefinition
+	| RepeatElementDefinition
 	| LogicalGroupDefinition
 	| PresentationGroupDefinition
 	| StructuralGroupDefinition
-	| InputDefinition
-	| AnySelectDefinition;
+	| ControlElementDefinition;
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 type BodyElementDefinitionConstructor = new (...args: any[]) => SupportedBodyElementDefinition;
 
 const BodyElementDefinitionConstructors = [
-	RepeatGroupDefinition,
+	RepeatElementDefinition,
 	LogicalGroupDefinition,
 	PresentationGroupDefinition,
 	StructuralGroupDefinition,
@@ -49,11 +55,6 @@ export type AnyGroupElementDefinition = Extract<
 	{ readonly type: `${string}-group` }
 >;
 
-export type NonRepeatGroupElementDefinition = Exclude<
-	AnyGroupElementDefinition,
-	{ readonly type: 'repeat-group' }
->;
-
 const isGroupElementDefinition = (
 	element: AnyBodyElementDefinition
 ): element is AnyGroupElementDefinition => {
@@ -96,13 +97,13 @@ class BodyElementMap extends Map<BodyElementReference, AnyBodyElementDefinition>
 		for (const element of elements) {
 			const { reference } = element;
 
-			if (element instanceof RepeatGroupDefinition) {
+			if (element instanceof RepeatElementDefinition) {
 				if (reference == null) {
-					throw new Error('Missing reference for repeat/repeat group');
+					throw new Error('Missing reference for repeat');
 				}
 
 				this.set(reference, element);
-				this.mapElementsByReference(element.repeatChildren);
+				this.mapElementsByReference(element.children);
 			}
 
 			if (
@@ -140,6 +141,10 @@ class BodyElementMap extends Map<BodyElementReference, AnyBodyElementDefinition>
 	}
 }
 
+const bodyClassParser = new TokenListParser(['pages' /*, 'theme-grid' */]);
+
+export type BodyClassList = ParsedTokenList<typeof bodyClassParser>;
+
 export class BodyDefinition extends DependencyContext {
 	static getChildElementDefinitions(
 		form: XFormDefinition,
@@ -161,6 +166,25 @@ export class BodyDefinition extends DependencyContext {
 	}
 
 	readonly element: Element;
+
+	/**
+	 * @todo this class is already an oddity in that it's **like** an element
+	 * definition, but it isn't one itself. Adding this property here emphasizes
+	 * that awkwardness. It also extends the applicable scope where instances of
+	 * this class are accessed. While it's still ephemeral, it's anticipated that
+	 * this extension might cause some disomfort. If so, the most plausible
+	 * alternative is an additional refactor to:
+	 *
+	 * 1. Introduce a `BodyElementDefinition` sublass for `<h:body>`.
+	 * 2. Disambiguate the respective names of those, in some reasonable way.
+	 * 3. Add a layer of indirection between this class and that new body element
+	 *    definition's class.
+	 * 4. At that point, we may as well prioritize the little bit of grunt work to
+	 *    pass the `BodyDefinition` instance by reference rather than assigning it
+	 *    to anything.
+	 */
+	readonly classes: BodyClassList;
+
 	readonly elements: readonly AnyBodyElementDefinition[];
 
 	protected readonly elementsByReference: BodyElementMap;
@@ -176,6 +200,7 @@ export class BodyDefinition extends DependencyContext {
 
 		this.reference = form.rootReference;
 		this.element = element;
+		this.classes = bodyClassParser.parseFrom(element, 'class');
 		this.elements = BodyDefinition.getChildElementDefinitions(form, this, element);
 		this.elementsByReference = new BodyElementMap(this.elements);
 	}
@@ -184,16 +209,6 @@ export class BodyDefinition extends DependencyContext {
 		return this.elementsByReference.get(reference) ?? null;
 	}
 
-	getRepeatGroup(reference: string): RepeatGroupDefinition | null {
-		const element = this.getBodyElement(reference);
-
-		if (element?.type === 'repeat-group') {
-			return element;
-		}
-
-		return null;
-	}
-
 	toJSON() {
 		const { form, ...rest } = this;
 

package/src/body/BodyElementDefinition.ts

@@ -1,8 +1,9 @@
 import type { XFormDefinition } from '../XFormDefinition.ts';
 import { DependencyContext } from '../expression/DependencyContext.ts';
+import type { HintDefinition } from '../parse/text/HintDefinition.ts';
+import type { ItemLabelDefinition } from '../parse/text/ItemLabelDefinition.ts';
+import type { LabelDefinition } from '../parse/text/LabelDefinition.ts';
 import type { BodyElementParentContext } from './BodyDefinition.ts';
-import type { HintDefinition } from './text/HintDefinition.ts';
-import type { LabelDefinition } from './text/LabelDefinition.ts';
 
 /**
  * These category names roughly correspond to each of the ODK XForms spec's
@@ -22,7 +23,7 @@ export abstract class BodyElementDefinition<Type extends string> extends Depende
 	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;

package/src/body/RepeatElementDefinition.ts

@@ -0,0 +1,58 @@
+import { JAVAROSA_NAMESPACE_URI } from '@getodk/common/constants/xmlns.ts';
+import type { XFormDefinition } from '../XFormDefinition.ts';
+import { LabelDefinition } from '../parse/text/LabelDefinition.ts';
+import { parseNodesetReference } from '../parse/xpath/reference-parsing.ts';
+import type { BodyElementDefinitionArray, BodyElementParentContext } from './BodyDefinition.ts';
+import { BodyDefinition } from './BodyDefinition.ts';
+import { BodyElementDefinition } from './BodyElementDefinition.ts';
+import type { StructureElementAppearanceDefinition } from './appearance/structureElementAppearanceParser.ts';
+import { structureElementAppearanceParser } from './appearance/structureElementAppearanceParser.ts';
+
+export class RepeatElementDefinition extends BodyElementDefinition<'repeat'> {
+	static override isCompatible(localName: string): boolean {
+		return localName === 'repeat';
+	}
+
+	override readonly category = 'structure';
+	readonly type = 'repeat';
+	override readonly reference: string;
+	readonly appearances: StructureElementAppearanceDefinition;
+	override readonly label: LabelDefinition | null;
+
+	readonly countExpression: string | null;
+	readonly noAddRemoveExpression: string | null;
+
+	readonly children: BodyElementDefinitionArray;
+
+	constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element) {
+		super(form, parent, element);
+
+		this.label = LabelDefinition.forRepeatGroup(form, this);
+
+		const reference = parseNodesetReference(parent, element, 'nodeset');
+
+		if (reference == null) {
+			throw new Error('Invalid repeat: missing `nodeset` reference');
+		}
+
+		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);
+
+		this.children = children;
+	}
+
+	override toJSON() {
+		const { form, parent, ...rest } = this;
+
+		return rest;
+	}
+}

package/src/body/appearance/inputAppearanceParser.ts

@@ -0,0 +1,39 @@
+import { TokenListParser, type ParsedTokenList } from '../../lib/TokenListParser.ts';
+
+export const inputAppearanceParser = new TokenListParser([
+	'multiline',
+	'numbers',
+	'url',
+	'thousand-sep',
+
+	// date (TODO: data types)
+	'no-calendar',
+	'month-year',
+	'year',
+	// date > calendars
+	'ethiopian',
+	'coptic',
+	'islamic',
+	'bikram-sambat',
+	'myanmar',
+	'persian',
+
+	// geo (TODO: data types)
+	'placement-map',
+	'maps',
+
+	// image/media (TODO: move to eventual `<upload>`?)
+	'hidden-answer',
+	'annotate',
+	'draw',
+	'signature',
+	'new-front',
+	'new',
+	'front',
+
+	// *?
+	'printer', // Note: actual usage uses `printer:...` (like `ex:...`).
+	'masked',
+]);
+
+export type InputAppearanceDefinition = ParsedTokenList<typeof inputAppearanceParser>;

package/src/body/appearance/selectAppearanceParser.ts

@@ -0,0 +1,38 @@
+import { TokenListParser, type ParsedTokenList } from '../../lib/TokenListParser.ts';
+
+export const selectAppearanceParser = new TokenListParser(
+	[
+		// From XLSForm Docs:
+		'compact',
+		'horizontal',
+		'horizontal-compact',
+		'label',
+		'list-nolabel',
+		'minimal',
+
+		// From Collect `Appearances.kt`:
+		'columns',
+		'columns-1',
+		'columns-2',
+		'columns-3',
+		'columns-4',
+		'columns-5',
+		// Note: Collect supports arbitrary columns-n. Technically we do too (we parse
+		// out any appearance, not just those we know about). But we'll only include
+		// types/defaults up to 5.
+		'columns-pack',
+		'autocomplete',
+
+		// TODO: these are `<select1>` only
+		'likert',
+		'quick',
+		'quickcompact',
+		'map',
+		// "quick map"
+	],
+	{
+		aliases: [{ fromAlias: 'search', toCanonical: 'autocomplete' }],
+	}
+);
+
+export type SelectAppearanceDefinition = ParsedTokenList<typeof selectAppearanceParser>;

package/src/body/appearance/structureElementAppearanceParser.ts

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

package/src/body/control/ControlDefinition.ts

@@ -1,8 +1,10 @@
 import type { XFormDefinition } from '../../XFormDefinition.ts';
+import type { ParsedTokenList } from '../../lib/TokenListParser.ts';
+import { HintDefinition } from '../../parse/text/HintDefinition.ts';
+import { LabelDefinition } from '../../parse/text/LabelDefinition.ts';
+import { parseNodesetReference } from '../../parse/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 =
@@ -23,10 +25,13 @@ export abstract class ControlDefinition<
 	override readonly label: LabelDefinition | null;
 	override readonly hint: HintDefinition | null;
 
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	abstract readonly appearances: ParsedTokenList<any>;
+
 	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/body/control/InputDefinition.ts

@@ -1,3 +1,9 @@
+import type { XFormDefinition } from '../../XFormDefinition.ts';
+import type { BodyElementParentContext } from '../BodyDefinition.ts';
+import {
+	inputAppearanceParser,
+	type InputAppearanceDefinition,
+} from '../appearance/inputAppearanceParser.ts';
 import { ControlDefinition } from './ControlDefinition.ts';
 
 export class InputDefinition extends ControlDefinition<'input'> {
@@ -6,4 +12,11 @@ export class InputDefinition extends ControlDefinition<'input'> {
 	}
 
 	readonly type = 'input';
+	readonly appearances: InputAppearanceDefinition;
+
+	constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element) {
+		super(form, parent, element);
+
+		this.appearances = inputAppearanceParser.parseFrom(element, 'appearance');
+	}
 }

package/src/body/control/select/ItemDefinition.ts

@@ -1,14 +1,14 @@
 import { getValueElement, type ItemElement } from '../../../lib/dom/query.ts';
+import { ItemLabelDefinition } from '../../../parse/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;
 	}
 }

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

@@ -1,7 +1,8 @@
-import { getValueElement, type ItemsetElement } from '../../../lib/dom/query.ts';
 import type { XFormDefinition } from '../../../XFormDefinition.ts';
+import { getValueElement, type ItemsetElement } from '../../../lib/dom/query.ts';
+import { ItemsetLabelDefinition } from '../../../parse/text/ItemsetLabelDefinition.ts';
+import { parseNodesetReference } from '../../../parse/xpath/reference-parsing.ts';
 import { BodyElementDefinition } from '../../BodyElementDefinition.ts';
-import { LabelDefinition } from '../../text/LabelDefinition.ts';
 import { ItemsetNodesetExpression } from './ItemsetNodesetExpression.ts';
 import { ItemsetValueExpression } from './ItemsetValueExpression.ts';
 import type { AnySelectDefinition } from './SelectDefinition.ts';
@@ -11,26 +12,42 @@ export class ItemsetDefinition extends BodyElementDefinition<'itemset'> {
 	readonly type = 'itemset';
 
 	override readonly reference: string;
-	override readonly label: LabelDefinition | null;
+	override readonly label: ItemsetLabelDefinition | null;
 
 	readonly nodes: ItemsetNodesetExpression;
 	readonly value: ItemsetValueExpression;
 
-	constructor(form: XFormDefinition, select: AnySelectDefinition, element: ItemsetElement) {
+	constructor(
+		form: XFormDefinition,
+		override readonly parent: AnySelectDefinition,
+		element: ItemsetElement
+	) {
+		super(form, parent, element);
+
+		const nodesetExpression = parseNodesetReference(parent, element, 'nodeset');
+
+		this.nodes = new ItemsetNodesetExpression(this, nodesetExpression);
+		this.reference = nodesetExpression;
+
 		const valueElement = getValueElement(element);
-		const valueExpression = valueElement?.getAttribute('ref');
 
-		if (valueExpression == null) {
-			throw new Error(`<itemset> has no <value>`);
+		if (valueElement == null) {
+			throw new Error('<itemset> has no <value>');
 		}
 
-		super(form, select, element);
+		const valueExpression = parseNodesetReference(
+			{
+				reference: null,
+			},
+			valueElement,
+			'ref'
+		);
 
-		const nodesetExpression = element.getAttribute('nodeset');
+		if (valueExpression == null) {
+			throw new Error(`<itemset> has no <value>`);
+		}
 
-		this.reference = nodesetExpression;
-		this.nodes = new ItemsetNodesetExpression(this, nodesetExpression);
 		this.value = new ItemsetValueExpression(this, valueExpression);
-		this.label = LabelDefinition.forItemset(form, this);
+		this.label = ItemsetLabelDefinition.from(form, this);
 	}
 }

package/src/body/control/select/ItemsetNodesetExpression.ts

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

package/src/body/control/select/SelectDefinition.ts

@@ -3,14 +3,21 @@ import type { LocalNamedElement } from '@getodk/common/types/dom.ts';
 import type { XFormDefinition } from '../../../XFormDefinition.ts';
 import { getItemElements, getItemsetElement } from '../../../lib/dom/query.ts';
 import type { AnyBodyElementDefinition, BodyElementParentContext } from '../../BodyDefinition.ts';
+import type { SelectAppearanceDefinition } from '../../appearance/selectAppearanceParser.ts';
+import { selectAppearanceParser } from '../../appearance/selectAppearanceParser.ts';
 import { ControlDefinition } from '../ControlDefinition.ts';
 import { ItemDefinition } from './ItemDefinition.ts';
 import { ItemsetDefinition } from './ItemsetDefinition.ts';
 
-// TODO: `<trigger>` is *almost* reasonable to support here too. The main
-// hesitation is that its single, implicit "item" does not have a distinct
-// <label>, and presumably has different UX **and translation** considerations.
-const selectLocalNames = new Set(['rank', 'select', 'select1'] as const);
+/**
+ * @todo We were previously a bit overzealous about introducing `<rank>` support
+ * here. It'll likely still fit, but we should approach it with more intention.
+ *
+ * @todo `<trigger>` is *almost* reasonable to support here too. The main
+ * hesitation is that its single, implicit "item" does not have a distinct
+ * <label>, and presumably has different UX **and translation** considerations.
+ */
+const selectLocalNames = new Set([/* 'rank', */ 'select', 'select1'] as const);
 
 export type SelectType = CollectionValues<typeof selectLocalNames>;
 
@@ -34,6 +41,7 @@ export class SelectDefinition<Type extends SelectType> extends ControlDefinition
 
 	override readonly type: Type;
 	override readonly element: SelectElement;
+	readonly appearances: SelectAppearanceDefinition;
 
 	readonly itemset: ItemsetDefinition | null;
 	readonly items: readonly ItemDefinition[];
@@ -45,8 +53,9 @@ export class SelectDefinition<Type extends SelectType> extends ControlDefinition
 
 		super(form, parent, element);
 
-		this.element = element;
 		this.type = element.localName as Type;
+		this.element = element;
+		this.appearances = selectAppearanceParser.parseFrom(element, 'appearance');
 
 		const itemsetElement = getItemsetElement(element);
 		const itemElements = getItemElements(element);