@getodk/xforms-engine 0.13.0 → 0.15.0

package/src/lib/reactivity/createAttributeState.ts

@@ -0,0 +1,51 @@
+import type { Accessor, Setter, Signal } from 'solid-js';
+import { createSignal } from 'solid-js';
+import type { Attribute } from '../../instance/Attribute.ts';
+import type { ReactiveScope } from './scope.ts';
+
+export interface AttributeState {
+	readonly attributes: Signal<readonly Attribute[]>;
+	readonly getAttributes: Accessor<readonly Attribute[]>;
+	readonly setAttributes: Setter<readonly Attribute[]>;
+}
+
+/**
+ * Creates attributes state suitable for all node types
+ *
+ * The produced {@link AttributeState.attributes} (and its get/set convenience
+ * methods) signal is intended to be used to store the engine's attribute state,
+ * and update that state when appropriate.
+ */
+export const createAttributeState = (scope: ReactiveScope): AttributeState => {
+	return scope.runTask(() => {
+		const baseState = createSignal<readonly Attribute[]>([]);
+		const [getAttributes, baseSetAttributes] = baseState;
+
+		type AttributeSetterCallback = (prev: readonly Attribute[]) => readonly Attribute[];
+		type AttributeOrSetterCallback = AttributeSetterCallback | readonly Attribute[];
+
+		const setAttributes: Setter<readonly Attribute[]> = (
+			valueOrSetterCallback: AttributeOrSetterCallback
+		) => {
+			let setterCallback: AttributeSetterCallback;
+
+			if (typeof valueOrSetterCallback === 'function') {
+				setterCallback = valueOrSetterCallback;
+			} else {
+				setterCallback = (_) => valueOrSetterCallback;
+			}
+
+			return baseSetAttributes((prev) => {
+				return setterCallback(prev);
+			});
+		};
+
+		const attributes: Signal<readonly Attribute[]> = [getAttributes, setAttributes];
+
+		return {
+			attributes,
+			getAttributes,
+			setAttributes,
+		};
+	});
+};

package/src/lib/reactivity/createAttributeValueState.ts

@@ -0,0 +1,189 @@
+import type { Signal } from 'solid-js';
+import { createComputed, createMemo, createSignal, untrack } from 'solid-js';
+import type { AttributeContext } from '../../instance/internal-api/AttributeContext.ts';
+import type { BindComputationExpression } from '../../parse/expression/BindComputationExpression.ts';
+import { createComputedExpression } from './createComputedExpression.ts';
+import type { SimpleAtomicState, SimpleAtomicStateSetter } from './types.ts';
+
+const isInstanceFirstLoad = (context: AttributeContext) => {
+	return context.rootDocument.initializationMode === 'create';
+};
+
+/**
+ * Special case, does not correspond to any event.
+ *
+ * @see {@link shouldPreloadUID}
+ */
+const isEditInitialLoad = (context: AttributeContext) => {
+	return context.rootDocument.initializationMode === 'edit';
+};
+
+const getInitialValue = (context: AttributeContext): string => {
+	const sourceNode = context.instanceNode ?? context.definition.template;
+
+	return context.decodeInstanceValue(sourceNode.value);
+};
+
+type BaseValueState = Signal<string>;
+
+type RelevantValueState = SimpleAtomicState<string>;
+
+/**
+ * Wraps {@link baseValueState} in a signal-like interface which:
+ *
+ * - produces a blank value for nodes ({@link context}) in a non-relevant state
+ * - persists, and restores, the most recent non-blank value state when a
+ *   node/context's relevance is restored
+ */
+const createRelevantValueState = (
+	context: AttributeContext,
+	baseValueState: BaseValueState
+): RelevantValueState => {
+	return context.scope.runTask(() => {
+		const [getRelevantValue, setValue] = baseValueState;
+
+		const getValue = createMemo(() => {
+			if (context.isRelevant()) {
+				return getRelevantValue();
+			}
+
+			return '';
+		});
+
+		return [getValue, setValue];
+	});
+};
+
+/**
+ * For fields with a `readonly` bind expression, prevent downstream
+ * (client/user) writes when the field is in a `readonly` state.
+ */
+const guardDownstreamReadonlyWrites = (
+	context: AttributeContext,
+	baseState: SimpleAtomicState<string>
+): SimpleAtomicState<string> => {
+	const { readonly } = context.definition.bind;
+
+	if (readonly.isDefaultExpression) {
+		return baseState;
+	}
+
+	const [getValue, baseSetValue] = baseState;
+
+	const setValue: SimpleAtomicStateSetter<string> = (value) => {
+		if (context.isReadonly()) {
+			const reference = untrack(() => context.contextReference());
+
+			throw new Error(`Cannot write to readonly field: ${reference}`);
+		}
+
+		return baseSetValue(value);
+	};
+
+	return [getValue, setValue];
+};
+
+/**
+ * Per {@link https://getodk.github.io/xforms-spec/#preload-attributes:~:text=concatenation%20of%20%E2%80%98uuid%3A%E2%80%99%20and%20uuid()}
+ */
+const PRELOAD_UID_EXPRESSION = 'concat("uuid:", uuid())';
+
+/**
+ * @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 shouldPreloadUID = (context: AttributeContext) => {
+	return isInstanceFirstLoad(context) || isEditInitialLoad(context);
+};
+
+/**
+ * @todo This is a temporary one-off, until we support the full range of
+ * {@link https://getodk.github.io/xforms-spec/#preload-attributes | preloads}.
+ *
+ * @todo ALSO, IMPORTANTLY(!): the **call site** for this function is
+ * semantically where we would expect to trigger a
+ * {@link https://getodk.github.io/xforms-spec/#event:odk-instance-first-load | odk-instance-first-load event},
+ * _and compute_ preloads semantically associated with that event.
+ */
+const setPreloadUIDValue = (context: AttributeContext, valueState: RelevantValueState): void => {
+	const { preload } = context.definition.bind;
+
+	if (preload?.type !== 'uid' || !shouldPreloadUID(context)) {
+		return;
+	}
+
+	const preloadUIDValue = context.evaluator.evaluateString(PRELOAD_UID_EXPRESSION, {
+		contextNode: context.contextNode,
+	});
+
+	const [, setValue] = valueState;
+
+	setValue(preloadUIDValue);
+};
+
+/**
+ * Defines a reactive effect which writes the result of `calculate` bind
+ * computations to the provided value setter, on initialization and any
+ * subsequent reactive update.
+ *
+ * @see {@link setPreloadUIDValue} for important details about spec ordering of
+ * events and computations.
+ */
+const createCalculation = (
+	context: AttributeContext,
+	setRelevantValue: SimpleAtomicStateSetter<string>,
+	calculateDefinition: BindComputationExpression<'calculate'>
+): void => {
+	context.scope.runTask(() => {
+		const calculate = createComputedExpression(context, calculateDefinition, {
+			defaultValue: '',
+		});
+
+		createComputed(() => {
+			if (context.isAttached() && context.isRelevant()) {
+				const calculated = calculate();
+				const value = context.decodeInstanceValue(calculated);
+
+				setRelevantValue(value);
+			}
+		});
+	});
+};
+
+export type InstanceValueState = SimpleAtomicState<string>;
+
+/**
+ * Provides a consistent interface for value nodes of any type which:
+ *
+ * - derives initial state from either an existing instance (e.g. for edits) or
+ *   the node's definition (e.g. initializing a new instance)
+ * - decodes current primary instance state into the value node's runtime type
+ * - encodes updated runtime values to store updated instance state
+ * - initializes reactive computation of `calculate` bind expressions for those
+ *   nodes defined with one
+ * - prevents downstream writes to nodes in a readonly state
+ */
+export const createAttributeValueState = (context: AttributeContext): InstanceValueState => {
+	return context.scope.runTask(() => {
+		const initialValue = getInitialValue(context);
+		const baseValueState = createSignal(initialValue);
+		const relevantValueState = createRelevantValueState(context, baseValueState);
+
+		/**
+		 * @see {@link setPreloadUIDValue} for important details about spec ordering of events and computations.
+		 */
+		setPreloadUIDValue(context, relevantValueState);
+
+		const { calculate } = context.definition.bind;
+
+		if (calculate != null) {
+			const [, setValue] = relevantValueState;
+
+			createCalculation(context, setValue, calculate);
+		}
+
+		return guardDownstreamReadonlyWrites(context, relevantValueState);
+	});
+};

package/src/lib/reactivity/createItemCollection.ts

@@ -2,13 +2,12 @@ import { UpsertableMap } from '@getodk/common/lib/collections/UpsertableMap.ts';
 import type { Accessor } from 'solid-js';
 import { createMemo } from 'solid-js';
 import type { ActiveLanguage } from '../../client/FormLanguage.ts';
-import type { SelectItem } from '../../client/SelectNode.ts';
-import type { RankItem } from '../../client/RankNode.ts';
+import type { BaseItem } from '../../client/BaseItem.ts';
 import type { TextRange as ClientTextRange } from '../../client/TextRange.ts';
 import type { EvaluationContext } from '../../instance/internal-api/EvaluationContext.ts';
 import type { TranslationContext } from '../../instance/internal-api/TranslationContext.ts';
-import type { SelectControl } from '../../instance/SelectControl.ts';
 import type { RankControl } from '../../instance/RankControl.ts';
+import type { SelectControl } from '../../instance/SelectControl.ts';
 import { TextChunk } from '../../instance/text/TextChunk.ts';
 import { TextRange } from '../../instance/text/TextRange.ts';
 import type { EngineXPathNode } from '../../integration/xpath/adapter/kind.ts';
@@ -19,8 +18,7 @@ import { createComputedExpression } from './createComputedExpression.ts';
 import type { ReactiveScope } from './scope.ts';
 import { createTextRange } from './text/createTextRange.ts';
 
-export type ItemCollectionControl = RankControl | SelectControl;
-type Item = RankItem | SelectItem;
+type ItemCollectionControl = RankControl | SelectControl;
 type DerivedItemLabel = ClientTextRange<'item-label', 'form-derived'>;
 
 const derivedItemLabel = (context: TranslationContext, value: string): DerivedItemLabel => {
@@ -45,7 +43,7 @@ const createItemLabel = (
 const createTranslatedStaticItems = (
 	control: ItemCollectionControl,
 	items: readonly ItemDefinition[]
-): Accessor<readonly Item[]> => {
+): Accessor<readonly BaseItem[]> => {
 	return control.scope.runTask(() => {
 		const labeledItems = items.map((item) => {
 			const { value } = item;
@@ -54,6 +52,7 @@ const createTranslatedStaticItems = (
 			return () => ({
 				value,
 				label: label(),
+				properties: [],
 			});
 		});
 
@@ -101,6 +100,7 @@ const createItemsetItemLabel = (
 interface ItemsetItem {
 	label(): ClientTextRange<'item-label'>;
 	value(): string;
+	properties: Array<[string, () => string]>;
 }
 
 const createItemsetItems = (
@@ -122,9 +122,20 @@ const createItemsetItems = (
 					});
 					const label = createItemsetItemLabel(context, itemset, value);
 
+					const nodeElements = itemNode
+						.getXPathChildNodes()
+						.filter((node) => node.nodeType === 'static-element');
+					const properties = itemset.getPropertiesExpressions(nodeElements).map((expression) => {
+						return [expression.toString(), createComputedExpression(context, expression)] as [
+							string,
+							() => string,
+						];
+					});
+
 					return {
 						label,
 						value,
+						properties,
 					};
 				});
 			});
@@ -135,7 +146,7 @@ const createItemsetItems = (
 const createItemset = (
 	control: ItemCollectionControl,
 	itemset: ItemsetDefinition
-): Accessor<readonly Item[]> => {
+): Accessor<readonly BaseItem[]> => {
 	return control.scope.runTask(() => {
 		const itemsetItems = createItemsetItems(control, itemset);
 
@@ -144,6 +155,9 @@ const createItemset = (
 				return {
 					label: item.label(),
 					value: item.value(),
+					properties: item.properties.map(
+						([propLabel, propValue]) => [propLabel, propValue()] as [string, string]
+					),
 				};
 			});
 		});
@@ -152,7 +166,7 @@ const createItemset = (
 
 /**
  * Creates a reactive computation of a {@link ItemCollectionControl}'s
- * {@link Item}s, in support of the field's `valueOptions`.
+ * {@link BaseItem}s, in support of the field's `valueOptions`.
  *
  * - The control defined with static `<item>`s will compute to an corresponding
  *   static list of items.
@@ -162,7 +176,9 @@ const createItemset = (
  *   their appropriate dependencies (whether relative to the itemset item node,
  *   referencing a form's `itext` translations, etc).
  */
-export const createItemCollection = (control: ItemCollectionControl): Accessor<readonly Item[]> => {
+export const createItemCollection = (
+	control: ItemCollectionControl
+): Accessor<readonly BaseItem[]> => {
 	const { items, itemset } = control.definition.bodyElement;
 
 	if (itemset != null) {

package/src/lib/xml-serialization.ts

@@ -1,3 +1,5 @@
+import type { GeneralChildNode } from '../client/hierarchy.ts';
+import type { Attribute } from '../instance/Attribute.ts';
 import type { NamespaceDeclarationMap } from './names/NamespaceDeclarationMap.ts';
 import type { QualifiedName } from './names/QualifiedName.ts';
 
@@ -78,15 +80,6 @@ export const escapeXMLText = <Text extends string>(
 		: (out as EscapedXMLText);
 };
 
-interface SerializableElementAttribute {
-	serializeAttributeXML(): string;
-}
-
-interface ElementXMLSerializationOptions {
-	readonly namespaceDeclarations?: NamespaceDeclarationMap;
-	readonly attributes?: readonly SerializableElementAttribute[];
-}
-
 const serializeElementNamespaceDeclarationXML = (
 	namespaceDeclarations?: NamespaceDeclarationMap
 ): string => {
@@ -103,24 +96,11 @@ const serializeElementNamespaceDeclarationXML = (
 		.join('');
 };
 
-const serializeElementAttributeXML = (
-	attributes?: readonly SerializableElementAttribute[]
-): string => {
-	if (attributes == null) {
-		return '';
-	}
-
-	return attributes
-		.map((attribute) => {
-			return attribute.serializeAttributeXML();
-		})
-		.join('');
-};
-
 const serializeElementXML = (
 	qualifiedName: QualifiedName,
 	children: string,
-	options: ElementXMLSerializationOptions = {}
+	attributes: string,
+	namespaceDeclarations?: NamespaceDeclarationMap
 ): string => {
 	// See JSDoc for the `getPrefixedName` method. If we find we do actually need
 	// custom element (subtree) prefix resolution, we'd uncomment the argument
@@ -133,11 +113,9 @@ const serializeElementXML = (
 	const nodeName = qualifiedName.getPrefixedName(
 		// options.namespaceDeclarations
 	);
-	const namespaceDeclarations = serializeElementNamespaceDeclarationXML(
-		options.namespaceDeclarations
-	);
-	const attributes = serializeElementAttributeXML(options.attributes);
-	const prefix = `<${nodeName}${namespaceDeclarations}${attributes}`;
+	const serializedNamespaceDeclarations =
+		serializeElementNamespaceDeclarationXML(namespaceDeclarations);
+	const prefix = `<${nodeName}${serializedNamespaceDeclarations}${attributes}`;
 
 	if (children === '') {
 		return `${prefix}/>`;
@@ -146,18 +124,36 @@ const serializeElementXML = (
 	return `${prefix}>${children}</${nodeName}>`;
 };
 
+export const serializeAttributeXML = (
+	qualifiedName: QualifiedName,
+	xmlValue: EscapedXMLText
+): string => {
+	const nodeName = qualifiedName.getPrefixedName();
+	return ` ${nodeName}="${xmlValue.normalize()}"`;
+};
+
 export const serializeParentElementXML = (
 	qualifiedName: QualifiedName,
-	serializedChildren: readonly string[],
-	options?: ElementXMLSerializationOptions
+	children: readonly GeneralChildNode[],
+	attributes: readonly Attribute[],
+	namespaceDeclarations?: NamespaceDeclarationMap
 ): string => {
-	return serializeElementXML(qualifiedName, serializedChildren.join(''), options);
+	const serializedChildren = children.map((child) => child.instanceState.instanceXML).join('');
+	const serializedAttributes = attributes
+		.map((attribute) => attribute.instanceState.instanceXML)
+		.join('');
+	return serializeElementXML(
+		qualifiedName,
+		serializedChildren,
+		serializedAttributes,
+		namespaceDeclarations
+	);
 };
 
 export const serializeLeafElementXML = (
 	qualifiedName: QualifiedName,
 	xmlValue: EscapedXMLText,
-	options?: ElementXMLSerializationOptions
+	namespaceDeclarations?: NamespaceDeclarationMap
 ): string => {
-	return serializeElementXML(qualifiedName, xmlValue.normalize(), options);
+	return serializeElementXML(qualifiedName, xmlValue.normalize(), '', namespaceDeclarations);
 };

package/src/parse/body/BodyDefinition.ts

@@ -10,9 +10,7 @@ import type { AnySelectControlDefinition } from './control/SelectControlDefiniti
 import { SelectControlDefinition } from './control/SelectControlDefinition.ts';
 import { TriggerControlDefinition } from './control/TriggerControlDefinition.ts';
 import { UploadControlDefinition } from './control/UploadControlDefinition.ts';
-import { LogicalGroupDefinition } from './group/LogicalGroupDefinition.ts';
-import { PresentationGroupDefinition } from './group/PresentationGroupDefinition.ts';
-import { StructuralGroupDefinition } from './group/StructuralGroupDefinition.ts';
+import { GroupElementDefinition } from './GroupElementDefinition.ts';
 import { RepeatElementDefinition } from './RepeatElementDefinition.ts';
 import { UnsupportedBodyElementDefinition } from './UnsupportedBodyElementDefinition.ts';
 
@@ -31,22 +29,18 @@ export type ControlElementDefinition =
 	| TriggerControlDefinition
 	| UploadControlDefinition;
 
+// prettier-ignore
 type SupportedBodyElementDefinition =
-	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
-	| RepeatElementDefinition
-	| LogicalGroupDefinition
-	| PresentationGroupDefinition
-	| StructuralGroupDefinition
-	| ControlElementDefinition;
+	| ControlElementDefinition
+	| GroupElementDefinition
+	| RepeatElementDefinition;
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 type BodyElementDefinitionConstructor = new (...args: any[]) => SupportedBodyElementDefinition;
 
 const BodyElementDefinitionConstructors = [
 	RepeatElementDefinition,
-	LogicalGroupDefinition,
-	PresentationGroupDefinition,
-	StructuralGroupDefinition,
+	GroupElementDefinition,
 	InputControlDefinition,
 	SelectControlDefinition,
 	RangeControlDefinition,
@@ -63,23 +57,6 @@ export type BodyElementDefinitionArray = readonly AnyBodyElementDefinition[];
 
 export type AnyBodyElementType = AnyBodyElementDefinition['type'];
 
-export type AnyGroupElementDefinition = Extract<
-	AnyBodyElementDefinition,
-	{ readonly type: `${string}-group` }
->;
-
-const isGroupElementDefinition = (
-	element: AnyBodyElementDefinition
-): element is AnyGroupElementDefinition => {
-	return element.type.endsWith('-group');
-};
-
-export const groupElementDefinition = (
-	element: AnyBodyElementDefinition
-): AnyGroupElementDefinition | null => {
-	return isGroupElementDefinition(element) ? element : null;
-};
-
 export type AnyControlElementDefinition = Extract<
 	AnyBodyElementDefinition,
 	{ readonly category: 'control' }
@@ -119,11 +96,7 @@ class BodyElementMap extends Map<BodyElementReference, AnyBodyElementDefinition>
 				this.mapElementsByReference(element.children);
 			}
 
-			if (
-				element instanceof LogicalGroupDefinition ||
-				element instanceof PresentationGroupDefinition ||
-				element instanceof StructuralGroupDefinition
-			) {
+			if (element instanceof GroupElementDefinition) {
 				if (reference != null) {
 					this.set(reference, element);
 				}

package/src/parse/body/GroupElementDefinition.ts

@@ -0,0 +1,47 @@
+import { LabelDefinition } from '../text/LabelDefinition.ts';
+import type { XFormDefinition } from '../XFormDefinition.ts';
+import { parseNodesetReference } from '../xpath/reference-parsing.ts';
+import type { StructureElementAppearanceDefinition } from './appearance/structureElementAppearanceParser.ts';
+import { structureElementAppearanceParser } from './appearance/structureElementAppearanceParser.ts';
+import {
+	type BodyElementDefinitionArray,
+	type BodyElementParentContext,
+} from './BodyDefinition.ts';
+import { BodyElementDefinition } from './BodyElementDefinition.ts';
+
+/**
+ * As per the spec: https://getodk.github.io/xforms-spec/#groups
+ *
+ * A group combines elements together.
+ * The group can have a label, and if so is referred to as a "presentation group".
+ * The group can have a ref, and if so is referred to as a "logical group".
+ */
+export class GroupElementDefinition extends BodyElementDefinition<'group'> {
+	override readonly category = 'structure';
+	override readonly type = 'group';
+
+	readonly children: BodyElementDefinitionArray;
+
+	override readonly reference: string | null;
+	readonly appearances: StructureElementAppearanceDefinition;
+	override readonly label: LabelDefinition | null;
+
+	static override isCompatible(localName: string): boolean {
+		return localName === 'group';
+	}
+
+	constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element) {
+		super(form, parent, element);
+
+		const childElements = Array.from(element.children).filter((child) => {
+			const childName = child.localName;
+
+			return childName !== 'label';
+		});
+
+		this.children = this.body.getChildElementDefinitions(form, this, element, childElements);
+		this.reference = parseNodesetReference(parent, element, 'ref');
+		this.appearances = structureElementAppearanceParser.parseFrom(element, 'appearance');
+		this.label = LabelDefinition.forGroup(form, this);
+	}
+}

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

@@ -1,5 +1,8 @@
+import type { StaticElement } from '../../../integration/xpath/static-dom/StaticElement.ts';
 import type { ItemsetElement } from '../../../lib/dom/query.ts';
 import { getValueElement } from '../../../lib/dom/query.ts';
+import { DependentExpression } from '../../expression/abstract/DependentExpression.ts';
+import { ItemPropertyExpression } from '../../expression/ItemPropertyExpression.ts';
 import { ItemsetNodesetExpression } from '../../expression/ItemsetNodesetExpression.ts';
 import { ItemsetValueExpression } from '../../expression/ItemsetValueExpression.ts';
 import { ItemsetLabelDefinition } from '../../text/ItemsetLabelDefinition.ts';
@@ -52,4 +55,8 @@ export class ItemsetDefinition extends BodyElementDefinition<'itemset'> {
 		this.value = new ItemsetValueExpression(this, valueExpression);
 		this.label = ItemsetLabelDefinition.from(form, this);
 	}
+
+	getPropertiesExpressions(propertiesNodes: StaticElement[]): Array<DependentExpression<'string'>> {
+		return ItemPropertyExpression.from(propertiesNodes);
+	}
 }

package/src/parse/expression/ItemPropertyExpression.ts

@@ -0,0 +1,12 @@
+import type { StaticElement } from '../../integration/xpath/static-dom/StaticElement.ts';
+import { DependentExpression } from './abstract/DependentExpression.ts';
+
+export class ItemPropertyExpression extends DependentExpression<'string'> {
+	static from(propertiesNodes: StaticElement[]) {
+		return propertiesNodes.map((node: StaticElement) => new this(node.qualifiedName.localName));
+	}
+
+	constructor(propertyName: string) {
+		super('string', propertyName);
+	}
+}

package/src/parse/model/AttributeDefinition.ts

@@ -0,0 +1,58 @@
+import { XMLNS_NAMESPACE_URI } from '@getodk/common/constants/xmlns.ts';
+import type { StaticAttribute } from '../../integration/xpath/static-dom/StaticAttribute.ts';
+import {
+	NamespaceDeclarationMap,
+	type NamedNodeDefinition,
+} from '../../lib/names/NamespaceDeclarationMap.ts';
+import { QualifiedName } from '../../lib/names/QualifiedName.ts';
+import { escapeXMLText, serializeAttributeXML } from '../../lib/xml-serialization.ts';
+import type { BindDefinition } from './BindDefinition.ts';
+import { NodeDefinition } from './NodeDefinition.ts';
+import type { RootDefinition } from './RootDefinition.ts';
+
+export class AttributeDefinition
+	extends NodeDefinition<'attribute'>
+	implements NamedNodeDefinition
+{
+	private readonly serializedXML: string;
+
+	readonly value: string;
+	readonly type = 'attribute';
+	readonly namespaceDeclarations: NamespaceDeclarationMap;
+	readonly bodyElement = null;
+	readonly root: RootDefinition;
+	readonly isTranslated: boolean = false;
+	readonly parent = null;
+	readonly children = null;
+	readonly attributes = null;
+
+	readonly qualifiedName: QualifiedName;
+
+	constructor(
+		root: RootDefinition,
+		bind: BindDefinition,
+		readonly template: StaticAttribute
+	) {
+		super(bind);
+
+		const { value } = template;
+
+		this.root = root;
+
+		this.value = value;
+		this.qualifiedName = template.qualifiedName;
+		this.namespaceDeclarations = new NamespaceDeclarationMap(this);
+
+		// We serialize namespace declarations separately
+		if (this.qualifiedName.namespaceURI?.href === XMLNS_NAMESPACE_URI) {
+			this.serializedXML = '';
+		} else {
+			const xmlValue = escapeXMLText(this.value, true);
+			this.serializedXML = serializeAttributeXML(this.qualifiedName, xmlValue);
+		}
+	}
+
+	serializeAttributeXML(): string {
+		return this.serializedXML;
+	}
+}