@getodk/xforms-engine 0.4.0 → 0.6.0

package/src/lib/xml-serialization.ts

@@ -0,0 +1,163 @@
+import type { NamespaceDeclarationMap } from './names/NamespaceDeclarationMap.ts';
+import type { QualifiedName } from './names/QualifiedName.ts';
+
+declare const ESCAPED_XML_TEXT_BRAND: unique symbol;
+
+export type EscapedXMLText = string & { readonly [ESCAPED_XML_TEXT_BRAND]: true };
+
+const ATTR_REGEX = /[&<>"]/;
+const CONTENT_REGEX = /[&<>]/;
+
+/**
+ * This is based on the `escapeHTML` implementation in
+ * {@link https://github.com/ryansolid/dom-expressions} (Solid's JSX transform).
+ *
+ * @see {@link https://github.com/ryansolid/dom-expressions/pull/27} for
+ * motivation to derive this implementation approach.
+ *
+ * The intent is that this can be updated easily if the base implementation
+ * changes. As such, some aspects of this implementation differ from some of our
+ * typical code style preferences.
+ *
+ * Notable changes from the base implementation:
+ *
+ * - Formatting: automated only.
+ * - Naming: the {@link text} parameter is named `html` in the base
+ *   implementation. That would be confusing if preserved.
+ * - Types:
+ *     - Parameter types are added (of course)
+ *     - Return type is branded as {@link EscapedXMLText}, to allow downstream
+ *       checks that escaping has been performed. Return statements are cast
+ *       accordingly.
+ *     - {@link text} attempts to minimize risk of double-escaping by excluding
+ *       that same branded type.
+ * - The '>' character is also escaped, necessary for producing valid XML.
+ *
+ * As with the base implementation, we leave some characters unescaped:
+ *
+ * - " (double quote): except when {@link attr} is `true`.
+ *
+ * - ' (single quote): on the assumption that attributes are always serialized
+ *   in double quotes. If we ever move this to `@getodk/common`, we'd want to
+ *   reconsider this assumption.
+ */
+export const escapeXMLText = <Text extends string>(
+	text: Exclude<Text, EscapedXMLText>,
+	attr?: boolean
+): EscapedXMLText => {
+	const match = (attr ? ATTR_REGEX : CONTENT_REGEX).exec(text);
+	if (!match) return text as string as EscapedXMLText;
+	let index = 0;
+	let lastIndex = 0;
+	let out = '';
+	let escape = '';
+	for (index = match.index; index < text.length; index++) {
+		switch (text.charCodeAt(index)) {
+			case 34: // "
+				if (!attr) continue;
+				escape = '&quot;';
+				break;
+			case 38: // &
+				escape = '&amp;';
+				break;
+			case 60: // <
+				escape = '&lt;';
+				break;
+			case 62: // >
+				escape = '&gt;';
+				break;
+			default:
+				continue;
+		}
+		if (lastIndex !== index) out += text.substring(lastIndex, index);
+		lastIndex = index + 1;
+		out += escape;
+	}
+	return lastIndex !== index
+		? ((out + text.substring(lastIndex, index)) as EscapedXMLText)
+		: (out as EscapedXMLText);
+};
+
+interface SerializableElementAttribute {
+	serializeAttributeXML(): string;
+}
+
+interface ElementXMLSerializationOptions {
+	readonly namespaceDeclarations?: NamespaceDeclarationMap;
+	readonly attributes?: readonly SerializableElementAttribute[];
+}
+
+const serializeElementNamespaceDeclarationXML = (
+	namespaceDeclarations?: NamespaceDeclarationMap
+): string => {
+	if (namespaceDeclarations == null) {
+		return '';
+	}
+
+	return Array.from(namespaceDeclarations.values())
+		.map((namespaceDeclaration) => {
+			return namespaceDeclaration.serializeNamespaceDeclarationXML({
+				omitDefaultNamespace: true,
+			});
+		})
+		.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 = {}
+): string => {
+	// See JSDoc for the `getPrefixedName` method. If we find we do actually need
+	// custom element (subtree) prefix resolution, we'd uncomment the argument
+	// below. (Either way, at time of writing the affected tests pass where
+	// expected when the option is passed. It's omitted on the presumption that it
+	// would be redundant, since the nodes being serialized are already resolved
+	// with the same set of namespace declarations which would affect them.)
+	//
+	// prettier-ignore
+	const nodeName = qualifiedName.getPrefixedName(
+		// options.namespaceDeclarations
+	);
+	const namespaceDeclarations = serializeElementNamespaceDeclarationXML(
+		options.namespaceDeclarations
+	);
+	const attributes = serializeElementAttributeXML(options.attributes);
+	const prefix = `<${nodeName}${namespaceDeclarations}${attributes}`;
+
+	if (children === '') {
+		return `${prefix}/>`;
+	}
+
+	return `${prefix}>${children}</${nodeName}>`;
+};
+
+export const serializeParentElementXML = (
+	qualifiedName: QualifiedName,
+	serializedChildren: readonly string[],
+	options?: ElementXMLSerializationOptions
+): string => {
+	return serializeElementXML(qualifiedName, serializedChildren.join(''), options);
+};
+
+export const serializeLeafElementXML = (
+	qualifiedName: QualifiedName,
+	xmlValue: EscapedXMLText,
+	options?: ElementXMLSerializationOptions
+): string => {
+	return serializeElementXML(qualifiedName, xmlValue.normalize(), options);
+};

package/src/parse/XFormDOM.ts

@@ -1,5 +1,154 @@
-import { XFORMS_NAMESPACE_URI, XMLNS_NAMESPACE_URI } from '@getodk/common/constants/xmlns.ts';
-import { XFormsXPathEvaluator } from '@getodk/xpath';
+import {
+	JAVAROSA_NAMESPACE_URI,
+	OPENROSA_XFORMS_NAMESPACE_URI,
+	XFORMS_NAMESPACE_URI,
+	XMLNS_NAMESPACE_URI,
+} from '@getodk/common/constants/xmlns.ts';
+import type {
+	KnownAttributeLocalNamedElement,
+	LocalNamedElement,
+} from '@getodk/common/types/dom.ts';
+import { DefaultEvaluator } from '@getodk/xpath';
+
+interface DOMBindElement extends KnownAttributeLocalNamedElement<'bind', 'nodeset'> {}
+
+const getMetaElement = (primaryInstanceRoot: Element): Element | null => {
+	for (const child of primaryInstanceRoot.children) {
+		const { localName, namespaceURI } = child;
+
+		if (
+			(namespaceURI === OPENROSA_XFORMS_NAMESPACE_URI || namespaceURI === XFORMS_NAMESPACE_URI) &&
+			localName === 'meta'
+		) {
+			return child;
+		}
+	}
+
+	return null;
+};
+
+const getMetaChildElement = (meta: Element | null, localName: string): Element | null => {
+	if (meta == null) {
+		return null;
+	}
+
+	const { namespaceURI } = meta;
+
+	for (const child of meta.children) {
+		if (child.localName === localName && child.namespaceURI === namespaceURI) {
+			return child;
+		}
+	}
+
+	return null;
+};
+
+const getQualifiedName = (
+	contextNode: Node,
+	namespaceURI: string | null,
+	localName: string
+): string => {
+	const prefix = contextNode.lookupPrefix(namespaceURI);
+
+	if (prefix == null) {
+		return localName;
+	}
+
+	return `${prefix}:${localName}`;
+};
+
+const createNamespacedChildElement = (
+	parent: Element,
+	namespaceURI: string | null,
+	localName: string
+): Element => {
+	const qualifiedName = getQualifiedName(parent, namespaceURI, localName);
+	const child = parent.ownerDocument.createElementNS(namespaceURI, qualifiedName);
+
+	parent.append(child);
+
+	return child;
+};
+
+const setNamespacedAttributeValue = (
+	element: Element,
+	namespaceURI: string | null,
+	localName: string,
+	value: string
+) => {
+	const qualifiedName = getQualifiedName(element, namespaceURI, localName);
+
+	element.setAttributeNS(namespaceURI, qualifiedName, value);
+};
+
+const createDefaultInstanceIDBinding = (
+	model: Element,
+	primaryInstanceRoot: Element,
+	meta: Element,
+	instanceID: Element
+): DOMBindElement => {
+	const bind = createNamespacedChildElement(model, model.namespaceURI, 'bind');
+	const nodeset = `/${primaryInstanceRoot.nodeName}/${meta.nodeName}/${instanceID.nodeName}`;
+
+	bind.setAttribute('nodeset', nodeset);
+	setNamespacedAttributeValue(bind, JAVAROSA_NAMESPACE_URI, 'preload', 'uid');
+
+	return bind as DOMBindElement;
+};
+
+const normalizeDefaultMetaBindings = (
+	model: Element,
+	primaryInstanceRoot: Element,
+	binds: readonly DOMBindElement[]
+): readonly DOMBindElement[] => {
+	let meta = getMetaElement(primaryInstanceRoot);
+	let instanceID = getMetaChildElement(meta, 'instanceID');
+
+	if (meta == null) {
+		meta = createNamespacedChildElement(primaryInstanceRoot, OPENROSA_XFORMS_NAMESPACE_URI, 'meta');
+	}
+
+	if (instanceID == null) {
+		instanceID = createNamespacedChildElement(meta, meta.namespaceURI, 'instanceID');
+
+		const instanceIDBinding = createDefaultInstanceIDBinding(
+			model,
+			primaryInstanceRoot,
+			meta,
+			instanceID
+		);
+
+		return [...binds, instanceIDBinding];
+	}
+
+	return binds;
+};
+
+export interface DOMItextTranslationElement
+	extends KnownAttributeLocalNamedElement<'translation', 'lang'> {}
+
+interface DOMInstanceElement extends LocalNamedElement<'instance'> {}
+
+export interface DOMSecondaryInstanceElement
+	extends KnownAttributeLocalNamedElement<'instance', 'id'> {}
+
+type AssertDOMSecondaryInstanceElement = (
+	element: DOMInstanceElement
+) => asserts element is DOMSecondaryInstanceElement;
+
+const assertDOMSecondaryInstanceElement: AssertDOMSecondaryInstanceElement = (element) => {
+	if (!element.hasAttribute('id')) {
+		throw new Error('Invalid secondary instance element: missing `id` attribute');
+	}
+};
+
+type AssertDOMSecondaryInstanceElements = (
+	elements: readonly DOMInstanceElement[]
+) => asserts elements is readonly DOMSecondaryInstanceElement[];
+
+const assertDOMSecondaryInstanceElements: AssertDOMSecondaryInstanceElements = (elements) => {
+	elements.forEach(assertDOMSecondaryInstanceElement);
+};
 
 const domParser = new DOMParser();
 
@@ -145,61 +294,33 @@ const normalizeRepeatGroups = (body: Element): void => {
 	}
 };
 
-interface NormalizedXForm {
-	readonly xformDocument: XMLDocument;
-	readonly rootEvaluator: XFormsXPathEvaluator;
-	readonly html: Element;
-	readonly body: Element;
-	readonly normalizedXML: string;
-}
-
-interface XFormDOMNormalizationOptions {
-	readonly isNormalized: boolean;
-}
-
 /**
- * Performs preprocess operations to normalize certain aspects of an XForm
- * structure for consistency when building up its runtime representations.
+ * Performs preprocess operations to normalize certain aspects of the body of an
+ * XForm, for consistency when parsing its runtime representations.
+ *
  * Currently this preprocessing:
  *
- * - Ensures consistent use of `ref` and `nodeset` where ambiguous in the
- *   ODK XForms spec
- * - Ensures `<repeat>` body elements are always enclosed by a `<group>`
- *   with the same `ref`
+ * - Ensures consistent use of `ref` and `nodeset` where ambiguous in the ODK
+ *   XForms spec
+ * - Ensures `<repeat>` body elements are always enclosed by a `<group>` with
+ *   the same `ref`
  */
-const parseNormalizedXForm = (
-	sourceXML: string,
-	options: XFormDOMNormalizationOptions
-): NormalizedXForm => {
-	const xformDocument: XMLDocument = domParser.parseFromString(sourceXML, 'text/xml');
-	const rootEvaluator = new XFormsXPathEvaluator({
-		rootNode: xformDocument,
-	});
-	const html = rootEvaluator.evaluateNonNullElement('/h:html');
-	const body = rootEvaluator.evaluateNonNullElement('./h:body', {
-		contextNode: html,
-	});
-
-	let normalizedXML: string;
-
-	if (options.isNormalized) {
-		normalizedXML = sourceXML;
-	} else {
-		normalizeBodyRefNodesetAttributes(body);
-		normalizeRepeatGroups(body);
+const normalizeXFormBody = <T extends Element>(body: T): T => {
+	normalizeBodyRefNodesetAttributes(body);
+	normalizeRepeatGroups(body);
 
-		normalizedXML = html.outerHTML;
-	}
-
-	return {
-		xformDocument,
-		rootEvaluator,
-		html,
-		body,
-		normalizedXML,
-	};
+	return body;
 };
 
+interface XFormDOMOptions {
+	readonly isNormalized: boolean;
+}
+
+/**
+ * @todo **Everything** in this class should be cacheable. Maybe not worth it
+ * for small forms, but may make a pretty substantial difference for very large
+ * forms (in bytes) in sessions creating multiple instances of the same form.
+ */
 export class XFormDOM {
 	static from(sourceXML: string) {
 		return new this(sourceXML, { isNormalized: false });
@@ -207,10 +328,6 @@ export class XFormDOM {
 
 	protected readonly normalizedXML: string;
 
-	// XPath
-	readonly rootEvaluator: XFormsXPathEvaluator;
-	readonly primaryInstanceEvaluator: XFormsXPathEvaluator;
-
 	// Commonly accessed landmark nodes
 	readonly xformDocument: XMLDocument;
 
@@ -220,59 +337,97 @@ export class XFormDOM {
 	readonly title: Element;
 
 	readonly model: Element;
+	readonly binds: readonly DOMBindElement[];
 	readonly primaryInstance: Element;
 	readonly primaryInstanceRoot: Element;
 
+	readonly itextTranslationElements: readonly DOMItextTranslationElement[];
+	readonly secondaryInstanceElements: readonly DOMSecondaryInstanceElement[];
+
 	readonly body: Element;
 
 	protected constructor(
 		protected readonly sourceXML: string,
-		options: XFormDOMNormalizationOptions
+		options: XFormDOMOptions
 	) {
-		const normalizedXForm: NormalizedXForm = parseNormalizedXForm(sourceXML, options);
-		const { xformDocument, html, body, rootEvaluator, normalizedXML } = normalizedXForm;
-		const head = rootEvaluator.evaluateNonNullElement('./h:head', {
+		const evaluator = new DefaultEvaluator();
+		const xformDocument: XMLDocument = domParser.parseFromString(sourceXML, 'text/xml');
+		const html = evaluator.evaluateNonNullElement('/h:html', {
+			contextNode: xformDocument,
+		});
+		const head = evaluator.evaluateNonNullElement('./h:head', {
 			contextNode: html,
 		});
-		const title = rootEvaluator.evaluateNonNullElement('./h:title', {
+		const title = evaluator.evaluateNonNullElement('./h:title', {
 			contextNode: head,
 		});
-		const model = rootEvaluator.evaluateNonNullElement('./xf:model', {
+		const model = evaluator.evaluateNonNullElement('./xf:model', {
 			contextNode: head,
 		});
-		// TODO: Evidently primary instance root will not always have an id
-		const primaryInstanceRoot = rootEvaluator.evaluateNonNullElement('./xf:instance/*[@id]', {
+		let binds: readonly DOMBindElement[] = evaluator.evaluateNodes<DOMBindElement>(
+			'./xf:bind[@nodeset]',
+			{
+				contextNode: model,
+			}
+		);
+
+		const instances = evaluator.evaluateNodes<DOMInstanceElement>('./xf:instance', {
 			contextNode: model,
 		});
-		// TODO: invert primary instance/root lookups
-		const primaryInstance = rootEvaluator.evaluateNonNullElement('..', {
-			contextNode: primaryInstanceRoot,
+
+		const [primaryInstance, ...secondaryInstanceElements] = instances;
+
+		assertDOMSecondaryInstanceElements(secondaryInstanceElements);
+
+		if (primaryInstance == null) {
+			throw new Error('Form is missing primary instance');
+		}
+
+		// TODO: Evidently primary instance root will not always have an id
+		const primaryInstanceRoot = evaluator.evaluateNonNullElement('./*[@id]', {
+			contextNode: primaryInstance,
 		});
 
-		this.normalizedXML = normalizedXML;
-		this.rootEvaluator = rootEvaluator;
-		this.primaryInstanceEvaluator = new XFormsXPathEvaluator({
-			rootNode: primaryInstance,
+		const itextTranslationElements = evaluator.evaluateNodes<DOMItextTranslationElement>(
+			'./xf:itext/xf:translation[@lang]',
+			{
+				contextNode: model,
+			}
+		);
+
+		let body = evaluator.evaluateNonNullElement('./h:body', {
+			contextNode: html,
 		});
+		let normalizedXML: string;
+
+		if (options.isNormalized) {
+			normalizedXML = sourceXML;
+		} else {
+			body = normalizeXFormBody(body);
+			binds = normalizeDefaultMetaBindings(model, primaryInstanceRoot, binds);
+
+			// TODO: if we keep doing normalization this way long term (or using the DOM
+			// for parsing long term, for that matter!), we should measure this. And we
+			// should measure against XMLSerializer while we're at it!
+			normalizedXML = xformDocument.documentElement.outerHTML;
+		}
+
+		this.normalizedXML = normalizedXML;
 		this.xformDocument = xformDocument;
 		this.html = html;
 		this.head = head;
 		this.title = title;
 		this.model = model;
+		this.binds = binds;
 		this.primaryInstance = primaryInstance;
 		this.primaryInstanceRoot = primaryInstanceRoot;
+		this.itextTranslationElements = itextTranslationElements;
+		this.secondaryInstanceElements = secondaryInstanceElements;
 		this.body = body;
 	}
 
-	// TODO: anticipating this will be an entry point for edits as well
-	createInstance(): XFormDOM {
-		return new XFormDOM(this.normalizedXML, { isNormalized: true });
-	}
-
 	toJSON() {
 		const {
-			rootEvaluator,
-			primaryInstanceEvaluator,
 			html,
 			head,
 			title,

package/src/parse/XFormDefinition.ts

@@ -3,7 +3,6 @@ import { ModelDefinition } from './model/ModelDefinition.ts';
 import { XFormDOM } from './XFormDOM.ts';
 
 export class XFormDefinition {
-	readonly xformDOM: XFormDOM;
 	readonly xformDocument: XMLDocument;
 
 	readonly id: string;
@@ -14,11 +13,7 @@ export class XFormDefinition {
 	readonly body: BodyDefinition;
 	readonly model: ModelDefinition;
 
-	constructor(readonly sourceXML: string) {
-		const xformDOM = XFormDOM.from(sourceXML);
-
-		this.xformDOM = xformDOM;
-
+	constructor(readonly xformDOM: XFormDOM) {
 		const { primaryInstanceRoot, title, xformDocument } = xformDOM;
 		const id = primaryInstanceRoot.getAttribute('id');
 
@@ -29,10 +24,7 @@ export class XFormDefinition {
 		this.xformDocument = xformDocument;
 		this.id = id;
 		this.title = title.textContent ?? '';
-
-		// TODO: highly unlikely primary instance root will need a namespace prefix
-		// but noting it just in case there is such weird usage...
-		this.rootReference = `/${primaryInstanceRoot.localName}`;
+		this.rootReference = `/${primaryInstanceRoot.nodeName}`;
 
 		this.body = new BodyDefinition(this);
 		this.model = new ModelDefinition(this);

package/src/parse/attachments/FormAttachmentResource.ts

@@ -0,0 +1,40 @@
+import type { JRResourceURL } from '@getodk/common/jr-resources/JRResourceURL.ts';
+
+export type FormAttachmentDataType = 'media' | 'secondary-instance';
+
+/**
+ * @todo This type anticipates work to support media form attachments, which
+ * will tend to be associated with binary data. The
+ * expectation is that:
+ *
+ * - {@link Blob} would be appropriate for representing data from attachment
+ *   resources which are conventionally loaded to completion (where network
+ *   conditions are favorable), such as images
+ *
+ * - {@link MediaSource} or {@link ReadableStream} may be more appropriate for
+ *   representing data from resources which are conventionally streamed in a
+ *   browser context (often regardless of network conditions), such as video and
+ *   audio
+ */
+// prettier-ignore
+export type FormAttachmentMediaData =
+	| Blob
+	| MediaSource
+	| ReadableStream<unknown>;
+
+export type FormAttachmentSecondaryInstanceData = string;
+
+// prettier-ignore
+type FormAttachmentData<DataType extends FormAttachmentDataType> =
+	DataType extends 'media'
+		? FormAttachmentMediaData
+		: FormAttachmentSecondaryInstanceData;
+
+export abstract class FormAttachmentResource<DataType extends FormAttachmentDataType> {
+	protected constructor(
+		readonly dataType: DataType,
+		readonly resourceURL: JRResourceURL,
+		readonly contentType: string,
+		readonly data: FormAttachmentData<DataType>
+	) {}
+}

package/src/parse/body/BodyDefinition.ts

@@ -3,11 +3,11 @@ import { TokenListParser } from '../../lib/TokenListParser.ts';
 import type { XFormDefinition } from '../../parse/XFormDefinition.ts';
 import { DependencyContext } from '../expression/abstract/DependencyContext.ts';
 import { ControlDefinition } from './control/ControlDefinition.ts';
-import { InputDefinition } from './control/InputDefinition.ts';
+import { InputControlDefinition } from './control/InputControlDefinition.ts';
 import { RangeControlDefinition } from './control/RangeControlDefinition.ts';
 import { RankControlDefinition } from './control/RankControlDefinition.ts';
-import type { AnySelectDefinition } from './control/select/SelectDefinition.ts';
-import { SelectDefinition } from './control/select/SelectDefinition.ts';
+import type { AnySelectControlDefinition } from './control/SelectControlDefinition.ts';
+import { SelectControlDefinition } from './control/SelectControlDefinition.ts';
 import { TriggerControlDefinition } from './control/TriggerControlDefinition.ts';
 import { UploadControlDefinition } from './control/UploadControlDefinition.ts';
 import { LogicalGroupDefinition } from './group/LogicalGroupDefinition.ts';
@@ -24,8 +24,8 @@ export interface BodyElementParentContext {
 
 // prettier-ignore
 export type ControlElementDefinition =
-	| AnySelectDefinition
-	| InputDefinition
+	| AnySelectControlDefinition
+	| InputControlDefinition
 	| RangeControlDefinition
 	| RankControlDefinition
 	| TriggerControlDefinition
@@ -47,8 +47,8 @@ const BodyElementDefinitionConstructors = [
 	LogicalGroupDefinition,
 	PresentationGroupDefinition,
 	StructuralGroupDefinition,
-	InputDefinition,
-	SelectDefinition,
+	InputControlDefinition,
+	SelectControlDefinition,
 	RangeControlDefinition,
 	RankControlDefinition,
 	TriggerControlDefinition,

package/src/parse/body/appearance/inputAppearanceParser.ts

@@ -4,7 +4,7 @@ export const inputAppearanceParser = new TokenListParser([
 	'multiline',
 	'numbers',
 	'url',
-	'thousand-sep',
+	'thousands-sep',
 
 	// date (TODO: data types)
 	'no-calendar',

package/src/parse/body/appearance/rangeAppearanceParser.ts

@@ -0,0 +1,11 @@
+import type { ParsedTokenList } from '../../../lib/TokenListParser.ts';
+import { TokenListParser } from '../../../lib/TokenListParser.ts';
+
+export const rangeAppearanceParser = new TokenListParser([
+	'no-ticks',
+	'picker',
+	'rating',
+	'vertical',
+]);
+
+export type RangeAppearanceDefinition = ParsedTokenList<typeof rangeAppearanceParser>;

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

@@ -0,0 +1,29 @@
+import type { XFormDefinition } from '../../XFormDefinition.ts';
+import type { InputAppearanceDefinition } from '../appearance/inputAppearanceParser.ts';
+import { inputAppearanceParser } from '../appearance/inputAppearanceParser.ts';
+import type { BodyElementParentContext } from '../BodyDefinition.ts';
+import { parseToFloat, parseToInteger } from '../../../lib/number-parsers.ts';
+import { ControlDefinition } from './ControlDefinition.ts';
+
+export class InputControlDefinition extends ControlDefinition<'input'> {
+	static override isCompatible(localName: string): boolean {
+		return localName === 'input';
+	}
+
+	readonly type = 'input';
+	readonly appearances: InputAppearanceDefinition;
+	readonly rows: number | null;
+	readonly accuracyThreshold: number | null;
+	readonly unacceptableAccuracyThreshold: number | null;
+
+	constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element) {
+		super(form, parent, element);
+
+		this.appearances = inputAppearanceParser.parseFrom(element, 'appearance');
+		this.rows = parseToInteger(element.getAttribute('rows'));
+		this.accuracyThreshold = parseToFloat(element.getAttribute('accuracyThreshold'));
+		this.unacceptableAccuracyThreshold = parseToFloat(
+			element.getAttribute('unacceptableAccuracyThreshold')
+		);
+	}
+}