@vizejs/composable 0.426.3 → 0.428.0

package/dist/use-file-dialog.mjs

@@ -0,0 +1,101 @@
+import { tryOnScopeDispose } from "./scope.mjs";
+import { shallowRef, toValue } from "vue";
+//#region src/use-file-dialog.ts
+function browserFileDialogHost() {
+	return typeof window === "undefined" ? void 0 : window.document;
+}
+/**
+* Open the native file picker without rendering an input.
+*
+* A detached `<input type="file">` is created lazily on the first `open`
+* (never during setup or server rendering), configured from reactive
+* options plus per-call overrides, and observed for `change` and `cancel`.
+* The selection is exposed as a readonly `File[]`. Listeners are removed
+* when the owning reactive scope stops.
+*
+* Server rendering: `files` is `initialFiles` and `open` returns false.
+*
+* @example
+* ```ts
+* const { files, open, onChange } = useFileDialog({ accept: "image/*" });
+* onChange((selection) => upload(selection));
+* ```
+*
+* @param options Dialog settings, initial selection, and capability.
+* @default options {}
+* @returns Selection state and dialog actions.
+*/
+function useFileDialog(options = {}) {
+	const files = shallowRef(options.initialFiles ?? null);
+	const changeHandlers = /* @__PURE__ */ new Set();
+	const cancelHandlers = /* @__PURE__ */ new Set();
+	let input;
+	let inputHost;
+	const resolveHost = () => options.host === void 0 ? browserFileDialogHost() : toValue(options.host) ?? void 0;
+	const onInputChange = () => {
+		const selected = input?.files ? Array.from(input.files) : [];
+		files.value = selected.length > 0 ? selected : null;
+		for (const handler of changeHandlers) handler(files.value);
+	};
+	const onInputCancel = () => {
+		for (const handler of cancelHandlers) handler();
+	};
+	const detach = () => {
+		input?.removeEventListener("change", onInputChange);
+		input?.removeEventListener("cancel", onInputCancel);
+		input = void 0;
+		inputHost = void 0;
+	};
+	const ensureInput = (host) => {
+		if (input && inputHost === host) return input;
+		detach();
+		const created = host.createElement("input");
+		created.type = "file";
+		created.addEventListener("change", onInputChange);
+		created.addEventListener("cancel", onInputCancel);
+		input = created;
+		inputHost = host;
+		return created;
+	};
+	const reset = () => {
+		files.value = null;
+		if (input) input.value = "";
+		for (const handler of changeHandlers) handler(null);
+	};
+	const open = (overrides = {}) => {
+		const host = resolveHost();
+		if (!host) return false;
+		const element = ensureInput(host);
+		element.accept = overrides.accept ?? toValue(options.accept) ?? "*";
+		element.multiple = overrides.multiple ?? toValue(options.multiple) ?? true;
+		const capture = overrides.capture ?? toValue(options.capture);
+		if (capture === void 0) element.removeAttribute("capture");
+		else element.setAttribute("capture", capture);
+		if (overrides.directory ?? toValue(options.directory) ?? false) element.setAttribute("webkitdirectory", "");
+		else element.removeAttribute("webkitdirectory");
+		if (overrides.reset ?? options.reset ?? false) reset();
+		element.value = "";
+		element.click();
+		return true;
+	};
+	const subscribe = (handlers) => (handler) => {
+		handlers.add(handler);
+		return () => {
+			handlers.delete(handler);
+		};
+	};
+	tryOnScopeDispose(() => {
+		detach();
+		changeHandlers.clear();
+		cancelHandlers.clear();
+	});
+	return {
+		files,
+		open,
+		reset,
+		onChange: subscribe(changeHandlers),
+		onCancel: subscribe(cancelHandlers)
+	};
+}
+//#endregion
+export { useFileDialog };

package/dist/use-file-system-access.d.mts

@@ -0,0 +1,184 @@
+import { ComputedRef, MaybeRefOrGetter, Ref, ShallowRef } from "vue";
+
+//#region src/use-file-system-access.d.ts
+/** Value types produced for each {@link FileSystemAccessDataType}. */
+interface FileSystemAccessDataMap {
+  /** UTF-8 decoded text. */
+  readonly text: string;
+  /** Raw bytes. */
+  readonly arrayBuffer: ArrayBuffer;
+  /** The file itself (a `Blob`). */
+  readonly blob: Blob;
+}
+/** How file contents are read into `data`. */
+type FileSystemAccessDataType = keyof FileSystemAccessDataMap;
+/** One accepted file type group for the pickers. */
+interface FilePickerAcceptTypeLike {
+  /** Human-readable description. */
+  readonly description?: string;
+  /** MIME type to extensions map, for example `{ "text/plain": [".txt"] }`. */
+  readonly accept: Readonly<Record<string, string | readonly string[]>>;
+}
+/** Writable stream returned by `createWritable`. */
+interface FileSystemWritableLike {
+  /** Write data. */
+  write(data: string | ArrayBuffer | Blob): Promise<void>;
+  /** Commit and close the stream. */
+  close(): Promise<void>;
+}
+/** Minimal `FileSystemFileHandle`. */
+interface FileSystemFileHandleLike {
+  /** File name. */
+  readonly name: string;
+  /** Snapshot of the current file contents. */
+  getFile(): Promise<File>;
+  /** Open a writable stream. */
+  createWritable(): Promise<FileSystemWritableLike>;
+}
+/** Options passed to `showOpenFilePicker`. */
+interface OpenFilePickerOptionsLike {
+  /** Accepted types. */
+  readonly types?: readonly FilePickerAcceptTypeLike[];
+  /** Hide the "all files" option. */
+  readonly excludeAcceptAllOption?: boolean;
+  /** Allow selecting multiple files. */
+  readonly multiple?: boolean;
+}
+/** Options passed to `showSaveFilePicker`. */
+interface SaveFilePickerOptionsLike {
+  /** Accepted types. */
+  readonly types?: readonly FilePickerAcceptTypeLike[];
+  /** Hide the "all files" option. */
+  readonly excludeAcceptAllOption?: boolean;
+  /** Suggested file name. */
+  readonly suggestedName?: string;
+}
+/** File System Access pickers (`window.showOpenFilePicker` and friends). */
+interface FileSystemAccessHost {
+  /** Show the open-file picker. */
+  showOpenFilePicker(options?: OpenFilePickerOptionsLike): Promise<readonly FileSystemFileHandleLike[]>;
+  /** Show the save-file picker. */
+  showSaveFilePicker(options?: SaveFilePickerOptionsLike): Promise<FileSystemFileHandleLike>;
+}
+/** Options for {@link useFileSystemAccess}. */
+interface UseFileSystemAccessOptions<Kind extends FileSystemAccessDataType = "text"> {
+  /**
+   * How file contents are exposed through `data`. Required for any
+   * representation other than text so the data type is always inferred
+   * from a runtime value.
+   *
+   * @default "text"
+   */
+  readonly dataType?: Kind;
+  /**
+   * Accepted file types for both pickers.
+   *
+   * @default undefined
+   */
+  readonly types?: MaybeRefOrGetter<readonly FilePickerAcceptTypeLike[] | undefined>;
+  /**
+   * Hide the "all files" option.
+   *
+   * @default false
+   */
+  readonly excludeAcceptAllOption?: MaybeRefOrGetter<boolean>;
+  /**
+   * Suggested name for the save picker.
+   *
+   * @default undefined
+   */
+  readonly suggestedName?: MaybeRefOrGetter<string | undefined>;
+  /**
+   * File System Access capability for alternate runtimes and tests.
+   *
+   * @default window when it implements both pickers
+   */
+  readonly host?: MaybeRefOrGetter<FileSystemAccessHost | null | undefined>;
+}
+/** Discriminated outcome of a file system action. */
+type FileSystemAccessResult = {
+  /** The action completed. */readonly status: "success";
+} | {
+  /** Picker dismissed, API missing, nothing to save, or another failure. */readonly status: "cancelled" | "unsupported" | "no-data" | "failed"; /** Exact error thrown by the host, when one was thrown. */
+  readonly error: unknown;
+};
+/** Reactive state and actions returned by {@link useFileSystemAccess}. */
+interface FileSystemAccessControls<Kind extends FileSystemAccessDataType> {
+  /** Whether the File System Access pickers are available. */
+  readonly supported: ComputedRef<boolean>;
+  /** File contents, typed by `dataType`. Assign to edit, then `save`. */
+  readonly data: Ref<FileSystemAccessDataMap[Kind] | undefined>;
+  /** Snapshot of the current file. */
+  readonly file: Readonly<ShallowRef<File | undefined>>;
+  /** Current file handle. */
+  readonly handle: Readonly<ShallowRef<FileSystemFileHandleLike | undefined>>;
+  /** Name of the current file. */
+  readonly fileName: ComputedRef<string>;
+  /** MIME type of the current file. */
+  readonly fileMIME: ComputedRef<string>;
+  /** Size in bytes of the current file. */
+  readonly fileSize: ComputedRef<number>;
+  /** Last modification time (Unix milliseconds) of the current file. */
+  readonly fileLastModified: ComputedRef<number>;
+  /**
+   * Pick a file and read it.
+   *
+   * @returns The discriminated outcome; never rejects.
+   */
+  readonly open: () => Promise<FileSystemAccessResult>;
+  /**
+   * Pick a new file location and clear `data`.
+   *
+   * @returns The discriminated outcome; never rejects.
+   */
+  readonly create: () => Promise<FileSystemAccessResult>;
+  /**
+   * Write `data` to the current file, or ask for a location first.
+   *
+   * @returns The discriminated outcome; never rejects.
+   */
+  readonly save: () => Promise<FileSystemAccessResult>;
+  /**
+   * Ask for a location and write `data` there.
+   *
+   * @returns The discriminated outcome; never rejects.
+   */
+  readonly saveAs: () => Promise<FileSystemAccessResult>;
+  /**
+   * Re-read the current file into `data`.
+   *
+   * @returns The discriminated outcome; never rejects.
+   */
+  readonly updateData: () => Promise<FileSystemAccessResult>;
+}
+/**
+ * Open, edit, and save local files with the File System Access API.
+ *
+ * `data` is typed by `dataType` (`string`, `ArrayBuffer`, or `Blob`) and is
+ * writable: edit it and call `save` to write back through the retained
+ * file handle. Every action resolves to a discriminated
+ * {@link FileSystemAccessResult}; a dismissed picker is `"cancelled"`.
+ * No listeners or timers are held, so nothing needs cleanup.
+ *
+ * Server rendering: `supported` is false, `data` is undefined, and every
+ * action resolves to `"unsupported"`.
+ *
+ * @example
+ * ```ts
+ * const editor = useFileSystemAccess({ types: [{ accept: { "text/markdown": [".md"] } }] });
+ * await editor.open();
+ * editor.data.value += "\n";
+ * await editor.save();
+ * ```
+ *
+ * @typeParam Kind Data representation, inferred from `dataType`.
+ * @param options Data type, picker settings, and capability.
+ * @default options {}
+ * @returns File state and actions.
+ */
+declare function useFileSystemAccess(options?: UseFileSystemAccessOptions<"text">): FileSystemAccessControls<"text">;
+declare function useFileSystemAccess<Kind extends FileSystemAccessDataType>(options: UseFileSystemAccessOptions<Kind> & {
+  readonly dataType: Kind;
+}): FileSystemAccessControls<Kind>;
+//#endregion
+export { FilePickerAcceptTypeLike, FileSystemAccessControls, FileSystemAccessDataMap, FileSystemAccessDataType, FileSystemAccessHost, FileSystemAccessResult, FileSystemFileHandleLike, FileSystemWritableLike, OpenFilePickerOptionsLike, SaveFilePickerOptionsLike, UseFileSystemAccessOptions, useFileSystemAccess };

package/dist/use-file-system-access.mjs

@@ -0,0 +1,151 @@
+import { computed, ref, shallowRef, toValue } from "vue";
+//#region src/use-file-system-access.ts
+const readers = {
+	text: (file) => file.text(),
+	arrayBuffer: (file) => file.arrayBuffer(),
+	blob: (file) => Promise.resolve(file)
+};
+function browserFileSystemAccessHost() {
+	if (typeof window === "undefined") return void 0;
+	const open = Reflect.get(window, "showOpenFilePicker");
+	const save = Reflect.get(window, "showSaveFilePicker");
+	if (typeof open !== "function" || typeof save !== "function") return void 0;
+	return {
+		showOpenFilePicker: (options) => Reflect.apply(open, window, [options]),
+		showSaveFilePicker: (options) => Reflect.apply(save, window, [options])
+	};
+}
+function isAbort(error) {
+	return typeof error === "object" && error !== null && "name" in error && error.name === "AbortError";
+}
+function failed(error) {
+	return {
+		status: isAbort(error) ? "cancelled" : "failed",
+		error
+	};
+}
+const success = { status: "success" };
+const unsupported = {
+	status: "unsupported",
+	error: void 0
+};
+function useFileSystemAccess(options = {}) {
+	const dataType = options.dataType ?? "text";
+	const data = ref(void 0);
+	const file = shallowRef(void 0);
+	const handle = shallowRef(void 0);
+	const resolveHost = () => options.host === void 0 ? browserFileSystemAccessHost() : toValue(options.host) ?? void 0;
+	const pickerBase = () => {
+		const types = toValue(options.types);
+		return {
+			...types === void 0 ? {} : { types },
+			excludeAcceptAllOption: toValue(options.excludeAcceptAllOption) ?? false
+		};
+	};
+	const read = async () => {
+		const current = handle.value;
+		if (!current) return;
+		const snapshot = await current.getFile();
+		file.value = snapshot;
+		data.value = await readers[dataType](snapshot);
+	};
+	const updateData = async () => {
+		if (!handle.value) return {
+			status: "no-data",
+			error: void 0
+		};
+		try {
+			await read();
+			return success;
+		} catch (error) {
+			return failed(error);
+		}
+	};
+	const open = async () => {
+		const host = resolveHost();
+		if (!host) return unsupported;
+		try {
+			const [picked] = await host.showOpenFilePicker({
+				...pickerBase(),
+				multiple: false
+			});
+			if (!picked) return {
+				status: "cancelled",
+				error: void 0
+			};
+			handle.value = picked;
+			await read();
+			return success;
+		} catch (error) {
+			return failed(error);
+		}
+	};
+	const pickSaveLocation = async (host) => {
+		const suggestedName = toValue(options.suggestedName);
+		return host.showSaveFilePicker({
+			...pickerBase(),
+			...suggestedName === void 0 ? {} : { suggestedName }
+		});
+	};
+	const create = async () => {
+		const host = resolveHost();
+		if (!host) return unsupported;
+		try {
+			handle.value = await pickSaveLocation(host);
+			data.value = void 0;
+			file.value = await handle.value.getFile();
+			return success;
+		} catch (error) {
+			return failed(error);
+		}
+	};
+	const write = async (target) => {
+		const value = data.value;
+		if (value === void 0) return {
+			status: "no-data",
+			error: void 0
+		};
+		const writable = await target.createWritable();
+		await writable.write(value);
+		await writable.close();
+		handle.value = target;
+		file.value = await target.getFile();
+		return success;
+	};
+	const saveAs = async () => {
+		const host = resolveHost();
+		if (!host) return unsupported;
+		try {
+			return await write(await pickSaveLocation(host));
+		} catch (error) {
+			return failed(error);
+		}
+	};
+	const save = async () => {
+		if (!resolveHost()) return unsupported;
+		const current = handle.value;
+		if (!current) return saveAs();
+		try {
+			return await write(current);
+		} catch (error) {
+			return failed(error);
+		}
+	};
+	return {
+		supported: computed(() => resolveHost() !== void 0),
+		data,
+		file,
+		handle,
+		fileName: computed(() => file.value?.name ?? ""),
+		fileMIME: computed(() => file.value?.type ?? ""),
+		fileSize: computed(() => file.value?.size ?? 0),
+		fileLastModified: computed(() => file.value?.lastModified ?? 0),
+		open,
+		create,
+		save,
+		saveAs,
+		updateData
+	};
+}
+//#endregion
+export { useFileSystemAccess };

package/dist/use-form-field-props.d.mts

@@ -0,0 +1,235 @@
+import { FormControls, FormFieldControls, FormPath, FormPathValue } from "./use-form.mjs";
+import { ComputedRef, MaybeRefOrGetter } from "vue";
+
+//#region src/use-form-field-props.d.ts
+/**
+ * Accessible relations for a form control.
+ *
+ * Structurally identical to `FieldControlProps` from `@vizejs/ui/field-wiring`,
+ * so the object can be bound with `v-bind` onto any `@vizejs/ui` control (or a
+ * native element) without this package depending on `@vizejs/ui`.
+ */
+interface FormFieldControlProps {
+  /** Control id, referenced by the label's `for`. */
+  readonly id: string;
+  /** Id of the field label. */
+  readonly "aria-labelledby": string;
+  /** Description id and, while invalid, error id. */
+  readonly "aria-describedby": string | undefined;
+  /** Error id while invalid. */
+  readonly "aria-errormessage": string | undefined;
+  /** `"true"` while invalid. */
+  readonly "aria-invalid": "true" | undefined;
+}
+/** Props for a `<label>` (or ui `FieldLabel`) element. */
+interface FormFieldLabelProps {
+  /** Label id. */
+  readonly id: string;
+  /** Id of the labelled control. */
+  readonly for: string;
+}
+/** Props for description and error-message elements. */
+interface FormFieldTextProps {
+  /** Element id referenced by the control. */
+  readonly id: string;
+}
+/**
+ * `v-model` bindings for any component that follows the `modelValue` /
+ * `update:modelValue` convention, plus a blur listener that marks the field
+ * touched (and validates on blur when the form is configured to).
+ */
+interface FormFieldModelProps<Value> {
+  /** Current value at the path. */
+  readonly modelValue: Value;
+  /** Writes the value at the path. */
+  readonly "onUpdate:modelValue": (value: Value) => void;
+  /** Marks the field touched. */
+  readonly onBlur: () => void;
+}
+/** When a field with errors is reported as invalid. */
+type FormFieldErrorVisibility = "always" | "submitted" | "touched";
+/** Options for {@link useFormFieldProps}. */
+interface UseFormFieldPropsOptions {
+  /**
+   * Explicit control id. Label, description, and error ids derive from it
+   * as `<id>-label`, `<id>-description`, and `<id>-error`.
+   *
+   * @default `${idPrefix}-${path}` with dots replaced by dashes
+   */
+  readonly id?: MaybeRefOrGetter<string | null | undefined>;
+  /**
+   * Prefix of the derived id. Use a unique prefix per form on pages with
+   * several forms that share field paths.
+   *
+   * @default "field"
+   */
+  readonly idPrefix?: string;
+  /**
+   * Whether a description element is rendered and joins `aria-describedby`.
+   *
+   * @default false
+   */
+  readonly hasDescription?: MaybeRefOrGetter<boolean | undefined>;
+  /**
+   * Whether an error element is rendered while invalid and is referenced.
+   *
+   * @default true
+   */
+  readonly hasErrorMessage?: MaybeRefOrGetter<boolean | undefined>;
+  /**
+   * When errors make the field invalid: immediately, after the first
+   * submit, or once the field is touched (or the form was submitted).
+   *
+   * @default "touched"
+   */
+  readonly showErrors?: FormFieldErrorVisibility;
+}
+/** Bindings returned by {@link useFormFieldProps}. */
+interface FormFieldPropsControls<Value, Path extends string> {
+  /** Underlying typed field controls. */
+  readonly field: FormFieldControls<Value, Path>;
+  /** Control id. */
+  readonly id: ComputedRef<string>;
+  /** Whether errors are currently reported. */
+  readonly invalid: ComputedRef<boolean>;
+  /** First reported error, or `undefined` while valid or hidden. */
+  readonly errorMessage: ComputedRef<string | undefined>;
+  /** Accessible relations for the control. */
+  readonly fieldProps: ComputedRef<FormFieldControlProps>;
+  /** Props for the label element. */
+  readonly labelProps: ComputedRef<FormFieldLabelProps>;
+  /** Props for the description element. */
+  readonly descriptionProps: ComputedRef<FormFieldTextProps>;
+  /** Props for the error element. */
+  readonly errorMessageProps: ComputedRef<FormFieldTextProps>;
+  /** `v-model` and blur bindings for the control. */
+  readonly modelProps: ComputedRef<FormFieldModelProps<Value>>;
+  /** `fieldProps` and `modelProps` merged, for a single `v-bind`. */
+  readonly controlProps: ComputedRef<FormFieldControlProps & FormFieldModelProps<Value>>;
+}
+/**
+ * One invalid field, structurally identical to `ErrorSummaryField` from
+ * `@vizejs/ui/error-summary`.
+ */
+interface FormErrorSummaryItem {
+  /** Id of the invalid control (link target). */
+  readonly id: string;
+  /** First error message. */
+  readonly message: string;
+  /** Optional field label prefixed to the message. */
+  readonly label?: string;
+}
+/**
+ * One error, structurally identical to `FormFieldError` from `@vizejs/ui/form`,
+ * so ui `Field` components match errors by `name`.
+ */
+interface FormFieldErrorEntry {
+  /** Dotted field path, used as the ui field `name`. */
+  readonly name: string;
+  /** Error message. */
+  readonly message: string;
+  /** Path segments; numeric segments are numbers. */
+  readonly path: readonly (string | number)[];
+}
+/** Options for {@link useFormErrorSummaryFields}. */
+interface UseFormErrorSummaryFieldsOptions<Values> {
+  /**
+   * Prefix used to derive control ids; must match {@link useFormFieldProps}.
+   *
+   * @default "field"
+   */
+  readonly idPrefix?: string;
+  /**
+   * Explicit control ids per path, for fields bound with a custom `id`.
+   *
+   * @default {}
+   */
+  readonly ids?: { readonly [Path in FormPath<Values>]?: string };
+  /**
+   * Human-readable labels per path.
+   *
+   * @default {}
+   */
+  readonly labels?: { readonly [Path in FormPath<Values>]?: string };
+  /**
+   * Paths in document order; unlisted paths follow in error order.
+   *
+   * @default []
+   */
+  readonly order?: readonly FormPath<Values>[];
+  /**
+   * Include form-level errors (the `""` path) with this control id.
+   *
+   * @default undefined
+   */
+  readonly rootId?: string;
+  /**
+   * When errors are listed: immediately, or only after the first submit.
+   *
+   * @default "submitted"
+   */
+  readonly showErrors?: "always" | "submitted";
+}
+/** Derive the default control id for a path. */
+declare function formFieldId(path: string, idPrefix?: string): string;
+/**
+ * Bind one `useForm` field to accessible field markup and any `v-model` control.
+ *
+ * Returns ids, ARIA relations (`fieldProps`), label/description/error props,
+ * and `modelProps` whose shapes match `@vizejs/ui`'s Field contracts
+ * structurally, so the bridge lives here without a runtime dependency on the
+ * UI package. Ids are derived from the path, so server and client agree
+ * without any instance-local id sequence.
+ *
+ * Server rendering: pure derived state, no host access. Cleanup: none needed
+ * beyond the owning form.
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ * const form = useForm({ initialValues: { address: { city: "" } } });
+ * const city = useFormFieldProps(form, "address.city");
+ * </script>
+ * <template>
+ *   <label v-bind="city.labelProps.value">City</label>
+ *   <TextInput v-bind="city.controlProps.value" />
+ *   <p v-if="city.invalid.value" v-bind="city.errorMessageProps.value">{{ city.errorMessage.value }}</p>
+ * </template>
+ * ```
+ *
+ * @param form Controls returned by `useForm`.
+ * @param path Typed dotted path.
+ * @param options Id, relation, and error-visibility options.
+ * @default options {}
+ * @returns Typed bindings for the field.
+ */
+declare function useFormFieldProps<Values extends object, Output, Path extends FormPath<Values>>(form: FormControls<Values, Output>, path: Path, options?: UseFormFieldPropsOptions): FormFieldPropsControls<FormPathValue<Values, Path>, Path>;
+/**
+ * Convert form errors into ui `FormFieldError` entries (`{ name, message, path }`),
+ * one per message, so `@vizejs/ui` `Field` components match them by `name`.
+ *
+ * @param errors `form.errors.value`.
+ * @returns Entries in record order; the form-level `""` path has an empty `path`.
+ */
+declare function toFormFieldErrors(errors: Readonly<Record<string, readonly string[]>>): readonly FormFieldErrorEntry[];
+/**
+ * Derive `@vizejs/ui` `ErrorSummary` fields from a `useForm` instance.
+ *
+ * Each invalid path becomes `{ id, message, label? }` pointing at the control
+ * id that {@link useFormFieldProps} assigns, in `order` then error order.
+ *
+ * Server rendering: pure derived state. Cleanup: none.
+ *
+ * @example
+ * ```vue
+ * <ErrorSummary :fields="summary" heading="Fix these fields" />
+ * ```
+ *
+ * @param form Controls returned by `useForm`.
+ * @param options Id, label, ordering, and visibility options.
+ * @default options {}
+ * @returns Summary fields, empty until errors should be shown.
+ */
+declare function useFormErrorSummaryFields<Values extends object, Output>(form: FormControls<Values, Output>, options?: UseFormErrorSummaryFieldsOptions<Values>): ComputedRef<readonly FormErrorSummaryItem[]>;
+//#endregion
+export { FormErrorSummaryItem, FormFieldControlProps, FormFieldErrorEntry, FormFieldErrorVisibility, FormFieldLabelProps, FormFieldModelProps, FormFieldPropsControls, FormFieldTextProps, UseFormErrorSummaryFieldsOptions, UseFormFieldPropsOptions, formFieldId, toFormFieldErrors, useFormErrorSummaryFields, useFormFieldProps };