@getodk/xforms-engine 0.5.0 → 0.7.0

package/src/parse/model/RootDefinition.ts

@@ -1,82 +1,78 @@
+import type { StaticElement } from '../../integration/xpath/static-dom/StaticElement.ts';
+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 { RepeatRangeDefinition } from './RepeatRangeDefinition.ts';
+import { RangeNodeDefinition } from './RangeNodeDefinition.ts';
+import { RepeatDefinition } from './RepeatDefinition.ts';
+import { RootAttributeMap } from './RootAttributeMap.ts';
+import type { SubmissionDefinition } from './SubmissionDefinition.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 template: StaticElement;
+	readonly namespaceDeclarations: NamespaceDeclarationMap;
+	readonly attributes: RootAttributeMap;
 	readonly children: readonly ChildNodeDefinition[];
-	readonly instances = null;
-	readonly node: Element;
-	readonly defaultValue = null;
 
 	readonly isTranslated = false;
 
 	constructor(
 		protected readonly form: XFormDefinition,
 		protected readonly model: ModelDefinition,
-		readonly submission: FormSubmissionDefinition,
+		readonly submission: SubmissionDefinition,
 		readonly classes: BodyClassList
 	) {
+		const template = model.instance.root;
+		const qualifiedName = template.qualifiedName;
+		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;
-		this.node = primaryInstanceRoot;
-		this.children = this.buildSubtree(this);
+		super(bind);
+
+		this.qualifiedName = qualifiedName;
+		this.template = template;
+		this.attributes = RootAttributeMap.from(this, template);
+		this.namespaceDeclarations = new NamespaceDeclarationMap(this);
+		this.children = this.buildSubtree(this, template);
 	}
 
-	buildSubtree(parent: ParentNodeDefinition): readonly ChildNodeDefinition[] {
+	buildSubtree(parent: ParentNodeDefinition, node: StaticElement): readonly ChildNodeDefinition[] {
 		const { form, model } = this;
 		const { body } = form;
 		const { binds } = model;
-		const { bind: parentBind, node } = parent;
+		const { bind: parentBind } = parent;
 		const { nodeset: parentNodeset } = parentBind;
 
-		const childrenByName = new Map<string, [Element, ...Element[]]>();
+		const childrenByName = new Map<string, [StaticElement, ...StaticElement[]]>();
 
-		for (const child of node.children) {
-			const { localName } = child;
+		for (const child of node.childElements) {
+			const nodeName = child.qualifiedName.getPrefixedName();
 
-			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,14 +80,14 @@ 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;
 
 			if (bodyElement?.type === 'repeat') {
-				return RepeatRangeDefinition.from(parent, bind, bodyElement, children);
+				return RepeatDefinition.from(parent, bind, bodyElement, children);
 			}
 
 			if (restChildren.length) {
@@ -99,9 +95,12 @@ export class RootDefinition implements NodeDefinition<'root'> {
 			}
 
 			const element = firstChild;
-			const isLeafNode = element.childElementCount === 0;
 
-			if (isLeafNode) {
+			if (element.isLeafElement()) {
+				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/SecondaryInstancesDefinition.ts

@@ -1,10 +1,15 @@
 import { JRResourceURL } from '@getodk/common/jr-resources/JRResourceURL.ts';
 import { UnreachableError } from '@getodk/common/lib/error/UnreachableError.ts';
-import type { XFormsSecondaryInstanceMap } from '@getodk/xpath';
+import type {
+	XFORMS_KNOWN_ATTRIBUTE,
+	XFORMS_LOCAL_NAME,
+	XFormsSecondaryInstanceMap,
+} from '@getodk/xpath';
 import { ErrorProductionDesignPendingError } from '../../../error/ErrorProductionDesignPendingError.ts';
 import type { EngineXPathNode } from '../../../integration/xpath/adapter/kind.ts';
+import type { StaticDocument } from '../../../integration/xpath/static-dom/StaticDocument.ts';
+import type { StaticElement } from '../../../integration/xpath/static-dom/StaticElement.ts';
 import type { XFormDOM } from '../../XFormDOM.ts';
-import { SecondaryInstanceRootDefinition } from './SecondaryInstanceRootDefinition.ts';
 import { BlankSecondaryInstanceSource } from './sources/BlankSecondaryInstanceSource.ts';
 import { CSVExternalSecondaryInstanceSource } from './sources/CSVExternalSecondaryInstance.ts';
 import type { ExternalSecondaryInstanceResourceLoadOptions } from './sources/ExternalSecondaryInstanceResource.ts';
@@ -14,6 +19,22 @@ import { InternalSecondaryInstanceSource } from './sources/InternalSecondaryInst
 import type { SecondaryInstanceSource } from './sources/SecondaryInstanceSource.ts';
 import { XMLExternalSecondaryInstanceSource } from './sources/XMLExternalSecondaryInstanceSource.ts';
 
+export interface SecondaryInstanceDefinition extends StaticDocument {
+	readonly rootDocument: SecondaryInstanceDefinition;
+	readonly root: SecondaryInstanceRootDefinition;
+}
+
+export interface SecondaryInstanceRootDefinition extends StaticElement {
+	readonly [XFORMS_LOCAL_NAME]: 'instance';
+	readonly [XFORMS_KNOWN_ATTRIBUTE]: 'id';
+
+	readonly rootDocument: SecondaryInstanceDefinition;
+	readonly root: SecondaryInstanceRootDefinition;
+
+	getAttributeValue(localName: 'id'): string;
+	getAttributeValue(localName: string): string | null;
+}
+
 export class SecondaryInstancesDefinition
 	extends Map<string, SecondaryInstanceRootDefinition>
 	implements XFormsSecondaryInstanceMap<EngineXPathNode>

package/src/parse/model/SecondaryInstance/assertSecondaryInstanceDefinition.ts

@@ -0,0 +1,14 @@
+import type { StaticDocument } from '../../../integration/xpath/static-dom/StaticDocument.ts';
+import type { SecondaryInstanceDefinition } from './SecondaryInstancesDefinition.ts';
+
+type AssertSecondaryInstanceDefinition = (
+	doc: StaticDocument
+) => asserts doc is SecondaryInstanceDefinition;
+
+export const assertSecondaryInstanceDefinition: AssertSecondaryInstanceDefinition = ({ root }) => {
+	const id = root.getAttributeValue('id');
+
+	if (id == null) {
+		throw new Error();
+	}
+};

package/src/parse/model/SecondaryInstance/defineSecondaryInstance.ts

@@ -0,0 +1,32 @@
+import { StaticDocument } from '../../../integration/xpath/static-dom/StaticDocument.ts';
+import type { StaticElementOptions } from '../../../integration/xpath/static-dom/StaticElement.ts';
+import { assertSecondaryInstanceDefinition } from './assertSecondaryInstanceDefinition.ts';
+import type { SecondaryInstanceDefinition } from './SecondaryInstancesDefinition.ts';
+
+// prettier-ignore
+type SecondaryInstanceRoot =
+	| StaticElementOptions
+	| '';
+
+export const defineSecondaryInstance = (
+	instanceId: string,
+	secondaryInstanceRoot: SecondaryInstanceRoot
+): SecondaryInstanceDefinition => {
+	const doc = new StaticDocument({
+		documentRoot: {
+			name: 'instance',
+			attributes: [
+				{
+					name: 'id',
+					value: instanceId,
+				},
+			],
+			children: [secondaryInstanceRoot],
+		},
+		nodesetPrefix: `instance('${instanceId}')`,
+	});
+
+	assertSecondaryInstanceDefinition(doc);
+
+	return doc;
+};

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

@@ -1,10 +1,7 @@
-import { XFORMS_NAMESPACE_URI } from '@getodk/common/constants/xmlns.ts';
 import type { JRResourceURL } from '@getodk/common/jr-resources/JRResourceURL.ts';
-import type { StaticNode } from '../../../../integration/xpath/static-dom/StaticNode.ts';
-import { parseStaticDocumentFromDOMSubtree } from '../../../shared/parseStaticDocumentFromDOMSubtree.ts';
 import type { DOMSecondaryInstanceElement } from '../../../XFormDOM.ts';
-import { SecondaryInstanceDefinition } from '../SecondaryInstanceDefinition.ts';
-import { SecondaryInstanceRootDefinition } from '../SecondaryInstanceRootDefinition.ts';
+import { defineSecondaryInstance } from '../defineSecondaryInstance.ts';
+import type { SecondaryInstanceDefinition } from '../SecondaryInstancesDefinition.ts';
 import { SecondaryInstanceSource } from './SecondaryInstanceSource.ts';
 
 export class BlankSecondaryInstanceSource extends SecondaryInstanceSource<'blank'> {
@@ -16,25 +13,7 @@ export class BlankSecondaryInstanceSource extends SecondaryInstanceSource<'blank
 		super('blank', instanceId, resourceURL, domElement);
 	}
 
-	/**
-	 * @todo there is really no sense in using the DOM for this, other than it was
-	 * quicker/more ergonomic than constructing the requisite {@link StaticNode}
-	 * structures directly. Pretty good sign those constructor signatures could
-	 * use some TLC!
-	 */
 	parseDefinition(): SecondaryInstanceDefinition {
-		const xmlDocument = this.domElement.ownerDocument.implementation.createDocument(
-			XFORMS_NAMESPACE_URI,
-			'instance'
-		);
-		const instanceElement = xmlDocument.documentElement;
-
-		instanceElement.setAttribute('id', this.instanceId);
-
-		return parseStaticDocumentFromDOMSubtree(
-			SecondaryInstanceDefinition,
-			SecondaryInstanceRootDefinition,
-			instanceElement
-		);
+		return defineSecondaryInstance(this.instanceId, '');
 	}
 }

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

@@ -1,12 +1,9 @@
-import { XFORMS_NAMESPACE_URI } from '@getodk/common/constants/xmlns.ts';
 import type { JRResourceURL } from '@getodk/common/jr-resources/JRResourceURL.ts';
 import * as papa from 'papaparse';
 import { ErrorProductionDesignPendingError } from '../../../../error/ErrorProductionDesignPendingError.ts';
-import { StaticAttribute } from '../../../../integration/xpath/static-dom/StaticAttribute.ts';
-import { StaticElement } from '../../../../integration/xpath/static-dom/StaticElement.ts';
-import { StaticText } from '../../../../integration/xpath/static-dom/StaticText.ts';
-import { SecondaryInstanceDefinition } from '../SecondaryInstanceDefinition.ts';
-import { SecondaryInstanceRootDefinition } from '../SecondaryInstanceRootDefinition.ts';
+import type { StaticElementOptions } from '../../../../integration/xpath/static-dom/StaticElement.ts';
+import { defineSecondaryInstance } from '../defineSecondaryInstance.ts';
+import type { SecondaryInstanceDefinition } from '../SecondaryInstancesDefinition.ts';
 import { ExternalSecondaryInstanceSource } from './ExternalSecondaryInstanceSource.ts';
 
 type CSVColumn = string;
@@ -88,89 +85,39 @@ interface CSVExternalSecondaryInstanceItemColumn {
 
 type CSVExternalSecondaryInstanceItem = readonly CSVExternalSecondaryInstanceItemColumn[];
 
-class CSVExternalSecondaryInstanceColumnElement extends StaticElement {
-	constructor(parent: StaticElement, column: CSVExternalSecondaryInstanceItemColumn) {
-		const { columnName, cellValue } = column;
-
-		super(
-			parent,
-			() => [],
-			(self) => [new StaticText(self, cellValue)],
-			{
-				namespaceURI: XFORMS_NAMESPACE_URI,
-				localName: columnName,
-			}
-		);
-	}
-}
+const columnChildOption = (
+	column: CSVExternalSecondaryInstanceItemColumn
+): StaticElementOptions => {
+	const { columnName, cellValue } = column;
 
-class CSVExternalSecondaryInstanceItemElement extends StaticElement {
-	constructor(parent: StaticElement, item: CSVExternalSecondaryInstanceItem) {
-		super(
-			parent,
-			() => [],
-			(self) => {
-				return item.map((column) => {
-					return new CSVExternalSecondaryInstanceColumnElement(self, column);
-				});
-			},
-			{
-				namespaceURI: XFORMS_NAMESPACE_URI,
-				localName: 'item',
-			}
-		);
-	}
-}
+	return {
+		name: columnName,
+		children: [cellValue],
+	};
+};
 
-class CSVExternalSecondaryInstanceRootElement extends StaticElement {
-	constructor(parent: StaticElement, items: readonly CSVExternalSecondaryInstanceItem[]) {
-		super(
-			parent,
-			() => [],
-			(self) => {
-				return items.map((item) => {
-					return new CSVExternalSecondaryInstanceItemElement(self, item);
-				});
-			},
-			{
-				namespaceURI: XFORMS_NAMESPACE_URI,
-				localName: 'root',
-			}
-		);
-	}
-}
+const itemChildOption = (item: CSVExternalSecondaryInstanceItem): StaticElementOptions => {
+	return {
+		name: 'item',
+		children: item.map(columnChildOption),
+	};
+};
 
-class CSVExternalSecondaryInstanceDocumentElement extends SecondaryInstanceRootDefinition {
-	constructor(
-		instanceId: string,
-		parent: CSVExternalSecondaryInstanceDefinition,
-		items: readonly CSVExternalSecondaryInstanceItem[]
-	) {
-		super(
-			parent,
-			(self) => [
-				new StaticAttribute(self, {
-					namespaceURI: XFORMS_NAMESPACE_URI,
-					localName: 'id',
-					value: instanceId,
-				}),
-			],
-			(self) => [new CSVExternalSecondaryInstanceRootElement(self, items)],
-			{
-				namespaceURI: XFORMS_NAMESPACE_URI,
-				localName: 'instance',
-			}
-		);
-	}
-}
+const rootChildOption = (
+	items: readonly CSVExternalSecondaryInstanceItem[]
+): StaticElementOptions => {
+	return {
+		name: 'root',
+		children: items.map(itemChildOption),
+	};
+};
 
-class CSVExternalSecondaryInstanceDefinition extends SecondaryInstanceDefinition {
-	constructor(instanceId: string, items: readonly CSVExternalSecondaryInstanceItem[]) {
-		super((self) => {
-			return new CSVExternalSecondaryInstanceDocumentElement(instanceId, self, items);
-		});
-	}
-}
+const csvExternalSecondaryInstanceDefinition = (
+	instanceId: string,
+	items: readonly CSVExternalSecondaryInstanceItem[]
+): SecondaryInstanceDefinition => {
+	return defineSecondaryInstance(instanceId, rootChildOption(items));
+};
 
 export class CSVExternalSecondaryInstanceSource extends ExternalSecondaryInstanceSource<'csv'> {
 	/**
@@ -283,6 +230,6 @@ export class CSVExternalSecondaryInstanceSource extends ExternalSecondaryInstanc
 		});
 		const items = this.toItems(columns, rows);
 
-		return new CSVExternalSecondaryInstanceDefinition(this.instanceId, items);
+		return csvExternalSecondaryInstanceDefinition(this.instanceId, items);
 	}
 }

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

@@ -1,4 +1,3 @@
-import { XFORMS_NAMESPACE_URI } from '@getodk/common/constants/xmlns.ts';
 import { UnreachableError } from '@getodk/common/lib/error/UnreachableError.ts';
 import { assertUnknownArray } from '@getodk/common/lib/type-assertions/assertUnknownArray.ts';
 import type { UnknownObject } from '@getodk/common/lib/type-assertions/assertUnknownObject.ts';
@@ -12,11 +11,9 @@ import type {
 	FeatureCollection as GeoJSONFeatureCollection,
 } from 'geojson';
 import { ErrorProductionDesignPendingError } from '../../../../error/ErrorProductionDesignPendingError.ts';
-import { StaticAttribute } from '../../../../integration/xpath/static-dom/StaticAttribute.ts';
-import { StaticElement } from '../../../../integration/xpath/static-dom/StaticElement.ts';
-import { StaticText } from '../../../../integration/xpath/static-dom/StaticText.ts';
-import { SecondaryInstanceDefinition } from '../SecondaryInstanceDefinition.ts';
-import { SecondaryInstanceRootDefinition } from '../SecondaryInstanceRootDefinition.ts';
+import type { StaticElementOptions } from '../../../../integration/xpath/static-dom/StaticElement.ts';
+import { defineSecondaryInstance } from '../defineSecondaryInstance.ts';
+import type { SecondaryInstanceDefinition } from '../SecondaryInstancesDefinition.ts';
 import { ExternalSecondaryInstanceSource } from './ExternalSecondaryInstanceSource.ts';
 
 const FEATURE_COLLECTION = 'FeatureCollection';
@@ -252,155 +249,86 @@ const serializeCoordinates = (coordinates: LongLatCoordinates): SerializedCoordi
 	return `${latitude} ${longitude} 0 0`;
 };
 
-class GeoJSONSecondaryInstanceFeatureGeometryElement extends StaticElement {
-	static from(
-		parent: StaticElement,
-		feature: Feature
-	): GeoJSONSecondaryInstanceFeatureGeometryElement {
-		const { geometry } = feature;
+const geometryValues = (geometry: SupportedGeometry): readonly string[] => {
+	switch (geometry.type) {
+		case 'LineString':
+			return geometry.coordinates.map(serializeCoordinates);
 
-		switch (geometry.type) {
-			case 'LineString':
-				return new this(parent, geometry.coordinates);
+		case 'Point':
+			return [serializeCoordinates(geometry.coordinates)];
 
-			case 'Point':
-				return new this(parent, [geometry.coordinates]);
+		case 'Polygon': {
+			const [coordinates = []] = geometry.coordinates;
 
-			case 'Polygon':
-				return new this(parent, geometry.coordinates[0] ?? []);
-
-			default:
-				throw new UnreachableError(geometry);
+			return coordinates.map(serializeCoordinates);
 		}
-	}
 
-	constructor(parent: StaticElement, points: readonly LongLatCoordinates[]) {
-		const values = points.map(serializeCoordinates);
-		const value = values.join('; ');
-
-		super(
-			parent,
-			() => [],
-			(self) => [new StaticText(self, value)],
-			{
-				namespaceURI: XFORMS_NAMESPACE_URI,
-				localName: 'geometry',
-			}
-		);
+		default:
+			throw new UnreachableError(geometry);
 	}
-}
+};
 
-class GeoJSONSecondaryInstanceFeaturePropertyElement extends StaticElement {
-	static *buildPropertyElements(
-		parent: StaticElement,
-		feature: Feature
-	): Iterable<GeoJSONSecondaryInstanceFeaturePropertyElement> {
-		const { properties } = feature;
+const geometryChildElementOption = (feature: Feature): StaticElementOptions => {
+	const { geometry } = feature;
+	const values = geometryValues(geometry);
+	const value = values.join('; ');
 
-		if (properties == null) {
-			return [];
-		}
+	return {
+		name: 'geometry',
+		children: [value],
+	};
+};
 
-		const { id: propertiesId, ...nonIdProperties } = properties;
-		const { id = propertiesId } = feature;
+const propertyChildOption = (propertyName: string, propertyValue: string): StaticElementOptions => {
+	return {
+		name: propertyName,
+		children: [propertyValue],
+	};
+};
 
-		if (id !== undefined) {
-			yield new this(parent, 'id', String(id));
-		}
+function* propertyChildOptions(feature: Feature): Iterable<StaticElementOptions> {
+	const { properties } = feature;
 
-		for (const [propertyName, propertyValue] of Object.entries(nonIdProperties)) {
-			yield new this(parent, propertyName, String(propertyValue));
-		}
+	if (properties == null) {
+		return [];
 	}
 
-	constructor(parent: StaticElement, propertyName: string, propertyValue: string) {
-		super(
-			parent,
-			() => [],
-			(self) => [new StaticText(self, propertyValue)],
-			{
-				namespaceURI: XFORMS_NAMESPACE_URI,
-				localName: propertyName,
-			}
-		);
-	}
-}
+	const { id: propertiesId, ...nonIdProperties } = properties;
+	const { id = propertiesId } = feature;
 
-class GeoJSONSecondaryInstanceFeatureItemElement extends StaticElement {
-	constructor(parent: StaticElement, feature: Feature) {
-		super(
-			parent,
-			() => [],
-			(self) => {
-				const geometry = GeoJSONSecondaryInstanceFeatureGeometryElement.from(self, feature);
-				const properties = GeoJSONSecondaryInstanceFeaturePropertyElement.buildPropertyElements(
-					self,
-					feature
-				);
-
-				return [geometry, ...properties];
-			},
-			{
-				namespaceURI: XFORMS_NAMESPACE_URI,
-				localName: 'item',
-			}
-		);
+	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 propertyChildOption('id', String(id));
 	}
-}
 
-class GeoJSONSecondaryInstanceRootElement extends StaticElement {
-	constructor(parent: StaticElement, featureCollection: FeatureCollection) {
-		super(
-			parent,
-			() => [],
-			(self) => {
-				return featureCollection.features.map((feature) => {
-					return new GeoJSONSecondaryInstanceFeatureItemElement(self, feature);
-				});
-			},
-			{
-				namespaceURI: XFORMS_NAMESPACE_URI,
-				localName: 'root',
-			}
-		);
+	for (const [propertyName, propertyValue] of Object.entries(nonIdProperties)) {
+		yield propertyChildOption(propertyName, String(propertyValue));
 	}
 }
 
-class GeoJSONExternalSecondaryInstanceDocumentElement extends SecondaryInstanceRootDefinition {
-	constructor(
-		instanceId: string,
-		parent: GeoJSONExternalSecondaryInstanceDefinition,
-		featureCollection: FeatureCollection
-	) {
-		super(
-			parent,
-			(self) => [
-				new StaticAttribute(self, {
-					namespaceURI: XFORMS_NAMESPACE_URI,
-					localName: 'id',
-					value: instanceId,
-				}),
-			],
-			(self) => [new GeoJSONSecondaryInstanceRootElement(self, featureCollection)],
-			{
-				namespaceURI: XFORMS_NAMESPACE_URI,
-				localName: 'instance',
-			}
-		);
-	}
-}
+const itemChildOption = (feature: Feature): StaticElementOptions => {
+	const geometry = geometryChildElementOption(feature);
+	const properties = propertyChildOptions(feature);
 
-class GeoJSONExternalSecondaryInstanceDefinition extends SecondaryInstanceDefinition {
-	constructor(instanceId: string, featureCollection: FeatureCollection) {
-		super((self) => {
-			return new GeoJSONExternalSecondaryInstanceDocumentElement(
-				instanceId,
-				self,
-				featureCollection
-			);
-		});
-	}
-}
+	return {
+		name: 'item',
+		children: [geometry, ...properties],
+	};
+};
+
+const rootChildOption = (featureCollection: FeatureCollection): StaticElementOptions => {
+	return {
+		name: 'root',
+		children: featureCollection.features.map(itemChildOption),
+	};
+};
+
+const geoJSONExternalSecondaryInstanceDefinition = (
+	instanceId: string,
+	featureCollection: FeatureCollection
+): SecondaryInstanceDefinition => {
+	return defineSecondaryInstance(instanceId, rootChildOption(featureCollection));
+};
 
 export class GeoJSONExternalSecondaryInstanceSource extends ExternalSecondaryInstanceSource<'geojson'> {
 	parseDefinition(): SecondaryInstanceDefinition {
@@ -409,6 +337,6 @@ export class GeoJSONExternalSecondaryInstanceSource extends ExternalSecondaryIns
 
 		assertFeatureCollection(value);
 
-		return new GeoJSONExternalSecondaryInstanceDefinition(this.instanceId, value);
+		return geoJSONExternalSecondaryInstanceDefinition(this.instanceId, value);
 	}
 }