@getodk/xforms-engine 0.5.0 → 0.7.0

package/src/integration/xpath/adapter/kind.ts

@@ -1,17 +1,7 @@
 import type { XPathNodeKind } from '@getodk/xpath';
 import { XPathNodeKindKey } from '@getodk/xpath';
-import type {
-	AnyChildNode,
-	AnyNode,
-	AnyParentNode,
-	AnyValueNode,
-} from '../../../instance/hierarchy.ts';
-import type { ValueContext } from '../../../instance/internal-api/ValueContext.ts';
+import type { AnyChildNode, AnyNode, AnyParentNode } from '../../../instance/hierarchy.ts';
 import type { PrimaryInstance } from '../../../instance/PrimaryInstance.ts';
-import type { ItextTranslationDefinition } from '../../../parse/model/ItextTranslation/ItextTranslationDefinition.ts';
-import type { ItextTranslationRootDefinition } from '../../../parse/model/ItextTranslation/ItextTranslationRootDefinition.ts';
-import type { SecondaryInstanceDefinition } from '../../../parse/model/SecondaryInstance/SecondaryInstanceDefinition.ts';
-import type { SecondaryInstanceRootDefinition } from '../../../parse/model/SecondaryInstance/SecondaryInstanceRootDefinition.ts';
 import type { StaticAttribute } from '../static-dom/StaticAttribute.ts';
 import type { StaticDocument } from '../static-dom/StaticDocument.ts';
 import type { StaticElement } from '../static-dom/StaticElement.ts';
@@ -35,26 +25,14 @@ export type PrimaryInstanceXPathChildNode =
 	| PrimaryInstanceXPathElement
 	| PrimaryInstanceXPathComment;
 
-// prettier-ignore
-export type PrimaryInstanceXPathValueElement<Value> =
-	& AnyValueNode
-	& ValueContext<Value>
-	& XFormsXPathElement;
-
 // prettier-ignore
 export type EngineXPathDocument =
-	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
 	| PrimaryInstance
-	| ItextTranslationDefinition
-	| SecondaryInstanceDefinition
 	| StaticDocument;
 
 // prettier-ignore
 export type EngineXPathElement =
-	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
 	| PrimaryInstanceXPathElement
-	| ItextTranslationRootDefinition
-	| SecondaryInstanceRootDefinition
 	| StaticElement;
 
 // prettier-ignore
@@ -83,12 +61,7 @@ type PrimaryInstanceXPathParentNode = Extract<AnyParentNode, XPathAdapterParentN
 
 // prettier-ignore
 export type EngineXPathParentNode =
-	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
 	| PrimaryInstanceXPathParentNode
-	| ItextTranslationDefinition
-	| SecondaryInstanceDefinition
-	| ItextTranslationRootDefinition
-	| SecondaryInstanceRootDefinition
 	| StaticDocument
 	| StaticElement;
 

package/src/integration/xpath/adapter/names.ts

@@ -15,49 +15,54 @@ import {
 	XHTML_NAMESPACE_URI,
 } from '@getodk/common/constants/xmlns.ts';
 import { XPathFunctionalityNotSupportedError } from '../../../error/XPathFunctionalityNotSupportedError.ts';
-import type { InstanceNode } from '../../../instance/abstract/InstanceNode.ts';
-import type { StaticNode } from '../static-dom/StaticNode.ts';
+import type { AnyStaticNode } from '../static-dom/StaticNode.ts';
 import type { EngineXPathNode } from './kind.ts';
-import type { getNamespaceDeclarations } from './traversal.ts';
 
 export const getEngineXPathNodeNamespaceURI = (node: EngineXPathNode): string | null => {
 	switch (node.nodeType) {
 		case 'primary-instance':
+		case 'static-document':
 		case 'static-text':
+		case 'repeat-range:controlled':
+		case 'repeat-range:uncontrolled':
 			return null;
 
 		case 'static-attribute':
 		case 'static-element':
-			return node.namespaceURI;
+			return node.qualifiedName.namespaceURI?.href ?? null;
 
 		default:
-			return XFORMS_NAMESPACE_URI;
+			return node.definition.qualifiedName.namespaceURI?.href ?? null;
 	}
 };
 
-/**
- * @todo currently, neither {@link InstanceNode} nor {@link StaticNode} account
- * for prefixes in qualified names. This was already a general enough gap that
- * it makes sense to defer to a broader solution as it becomes a priority
- * (likely prompted by a bug report about unexpected behavior of the XPath
- * `name` function).
- */
 export const getEngineXPathNodeQualifiedName = (node: EngineXPathNode): string => {
-	return getEngineXPathNodeLocalName(node);
+	switch (node.nodeType) {
+		case 'static-attribute':
+		case 'static-element':
+			return node.qualifiedName.getPrefixedName();
+
+		case 'static-document':
+		case 'static-text':
+			return '';
+
+		default:
+			return node.definition.qualifiedName.getPrefixedName();
+	}
 };
 
 export const getEngineXPathNodeLocalName = (node: EngineXPathNode): string => {
 	switch (node.nodeType) {
 		case 'static-attribute':
 		case 'static-element':
-			return node.localName;
+			return node.qualifiedName.localName;
 
 		case 'static-document':
 		case 'static-text':
 			return '';
 
 		default:
-			return node.definition.nodeName;
+			return node.definition.qualifiedName.localName;
 	}
 };
 
@@ -65,9 +70,23 @@ export const getEngineProcessingInstructionName =
 	XPathFunctionalityNotSupportedError.createStubImplementation('processing-instruction');
 
 /**
- * @todo @see {@link getNamespaceDeclarations}
+ * @todo in most cases we should not have **custom** namespace resolution from a
+ * static node (e.g. external secondary instance, itext translation) context.
+ * The main exception to that would be _XML external secondary instances_, which
+ * of course can declare arbitrary namespaces on any arbitrary subtree, just
+ * like a form definition's XML. In all other cases, we'd want to resolve a
+ * prefix here from the _primary instance_ context. However, we don't (yet) have
+ * access to the primary instance context from a static node. So we currently
+ * fall back to the previous (incomplete/potentially wrong) default mapping.
+ *
+ * Note that this is relatively safe for the general case, and only potentially
+ * wrong for:
+ *
+ * 1. Forms authored as XML, with arbitrary/non-default namespace declarations
+ * 2. XML external secondary instances, also with arbitrary/non-default
+ *    namespace declarations
  */
-export const resolveEngineXPathNodeNamespaceURI = (_: EngineXPathNode, prefix: string | null) => {
+const resolveNamespaceURIFromStaticNodeContext = (_: AnyStaticNode, prefix: string | null) => {
 	switch (prefix) {
 		case null:
 			return XFORMS_NAMESPACE_URI;
@@ -97,3 +116,33 @@ export const resolveEngineXPathNodeNamespaceURI = (_: EngineXPathNode, prefix: s
 			return null;
 	}
 };
+
+export const resolveEngineXPathNodeNamespaceURI = (
+	node: EngineXPathNode,
+	prefix: string | null
+): string | null => {
+	switch (node.nodeType) {
+		case 'static-attribute':
+		case 'static-document':
+		case 'static-element':
+		case 'static-text':
+			return resolveNamespaceURIFromStaticNodeContext(node, prefix);
+
+		case 'group':
+		case 'input':
+		case 'model-value':
+		case 'note':
+		case 'primary-instance':
+		case 'range':
+		case 'rank':
+		case 'repeat-instance':
+		case 'repeat-range:controlled':
+		case 'repeat-range:uncontrolled':
+		case 'root':
+		case 'select':
+		case 'subtree':
+		case 'trigger':
+		case 'upload':
+			return node.definition.namespaceDeclarations.get(prefix)?.declaredURI?.href ?? null;
+	}
+};

package/src/integration/xpath/adapter/traversal.ts

@@ -2,7 +2,7 @@ import { UnreachableError } from '@getodk/common/lib/error/UnreachableError.ts';
 import { ErrorProductionDesignPendingError } from '../../../error/ErrorProductionDesignPendingError.ts';
 import { XPathFunctionalityPendingError } from '../../../error/XPathFunctionalityPendingError.ts';
 import type { AnyNode } from '../../../instance/hierarchy.ts';
-import type { AnyStaticNode, StaticParentNode } from '../static-dom/StaticNode.ts';
+import type { AnyStaticNode, StaticNodeParent } from '../static-dom/StaticNode.ts';
 import type {
 	EngineXPathAttribute,
 	EngineXPathDocument,
@@ -27,16 +27,17 @@ export const getEngineXPathAttributes = (node: EngineXPathNode): Iterable<Engine
 };
 
 /**
- * @todo XML XForms may actually define explicit namespace declarations on
- * non-root elements (i.e. elements other than the form definition's `h:html`,
- * itext `translation`, secondary `instance`). Expressions defined in such forms
- * may also expect to use those namespace declarations. It would even seem
- * likely! Why declare namespaces on a subtree if you don't intend to use them?
- * We don't currently capture namespace declarations below `h:html` in the parse
- * stage (which, if we intend to support the use case, is where we should
- * start).
+ * @todo We've now laid most of the groundwork necessary to implement this
+ * properly. At time of writing it has still been deferred because:
  *
- * @todo At the very least, we should probably produce a set of default namespace declarations. At least for `h:html`, maybe for other "root" nodes.
+ * 1. The scope of changes enabling it is already a fairly large yak shave.
+ * 2. It is only used to support XPath LocationPath Steps whose AxisName is
+ *    `namespace`. If we _ever_ support this, it would probably be for extremely
+ *    niche use cases!
+ *
+ * @todo Since we've consciously deferred implementing this (twice now!), should
+ * it throw? It might be nice to be alerted if the assumptions in point 2 above
+ * are somehow wrong (or become wrong).
  */
 export const getNamespaceDeclarations = (): Iterable<never> => [];
 
@@ -167,7 +168,7 @@ const primaryInstanceElementContains = (ancestor: AnyNode, other: AnyNode): bool
 	return primaryInstanceElementContains(ancestor, parent);
 };
 
-const staticParentNodeContains = (ancestor: StaticParentNode, other: AnyStaticNode): boolean => {
+const staticParentNodeContains = (ancestor: StaticNodeParent, other: AnyStaticNode): boolean => {
 	if (ancestor === other) {
 		return false;
 	}

package/src/integration/xpath/static-dom/StaticAttribute.ts

@@ -1,28 +1,37 @@
 import { XPathNodeKindKey } from '@getodk/xpath';
+import { QualifiedName } from '../../../lib/names/QualifiedName.ts';
 import type { XFormsXPathAttribute } from '../adapter/XFormsXPathNode.ts';
+import type { StaticDocument } from './StaticDocument.ts';
 import type { StaticElement } from './StaticElement.ts';
-import type { StaticNamedNodeOptions } from './StaticNamedNode.ts';
-import { StaticNamedNode } from './StaticNamedNode.ts';
+import { StaticNode } from './StaticNode.ts';
+import { staticNodeName, type StaticNodeNameSource } from './staticNodeName.ts';
 
-interface StaticAttributeOptions extends StaticNamedNodeOptions {
+export interface StaticAttributeOptions {
+	readonly name: StaticNodeNameSource;
 	readonly value: string;
 }
 
-export class StaticAttribute extends StaticNamedNode<'attribute'> implements XFormsXPathAttribute {
+export class StaticAttribute extends StaticNode<'attribute'> implements XFormsXPathAttribute {
 	readonly [XPathNodeKindKey] = 'attribute';
 	readonly nodeType = 'static-attribute';
+	readonly rootDocument: StaticDocument;
 	readonly root: StaticElement;
+	readonly qualifiedName: QualifiedName;
+	readonly nodeset: string;
 	readonly attributes = [] as const;
 	readonly children = null;
-	override readonly value: string;
+	readonly value: string;
 
 	constructor(
-		override readonly parent: StaticElement,
+		readonly parent: StaticElement,
 		options: StaticAttributeOptions
 	) {
-		super(parent, options);
+		super();
 
+		this.rootDocument = parent.rootDocument;
 		this.root = parent.root;
+		this.qualifiedName = staticNodeName(options.name);
+		this.nodeset = `${parent.nodeset}/@${this.qualifiedName.getPrefixedName()}`;
 		this.value = options.value;
 	}
 

package/src/integration/xpath/static-dom/StaticDocument.ts

@@ -1,34 +1,33 @@
-import { XPathNodeKindKey } from '@getodk/xpath';
 import type { XFormsXPathDocument } from '../adapter/XFormsXPathNode.ts';
+import type { StaticElementOptions } from './StaticElement.ts';
 import { StaticElement } from './StaticElement.ts';
-import { StaticNode } from './StaticNode.ts';
+import { StaticParentNode } from './StaticParentNode.ts';
 
-export type StaticDocumentRootFactory<T extends StaticDocument, Root extends StaticElement> = (
-	staticDocument: T
-) => Root;
+interface StaticDocumentOptions {
+	readonly documentRoot: StaticElementOptions;
+	readonly nodesetPrefix?: string;
+}
 
-export abstract class StaticDocument<DocumentRoot extends StaticElement = StaticElement>
-	extends StaticNode<'document'>
-	implements XFormsXPathDocument
-{
-	readonly [XPathNodeKindKey] = 'document';
-	readonly nodeType = 'static-document';
+export class StaticDocument extends StaticParentNode<'document'> implements XFormsXPathDocument {
 	readonly rootDocument: StaticDocument;
-	readonly root: DocumentRoot;
-	readonly isXFormsNamespace: boolean;
+	readonly root: StaticElement;
 	readonly parent = null;
-	readonly children: readonly [root: DocumentRoot];
+	readonly nodeset: string;
+	readonly children: readonly [root: StaticElement];
+	readonly childElements: readonly [root: StaticElement];
 
-	constructor(rootFactory: StaticDocumentRootFactory<StaticDocument<DocumentRoot>, DocumentRoot>) {
-		super();
+	constructor(options: StaticDocumentOptions) {
+		super('document');
 
+		this.nodeset = options.nodesetPrefix ?? '/';
 		this.rootDocument = this;
 
-		const root = rootFactory(this);
+		const { documentRoot } = options;
+		const root = new StaticElement(this, documentRoot);
 
 		this.root = root;
-		this.isXFormsNamespace = root.isXFormsNamespace;
 		this.children = [root];
+		this.childElements = this.children;
 	}
 
 	// XFormsXPathDocument

package/src/integration/xpath/static-dom/StaticElement.ts

@@ -1,68 +1,218 @@
-import { XFORMS_KNOWN_ATTRIBUTE, XFORMS_LOCAL_NAME, XPathNodeKindKey } from '@getodk/xpath';
+import { UnreachableError } from '@getodk/common/lib/error/UnreachableError.ts';
+import { ErrorProductionDesignPendingError } from '../../../error/ErrorProductionDesignPendingError.ts';
+import type { QualifiedNameSource } from '../../../lib/names/QualifiedName.ts';
+import { QualifiedName } from '../../../lib/names/QualifiedName.ts';
 import type { EngineDOMAdapter } from '../adapter/engineDOMAdapter.ts';
 import type { XFormsXPathElement } from '../adapter/XFormsXPathNode.ts';
+import type { StaticAttributeOptions } from './StaticAttribute.ts';
 import { StaticAttribute } from './StaticAttribute.ts';
-import type { StaticNamedNodeOptions } from './StaticNamedNode.ts';
-import { StaticNamedNode } from './StaticNamedNode.ts';
-import type { StaticChildNode, StaticParentNode } from './StaticNode.ts';
-
-export type StaticElementAttributesFactory = (element: StaticElement) => readonly StaticAttribute[];
-
-export type StaticElementChildNodesFactory = (element: StaticElement) => readonly StaticChildNode[];
-
-export interface StaticElementOptions extends StaticNamedNodeOptions {}
-
-type StaticElementKnownAttributeValue<
-	T extends StaticElement,
-	LocalName extends string,
-> = T extends { readonly [XFORMS_KNOWN_ATTRIBUTE]: LocalName } ? string : string | null;
-
-type AssertStaticElementKnownAttributeValue = <T extends StaticElement, LocalName extends string>(
-	element: T,
-	localName: LocalName,
-	value: string | null
-) => asserts value is StaticElementKnownAttributeValue<T, LocalName>;
-
-const assertStaticElementKnownAttributeValue: AssertStaticElementKnownAttributeValue = (
-	element,
-	localName,
-	value
-) => {
-	if (localName === element[XFORMS_KNOWN_ATTRIBUTE] && value == null) {
-		throw new Error(`Expected attribute: ${element[XFORMS_KNOWN_ATTRIBUTE]}`);
+import type { StaticDocument } from './StaticDocument.ts';
+import type { StaticChildNode } from './StaticNode.ts';
+import { staticNodeName } from './staticNodeName.ts';
+import { StaticParentNode } from './StaticParentNode.ts';
+import { StaticText } from './StaticText.ts';
+
+// prettier-ignore
+export type StaticElementChildOption =
+	| StaticElementOptions
+	| string;
+
+export interface StaticElementOptions {
+	readonly name: QualifiedNameSource | string;
+	readonly attributes?: readonly StaticAttributeOptions[];
+	readonly children?: readonly StaticElementChildOption[];
+}
+
+interface StaticElementChildrenResult {
+	readonly children: readonly StaticChildNode[];
+	readonly childElements: readonly StaticElement[];
+	readonly leafValue: string | null;
+}
+
+const leafElementChildrenResult = (
+	parent: StaticElement,
+	leafValue: string
+): StaticElementChildrenResult => {
+	const child = new StaticText(parent, leafValue);
+
+	return {
+		children: [child],
+		childElements: [],
+		leafValue: leafValue,
+	};
+};
+
+const blankLeafElementChildrenResult = (parent: StaticElement): StaticElementChildrenResult => {
+	return leafElementChildrenResult(parent, '');
+};
+
+/**
+ * Builds several "views" into a {@link StaticElement}'s children as:
+ *
+ * - An array of all of its {@link StaticChildNode | child nodes}
+ * - A subset array of only its {@link StaticElement | child elements}
+ * - A {@link StaticElementChildrenResult.leafValue | "leaf value"} which is
+ *   populated with the text value of a {@link StaticText | text node} if **and
+ *   only if** that text node is the element's sole child node (which is in turn
+ *   used to identify which _elements_ are {@link StaticLeafElement | leaf}
+ *   nodes)
+ *
+ * @todo this is awkwardly named and awkward to describe! It's done this way for
+ * efficiency (which makes a substantial difference for large forms), at the
+ * expense of code clarity.
+ *
+ * @todo Handle comment nodes (1): we have discussed the possibility of using
+ * comments as a placeholder for omitted non-relevant repeat instances, as an
+ * aide to recreating them in restore/edit modes.
+ *
+ * @todo Handle comment nodes (2): comments are currently _effectively implied_
+ * in the function-body comment about a homogenous sequence of 2+ strings, i.e.
+ * in a structure like `<foo>bar<!-- bat -->quux</foo>`. If we handle comment
+ * nodes, the only way we'd encounter that scenario is if we're parsing a
+ * `StaticElement` from a DOM `Element` (or some other source with similar
+ * semantics) where its child nodes have been manipulated into that state. As
+ * such, if we do handle comments, that comment should likely be removed.
+ */
+const buildStaticElementChildren = (
+	parent: StaticElement,
+	options: StaticElementOptions
+): StaticElementChildrenResult => {
+	const children = Array<StaticChildNode>();
+	const childElements = Array<StaticElement>();
+	const childOptions = options.children ?? [''];
+
+	// No children: blank value
+	if (childOptions.length === 0) {
+		return {
+			children,
+			childElements,
+			leafValue: '',
+		};
+	}
+
+	const [head, ...tail] = childOptions;
+
+	if (tail.length === 0) {
+		// - If no child options are specified, default to a single empty/blank
+		//   `StaticText` child node, and assign its value
+		if (head == null) {
+			return blankLeafElementChildrenResult(parent);
+		}
+
+		// - If exactly one child option is specified, and it is a string, create
+		//   `StaticText` child and assign its value
+		if (typeof head === 'string') {
+			return leafElementChildrenResult(parent, head);
+		}
+	}
+
+	// If 2+ child options, for each:
+	//
+	// - Populate `children` (and `childElements`, as appopriate)
+	// - Do not populate `value`. For cases which need an arbitrary
+	//   `StaticElement`'s text value (i.e. `XPath`, perhaps eventually some
+	//   serialization use cases), it will be computed recursively as needed.
+	//
+	// Note: in theory, we may encounter a homogenous sequence of 2+ strings! In
+	// theory we should normalize those into a single string.
+	if (typeof head === 'string' && tail.length === 0) {
+		const child = new StaticText(parent, head);
+
+		children.push(child);
+
+		return {
+			children,
+			childElements,
+			leafValue: child.value,
+		};
+	}
+
+	for (const item of childOptions) {
+		switch (typeof item) {
+			case 'string':
+				children.push(new StaticText(parent, item));
+				break;
+
+			case 'object': {
+				const childElement = new StaticElement(parent, item);
+
+				children.push(childElement);
+				childElements.push(childElement);
+
+				break;
+			}
+
+			default:
+				throw new UnreachableError(item);
+		}
 	}
+
+	return {
+		children,
+		childElements,
+		leafValue: null,
+	};
 };
 
-export class StaticElement<Parent extends StaticParentNode = StaticParentNode>
-	extends StaticNamedNode<'element'>
-	implements XFormsXPathElement
-{
-	readonly [XFORMS_LOCAL_NAME]?: string;
-	readonly [XFORMS_KNOWN_ATTRIBUTE]?: string;
+export class StaticElement extends StaticParentNode<'element'> implements XFormsXPathElement {
+	private computedValue: string | null;
 
-	readonly [XPathNodeKindKey] = 'element';
-	readonly nodeType = 'static-element';
+	readonly rootDocument: StaticDocument;
 	readonly root: StaticElement;
+	readonly qualifiedName: QualifiedName;
+	readonly nodeset: string;
 	readonly attributes: readonly StaticAttribute[];
 	readonly children: readonly StaticChildNode[];
+	readonly childElements: readonly StaticElement[];
+	readonly value: string | null;
 
 	constructor(
-		parent: Parent,
-		attributesFactory: StaticElementAttributesFactory,
-		childNodesFactory: StaticElementChildNodesFactory,
+		readonly parent: StaticDocument | StaticElement,
 		options: StaticElementOptions
 	) {
-		super(parent, options);
+		super('element');
+
+		const { rootDocument } = parent;
+		let nodesetPrefix = parent.nodeset;
+
+		this.rootDocument = rootDocument;
 
 		// Account for the fact that we may be constructing the document root!
-		if (parent === this.rootDocument) {
+		if (parent === rootDocument) {
 			this.root = this;
+
+			// Avoid nodeset like `//foo` when `/foo` is expected/intended
+			if (nodesetPrefix === '/') {
+				nodesetPrefix = '';
+			}
 		} else {
 			this.root = parent.root;
 		}
 
-		this.attributes = attributesFactory(this);
-		this.children = childNodesFactory(this);
+		const { name, attributes = [] } = options;
+
+		this.qualifiedName = staticNodeName(name);
+		this.nodeset = `${nodesetPrefix}/${this.qualifiedName.getPrefixedName()}`;
+		this.attributes = attributes.map((attrOptions) => {
+			return new StaticAttribute(this, attrOptions);
+		});
+
+		const { children, childElements, leafValue } = buildStaticElementChildren(this, options);
+
+		this.children = children;
+		this.childElements = childElements;
+		this.computedValue = leafValue;
+		this.value = leafValue;
+	}
+
+	isLeafElement(): this is StaticLeafElement {
+		return this.value != null;
+	}
+
+	assertLeafElement(): asserts this is StaticLeafElement {
+		if (!this.isLeafElement()) {
+			throw new ErrorProductionDesignPendingError();
+		}
 	}
 
 	/**
@@ -73,7 +223,7 @@ export class StaticElement<Parent extends StaticParentNode = StaticParentNode>
 	protected getAttributeNode(localName: string): StaticAttribute | null {
 		return (
 			this.attributes.find((attribute) => {
-				return attribute.localName === localName;
+				return attribute.qualifiedName.localName === localName;
 			}) ?? null
 		);
 	}
@@ -87,20 +237,29 @@ export class StaticElement<Parent extends StaticParentNode = StaticParentNode>
 	 * up. (This was put off because the types are already plenty complex as it
 	 * is.)
 	 */
-	getAttributeValue<This extends StaticElement, LocalName extends string>(
-		this: This,
-		localName: LocalName
-	): StaticElementKnownAttributeValue<This, LocalName> {
+	getAttributeValue(localName: string): string | null {
 		const attribute = this.getAttributeNode(localName);
 		const value = attribute?.value ?? null;
 
-		assertStaticElementKnownAttributeValue(this, localName, value);
-
 		return value;
 	}
 
 	// XFormsXPathElement
 	getXPathValue(): string {
-		return this.children.map((child) => child.getXPathValue()).join('');
+		const { computedValue } = this;
+
+		if (computedValue != null) {
+			return computedValue;
+		}
+
+		const result = this.children.map((child) => child.getXPathValue()).join('');
+
+		this.computedValue = result;
+
+		return result;
 	}
 }
+
+export interface StaticLeafElement extends StaticElement {
+	readonly value: string;
+}

package/src/integration/xpath/static-dom/StaticNode.ts

@@ -58,7 +58,7 @@ export type AnyStaticNode =
 	| StaticText;
 
 // prettier-ignore
-export type StaticParentNode =
+export type StaticNodeParent =
 	| StaticDocument
 	| StaticElement;
 

package/src/integration/xpath/static-dom/StaticParentNode.ts

@@ -0,0 +1,22 @@
+import { XPathNodeKindKey } from '@getodk/xpath';
+import type { StaticElement } from './StaticElement.ts';
+import { StaticNode, type StaticChildNode } from './StaticNode.ts';
+
+type StaticParentNodeKind = 'document' | 'element';
+
+type StaticParentNodeType<Kind extends StaticParentNodeKind> = `static-${Kind}`;
+
+export abstract class StaticParentNode<Kind extends StaticParentNodeKind> extends StaticNode<Kind> {
+	abstract override readonly children: readonly StaticChildNode[];
+	abstract readonly childElements: readonly StaticElement[];
+
+	readonly [XPathNodeKindKey]: Kind;
+	readonly nodeType: StaticParentNodeType<Kind>;
+
+	constructor(kind: Kind) {
+		super();
+
+		this[XPathNodeKindKey] = kind;
+		this.nodeType = `static-${kind}`;
+	}
+}