@povio/ui 5.0.0-rc.8 → 6.0.0-rc.1

package/dist/useAsyncList-yHz7twsj.js

@@ -0,0 +1,445 @@
+import { useEffect, useReducer, useRef, useState } from "react";
+import { c } from "react/compiler-runtime";
+//#region ../../node_modules/.bun/react-stately@3.51.0+83d5fd7b249dbeef/node_modules/react-stately/dist/private/data/useListData.mjs
+function $232f8dea1b0a4f2f$export$79c0c687a5963b0a(opts, dispatch) {
+	let { cursor, getKey } = opts;
+	return {
+		setSelectedKeys(selectedKeys) {
+			dispatch((state) => ({
+				...state,
+				selectedKeys
+			}));
+		},
+		addKeysToSelection(selectedKeys) {
+			dispatch((state) => {
+				if (state.selectedKeys === "all") return state;
+				if (selectedKeys === "all") return {
+					...state,
+					selectedKeys: "all"
+				};
+				return {
+					...state,
+					selectedKeys: /* @__PURE__ */ new Set([...state.selectedKeys, ...selectedKeys])
+				};
+			});
+		},
+		removeKeysFromSelection(selectedKeys) {
+			dispatch((state) => {
+				if (selectedKeys === "all") return {
+					...state,
+					selectedKeys: /* @__PURE__ */ new Set()
+				};
+				let selection = state.selectedKeys === "all" ? new Set(state.items.map(getKey)) : new Set(state.selectedKeys);
+				for (let key of selectedKeys) selection.delete(key);
+				return {
+					...state,
+					selectedKeys: selection
+				};
+			});
+		},
+		setFilterText(filterText) {
+			dispatch((state) => ({
+				...state,
+				filterText
+			}));
+		},
+		insert(index, ...values) {
+			dispatch((state) => $232f8dea1b0a4f2f$var$insert(state, index, ...values));
+		},
+		insertBefore(key, ...values) {
+			dispatch((state) => {
+				let index = state.items.findIndex((item) => getKey?.(item) === key);
+				if (index === -1) {
+					if (state.items.length === 0) index = 0;
+					else return state;
+				}
+				return $232f8dea1b0a4f2f$var$insert(state, index, ...values);
+			});
+		},
+		insertAfter(key, ...values) {
+			dispatch((state) => {
+				let index = state.items.findIndex((item) => getKey?.(item) === key);
+				if (index === -1) {
+					if (state.items.length === 0) index = 0;
+					else return state;
+				}
+				return $232f8dea1b0a4f2f$var$insert(state, index + 1, ...values);
+			});
+		},
+		prepend(...values) {
+			dispatch((state) => $232f8dea1b0a4f2f$var$insert(state, 0, ...values));
+		},
+		append(...values) {
+			dispatch((state) => $232f8dea1b0a4f2f$var$insert(state, state.items.length, ...values));
+		},
+		remove(...keys) {
+			dispatch((state) => {
+				let keySet = new Set(keys);
+				let items = state.items.filter((item) => !keySet.has(getKey(item)));
+				let selection = "all";
+				if (state.selectedKeys !== "all") {
+					selection = new Set(state.selectedKeys);
+					for (let key of keys) selection.delete(key);
+				}
+				if (cursor == null && items.length === 0) selection = /* @__PURE__ */ new Set();
+				return {
+					...state,
+					items,
+					selectedKeys: selection
+				};
+			});
+		},
+		removeSelectedItems() {
+			dispatch((state) => {
+				if (state.selectedKeys === "all") return {
+					...state,
+					items: [],
+					selectedKeys: /* @__PURE__ */ new Set()
+				};
+				let selectedKeys = state.selectedKeys;
+				let items = state.items.filter((item) => !selectedKeys.has(getKey(item)));
+				return {
+					...state,
+					items,
+					selectedKeys: /* @__PURE__ */ new Set()
+				};
+			});
+		},
+		move(key, toIndex) {
+			dispatch((state) => {
+				let index = state.items.findIndex((item) => getKey(item) === key);
+				if (index === -1) return state;
+				let copy = state.items.slice();
+				let [item] = copy.splice(index, 1);
+				copy.splice(toIndex, 0, item);
+				return {
+					...state,
+					items: copy
+				};
+			});
+		},
+		moveBefore(key, keys) {
+			dispatch((state) => {
+				let toIndex = state.items.findIndex((item) => getKey(item) === key);
+				if (toIndex === -1) return state;
+				return $232f8dea1b0a4f2f$var$move(state, (Array.isArray(keys) ? keys : [...keys]).map((key) => state.items.findIndex((item) => getKey(item) === key)).sort((a, b) => a - b), toIndex);
+			});
+		},
+		moveAfter(key, keys) {
+			dispatch((state) => {
+				let toIndex = state.items.findIndex((item) => getKey(item) === key);
+				if (toIndex === -1) return state;
+				return $232f8dea1b0a4f2f$var$move(state, (Array.isArray(keys) ? keys : [...keys]).map((key) => state.items.findIndex((item) => getKey(item) === key)).sort((a, b) => a - b), toIndex + 1);
+			});
+		},
+		update(key, newValue) {
+			dispatch((state) => {
+				let index = state.items.findIndex((item) => getKey(item) === key);
+				if (index === -1) return state;
+				let updatedValue;
+				if (typeof newValue === "function") updatedValue = newValue(state.items[index]);
+				else updatedValue = newValue;
+				return {
+					...state,
+					items: [
+						...state.items.slice(0, index),
+						updatedValue,
+						...state.items.slice(index + 1)
+					]
+				};
+			});
+		}
+	};
+}
+function $232f8dea1b0a4f2f$var$insert(state, index, ...values) {
+	return {
+		...state,
+		items: [
+			...state.items.slice(0, index),
+			...values,
+			...state.items.slice(index)
+		]
+	};
+}
+function $232f8dea1b0a4f2f$var$move(state, indices, toIndex) {
+	toIndex -= indices.filter((index) => index < toIndex).length;
+	let moves = indices.map((from) => ({
+		from,
+		to: toIndex++
+	}));
+	for (let i = 0; i < moves.length; i++) {
+		let a = moves[i].from;
+		for (let j = i; j < moves.length; j++) if (moves[j].from > a) moves[j].from--;
+	}
+	for (let i = 0; i < moves.length; i++) {
+		let a = moves[i];
+		for (let j = moves.length - 1; j > i; j--) {
+			let b = moves[j];
+			if (b.from < a.to) a.to++;
+			else b.from++;
+		}
+	}
+	let copy = state.items.slice();
+	for (let move of moves) {
+		let [item] = copy.splice(move.from, 1);
+		copy.splice(move.to, 0, item);
+	}
+	return {
+		...state,
+		items: copy
+	};
+}
+//#endregion
+//#region ../../node_modules/.bun/react-stately@3.51.0+83d5fd7b249dbeef/node_modules/react-stately/dist/private/data/useAsyncList.mjs
+function $c73d3f3d5ec90946$var$reducer(data, action) {
+	let selectedKeys;
+	switch (data.state) {
+		case "idle":
+		case "error": switch (action.type) {
+			case "loading":
+			case "loadingMore":
+			case "sorting":
+			case "filtering": return {
+				...data,
+				filterText: action.filterText ?? data.filterText,
+				state: action.type,
+				items: action.type === "loading" ? [] : data.items,
+				sortDescriptor: action.sortDescriptor ?? data.sortDescriptor,
+				abortController: action.abortController
+			};
+			case "update": return {
+				...data,
+				...action.updater?.(data)
+			};
+			case "success":
+			case "error": return data;
+			default: throw new Error(`Invalid action "${action.type}" in state "${data.state}"`);
+		}
+		case "loading":
+		case "sorting":
+		case "filtering": switch (action.type) {
+			case "success":
+				if (action.abortController !== data.abortController) return data;
+				selectedKeys = action.selectedKeys ?? data.selectedKeys;
+				return {
+					...data,
+					filterText: action.filterText ?? data.filterText,
+					state: "idle",
+					items: [...action.items ?? []],
+					selectedKeys: selectedKeys === "all" ? "all" : new Set(selectedKeys),
+					sortDescriptor: action.sortDescriptor ?? data.sortDescriptor,
+					abortController: void 0,
+					cursor: action.cursor
+				};
+			case "error":
+				if (action.abortController !== data.abortController) return data;
+				return {
+					...data,
+					state: "error",
+					error: action.error,
+					abortController: void 0
+				};
+			case "loading":
+			case "loadingMore":
+			case "sorting":
+			case "filtering":
+				data.abortController?.abort("aborting current load and starting new one");
+				return {
+					...data,
+					filterText: action.filterText ?? data.filterText,
+					state: action.type,
+					items: action.type === "loading" ? [] : data.items,
+					abortController: action.abortController
+				};
+			case "update": return {
+				...data,
+				...action.updater?.(data)
+			};
+			default: throw new Error(`Invalid action "${action.type}" in state "${data.state}"`);
+		}
+		case "loadingMore": switch (action.type) {
+			case "success":
+				selectedKeys = data.selectedKeys === "all" || action.selectedKeys === "all" ? "all" : /* @__PURE__ */ new Set([...data.selectedKeys, ...action.selectedKeys ?? []]);
+				return {
+					...data,
+					state: "idle",
+					items: [...data.items, ...action.items ?? []],
+					selectedKeys,
+					sortDescriptor: action.sortDescriptor ?? data.sortDescriptor,
+					abortController: void 0,
+					cursor: action.cursor
+				};
+			case "error":
+				if (action.abortController !== data.abortController) return data;
+				return {
+					...data,
+					state: "error",
+					error: action.error
+				};
+			case "loading":
+			case "sorting":
+			case "filtering":
+				data.abortController?.abort();
+				return {
+					...data,
+					filterText: action.filterText ?? data.filterText,
+					state: action.type,
+					items: action.type === "loading" ? [] : data.items,
+					abortController: action.abortController
+				};
+			case "loadingMore":
+				action.abortController?.abort();
+				return data;
+			case "update": return {
+				...data,
+				...action.updater?.(data)
+			};
+			default: throw new Error(`Invalid action "${action.type}" in state "${data.state}"`);
+		}
+		default: throw new Error(`Invalid state "${data.state}"`);
+	}
+}
+function $c73d3f3d5ec90946$export$bc3384a35de93d66(options) {
+	const { load, sort, initialSelectedKeys, initialSortDescriptor, getKey = (item) => item.id || item.key, initialFilterText = "" } = options;
+	let [data, dispatch] = useReducer($c73d3f3d5ec90946$var$reducer, {
+		state: "idle",
+		error: void 0,
+		items: [],
+		selectedKeys: initialSelectedKeys === "all" ? "all" : new Set(initialSelectedKeys),
+		sortDescriptor: initialSortDescriptor,
+		filterText: initialFilterText
+	});
+	const dispatchFetch = async (action, fn) => {
+		let abortController = new AbortController();
+		try {
+			dispatch({
+				...action,
+				abortController
+			});
+			let previousFilterText = action.filterText ?? data.filterText;
+			let response = await fn({
+				items: data.items.slice(),
+				selectedKeys: data.selectedKeys,
+				sortDescriptor: action.sortDescriptor ?? data.sortDescriptor,
+				signal: abortController.signal,
+				cursor: action.type === "loadingMore" ? data.cursor : void 0,
+				filterText: previousFilterText,
+				loadingState: data.state
+			});
+			let filterText = response.filterText ?? previousFilterText;
+			dispatch({
+				type: "success",
+				...response,
+				abortController
+			});
+			if (filterText && filterText !== previousFilterText && !abortController.signal.aborted) dispatchFetch({
+				type: "filtering",
+				filterText
+			}, load);
+		} catch (e) {
+			dispatch({
+				type: "error",
+				error: e,
+				abortController
+			});
+		}
+	};
+	let didDispatchInitialFetch = useRef(false);
+	useEffect(() => {
+		if (!didDispatchInitialFetch.current) {
+			dispatchFetch({ type: "loading" }, load);
+			didDispatchInitialFetch.current = true;
+		}
+	}, []);
+	return {
+		items: data.items,
+		selectedKeys: data.selectedKeys,
+		sortDescriptor: data.sortDescriptor,
+		isLoading: data.state === "loading" || data.state === "loadingMore" || data.state === "sorting" || data.state === "filtering",
+		loadingState: data.state,
+		error: data.error,
+		filterText: data.filterText,
+		getItem(key) {
+			return data.items.find((item) => getKey(item) === key);
+		},
+		reload() {
+			dispatchFetch({ type: "loading" }, load);
+		},
+		loadMore() {
+			if (data.state === "loading" || data.state === "loadingMore" || data.state === "filtering" || data.cursor == null) return;
+			dispatchFetch({ type: "loadingMore" }, load);
+		},
+		sort(sortDescriptor) {
+			dispatchFetch({
+				type: "sorting",
+				sortDescriptor
+			}, sort || load);
+		},
+		...$232f8dea1b0a4f2f$export$79c0c687a5963b0a({
+			...options,
+			getKey,
+			cursor: data.cursor
+		}, (fn) => {
+			dispatch({
+				type: "update",
+				updater: fn
+			});
+		}),
+		setFilterText(filterText) {
+			dispatchFetch({
+				type: "filtering",
+				filterText
+			}, load);
+		}
+	};
+}
+//#endregion
+//#region src/hooks/useAsyncList.ts
+function useAsyncList(options) {
+	const $ = c(9);
+	const [hasMore, setHasMore] = useState(false);
+	const sort = options.sort;
+	let t0;
+	if ($[0] !== sort) {
+		t0 = sort ? async (args) => {
+			const result = await sort(args);
+			if (!args.signal.aborted) setHasMore(result.cursor != null);
+			return result;
+		} : void 0;
+		$[0] = sort;
+		$[1] = t0;
+	} else t0 = $[1];
+	let t1;
+	if ($[2] !== options || $[3] !== t0) {
+		t1 = {
+			...options,
+			sort: t0,
+			async load(args_0) {
+				const result_0 = await options.load(args_0);
+				if (!args_0.signal.aborted) setHasMore(result_0.cursor != null);
+				return result_0;
+			}
+		};
+		$[2] = options;
+		$[3] = t0;
+		$[4] = t1;
+	} else t1 = $[4];
+	const list = $c73d3f3d5ec90946$export$bc3384a35de93d66(t1);
+	const t2 = list.loadingState === "error" ? list.error : void 0;
+	const t3 = hasMore && list.loadingState !== "error";
+	let t4;
+	if ($[5] !== list || $[6] !== t2 || $[7] !== t3) {
+		t4 = {
+			...list,
+			error: t2,
+			hasMore: t3
+		};
+		$[5] = list;
+		$[6] = t2;
+		$[7] = t3;
+		$[8] = t4;
+	} else t4 = $[8];
+	return t4;
+}
+//#endregion
+export { useAsyncList as t };

package/dist/{useBreakpoint-DQoMN-BG.js → useBreakpoint-BzYqQEBO.js}

@@ -1,4 +1,4 @@
-import { t as UIConfig } from "./uiConfig.context-BS3r_kTS.js";
+import { t as UIConfig } from "./uiConfig.context-CT9EVqC5.js";
 import { useSyncExternalStore } from "react";
 import { c } from "react/compiler-runtime";
 //#region src/hooks/useBreakpoint.ts

package/dist/{useControlledState-CzXkZCX8.js → useControlledState-CuU1VIh1.js}

@@ -1,6 +1,6 @@
 import $ahdqC$react, { useCallback, useEffect, useReducer, useRef, useState } from "react";
-//#region ../../node_modules/.bun/react-stately@3.50.0+83d5fd7b249dbeef/node_modules/react-stately/dist/private/utils/useControlledState.mjs
-const $3e6197669829fe11$var$useEarlyEffect = typeof document !== "undefined" ? $ahdqC$react["useInsertionEffect"] ?? $ahdqC$react.useLayoutEffect : () => {};
+//#region ../../node_modules/.bun/react-stately@3.51.0+83d5fd7b249dbeef/node_modules/react-stately/dist/private/utils/useControlledState.mjs
+const $3e6197669829fe11$var$useEarlyEffect = typeof document !== "undefined" || parseInt($ahdqC$react.version, 10) >= 19 ? $ahdqC$react["useInsertionEffect"] ?? $ahdqC$react.useLayoutEffect : () => {};
 function $3e6197669829fe11$export$40bfa8c7b0832715(value, defaultValue, onChange) {
 	let [stateValue, setStateValue] = useState(value || defaultValue);
 	let valueRef = useRef(stateValue);

package/dist/useFieldAccessibility-eZIMECmG.js

@@ -0,0 +1,19 @@
+import { useId } from "react";
+//#region src/components/inputs/shared/useFieldAccessibility.ts
+const joinIds = (...ids) => {
+	const uniqueIds = [...new Set(ids.flatMap((id) => id?.split(/\s+/u).filter(Boolean) ?? []))];
+	return uniqueIds.length > 0 ? uniqueIds.join(" ") : void 0;
+};
+const useFieldAccessibility = ({ describedBy, error, helperText }) => {
+	const generatedHelperTextId = useId();
+	const generatedErrorMessageId = useId();
+	const helperTextId = helperText ? `field-helper-${generatedHelperTextId}` : void 0;
+	const errorMessageId = error ? `field-error-${generatedErrorMessageId}` : void 0;
+	return {
+		describedBy: joinIds(describedBy, helperTextId, errorMessageId),
+		errorMessageId,
+		helperTextId
+	};
+};
+//#endregion
+export { useFieldAccessibility as t };

package/dist/{useFilters-XNH27Md2.js → useFilters-HIngImwn.js}

@@ -1,5 +1,5 @@
 import { t as UIRouter } from "./router.context-B4FvsTim.js";
-import { t as RoutingUtils } from "./routing.utils-UTQonIhB.js";
+import { t as RoutingUtils } from "./routing.utils-DfxEt0_Y.js";
 import { useEffect, useState } from "react";
 import { c } from "react/compiler-runtime";
 import { z } from "zod";

package/dist/{form.binding-DVJ5F0JE.d.ts → useForm-I6z23FXf.d.ts}

@@ -13,20 +13,20 @@ type FieldValidators = {
 type FormSubmitHandler<TValues> = (values: TValues) => void | Promise<void>;
 type FormSubmitErrorHandler<TValues> = (errors: unknown, values: TValues) => unknown;
 type TanStackForm<TFieldValues> = ReactFormExtendedApi<TFieldValues, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, never>;
-type UIForm<TFieldValues extends Record<string, unknown> = Record<string, unknown>> = Omit<TanStackForm<TFieldValues>, "handleSubmit"> & {
+type UIForm<TFieldValues extends Record<string, unknown> = Record<string, unknown>, TTransformedValues = TFieldValues> = Omit<TanStackForm<TFieldValues>, "handleSubmit"> & {
   readonly disabled: boolean;
   getFieldValidators: (name: DeepKeys<TFieldValues>) => FieldValidators | undefined;
   notifyBlur: (name: DeepKeys<TFieldValues>) => void;
-  parseValues: (values: TFieldValues) => unknown;
+  parseValues: (values: TFieldValues) => TTransformedValues;
   subscribeBlur: (listener: (name: DeepKeys<TFieldValues>) => void) => () => void;
-  handleSubmit: (onValid: FormSubmitHandler<any>, onInvalid?: FormSubmitErrorHandler<TFieldValues>) => (event?: {
+  handleSubmit: (onValid: FormSubmitHandler<TTransformedValues>, onInvalid?: FormSubmitErrorHandler<TFieldValues>) => (event?: {
     preventDefault?: () => void;
     stopPropagation?: () => void;
   }) => Promise<void>;
 };
 type AsyncDefaultValues<TFieldValues> = (payload?: unknown) => Promise<TFieldValues>;
 type NullableDefaults<T> = T extends Date | File | Blob ? T : T extends Array<infer TItem> ? Array<NullableDefaults<TItem>> : T extends object ? { [K in keyof T]?: NullableDefaults<T[K]> | null; } : T | null;
-interface UseFormProps<TFieldValues, TTransformedValues = TFieldValues> {
+interface BaseUseFormProps<TFieldValues, TTransformedValues = TFieldValues> {
   /** Initial form values. Changes after mount are ignored; use `form.reset()` to replace form values. */
   defaultValues?: NullableDefaults<TFieldValues> | AsyncDefaultValues<TFieldValues>;
   disabled?: boolean;
@@ -36,16 +36,16 @@ interface UseFormProps<TFieldValues, TTransformedValues = TFieldValues> {
   }) => Promise<unknown>;
   zodSchema?: z.ZodType<TTransformedValues, TFieldValues>;
 }
-declare function useForm<TSchema extends z.ZodType<Record<string, unknown>, Record<string, unknown>>, _TContext = unknown>(props: UseFormProps<z.input<TSchema>, z.output<TSchema>> & {
+/** A distinct parsed output requires the schema that produces it. */
+type UseFormProps<TFieldValues, TTransformedValues = TFieldValues> = BaseUseFormProps<TFieldValues, TTransformedValues> & ([TFieldValues] extends [TTransformedValues] ? unknown : {
+  zodSchema: z.ZodType<TTransformedValues, TFieldValues>;
+});
+type UseFormArguments<TFieldValues, TTransformedValues> = [TFieldValues] extends [TTransformedValues] ? [props?: UseFormProps<TFieldValues, TTransformedValues>] : [props: UseFormProps<TFieldValues, TTransformedValues>];
+declare function useForm<TSchema extends z.ZodType<unknown, Record<string, unknown>>>(props: UseFormProps<z.input<NoInfer<TSchema>>, z.output<NoInfer<TSchema>>> & {
   zodSchema: TSchema;
-}): UIForm<z.input<TSchema>>;
-declare function useForm<TFieldValues extends Record<string, unknown> = Record<string, unknown>, _TContext = unknown, TTransformedValues = TFieldValues>(props?: UseFormProps<TFieldValues, TTransformedValues>): UIForm<TFieldValues>;
-declare const useFormValue: <TFieldValues extends Record<string, unknown>, TSelected>(form: UIForm<TFieldValues>, selector: (values: TFieldValues) => TSelected) => TSelected;
-declare const useFormState: <TFieldValues extends Record<string, unknown>, TSelected>(form: UIForm<TFieldValues>, selector: (state: UIForm<TFieldValues>["state"]) => TSelected) => TSelected;
+}): UIForm<z.input<TSchema>, z.output<TSchema>>;
+declare function useForm<TFieldValues extends Record<string, unknown> = Record<string, unknown>, TTransformedValues = TFieldValues>(...args: UseFormArguments<TFieldValues, TTransformedValues>): UIForm<TFieldValues, TTransformedValues>;
+declare const useFormValue: <TFieldValues extends Record<string, unknown>, TSelected>(form: UIForm<TFieldValues, unknown>, selector: (values: TFieldValues) => TSelected) => TSelected;
+declare const useFormState: <TFieldValues extends Record<string, unknown>, TSelected>(form: UIForm<TFieldValues, unknown>, selector: (state: UIForm<TFieldValues>["state"]) => TSelected) => TSelected;
 //#endregion
-//#region src/components/inputs/shared/form.binding.d.ts
-type FieldValues = Record<string, any>;
-type FieldPath<TFieldValues extends FieldValues> = DeepKeys<TFieldValues>;
-type FormInstance<TFieldValues extends FieldValues> = UIForm<TFieldValues>;
-//#endregion
-export { DeepValue as a, UIForm as c, useFormState as d, useFormValue as f, DeepKeys as i, UseFormProps as l, FieldValues as n, FormSubmitErrorHandler as o, FormInstance as r, FormSubmitHandler as s, FieldPath as t, useForm as u };
+export { UIForm as a, useFormState as c, FormSubmitHandler as i, useFormValue as l, DeepValue as n, UseFormProps as o, FormSubmitErrorHandler as r, useForm as s, DeepKeys as t };

package/dist/{form.binding-CG1RPv6o.js → useForm-eW4KpH1u.js}

@@ -1,8 +1,67 @@
+import { t as logger } from "./logger-CqZjM-sn.js";
+import { n as ObjectUtils, t as isEqual } from "./isEqual-LFw0W5rU.js";
 import { useEffect, useLayoutEffect, useMemo, useRef } from "react";
 import { c } from "react/compiler-runtime";
-import { jsx } from "react/jsx-runtime";
-import { useForm, useStore } from "@tanstack/react-form";
+import { getBy, setBy, useForm, useStore } from "@tanstack/react-form";
 import { Store } from "@tanstack/store";
+//#region src/hooks/autosaveFields.ts
+/** Raw fields edited since a submitted snapshot. Arrays and dates are replaced whole. */
+function getChangedAutosaveFields(current, submitted, path = "") {
+	if (isEqual(current, submitted)) return [];
+	if (!ObjectUtils.isObject(current) || Array.isArray(current) || ObjectUtils.isDate(current) || ObjectUtils.isRegExp(current) || ObjectUtils.isEmpty(current)) return [[path, current]];
+	const values = current;
+	const previous = ObjectUtils.isObject(submitted) ? submitted : {};
+	return [.../* @__PURE__ */ new Set([...Object.keys(values), ...Object.keys(previous)])].flatMap((key) => getChangedAutosaveFields(values[key], previous[key], path ? `${path}.${key}` : key));
+}
+/** Select raw field paths included by a parsed patch, stopping at atomic raw fields. */
+function getSubmittedAutosaveFields(patch, raw, path = "") {
+	if (!ObjectUtils.isObject(raw) || Array.isArray(raw) || ObjectUtils.isDate(raw) || ObjectUtils.isRegExp(raw) || !ObjectUtils.isObject(patch) || Array.isArray(patch)) return [[path, raw]];
+	return Object.entries(patch).flatMap(([key, value]) => getSubmittedAutosaveFields(value, raw[key], path ? `${path}.${key}` : key));
+}
+/** Project raw changes into parsed values, retaining explicit undefined clears. */
+function getAutosavePatch(parsed, changes) {
+	let patch = {};
+	for (const [path] of changes) {
+		if (!path) return parsed;
+		patch = setBy(patch, path, getBy(parsed, path));
+	}
+	return patch;
+}
+//#endregion
+//#region src/hooks/formReset.ts
+const listeners = /* @__PURE__ */ new WeakMap();
+const refreshing = /* @__PURE__ */ new WeakSet();
+const versions = /* @__PURE__ */ new WeakMap();
+function getFormResetVersion(form) {
+	return versions.get(form) ?? 0;
+}
+function subscribeFormReset(form, listener) {
+	let callbacks = listeners.get(form);
+	if (!callbacks) {
+		callbacks = /* @__PURE__ */ new Set();
+		listeners.set(form, callbacks);
+	}
+	callbacks.add(listener);
+	return () => callbacks.delete(listener);
+}
+function notifyFormReset(form) {
+	if (refreshing.has(form)) return;
+	versions.set(form, getFormResetVersion(form) + 1);
+	listeners.get(form)?.forEach((listener) => listener());
+}
+function refreshAutosaveForm(form, baseline, refresh, acknowledged = []) {
+	refreshing.add(form);
+	try {
+		refresh();
+	} finally {
+		refreshing.delete(form);
+	}
+	listeners.get(form)?.forEach((listener) => listener({
+		baseline,
+		acknowledged
+	}));
+}
+//#endregion
 //#region src/hooks/useForm.ts
 const disabledStores = /* @__PURE__ */ new WeakMap();
 function useForm$1({ defaultValues, disabled = false, mode = "onSubmit", onSubmitAsync, zodSchema } = {}) {
@@ -82,6 +141,7 @@ function useForm$1({ defaultValues, disabled = false, mode = "onSubmit", onSubmi
 		touchedFieldsRef.current.clear();
 		if (args[0] !== void 0 && !args[1]?.keepDefaultValues) defaultValuesRef.current = args[0];
 		originalReset(...args);
+		notifyFormReset(uiForm);
 	};
 	uiForm.subscribeBlur = (listener_0) => {
 		blurListenersRef.current.add(listener_0);
@@ -95,7 +155,22 @@ function useForm$1({ defaultValues, disabled = false, mode = "onSubmit", onSubmi
 		await originalHandleSubmit();
 	};
 	useEffect(() => {
-		if (typeof initialDefaultValues === "function") initialDefaultValues().then((values_0) => form.reset(values_0));
+		let active = true;
+		const revision = getFormResetVersion(form);
+		const valuesAtLoad = structuredClone(form.state.values);
+		if (typeof initialDefaultValues === "function") initialDefaultValues().then((values_0) => {
+			if (!active || revision !== getFormResetVersion(form)) return;
+			const edits = getChangedAutosaveFields(form.state.values, valuesAtLoad);
+			form.reset(values_0);
+			for (const [path, value_3] of edits) {
+				if (!path) continue;
+				const name_1 = path;
+				form.setFieldValue(name_1, value_3);
+			}
+		}).catch((error) => logger.warn("Unable to load form defaults", error));
+		return () => {
+			active = false;
+		};
 	}, [form, initialDefaultValues]);
 	useLayoutEffect(() => {
 		if (disabledStore.state !== disabled) disabledStore.setState(() => disabled);
@@ -139,42 +214,4 @@ const getSchemaAtPath = (rootSchema, path) => {
 const parsePath = (path) => path.replaceAll("[", ".").replaceAll("]", "").split(".").filter(Boolean).map((segment) => /^\d+$/.test(segment) ? Number(segment) : segment);
 const pathToString = (path) => path.reduce((result, segment) => typeof segment === "number" ? `${result}[${segment}]` : result ? `${result}.${String(segment)}` : String(segment), "");
 //#endregion
-//#region src/components/inputs/shared/form.types.ts
-const getFieldError = (errors) => errors.flatMap((error) => {
-	if (typeof error === "string") return [error];
-	if (error && typeof error === "object" && "message" in error) return [String(error.message)];
-	return [];
-}).at(0);
-//#endregion
-//#region src/components/inputs/shared/form.binding.tsx
-function FieldController({ control: form, name, render }) {
-	const isFormDisabled = useFormDisabled(form);
-	const submissionAttempts = useFormState(form, (state) => state.submissionAttempts);
-	return /* @__PURE__ */ jsx(form.Field, {
-		name,
-		validators: form.getFieldValidators(name),
-		children: (field) => {
-			const validators = form.getFieldValidators(name);
-			const validationError = submissionAttempts > 0 ? getFieldError(field.state.meta.errors) : validators?.onChange && field.state.meta.isDirty ? validators.onChange({ value: field.state.value }) : validators?.onBlur && field.state.meta.isTouched ? validators.onBlur({ value: field.state.value }) : void 0;
-			return render({
-				field: {
-					disabled: isFormDisabled,
-					name: field.name,
-					onBlur: () => {
-						field.handleBlur();
-						form.notifyBlur(name);
-					},
-					onChange: field.handleChange,
-					ref: () => void 0,
-					value: field.state.value
-				},
-				fieldState: {
-					error: validationError ? { message: validationError } : void 0,
-					isDirty: field.state.meta.isDirty
-				}
-			});
-		}
-	});
-}
-//#endregion
-export { useFormValue as i, useForm$1 as n, useFormState as r, FieldController as t };
+export { getFormResetVersion as a, getAutosavePatch as c, useFormValue as i, getChangedAutosaveFields as l, useFormDisabled as n, refreshAutosaveForm as o, useFormState as r, subscribeFormReset as s, useForm$1 as t, getSubmittedAutosaveFields as u };