@getodk/xforms-engine 0.16.0 → 0.17.0

package/src/lib/codecs/geolocation/Geopoint.ts

@@ -0,0 +1,15 @@
+import { Geolocation, type LocationPoint } from './Geolocation.ts';
+
+export type GeopointRuntimeValue = LocationPoint | null;
+
+export type GeopointInputValue = GeopointRuntimeValue | string;
+
+export class Geopoint extends Geolocation {
+	static parseStringToGeopoint(value: string): GeopointRuntimeValue {
+		return Geolocation.parseString(value);
+	}
+
+	static parseGeopointToString(value: GeopointInputValue): string {
+		return Geolocation.toCoordinatesString(value);
+	}
+}

package/src/lib/codecs/geolocation/Geoshape.ts

@@ -0,0 +1,36 @@
+import { Geolocation, type LocationPoint, SEGMENT_SEPARATOR } from './Geolocation.ts';
+
+export type GeoshapeRuntimeValue = LocationPoint[] | null;
+
+export type GeoshapeInputValue = GeoshapeRuntimeValue | string;
+
+export class Geoshape extends Geolocation {
+	static parseStringToGeoshape(value: string): GeoshapeRuntimeValue {
+		const parts = Geolocation.getSegments(value);
+		if (parts === null) {
+			return null;
+		}
+
+		const points = parts.map((point) => Geolocation.parseString(point)) as LocationPoint[];
+		if (points.some((p) => p === null) || points.length < 3 || !Geolocation.isClosedShape(points)) {
+			return null;
+		}
+
+		return points;
+	}
+
+	static parseGeoshapeString(points: GeoshapeInputValue): string {
+		const decodedPoints =
+			typeof points === 'string' ? Geoshape.parseStringToGeoshape(points) : points;
+		if (!decodedPoints) {
+			return '';
+		}
+
+		const segments = decodedPoints.map((point) => Geolocation.toCoordinatesString(point));
+		if (segments.some((s) => !s.length)) {
+			return '';
+		}
+
+		return segments.join(SEGMENT_SEPARATOR);
+	}
+}

package/src/lib/codecs/geolocation/Geotrace.ts

@@ -0,0 +1,36 @@
+import { Geolocation, type LocationPoint, SEGMENT_SEPARATOR } from './Geolocation.ts';
+
+export type GeotraceRuntimeValue = LocationPoint[] | null;
+
+export type GeotraceInputValue = GeotraceRuntimeValue | string;
+
+export class Geotrace extends Geolocation {
+	static parseStringToGeotrace(value: string): GeotraceRuntimeValue {
+		const parts = Geolocation.getSegments(value);
+		if (parts === null) {
+			return null;
+		}
+
+		const points = parts.map((point) => Geolocation.parseString(point)) as LocationPoint[];
+		if (points.some((p) => p === null) || points.length < 2 || Geolocation.isClosedShape(points)) {
+			return null;
+		}
+
+		return points;
+	}
+
+	static parseGeotraceString(points: GeotraceInputValue): string {
+		const decodedPoints =
+			typeof points === 'string' ? Geotrace.parseStringToGeotrace(points) : points;
+		if (!decodedPoints) {
+			return '';
+		}
+
+		const segments = decodedPoints.map((point) => Geolocation.toCoordinatesString(point));
+		if (segments.some((s) => !s.length)) {
+			return '';
+		}
+
+		return segments.join(SEGMENT_SEPARATOR);
+	}
+}

package/src/lib/codecs/geolocation/createGeolocationValueCodec.ts

@@ -0,0 +1,18 @@
+import type { ValueType } from '../../../client';
+import { type CodecDecoder, type CodecEncoder, ValueCodec } from '../ValueCodec.ts';
+
+export function createGeolocationValueCodec<
+	V extends ValueType,
+	RuntimeValue extends RuntimeInputValue,
+	RuntimeInputValue = RuntimeValue,
+>(
+	valueType: V,
+	encodeValue: CodecEncoder<RuntimeInputValue>,
+	decodeValue: CodecDecoder<RuntimeValue>
+): ValueCodec<V, RuntimeValue, RuntimeInputValue> {
+	return new (class extends ValueCodec<V, RuntimeValue, RuntimeInputValue> {})(
+		valueType,
+		encodeValue,
+		decodeValue
+	);
+}

package/src/lib/codecs/getSharedValueCodec.ts

@@ -2,13 +2,27 @@ import type { ValueType } from '../../client/ValueType.ts';
 import type { DatetimeInputValue, DatetimeRuntimeValue } from './DateValueCodec.ts';
 import { DateValueCodec } from './DateValueCodec.ts';
 import {
-	DecimalValueCodec,
 	type DecimalInputValue,
 	type DecimalRuntimeValue,
+	DecimalValueCodec,
 } from './DecimalValueCodec.ts';
-import type { GeopointInputValue, GeopointRuntimeValue } from './Geopoint/Geopoint.ts';
-import { GeopointValueCodec } from './Geopoint/GeopointValueCodec.ts';
-import { IntValueCodec, type IntInputValue, type IntRuntimeValue } from './IntValueCodec.ts';
+import { createGeolocationValueCodec } from './geolocation/createGeolocationValueCodec.ts';
+import {
+	Geopoint,
+	type GeopointInputValue,
+	type GeopointRuntimeValue,
+} from './geolocation/Geopoint.ts';
+import {
+	Geoshape,
+	type GeoshapeInputValue,
+	type GeoshapeRuntimeValue,
+} from './geolocation/Geoshape.ts';
+import {
+	Geotrace,
+	type GeotraceInputValue,
+	type GeotraceRuntimeValue,
+} from './geolocation/Geotrace.ts';
+import { type IntInputValue, type IntRuntimeValue, IntValueCodec } from './IntValueCodec.ts';
 import { StringValueCodec } from './StringValueCodec.ts';
 import type { ValueCodec } from './ValueCodec.ts';
 import { ValueTypePlaceholderCodec } from './ValueTypePlaceholderCodec.ts';
@@ -22,8 +36,8 @@ interface RuntimeValuesByType {
 	readonly time: string;
 	readonly dateTime: string;
 	readonly geopoint: GeopointRuntimeValue;
-	readonly geotrace: string;
-	readonly geoshape: string;
+	readonly geotrace: GeotraceRuntimeValue;
+	readonly geoshape: GeoshapeRuntimeValue;
 	readonly binary: string;
 	readonly barcode: string;
 	readonly intent: string;
@@ -40,8 +54,8 @@ interface RuntimeInputValuesByType {
 	readonly time: string;
 	readonly dateTime: string;
 	readonly geopoint: GeopointInputValue;
-	readonly geotrace: string;
-	readonly geoshape: string;
+	readonly geotrace: GeotraceInputValue;
+	readonly geoshape: GeoshapeInputValue;
 	readonly binary: string;
 	readonly barcode: string;
 	readonly intent: string;
@@ -68,12 +82,24 @@ export const sharedValueCodecs: SharedValueCodecs = {
 	date: new DateValueCodec(),
 	time: new ValueTypePlaceholderCodec('time'),
 	dateTime: new ValueTypePlaceholderCodec('dateTime'),
-	geopoint: new GeopointValueCodec(),
-	geotrace: new ValueTypePlaceholderCodec('geotrace'),
-	geoshape: new ValueTypePlaceholderCodec('geoshape'),
 	binary: new ValueTypePlaceholderCodec('binary'),
 	barcode: new ValueTypePlaceholderCodec('barcode'),
 	intent: new ValueTypePlaceholderCodec('intent'),
+	geopoint: createGeolocationValueCodec<'geopoint', GeopointRuntimeValue, GeopointInputValue>(
+		'geopoint',
+		(value) => Geopoint.parseGeopointToString(value),
+		(value) => Geopoint.parseStringToGeopoint(value)
+	),
+	geotrace: createGeolocationValueCodec<'geotrace', GeotraceRuntimeValue, GeotraceInputValue>(
+		'geotrace',
+		(value) => Geotrace.parseGeotraceString(value),
+		(value) => Geotrace.parseStringToGeotrace(value)
+	),
+	geoshape: createGeolocationValueCodec<'geoshape', GeoshapeRuntimeValue, GeoshapeInputValue>(
+		'geoshape',
+		(value) => Geoshape.parseGeoshapeString(value),
+		(value) => Geoshape.parseStringToGeoshape(value)
+	),
 };
 
 export const getSharedValueCodec = <V extends ValueType>(valueType: V): SharedValueCodec<V> => {

package/src/lib/reactivity/createInstanceValueState.ts

@@ -7,6 +7,8 @@ import type { BindComputationExpression } from '../../parse/expression/BindCompu
 import { ActionDefinition } from '../../parse/model/ActionDefinition.ts';
 import type { AnyBindPreloadDefinition } from '../../parse/model/BindPreloadDefinition.ts';
 import { XFORM_EVENT } from '../../parse/model/Event.ts';
+import { SET_GEOPOINT_LOCAL_NAME } from '../../parse/XFormDOM.ts';
+import { sharedValueCodecs } from '../codecs/getSharedValueCodec.ts';
 import { createComputedExpression } from './createComputedExpression.ts';
 import type { SimpleAtomicState, SimpleAtomicStateSetter } from './types.ts';
 
@@ -15,7 +17,7 @@ const REPEAT_INDEX_REGEX = /([^[]*)(\[[0-9]+\])/g;
 type ValueContext = AttributeContext | InstanceValueContext;
 
 const isInstanceFirstLoad = (context: ValueContext) => {
-	return context.rootDocument.initializationMode === 'create';
+	return context.rootDocument.initializationMode === 'create' && !isAddingRepeatChild(context);
 };
 
 const isAddingRepeatChild = (context: ValueContext) => {
@@ -26,7 +28,7 @@ const isAddingRepeatChild = (context: ValueContext) => {
  * Special case, does not correspond to any event.
  */
 const isEditInitialLoad = (context: ValueContext) => {
-	return context.rootDocument.initializationMode === 'edit';
+	return context.rootDocument.initializationMode === 'edit' && !isAddingRepeatChild(context);
 };
 
 const getInitialValue = (context: ValueContext): string => {
@@ -94,16 +96,6 @@ const guardDownstreamReadonlyWrites = (
 	return [getValue, setValue];
 };
 
-/**
- * @todo It feels increasingly awkward to keep piling up preload stuff here, but it won't stay that way for long. In the meantime, this seems like the best way to express the cases where `preload="uid"` should be effective, i.e.:
- *
- * - When an instance is first loaded ({@link isInstanceFirstLoad})
- * - When an instance is initially loaded for editing ({@link isEditInitialLoad})
- */
-const isLoading = (context: ValueContext) => {
-	return isInstanceFirstLoad(context) || isEditInitialLoad(context);
-};
-
 const setValueIfPreloadDefined = (
 	context: ValueContext,
 	setValue: SimpleAtomicStateSetter<string>,
@@ -134,11 +126,14 @@ const preloadValue = (context: ValueContext, setValue: SimpleAtomicStateSetter<s
 
 	if (preload.event === XFORM_EVENT.xformsRevalidate) {
 		postloadValue(context, setValue, preload);
-		return;
-	}
-
-	if (isLoading(context)) {
-		setValueIfPreloadDefined(context, setValue, preload);
+	} else if (preload.event === XFORM_EVENT.odkInstanceFirstLoad) {
+		if (isInstanceFirstLoad(context)) {
+			setValueIfPreloadDefined(context, setValue, preload);
+		}
+	} else if (preload.event === XFORM_EVENT.odkInstanceLoad) {
+		if (isInstanceFirstLoad(context) || isEditInitialLoad(context)) {
+			setValueIfPreloadDefined(context, setValue, preload);
+		}
 	}
 };
 
@@ -199,6 +194,42 @@ const createCalculation = (
 	});
 };
 
+/**
+ * Runs the computation without maintaining a reactive listener, so
+ * actions that should run only at a specific time are not triggered
+ * when referenced elements are updated.
+ */
+const createActionCalculation = (
+	context: ValueContext,
+	setRelevantValue: SimpleAtomicStateSetter<string>,
+	computation: ActionComputationExpression<'string'>
+): void => {
+	createComputed(() => {
+		if (context.isAttached()) {
+			// use untrack so the expression evaluation isn't reactive
+			const relevant = untrack(() => context.isRelevant());
+			if (!relevant) {
+				return;
+			}
+			const calculated = untrack(() => {
+				return context.evaluator.evaluateString(computation.expression, context);
+			});
+			const value = context.decodeInstanceValue(calculated);
+			setRelevantValue(value);
+		}
+	});
+};
+
+const resolveAndSetValueChanged = (
+	context: ValueContext,
+	setRelevantValue: SimpleAtomicStateSetter<string>,
+	expression: string
+): void => {
+	const calc = context.evaluator.evaluateString(expression, context);
+	const value = context.decodeInstanceValue(calc);
+	setRelevantValue(value);
+};
+
 const createValueChangedCalculation = (
 	context: ValueContext,
 	setRelevantValue: SimpleAtomicStateSetter<string>,
@@ -206,21 +237,27 @@ const createValueChangedCalculation = (
 ): void => {
 	const { source, ref } = bindToRepeatInstance(context, action);
 	if (!source) {
-		// no element to listen to
+		// No element to listen to
 		return;
 	}
-	let previous = '';
+	let previous: string;
 	const sourceElementExpression = new ActionComputationExpression('string', source);
-	const calculateValueSource = createComputedExpression(context, sourceElementExpression); // registers listener
+	const calculateValueSource = createComputedExpression(context, sourceElementExpression); // Registers listener
 	createComputed(() => {
 		if (context.isAttached() && context.isRelevant()) {
 			const valueSource = calculateValueSource();
-			if (previous !== valueSource) {
-				// only update if value has changed
-				if (referencesCurrentNode(context, ref)) {
-					const calc = context.evaluator.evaluateString(action.computation.expression, context);
-					const value = context.decodeInstanceValue(calc);
-					setRelevantValue(value);
+			if (
+				previous !== undefined &&
+				previous !== valueSource &&
+				referencesCurrentNode(context, ref)
+			) {
+				// Only update if value has changed
+				if (action.element.nodeName === SET_GEOPOINT_LOCAL_NAME) {
+					getGeopointValue(context, (point) => {
+						setRelevantValue(point);
+					});
+				} else {
+					resolveAndSetValueChanged(context, setRelevantValue, action.computation.expression);
 				}
 			}
 			previous = valueSource;
@@ -228,24 +265,45 @@ const createValueChangedCalculation = (
 	});
 };
 
-const registerAction = (
+const getGeopointValue = (context: ValueContext, callback: (value: string) => void) => {
+	// eslint-disable-next-line @typescript-eslint/no-floating-promises -- we don't want to block
+	context.rootDocument.getBackgroundGeopoint()?.then((point) => {
+		// Allow the codec to manage all geolocation validation.
+		// It decodes and encodes the value, and setValue expects a string.
+		callback(sharedValueCodecs.geopoint.encodeValue(point));
+	});
+};
+
+const performActionComputation = (
+	context: ValueContext,
+	setValue: SimpleAtomicStateSetter<string>,
+	action: ActionDefinition
+) => {
+	if (action.element.nodeName === SET_GEOPOINT_LOCAL_NAME) {
+		getGeopointValue(context, (point) => setValue(point));
+		return;
+	}
+	createActionCalculation(context, setValue, action.computation);
+};
+
+const dispatchAction = (
 	context: ValueContext,
 	setValue: SimpleAtomicStateSetter<string>,
 	action: ActionDefinition
 ) => {
 	if (action.events.includes(XFORM_EVENT.odkInstanceFirstLoad)) {
 		if (isInstanceFirstLoad(context)) {
-			createCalculation(context, setValue, action.computation);
+			performActionComputation(context, setValue, action);
 		}
 	}
 	if (action.events.includes(XFORM_EVENT.odkInstanceLoad)) {
 		if (!isAddingRepeatChild(context)) {
-			createCalculation(context, setValue, action.computation);
+			performActionComputation(context, setValue, action);
 		}
 	}
 	if (action.events.includes(XFORM_EVENT.odkNewRepeat)) {
 		if (isAddingRepeatChild(context)) {
-			createCalculation(context, setValue, action.computation);
+			performActionComputation(context, setValue, action);
 		}
 	}
 	if (action.events.includes(XFORM_EVENT.xformsValueChanged)) {
@@ -281,10 +339,8 @@ export const createInstanceValueState = (context: ValueContext): InstanceValueSt
 			createCalculation(context, setValue, calculate);
 		}
 
-		const action = context.definition.model.actions.get(context.contextReference());
-		if (action) {
-			registerAction(context, setValue, action);
-		}
+		const actions = context.definition.model.actions.get(context.contextReference());
+		actions?.forEach((action) => dispatchAction(context, setValue, action));
 
 		return guardDownstreamReadonlyWrites(context, relevantValueState);
 	});

package/src/lib/reactivity/text/createTextRange.ts

@@ -1,14 +1,17 @@
 import {
+	isResourceType,
 	JRResourceURL,
 	type JRResourceURLString,
+	type ResourceType,
 } from '@getodk/common/jr-resources/JRResourceURL.ts';
+import { isElementNode, isTextNode } from '@getodk/common/lib/dom/predicates.ts';
 import type { Accessor } from 'solid-js';
 import { createMemo } from 'solid-js';
 import type { TextRole } from '../../../client/TextRange.ts';
 import type { EvaluationContext } from '../../../instance/internal-api/EvaluationContext.ts';
 import { TextChunk } from '../../../instance/text/TextChunk.ts';
 import { TextRange, type MediaSources } from '../../../instance/text/TextRange.ts';
-import { type TextChunkExpression } from '../../../parse/expression/TextChunkExpression.ts';
+import { TextChunkExpression } from '../../../parse/expression/TextChunkExpression.ts';
 import type { TextRangeDefinition } from '../../../parse/text/abstract/TextRangeDefinition.ts';
 import { createComputedExpression } from '../createComputedExpression.ts';
 
@@ -17,57 +20,84 @@ interface ChunksAndMedia {
 	mediaSources: MediaSources;
 }
 
+const generateChunk = (node: Node): TextChunkExpression<'string'> | null => {
+	if (isElementNode(node)) {
+		return TextChunkExpression.fromOutput(node);
+	}
+	if (isTextNode(node)) {
+		const formAttribute = node.parentElement!.getAttribute('form') as ResourceType;
+		if (isResourceType(formAttribute)) {
+			return TextChunkExpression.fromResource(node.data as JRResourceURLString, formAttribute);
+		}
+		return TextChunkExpression.fromLiteral(node.data);
+	}
+	return null;
+};
+
+const generateChunksForTranslation = (
+	textElement: Element
+): Array<TextChunkExpression<'string'>> => {
+	const chunks = [];
+	for (const child of textElement.childNodes) {
+		for (const grandchild of child.childNodes) {
+			const chunk = generateChunk(grandchild);
+			if (chunk) {
+				chunks.push(chunk);
+			}
+		}
+	}
+	return chunks;
+};
+
+const getChunkExpressions = <Role extends TextRole>(
+	context: EvaluationContext,
+	definition: TextRangeDefinition<Role>
+): ReadonlyArray<TextChunkExpression<'string'>> => {
+	if (definition.chunks[0]?.source !== 'translation') {
+		// only translations have 'nodes' chunks
+		return definition.chunks as Array<TextChunkExpression<'string'>>;
+	}
+	const itextId = context.evaluator.evaluateString(definition.chunks[0].toString()!, {
+		contextNode: context.contextNode,
+	});
+	const lang = context.getActiveLanguage();
+	const elem = definition.form.model.getItextElement(lang, itextId);
+	return elem ? generateChunksForTranslation(elem) : [];
+};
+
 /**
- * Creates a reactive accessor for text chunks and an optional image from text source expressions.
+ * Creates a reactive accessor for text chunks and an optional image, audio and video from text source expressions.
  * - Combines chunks from literal and computed sources into a single array.
- * - Captures the first image found with a 'from="image"' attribute.
+ * - Captures the first image found with a 'from=<"image"|"audio"|"video">' attribute.
  *
- * @param context - The evaluation context for reactive XPath computations.
- * @param chunkExpressions - Array of text source expressions to process.
- * @returns An accessor for an object with all chunks and the first image (if any).
+ * @param context The evaluation context for reactive XPath computations.
+ * @param definition The definition for the text range which contains chunks to transform
+ * @returns An accessor for an object with all chunks and the first image, audio and video (if any).
  */
 const createTextChunks = <Role extends TextRole>(
 	context: EvaluationContext,
 	definition: TextRangeDefinition<Role>
-): Accessor<ChunksAndMedia> => {
-	return createMemo(() => {
-		const chunks: TextChunk[] = [];
-		const mediaSources: MediaSources = {};
-
-		let chunkExpressions: ReadonlyArray<TextChunkExpression<'string'>>;
-
-		if (definition.chunks[0]?.source === 'translation') {
-			const itextId = context.evaluator.evaluateString(definition.chunks[0].toString()!, {
-				contextNode: context.contextNode,
-			});
-			chunkExpressions = definition.form.model.getTranslationChunks(
-				itextId,
-				context.getActiveLanguage()
+): ChunksAndMedia => {
+	const chunks: TextChunk[] = [];
+	const mediaSources: MediaSources = {};
+	const chunkExpressions = getChunkExpressions(context, definition);
+	chunkExpressions.forEach((chunkExpression) => {
+		if (chunkExpression.resourceType) {
+			mediaSources[chunkExpression.resourceType] = JRResourceURL.from(
+				chunkExpression.stringValue as JRResourceURLString
 			);
-		} else {
-			// only translations have 'nodes' chunks
-			chunkExpressions = definition.chunks as Array<TextChunkExpression<'string'>>;
+			return;
 		}
 
-		chunkExpressions.forEach((chunkExpression) => {
-			if (chunkExpression.resourceType) {
-				mediaSources[chunkExpression.resourceType] = JRResourceURL.from(
-					chunkExpression.stringValue as JRResourceURLString
-				);
-				return;
-			}
-
-			if (chunkExpression.source === 'literal') {
-				chunks.push(new TextChunk(context, chunkExpression.source, chunkExpression.stringValue));
-				return;
-			}
-
-			const computed = createComputedExpression(context, chunkExpression)();
-			chunks.push(new TextChunk(context, chunkExpression.source, computed));
-		});
+		if (chunkExpression.source === 'literal') {
+			chunks.push(new TextChunk(context, chunkExpression.source, chunkExpression.stringValue));
+			return;
+		}
 
-		return { chunks, mediaSources };
+		const computed = createComputedExpression(context, chunkExpression)();
+		chunks.push(new TextChunk(context, chunkExpression.source, computed));
 	});
+	return { chunks, mediaSources };
 };
 
 type ComputedFormTextRange<Role extends TextRole> = Accessor<TextRange<Role, 'form'>>;
@@ -77,8 +107,6 @@ type ComputedFormTextRange<Role extends TextRole> = Accessor<TextRange<Role, 'fo
  *
  * - The form's current language (e.g. `<label ref="jr:itext('text-id')" />`)
  * - Direct `<output>` references within the label's children
- *
- * @todo This does not yet handle itext translations **with** outputs!
  */
 export const createTextRange = <Role extends TextRole>(
 	context: EvaluationContext,
@@ -86,10 +114,8 @@ export const createTextRange = <Role extends TextRole>(
 	definition: TextRangeDefinition<Role>
 ): ComputedFormTextRange<Role> => {
 	return context.scope.runTask(() => {
-		const textChunks = createTextChunks(context, definition);
-
 		return createMemo(() => {
-			const chunks = textChunks();
+			const chunks = createTextChunks(context, definition);
 			return new TextRange('form', role, chunks.chunks, chunks.mediaSources);
 		});
 	});

package/src/parse/XFormDOM.ts

@@ -10,8 +10,13 @@ import type {
 } from '@getodk/common/types/dom.ts';
 import { DefaultEvaluator } from '@getodk/xpath';
 
+export const SET_VALUE_LOCAL_NAME = 'setvalue';
+export const SET_GEOPOINT_LOCAL_NAME = 'odk:setgeopoint';
+
 interface DOMBindElement extends KnownAttributeLocalNamedElement<'bind', 'nodeset'> {}
-interface DOMSetValueElement extends KnownAttributeLocalNamedElement<'setvalue', 'event'> {}
+export interface DOMSetValueElement extends KnownAttributeLocalNamedElement<'setvalue', 'event'> {}
+export interface DOMSetGeopointElement
+	extends KnownAttributeLocalNamedElement<'odk:setgeopoint', 'event'> {}
 
 const getMetaElement = (primaryInstanceRoot: Element): Element | null => {
 	for (const child of primaryInstanceRoot.children) {
@@ -325,6 +330,15 @@ export class XFormDOM {
 		return new this(sourceXML, { isNormalized: false });
 	}
 
+	isInstanceID = (nodeset: string) => {
+		const meta = getMetaElement(this.primaryInstanceRoot);
+		const instanceId = meta && getMetaChildElement(meta, 'instanceID');
+		return (
+			instanceId &&
+			nodeset === `/${this.primaryInstanceRoot.nodeName}/${meta.nodeName}/${instanceId.nodeName}`
+		);
+	};
+
 	protected readonly normalizedXML: string;
 
 	// Commonly accessed landmark nodes
@@ -338,6 +352,7 @@ export class XFormDOM {
 	readonly model: Element;
 	readonly binds: readonly DOMBindElement[];
 	readonly setValues: readonly DOMSetValueElement[];
+	readonly setGeopoints: readonly DOMSetGeopointElement[];
 	readonly primaryInstance: Element;
 	readonly primaryInstanceRoot: Element;
 
@@ -371,11 +386,15 @@ export class XFormDOM {
 			}
 		);
 		const setValues: readonly DOMSetValueElement[] = evaluator.evaluateNodes<DOMSetValueElement>(
-			'./xf:setvalue[@event]',
+			`./xf:${SET_VALUE_LOCAL_NAME}[@event]`,
 			{
 				contextNode: model,
 			}
 		);
+		const setGeopoints: readonly DOMSetGeopointElement[] =
+			evaluator.evaluateNodes<DOMSetGeopointElement>(`./${SET_GEOPOINT_LOCAL_NAME}[@event]`, {
+				contextNode: model,
+			});
 
 		const instances = evaluator.evaluateNodes<DOMInstanceElement>('./xf:instance', {
 			contextNode: model,
@@ -426,6 +445,7 @@ export class XFormDOM {
 		this.model = model;
 		this.binds = binds;
 		this.setValues = setValues;
+		this.setGeopoints = setGeopoints;
 		this.primaryInstance = primaryInstance;
 		this.primaryInstanceRoot = primaryInstanceRoot;
 		this.itextTranslationElements = itextTranslationElements;

package/src/parse/model/ActionDefinition.ts

@@ -4,12 +4,12 @@ import { type XFormEvent, XFORM_EVENT } from './Event.ts';
 import type { ModelDefinition } from './ModelDefinition.ts';
 
 export class ActionDefinition {
-	static getRef(model: ModelDefinition, setValueElement: Element): string | null {
-		if (setValueElement.hasAttribute('ref')) {
-			return setValueElement.getAttribute('ref') ?? null;
+	static getRef(model: ModelDefinition, element: Element): string | null {
+		if (element.hasAttribute('ref')) {
+			return element.getAttribute('ref') ?? null;
 		}
-		if (setValueElement.hasAttribute('bind')) {
-			const bindId = setValueElement.getAttribute('bind');
+		if (element.hasAttribute('bind')) {
+			const bindId = element.getAttribute('bind');
 			const bindDefinition = Array.from(model.binds.values()).find((definition) => {
 				return definition.bindElement.getAttribute('id') === bindId;
 			});
@@ -58,7 +58,7 @@ export class ActionDefinition {
 		const ref = ActionDefinition.getRef(model, element);
 		if (!ref) {
 			throw new Error(
-				'Invalid setvalue element - you must define either "ref" or "bind" attribute'
+				`Invalid ${element.localName} element - you must define either "ref" or "bind" attribute`
 			);
 		}
 		this.ref = ref;

package/src/parse/model/AttributeDefinition.ts

@@ -19,6 +19,7 @@ export class AttributeDefinition
 
 	readonly value: string;
 	readonly type = 'attribute';
+	readonly valueType = 'string';
 	readonly namespaceDeclarations: NamespaceDeclarationMap;
 	readonly bodyElement = null;
 	readonly root: RootDefinition;
@@ -56,4 +57,10 @@ export class AttributeDefinition
 	serializeAttributeXML(): string {
 		return this.serializedXML;
 	}
+
+	toJSON() {
+		const { bind, bodyElement, parent, root, ...rest } = this;
+
+		return rest;
+	}
 }