@getodk/xforms-engine 0.7.0 → 0.9.0

package/src/lib/reactivity/createInstanceAttachment.ts

@@ -0,0 +1,212 @@
+import { createMemo, createSignal } from 'solid-js';
+import type { FormNodeID } from '../../client/identity.ts';
+import { ErrorProductionDesignPendingError } from '../../error/ErrorProductionDesignPendingError.ts';
+import type { InstanceAttachmentFileName } from '../../instance/attachments/InstanceAttachment.ts';
+import { InstanceAttachment } from '../../instance/attachments/InstanceAttachment.ts';
+import type { InstanceAttachmentContext } from '../../instance/internal-api/InstanceAttachmentContext.ts';
+import type { DecodeInstanceValue } from '../../instance/internal-api/InstanceValueContext.ts';
+import type { SimpleAtomicStateSetter } from './types.ts';
+
+type FileNameExtension = `.${string}`;
+
+type AssertFileNameExtension = (value: string) => asserts value is FileNameExtension;
+
+const assertFileNameExtension: AssertFileNameExtension = (value) => {
+	if (!value.startsWith('.')) {
+		throw new ErrorProductionDesignPendingError('Expected file name extension to start with "."');
+	}
+};
+
+interface SplitFileNameResult {
+	readonly basename: string;
+	readonly extension: FileNameExtension | null;
+}
+
+const EXTENSION_PATTERN = /\.[^.]+?$/;
+
+interface SearchPatternResult extends Array<string> {
+	readonly 0?: string;
+	readonly index?: number;
+}
+
+const searchPattern = (pattern: RegExp, string: string): SearchPatternResult => {
+	return pattern.exec(string) ?? [];
+};
+
+const splitFileName = (fileName: string): SplitFileNameResult => {
+	const extensionMatches = searchPattern(EXTENSION_PATTERN, fileName);
+	const [extension = null] = extensionMatches;
+	const basename = fileName.slice(0, extensionMatches.index);
+
+	if (extension == null) {
+		return {
+			basename,
+			extension,
+		};
+	}
+
+	assertFileNameExtension(extension);
+
+	return {
+		basename,
+		extension,
+	};
+};
+
+export type InstanceAttachmentRuntimeValue = File | null;
+
+export type InstanceAttachmentFormDataEntry = readonly [
+	key: InstanceAttachmentFileName,
+	value: NonNullable<InstanceAttachmentRuntimeValue>,
+];
+
+interface InstanceAttachmentValueOptions {
+	readonly nodeId: FormNodeID;
+	readonly writtenAt: Date | null;
+	readonly file: InstanceAttachmentRuntimeValue;
+}
+
+interface BaseInstanceAttachmentState {
+	readonly computedName: string | null;
+	readonly intrinsicName: string | null;
+	readonly file: InstanceAttachmentRuntimeValue;
+}
+
+interface BlankInstanceAttachmentState extends BaseInstanceAttachmentState {
+	readonly computedName: null;
+	readonly intrinsicName: null;
+	readonly file: null;
+}
+
+interface NonBlankInstanceAttachmentState extends BaseInstanceAttachmentState {
+	readonly computedName: string | null;
+	readonly intrinsicName: string;
+	readonly file: NonNullable<InstanceAttachmentRuntimeValue>;
+}
+
+// prettier-ignore
+type InstanceAttachmentState =
+	| BlankInstanceAttachmentState
+	| NonBlankInstanceAttachmentState;
+
+const instanceAttachmentState = (
+	context: InstanceAttachmentContext,
+	options: InstanceAttachmentValueOptions
+): InstanceAttachmentState => {
+	const { nodeId, file, writtenAt } = options;
+
+	// No file -> no intrinsic name, no name to compute
+	if (file == null) {
+		return {
+			computedName: null,
+			intrinsicName: null,
+			file: null,
+		};
+	}
+
+	const intrinsicName = file.name;
+
+	// File exists, not written by client -> preserve instance input name
+	if (writtenAt == null) {
+		return {
+			computedName: null,
+			intrinsicName,
+			file,
+		};
+	}
+
+	// File was written by client, name is computed as configured by client
+	const { basename, extension } = splitFileName(intrinsicName);
+	const computedName = context.instanceConfig.computeAttachmentName({
+		nodeId,
+		writtenAt,
+		basename,
+		extension,
+	});
+
+	return {
+		computedName,
+		intrinsicName,
+		file,
+	};
+};
+
+export const createInstanceAttachment = (
+	context: InstanceAttachmentContext
+): InstanceAttachment => {
+	return context.scope.runTask(() => {
+		const { rootDocument, nodeId } = context;
+		const { attachments } = rootDocument;
+		const file = attachments.getInitialFileValue(context.instanceNode);
+		const initialState = instanceAttachmentState(context, {
+			nodeId,
+			file,
+			writtenAt: null,
+		});
+
+		const [getState, setState] = createSignal<InstanceAttachmentState>(initialState);
+
+		const decodeInstanceValue: DecodeInstanceValue = (value) => {
+			const { computedName, intrinsicName } = getState();
+
+			if (value === '') {
+				if (computedName != null || intrinsicName != null) {
+					throw new ErrorProductionDesignPendingError(
+						`Unexpected file name reference. Expected one of "${computedName}", "${intrinsicName}", got: ""`
+					);
+				}
+			}
+
+			if (value === intrinsicName) {
+				return computedName ?? intrinsicName;
+			}
+
+			if (value === computedName) {
+				return computedName;
+			}
+
+			throw new ErrorProductionDesignPendingError(
+				`Unexpected file name reference. Expected one of "${computedName}", "${intrinsicName}", got: "${value}"`
+			);
+		};
+
+		const getValue = createMemo(() => {
+			const { computedName, file: currentFile } = getState();
+
+			if (computedName == null) {
+				return currentFile;
+			}
+
+			return new File([currentFile], computedName, {
+				type: currentFile.type,
+			});
+		});
+		const setValue: SimpleAtomicStateSetter<InstanceAttachmentRuntimeValue> = (value) => {
+			const updatedState = instanceAttachmentState(context, {
+				nodeId,
+				file: value,
+				writtenAt: new Date(),
+			});
+
+			return setState(updatedState).file;
+		};
+		const valueState = [getValue, setValue] as const;
+
+		const getFileName = createMemo(() => {
+			const { computedName, intrinsicName } = getState();
+
+			return computedName ?? intrinsicName;
+		});
+		const getInstanceValue = createMemo(() => getFileName() ?? '');
+
+		return InstanceAttachment.init(context, {
+			getFileName,
+			getInstanceValue,
+			decodeInstanceValue,
+
+			getValue,
+			setValue,
+			valueState,
+		});
+	});
+};

package/src/lib/resource-helpers.ts

@@ -0,0 +1,33 @@
+import type { FetchResourceResponse } from '../client/resources.ts';
+
+const CONTENT_TYPE_CHARSET_PATTERN = /\s*;\s*charset\s*=.*$/;
+
+const stripContentTypeCharset = (contentType: string): string => {
+	return contentType.replace(CONTENT_TYPE_CHARSET_PATTERN, '');
+};
+
+export const getResponseContentType = (response: FetchResourceResponse): string | null => {
+	const { headers } = response;
+
+	if (headers == null) {
+		return null;
+	}
+
+	const contentType = headers.get('content-type');
+
+	if (contentType != null) {
+		return stripContentTypeCharset(contentType);
+	}
+
+	if (headers instanceof Headers) {
+		return contentType;
+	}
+
+	for (const [header, value] of headers) {
+		if (header.toLowerCase() === 'content-type') {
+			return stripContentTypeCharset(value);
+		}
+	}
+
+	return null;
+};

package/src/parse/XFormDOM.ts

@@ -104,9 +104,7 @@ const normalizeDefaultMetaBindings = (
 	let meta = getMetaElement(primaryInstanceRoot);
 	let instanceID = getMetaChildElement(meta, 'instanceID');
 
-	if (meta == null) {
-		meta = createNamespacedChildElement(primaryInstanceRoot, OPENROSA_XFORMS_NAMESPACE_URI, 'meta');
-	}
+	meta ??= createNamespacedChildElement(primaryInstanceRoot, OPENROSA_XFORMS_NAMESPACE_URI, 'meta');
 
 	if (instanceID == null) {
 		instanceID = createNamespacedChildElement(meta, meta.namespaceURI, 'instanceID');

package/src/parse/body/BodyDefinition.ts

@@ -207,6 +207,10 @@ export class BodyDefinition extends DependencyContext implements BodyElementPare
 		return this.elementsByReference.get(reference) ?? null;
 	}
 
+	getBodyElementType(reference: BodyElementReference): AnyBodyElementType | null {
+		return this.elementsByReference.getBodyElementType(reference);
+	}
+
 	getChildElementDefinitions(
 		form: XFormDefinition,
 		parent: BodyElementParentContext,

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

@@ -1,3 +1,5 @@
+import type { UploadMediaOptions, UploadNodeOptions } from '../../../client/UploadNode.ts';
+import { ErrorProductionDesignPendingError } from '../../../error/ErrorProductionDesignPendingError.ts';
 import type { XFormDefinition } from '../../XFormDefinition.ts';
 import {
 	unknownAppearanceParser,
@@ -6,6 +8,44 @@ import {
 import type { BodyElementParentContext } from '../BodyDefinition.ts';
 import { ControlDefinition } from './ControlDefinition.ts';
 
+const MEDIATYPE_PATTERN = /^([^/]+)\/([^/]+)$/;
+
+// prettier-ignore
+type MediaTypeMatches =
+	| readonly [$0: string, $1: string, $2: string];
+
+const parseUploadMediaOptions = (element: Element): UploadMediaOptions => {
+	const mediaType = element.getAttribute('mediatype')?.trim();
+
+	if (mediaType == null || mediaType === '') {
+		return {
+			accept: '*',
+			type: null,
+			subtype: null,
+		};
+	}
+
+	const matches = MEDIATYPE_PATTERN.exec(mediaType) as MediaTypeMatches | null;
+
+	if (matches == null) {
+		throw new ErrorProductionDesignPendingError(`Unsupported mediatype: ${mediaType}`);
+	}
+
+	const [accept, type, subtype] = matches;
+
+	return {
+		accept,
+		type,
+		subtype,
+	};
+};
+
+const parseUploadNodeOptions = (element: Element): UploadNodeOptions => {
+	const media = parseUploadMediaOptions(element);
+
+	return { media };
+};
+
 export class UploadControlDefinition extends ControlDefinition<'upload'> {
 	static override isCompatible(localName: string): boolean {
 		return localName === 'upload';
@@ -13,11 +53,13 @@ export class UploadControlDefinition extends ControlDefinition<'upload'> {
 
 	readonly type = 'upload';
 	readonly appearances: UnknownAppearanceDefinition;
+	readonly options: UploadNodeOptions;
 
 	constructor(form: XFormDefinition, parent: BodyElementParentContext, element: Element) {
 		super(form, parent, element);
 
 		this.appearances = unknownAppearanceParser.parseFrom(element, 'appearance');
+		this.options = parseUploadNodeOptions(element);
 	}
 
 	override toJSON(): object {

package/src/parse/model/BindDefinition.ts

@@ -80,7 +80,7 @@ export class BindDefinition<T extends BindType = BindType> extends DependencyCon
 	) {
 		super();
 
-		this.type = BindTypeDefinition.from(bindElement);
+		this.type = BindTypeDefinition.from(form, nodeset, bindElement);
 
 		const parentNodeset = nodeset.replace(/\/[^/]+$/, '');
 

package/src/parse/model/BindTypeDefinition.ts

@@ -1,19 +1,14 @@
 import { XSD_NAMESPACE_URI, XSD_PREFIX } from '@getodk/common/constants/xmlns.ts';
+import type { AnyBodyElementType } from '../body/BodyDefinition.ts';
+import type { XFormDefinition } from '../XFormDefinition.ts';
 import { parseQualifiedNameExpression } from '../xpath/semantic-analysis.ts';
 import type { BindElement } from './BindElement.ts';
 
-/**
- * As specified by {@link https://getodk.github.io/xforms-spec/#bind-attributes}
- */
-export const DEFAULT_BIND_TYPE = 'string';
-
-export type DefaultBindType = typeof DEFAULT_BIND_TYPE;
-
 /**
  * As specified by {@link https://getodk.github.io/xforms-spec/#data-types}
  */
 const BIND_TYPES = [
-	DEFAULT_BIND_TYPE,
+	'string',
 	'int',
 	'boolean',
 	'decimal',
@@ -32,6 +27,47 @@ type BindTypes = typeof BIND_TYPES;
 
 export type BindType = BindTypes[number];
 
+type BindTypeDefaultOverridesByBodyType = Partial<Readonly<Record<AnyBodyElementType, BindType>>>;
+
+/**
+ * As specified by {@link https://getodk.github.io/xforms-spec/#bind-attributes}
+ */
+const SPEC_BIND_TYPE_DEFAULT = 'string' satisfies BindType;
+
+/**
+ * If an `<upload>` is not explicitly associated with any `<bind type>`, we can do one of two things:
+ *
+ * - correct: default to {@link SPEC_BIND_TYPE_DEFAULT | the spec default regardless of control type}
+ * - more useful and robust: default to "binary", which is the only type the spec allows for an `<upload>` control
+ *
+ * Asked which would be preferable, @lognaturel responded:
+ *
+ * > I think we should assume in the spirit of doing the most useful thing!
+ */
+const UPLOAD_BIND_TYPE_DEFAULT = 'binary' satisfies BindType;
+
+const BODY_BIND_TYPE_DEFAULT_OVERRIDES = {
+	upload: UPLOAD_BIND_TYPE_DEFAULT,
+} as const satisfies BindTypeDefaultOverridesByBodyType;
+
+type BodyBindTypeDefaultOverrides = typeof BODY_BIND_TYPE_DEFAULT_OVERRIDES;
+
+type BodyBindTypeDefaultOverride = keyof BodyBindTypeDefaultOverrides;
+
+const isBodyBindTypeDefaultOverride = (
+	bodyElementType: AnyBodyElementType | null
+): bodyElementType is BodyBindTypeDefaultOverride => {
+	return bodyElementType != null && bodyElementType in BODY_BIND_TYPE_DEFAULT_OVERRIDES;
+};
+
+const resolveDefaultBindType = (bodyElementType: AnyBodyElementType | null): BindType => {
+	if (isBodyBindTypeDefaultOverride(bodyElementType)) {
+		return BODY_BIND_TYPE_DEFAULT_OVERRIDES[bodyElementType];
+	}
+
+	return SPEC_BIND_TYPE_DEFAULT;
+};
+
 const isBindType = (value: string): value is BindType => {
 	return BIND_TYPES.includes(value as BindType);
 };
@@ -42,14 +78,10 @@ const resolveSupportedBindType = (sourceType: string): BindType | null => {
 
 type BindTypeAliasMapping = Readonly<Record<string, BindType>>;
 
-/**
- * @todo should we make these aliases explicit (rather than relying on {@link resolveUnsupportedBindType})?
- *
- * - select1
- * - rank
- * - odk:rank
- */
 const BIND_TYPE_ALIASES: BindTypeAliasMapping = {
+	select1: SPEC_BIND_TYPE_DEFAULT,
+	rank: SPEC_BIND_TYPE_DEFAULT,
+	'odk:rank': SPEC_BIND_TYPE_DEFAULT,
 	integer: 'int',
 };
 
@@ -65,7 +97,7 @@ const resolveAliasedBindType = (sourceType: string): BindType | null => {
  * @todo Should we warn on this fallback?
  */
 const resolveUnsupportedBindType = (_unsupportedType: string): BindType => {
-	return DEFAULT_BIND_TYPE;
+	return SPEC_BIND_TYPE_DEFAULT;
 };
 
 interface BindDataTypeNamespaceResolver {
@@ -144,7 +176,15 @@ const resolveNamespacedBindType = (
 	return null;
 };
 
-const resolveBindType = (bindElement: BindElement, sourceType: string): BindType => {
+const resolveBindType = (
+	bodyElementType: AnyBodyElementType | null,
+	bindElement: BindElement,
+	sourceType: string | null
+): BindType => {
+	if (sourceType == null) {
+		return resolveDefaultBindType(bodyElementType);
+	}
+
 	return (
 		resolveSupportedBindType(sourceType) ??
 		resolveAliasedBindType(sourceType) ??
@@ -154,20 +194,22 @@ const resolveBindType = (bindElement: BindElement, sourceType: string): BindType
 };
 
 export class BindTypeDefinition<T extends BindType = BindType> {
-	static from<T extends BindType>(bindElement: BindElement): BindTypeDefinition<T> {
+	static from<T extends BindType>(
+		form: XFormDefinition,
+		nodeset: string,
+		bindElement: BindElement
+	): BindTypeDefinition<T> {
+		const bodyElementType = form.body.getBodyElementType(nodeset);
 		const sourceType = bindElement.getAttribute('type');
-
-		if (sourceType == null) {
-			return new this(sourceType, DEFAULT_BIND_TYPE);
-		}
-
-		const resolved = resolveBindType(bindElement, sourceType);
+		const resolved = resolveBindType(
+			bodyElementType,
+			bindElement,
+			sourceType
+		) satisfies BindType as T;
 
 		return new this(sourceType, resolved);
 	}
 
-	private constructor(source: null, resolved: DefaultBindType);
-	private constructor(source: string, resolved: BindType);
 	private constructor(
 		readonly source: string | null,
 		readonly resolved: T

package/src/parse/model/ModelBindMap.ts

@@ -1,7 +1,6 @@
 import type { XFormDefinition } from '../XFormDefinition.ts';
 import { BindDefinition } from './BindDefinition.ts';
 import type { BindElement, BindNodeset } from './BindElement.ts';
-import { DEFAULT_BIND_TYPE } from './BindTypeDefinition.ts';
 import type { ModelDefinition } from './ModelDefinition.ts';
 
 class ArtificialBindElement implements BindElement {
@@ -16,10 +15,6 @@ class ArtificialBindElement implements BindElement {
 			return this.ancestorNodeset;
 		}
 
-		if (name === 'type') {
-			return DEFAULT_BIND_TYPE;
-		}
-
 		return null;
 	}
 

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

@@ -2,6 +2,7 @@ import type { JRResourceURL } from '@getodk/common/jr-resources/JRResourceURL.ts
 import type { MissingResourceBehavior } from '../../../../client/constants.ts';
 import type { FetchResource, FetchResourceResponse } from '../../../../client/resources.ts';
 import { ErrorProductionDesignPendingError } from '../../../../error/ErrorProductionDesignPendingError.ts';
+import { getResponseContentType } from '../../../../lib/resource-helpers.ts';
 import { FormAttachmentResource } from '../../../attachments/FormAttachmentResource.ts';
 import type { ExternalSecondaryInstanceSourceFormat } from './SecondaryInstanceSource.ts';
 
@@ -13,36 +14,6 @@ const assertResponseSuccess = (resourceURL: JRResourceURL, response: FetchResour
 	}
 };
 
-const stripContentTypeCharset = (contentType: string): string => {
-	return contentType.replace(/;charset=.*$/, '');
-};
-
-const getResponseContentType = (response: FetchResourceResponse): string | null => {
-	const { headers } = response;
-
-	if (headers == null) {
-		return null;
-	}
-
-	const contentType = headers.get('content-type');
-
-	if (contentType != null) {
-		return stripContentTypeCharset(contentType);
-	}
-
-	if (headers instanceof Headers) {
-		return contentType;
-	}
-
-	for (const [header, value] of headers) {
-		if (header.toLowerCase() === 'content-type') {
-			return stripContentTypeCharset(value);
-		}
-	}
-
-	return null;
-};
-
 interface ExternalSecondaryInstanceResourceMetadata<
 	Format extends ExternalSecondaryInstanceSourceFormat = ExternalSecondaryInstanceSourceFormat,
 > {

package/src/parse/text/abstract/TextElementDefinition.ts

@@ -21,8 +21,8 @@ export type RefAttributeChunk =
 
 // prettier-ignore
 type TextElementChildChunk =
-	| TextOutputExpression
-	| TextLiteralExpression;
+	| TextLiteralExpression
+	| TextOutputExpression;
 
 // prettier-ignore
 type TextElementChunks =

package/dist/client/unsupported/UnsupportedControlNode.d.ts

@@ -1,30 +0,0 @@
-import { UnknownAppearanceDefinition } from '../../parse/body/appearance/unknownAppearanceParser.ts';
-import { UploadControlDefinition } from '../../parse/body/control/UploadControlDefinition.ts';
-import { LeafNodeDefinition } from '../../parse/model/LeafNodeDefinition.ts';
-import { BaseNode, BaseNodeState } from '../BaseNode.ts';
-import { RootNode } from '../RootNode.ts';
-import { GeneralParentNode } from '../hierarchy.ts';
-import { UnsupportedControlNodeType } from '../node-types.ts';
-import { LeafNodeValidationState } from '../validation.ts';
-export interface UnsupportedControlNodeState extends BaseNodeState {
-    get children(): null;
-    get valueOptions(): unknown;
-    get value(): unknown;
-}
-export type UnsupportedControlElementDefinition = UploadControlDefinition;
-export interface UnsupportedControlDefinition extends LeafNodeDefinition {
-    readonly bodyElement: UnsupportedControlElementDefinition;
-}
-/**
- * Stub node, for form controls pending further engine support.
- */
-export interface UnsupportedControlNode extends BaseNode {
-    readonly nodeType: UnsupportedControlNodeType;
-    readonly appearances: UnknownAppearanceDefinition;
-    readonly definition: UnsupportedControlDefinition;
-    readonly root: RootNode;
-    readonly parent: GeneralParentNode;
-    readonly currentState: UnsupportedControlNodeState;
-    readonly validationState: LeafNodeValidationState;
-    setValue?(value: never): never;
-}

package/dist/client/unsupported/UploadNode.d.ts

@@ -1,9 +0,0 @@
-import { UploadControlDefinition } from '../../parse/body/control/UploadControlDefinition.ts';
-import { UnsupportedControlDefinition, UnsupportedControlNode } from './UnsupportedControlNode.ts';
-export interface UploadNodeDefinition extends UnsupportedControlDefinition {
-    readonly bodyElement: UploadControlDefinition;
-}
-export interface UploadNode extends UnsupportedControlNode {
-    readonly nodeType: 'upload';
-    readonly definition: UploadNodeDefinition;
-}

package/dist/instance/unsupported/UploadControl.d.ts

@@ -1,34 +0,0 @@
-import { XPathNodeKindKey } from '@getodk/xpath';
-import { Accessor } from 'solid-js';
-import { TextRange } from '../../client/TextRange.ts';
-import { ValueType } from '../../client/ValueType.ts';
-import { UploadNode, UploadNodeDefinition } from '../../client/unsupported/UploadNode.ts';
-import { XFormsXPathElement } from '../../integration/xpath/adapter/XFormsXPathNode.ts';
-import { StaticLeafElement } from '../../integration/xpath/static-dom/StaticElement.ts';
-import { TempUnsupportedInputValue, TempUnsupportedRuntimeValue } from '../../lib/codecs/TempUnsupportedControlCodec.ts';
-import { CurrentState } from '../../lib/reactivity/node-state/createCurrentState.ts';
-import { EngineState } from '../../lib/reactivity/node-state/createEngineState.ts';
-import { SharedNodeState } from '../../lib/reactivity/node-state/createSharedNodeState.ts';
-import { UnknownAppearanceDefinition } from '../../parse/body/appearance/unknownAppearanceParser.ts';
-import { ValueNode, ValueNodeStateSpec } from '../abstract/ValueNode.ts';
-import { GeneralParentNode } from '../hierarchy.ts';
-import { EvaluationContext } from '../internal-api/EvaluationContext.ts';
-import { ValidationContext } from '../internal-api/ValidationContext.ts';
-import { ClientReactiveSerializableValueNode } from '../internal-api/serialization/ClientReactiveSerializableValueNode.ts';
-interface UploadControlStateSpec extends ValueNodeStateSpec<TempUnsupportedRuntimeValue> {
-    readonly label: Accessor<TextRange<'label'> | null>;
-    readonly hint: Accessor<TextRange<'hint'> | null>;
-    readonly valueOptions: null;
-}
-export declare class UploadControl extends ValueNode<ValueType, UploadNodeDefinition, TempUnsupportedRuntimeValue, TempUnsupportedInputValue> implements UploadNode, XFormsXPathElement, EvaluationContext, ValidationContext, ClientReactiveSerializableValueNode {
-    readonly [XPathNodeKindKey] = "element";
-    protected readonly state: SharedNodeState<UploadControlStateSpec>;
-    protected readonly engineState: EngineState<UploadControlStateSpec>;
-    readonly nodeType = "upload";
-    readonly appearances: UnknownAppearanceDefinition;
-    readonly nodeOptions: null;
-    readonly currentState: CurrentState<UploadControlStateSpec>;
-    constructor(parent: GeneralParentNode, instanceNode: StaticLeafElement | null, definition: UploadNodeDefinition);
-    setValue(_: never): never;
-}
-export {};

package/dist/lib/codecs/TempUnsupportedControlCodec.d.ts

@@ -1,7 +0,0 @@
-import { ValueType } from '../../client/ValueType.ts';
-import { ValueCodec } from './ValueCodec.ts';
-export type TempUnsupportedRuntimeValue = unknown;
-export type TempUnsupportedInputValue = unknown;
-export declare class TempUnsupportedControlCodec<V extends ValueType> extends ValueCodec<V, TempUnsupportedRuntimeValue, TempUnsupportedInputValue> {
-    constructor(valueType: V);
-}