@getodk/xforms-engine 0.1.0 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getodk/xforms-engine",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "license": "Apache-2.0",
   "description": "XForms engine for ODK Web Forms",
   "type": "module",
@@ -29,7 +29,7 @@
     "README.md"
   ],
   "engines": {
-    "node": "^18.19.1 || ^20.11.1",
+    "node": "^18.20.3 || ^20.13.1 || ^22.2.0",
     "yarn": "1.22.19"
   },
   "scripts": {
@@ -54,30 +54,26 @@
     "test:types": "tsc --project ./tsconfig.json --emitDeclarationOnly false --noEmit"
   },
   "dependencies": {
-    "solid-js": "^1.8.3"
+    "solid-js": "^1.8.17"
   },
   "devDependencies": {
-    "@babel/core": "^7.23.2",
-    "@getodk/tree-sitter-xpath": "0.1.0",
-    "@getodk/xpath": "0.1.0",
-    "@playwright/test": "^1.42.1",
-    "@suid/vite-plugin": "^0.1.5",
-    "@vitest/browser": "^1.3.1",
+    "@babel/core": "^7.24.6",
+    "@getodk/tree-sitter-xpath": "0.1.1",
+    "@getodk/xpath": "0.1.2",
+    "@playwright/test": "^1.44.1",
+    "@vitest/browser": "^1.6.0",
     "babel-plugin-transform-jsbi-to-bigint": "^1.4.0",
     "http-server": "^14.1.1",
     "jsdom": "^24.0.0",
-    "typedoc": "^0.25.12",
+    "typedoc": "^0.25.13",
     "unplugin-fonts": "^1.1.1",
-    "vite": "^5.1.5",
-    "vite-plugin-babel": "^1.2.0",
-    "vite-plugin-dts": "^3.7.3",
-    "vite-plugin-no-bundle": "^3.0.0",
-    "vite-plugin-solid": "^2.10.1",
-    "vitest": "^1.3.1",
-    "vitest-github-actions-reporter": "^0.11.1"
+    "vite": "^5.2.11",
+    "vite-plugin-dts": "^3.9.1",
+    "vite-plugin-no-bundle": "^4.0.0",
+    "vitest": "^1.6.0"
   },
   "peerDependencies": {
-    "solid-js": "^1.8.3"
+    "solid-js": "^1.8.17"
   },
   "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/RepeatElementDefinition.ts

@@ -0,0 +1,70 @@
+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 { 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 {
+		return localName === 'repeat';
+	}
+
+	override readonly category = 'structure';
+	readonly type = 'repeat';
+	override readonly reference: string;
+	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 children: BodyElementDefinitionArray;
+
+	constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element) {
+		super(form, parent, element);
+
+		this.label = LabelDefinition.forRepeatGroup(form, this);
+
+		const reference = element.getAttribute('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');
+
+		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;
+
+		// 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() {
+		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,4 +1,5 @@
 import type { XFormDefinition } from '../../XFormDefinition.ts';
+import type { ParsedTokenList } from '../../lib/TokenListParser.ts';
 import type { BodyElementParentContext } from '../BodyDefinition.ts';
 import { BodyElementDefinition } from '../BodyElementDefinition.ts';
 import { HintDefinition } from '../text/HintDefinition.ts';
@@ -23,6 +24,9 @@ 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);
 

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/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);

package/src/body/group/BaseGroupDefinition.ts

@@ -1,13 +1,14 @@
 import { UpsertableMap } from '@getodk/common/lib/collections/UpsertableMap.ts';
-import type { XFormDOM } from '../../XFormDOM.ts';
 import type { XFormDefinition } from '../../XFormDefinition.ts';
-import { getLabelElement, getRepeatElement } from '../../lib/dom/query.ts';
+import { getLabelElement } from '../../lib/dom/query.ts';
 import {
 	BodyDefinition,
 	type BodyElementDefinitionArray,
 	type BodyElementParentContext,
 } from '../BodyDefinition.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';
 
 /**
@@ -23,10 +24,6 @@ import { LabelDefinition } from '../text/LabelDefinition.ts';
  * - `presentation-group` is a group with a `<label>` child; its usage here
  *   differs from the spec language in that `presentation-group` does **not**
  *   have a `ref`
- * - `repeat-group` is not mentioned by the spec; it is an extension of
- *   `logical-group`, wherein its `ref` is the same as its immediate `<repeat>`
- *   child's `nodeset` (usage of each attribute is normalized during
- *   initialization, in {@link XFormDOM})
  * - `structural-group` is any `<group>` element which does not satisfy any of
  *   the other usage scenarios; this isn't exactly the terminology used, but is
  *   the most closely fitting name for the concept where the other sceanarios
@@ -34,20 +31,17 @@ import { LabelDefinition } from '../text/LabelDefinition.ts';
  *
  * A more succinct decision tree:
  *
- * - `<group ref="$ref"><repeat nodeset="$ref">` -> `repeat-group`, else
  * - `<group ref="$ref">` -> `logical-group`, else
  * - `<group><label>` -> `presentation-group`, else
  * - `<group>` -> `structural-group`
  */
-export type GroupType =
-	| 'logical-group'
-	| 'presentation-group'
-	| 'repeat-group'
-	| 'structural-group';
+export type GroupType = 'logical-group' | 'presentation-group' | 'structural-group';
 
 export abstract class BaseGroupDefinition<
 	Type extends GroupType,
 > extends BodyElementDefinition<Type> {
+	// TODO: does this really accomplish anything? It seems highly unlikely it
+	// has enough performance benefit to outweigh its memory and lookup costs.
 	private static groupTypes = new UpsertableMap<Element, GroupType | null>();
 
 	protected static getGroupType(localName: string, element: Element): GroupType | null {
@@ -56,20 +50,8 @@ export abstract class BaseGroupDefinition<
 				return null;
 			}
 
-			const ref = element.getAttribute('ref');
-
-			if (ref != null) {
-				const repeat = getRepeatElement(element);
-
-				if (repeat == null) {
-					return 'logical-group';
-				}
-
-				if (repeat.getAttribute('nodeset') === ref) {
-					return 'repeat-group';
-				}
-
-				throw new Error('Unexpected <repeat> child of unrelated <group>');
+			if (element.hasAttribute('ref')) {
+				return 'logical-group';
 			}
 
 			const label = getLabelElement(element);
@@ -87,6 +69,7 @@ export abstract class BaseGroupDefinition<
 	readonly children: BodyElementDefinitionArray;
 
 	override readonly reference: string | null;
+	readonly appearances: StructureElementAppearanceDefinition;
 	override readonly label: LabelDefinition | null;
 
 	constructor(
@@ -99,6 +82,7 @@ export abstract class BaseGroupDefinition<
 
 		this.children = children ?? this.getChildren(element);
 		this.reference = element.getAttribute('ref');
+		this.appearances = structureElementAppearanceParser.parseFrom(element, 'appearance');
 		this.label = LabelDefinition.forGroup(form, this);
 	}
 
@@ -107,31 +91,9 @@ export abstract class BaseGroupDefinition<
 		const children = Array.from(element.children).filter((child) => {
 			const childName = child.localName;
 
-			return childName !== 'label' && childName !== 'repeat';
+			return childName !== 'label';
 		});
 
 		return BodyDefinition.getChildElementDefinitions(form, this, element, children);
 	}
 }
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const repeatGroup = <T extends BaseGroupDefinition<any>>(
-	groupDefinition: T
-): Extract<T, BaseGroupDefinition<'repeat-group'>> | null => {
-	if (groupDefinition.type === 'repeat-group') {
-		return groupDefinition as Extract<T, BaseGroupDefinition<'repeat-group'>>;
-	}
-
-	return null;
-};
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const nonRepeatGroup = <T extends BaseGroupDefinition<any>>(
-	groupDefinition: T
-): Exclude<T, BaseGroupDefinition<'repeat-group'>> | null => {
-	if (groupDefinition.type === 'repeat-group') {
-		return null;
-	}
-
-	return groupDefinition as Exclude<T, BaseGroupDefinition<'repeat-group'>>;
-};