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

package/dist/useFormAutosave-BBLm3Ujo.d.ts

@@ -0,0 +1,34 @@
+import { a as UIForm, o as UseFormProps } from "./useForm-I6z23FXf.js";
+import { DependencyList } from "react";
+//#region src/hooks/useAutosave.d.ts
+type MissingOutputKeys<TInput, TOutput> = TInput extends Date | RegExp | readonly unknown[] ? never : TInput extends object ? TOutput extends object ? { [K in keyof TInput]-?: K extends keyof TOutput ? MissingOutputKeys<NonNullable<TInput[K]>, NonNullable<TOutput[K]>> : K; }[keyof TInput] : keyof TInput : never;
+/** Changed object paths are recursive patches; arrays, dates and regular expressions are replaced whole. */
+type AutosavePatch<T> = T extends Date | RegExp | readonly unknown[] ? T : T extends object ? { [K in keyof T]?: AutosavePatch<T[K]>; } : T;
+type AutosaveHandler<TInput, TOutput, TResponse> = [TOutput] extends [object] ? [MissingOutputKeys<TInput, TOutput>] extends [never] ? (data: AutosavePatch<TOutput>) => Promise<TResponse> : never : never;
+interface UseAutosaveProps<TFieldValues extends Record<string, unknown>, TTransformedValues = TFieldValues, TResponse = unknown> {
+  form: UIForm<TFieldValues, TTransformedValues>;
+  delay?: number;
+  enabled?: boolean;
+  trigger?: "change" | "blur";
+  /** Parsed output must remain an object preserving every raw field path; optional output fields are supported. */
+  onSave: AutosaveHandler<TFieldValues, TTransformedValues, TResponse>;
+  onSaveSuccess?: () => void;
+}
+/** Autosaves changed fields only. Schemas must preserve raw field paths in their object output. */
+declare function useAutosave<TFieldValues extends Record<string, unknown>, TTransformedValues = TFieldValues, TResponse = unknown>({ form, delay, enabled, trigger, onSave, onSaveSuccess }: UseAutosaveProps<TFieldValues, TTransformedValues, TResponse>): void;
+//#endregion
+//#region src/hooks/useFormAutosave.d.ts
+type UseFormAutosaveProps<TFieldValues extends Record<string, unknown> = Record<string, unknown>, TTransformedValues = TFieldValues, TResponse = unknown> = Omit<UseFormProps<TFieldValues, TTransformedValues>, "defaultValues"> & {
+  autosaveDelay?: UseAutosaveProps<TFieldValues, TTransformedValues, TResponse>["delay"];
+  enableAutosave?: UseAutosaveProps<TFieldValues, TTransformedValues, TResponse>["enabled"];
+  autosaveOn?: UseAutosaveProps<TFieldValues, TTransformedValues, TResponse>["trigger"];
+  normalizeAutosaveData?: (data: AutosavePatch<NoInfer<TTransformedValues>>) => AutosavePatch<NoInfer<TTransformedValues>> | undefined;
+  onAutosave: UseAutosaveProps<TFieldValues, TTransformedValues, TResponse>["onSave"];
+  getResetValues: () => UseFormProps<TFieldValues, TTransformedValues>["defaultValues"];
+  resetDeps: DependencyList;
+  resetTimeout?: number;
+};
+/** Autosave schemas must produce objects preserving every raw field path, including optional fields. */
+declare function useFormAutosave<TFieldValues extends Record<string, unknown> = Record<string, unknown>, TTransformedValues = TFieldValues, TResponse = unknown>({ autosaveDelay, enableAutosave, autosaveOn, normalizeAutosaveData, onAutosave, getResetValues, resetDeps, resetTimeout, ...props }: UseFormAutosaveProps<TFieldValues, TTransformedValues, TResponse>): UIForm<TFieldValues, TTransformedValues>;
+//#endregion
+export { UseAutosaveProps as a, AutosavePatch as i, useFormAutosave as n, useAutosave as o, AutosaveHandler as r, UseFormAutosaveProps as t };

package/dist/useFormAutosave-XEQqk1lK.js

@@ -0,0 +1,216 @@
+import { t as logger } from "./logger-CqZjM-sn.js";
+import { n as ObjectUtils, t as isEqual } from "./isEqual-LFw0W5rU.js";
+import { a as getFormResetVersion, c as getAutosavePatch, l as getChangedAutosaveFields, o as refreshAutosaveForm, s as subscribeFormReset, t as useForm$1, u as getSubmittedAutosaveFields } from "./useForm-eW4KpH1u.js";
+import { useCallback, useEffect, useRef } from "react";
+import { getBy, setBy } from "@tanstack/react-form";
+//#region src/hooks/useAutosave.ts
+const snapshot = (value) => structuredClone(value);
+/** Autosaves changed fields only. Schemas must preserve raw field paths in their object output. */
+function useAutosave({ form, delay = 500, enabled = true, trigger = "change", onSave, onSaveSuccess }) {
+	const timeoutRef = useRef(void 0);
+	const savedSnapshotRef = useRef(snapshot(form.state.values));
+	const saveQueueRef = useRef(Promise.resolve());
+	const acknowledgedFieldsRef = useRef(/* @__PURE__ */ new Map());
+	const resetRevisionRef = useRef(getFormResetVersion(form));
+	const latestSaveRef = useRef({
+		onSave,
+		onSaveSuccess
+	});
+	latestSaveRef.current = {
+		onSave,
+		onSaveSuccess
+	};
+	useEffect(() => {
+		let active = true;
+		const clearPending = () => {
+			if (timeoutRef.current) {
+				clearTimeout(timeoutRef.current);
+				timeoutRef.current = void 0;
+			}
+		};
+		const queueSave = () => {
+			if (!enabled) return;
+			clearPending();
+			const revision = resetRevisionRef.current;
+			timeoutRef.current = setTimeout(() => {
+				saveQueueRef.current = saveQueueRef.current.then(async () => {
+					if (!active || revision !== resetRevisionRef.current) return;
+					const valuesAtSaveTime = snapshot(form.state.values);
+					const previousSavedValues = savedSnapshotRef.current;
+					const changedFields = getChangedAutosaveFields(valuesAtSaveTime, previousSavedValues);
+					if (changedFields.length === 0) return;
+					let transformedValues;
+					try {
+						transformedValues = form.parseValues(valuesAtSaveTime);
+					} catch {
+						return;
+					}
+					const payload = getAutosavePatch(transformedValues, changedFields);
+					if (ObjectUtils.isEmpty(payload)) return;
+					acknowledgedFieldsRef.current.clear();
+					try {
+						await latestSaveRef.current.onSave(payload);
+						if (!active || revision !== resetRevisionRef.current) return;
+						for (const [path, value] of getChangedAutosaveFields(valuesAtSaveTime, previousSavedValues)) {
+							if (acknowledgedFieldsRef.current.has(path) && isEqual(acknowledgedFieldsRef.current.get(path), value)) continue;
+							savedSnapshotRef.current = setBy(savedSnapshotRef.current, path, value);
+						}
+						for (const name of Object.keys(form.state.fieldMeta)) {
+							const submittedValue = getBy(valuesAtSaveTime, name);
+							if (!isEqual(getBy(previousSavedValues, name), submittedValue) && isEqual(form.getFieldValue(name), submittedValue)) form.setFieldMeta(name, (meta) => ({
+								...meta,
+								isDirty: false
+							}));
+						}
+						latestSaveRef.current.onSaveSuccess?.();
+					} catch {}
+				});
+			}, delay);
+		};
+		const unsubscribeStore = trigger === "change" ? form.store.subscribe(() => {
+			if (!isEqual(form.state.values, savedSnapshotRef.current)) queueSave();
+		}) : void 0;
+		const unsubscribeBlur = trigger === "blur" ? form.subscribeBlur(queueSave) : void 0;
+		const syncReset = (refresh) => {
+			if (refresh) {
+				for (const [path_0, value_0] of refresh.acknowledged) acknowledgedFieldsRef.current.set(path_0, value_0);
+				savedSnapshotRef.current = snapshot(refresh.baseline);
+				return;
+			}
+			resetRevisionRef.current = getFormResetVersion(form);
+			acknowledgedFieldsRef.current.clear();
+			clearPending();
+			savedSnapshotRef.current = snapshot(form.state.values);
+		};
+		if (resetRevisionRef.current !== getFormResetVersion(form)) syncReset();
+		const unsubscribeReset = subscribeFormReset(form, syncReset);
+		return () => {
+			active = false;
+			clearPending();
+			unsubscribeStore?.unsubscribe();
+			unsubscribeBlur?.();
+			unsubscribeReset();
+		};
+	}, [
+		delay,
+		enabled,
+		form,
+		trigger
+	]);
+}
+//#endregion
+//#region src/hooks/useFormAutosave.ts
+const getResetTimeoutErrorMessage = (resetTimeout) => `Form Reset Timeout (${resetTimeout}ms) - Action Required
+Problem: Form values weren't reset after submission.
+
+Likely causes:
+• Missing variables in reset dependency array
+• Reset dependencies not updating after form save
+• Async operations blocking timely reset
+
+Solutions:
+1. Ensure reset dependencies include all relevant state variables
+2. Confirm your submission handler updates state properly (check query invalidation)
+3. For slower operations, consider increasing the timeout threshold`;
+/** Autosave schemas must produce objects preserving every raw field path, including optional fields. */
+function useFormAutosave({ autosaveDelay, enableAutosave, autosaveOn = "change", normalizeAutosaveData, onAutosave, getResetValues, resetDeps, resetTimeout = 5e3, ...props }) {
+	const initialValues = getResetValues();
+	const form = useForm$1(...[{
+		...props,
+		defaultValues: typeof initialValues === "function" ? void 0 : initialValues
+	}]);
+	const serverBaselineRef = useRef(structuredClone(form.state.values));
+	const pendingRefreshesRef = useRef([]);
+	const resetFormValuesTimeoutRef = useRef(void 0);
+	useEffect(() => {
+		const clearRefreshes = () => {
+			pendingRefreshesRef.current = [];
+			if (resetFormValuesTimeoutRef.current) clearTimeout(resetFormValuesTimeoutRef.current);
+		};
+		const unsubscribe = subscribeFormReset(form, (refresh) => {
+			if (!refresh) {
+				serverBaselineRef.current = structuredClone(form.state.values);
+				clearRefreshes();
+			}
+		});
+		return () => {
+			unsubscribe();
+			clearRefreshes();
+		};
+	}, [form]);
+	useEffect(() => {
+		const resetValues = getResetValues();
+		if (resetValues === void 0) return;
+		let active = true;
+		const revision = getFormResetVersion(form);
+		const resetFormValues = async () => {
+			let values;
+			if (ObjectUtils.isFunction(resetValues)) values = await resetValues();
+			else values = resetValues;
+			if (!active || revision !== getFormResetVersion(form)) return;
+			const refreshedIndex = Math.max(0, pendingRefreshesRef.current.findLastIndex((pending) => pending.completed));
+			const submitted = pendingRefreshesRef.current[refreshedIndex];
+			pendingRefreshesRef.current.splice(0, refreshedIndex + 1);
+			const edits = getChangedAutosaveFields(form.state.values, submitted?.values ?? serverBaselineRef.current);
+			serverBaselineRef.current = structuredClone(values);
+			for (const pending_0 of pendingRefreshesRef.current) {
+				pending_0.values = structuredClone(values);
+				for (const [path, value] of pending_0.fields) pending_0.values = setBy(pending_0.values, path, value);
+			}
+			const applyRefresh = () => {
+				form.reset(values);
+				for (const [path_0, value_0] of edits) {
+					const name = path_0;
+					form.setFieldValue(name, value_0);
+				}
+			};
+			refreshAutosaveForm(form, values, applyRefresh, submitted?.fields);
+			if (pendingRefreshesRef.current.length === 0 && resetFormValuesTimeoutRef.current) clearTimeout(resetFormValuesTimeoutRef.current);
+		};
+		resetFormValues().catch((error) => logger.warn("Unable to refresh autosave form", error));
+		return () => {
+			active = false;
+		};
+	}, [...resetDeps]);
+	const prepareForSaveReset = () => {
+		if (resetFormValuesTimeoutRef.current) clearTimeout(resetFormValuesTimeoutRef.current);
+		resetFormValuesTimeoutRef.current = setTimeout(() => {
+			if (pendingRefreshesRef.current.length > 0) logger.warn(getResetTimeoutErrorMessage(resetTimeout));
+		}, resetTimeout);
+	};
+	useAutosave({
+		form,
+		delay: autosaveDelay,
+		enabled: enableAutosave,
+		trigger: autosaveOn,
+		onSave: useCallback(async (data) => {
+			const normalizedData = normalizeAutosaveData ? normalizeAutosaveData(data) : data;
+			if (!normalizedData || ObjectUtils.isEmpty(normalizedData)) return;
+			const values_0 = structuredClone(form.state.values);
+			const submitted_0 = {
+				values: values_0,
+				fields: getSubmittedAutosaveFields(normalizedData, values_0),
+				completed: false
+			};
+			pendingRefreshesRef.current.push(submitted_0);
+			prepareForSaveReset();
+			try {
+				const response = await onAutosave(normalizedData);
+				submitted_0.completed = true;
+				pendingRefreshesRef.current = pendingRefreshesRef.current.filter((pending_2) => !pending_2.completed || pending_2 === submitted_0);
+				return response;
+			} catch (error_0) {
+				pendingRefreshesRef.current = pendingRefreshesRef.current.filter((pending_1) => pending_1 !== submitted_0);
+				if (pendingRefreshesRef.current.length === 0 && resetFormValuesTimeoutRef.current) clearTimeout(resetFormValuesTimeoutRef.current);
+				throw error_0;
+			}
+		}, [
+			normalizeAutosaveData,
+			onAutosave,
+			resetTimeout
+		])
+	});
+	return form;
+}
+//#endregion
+export { useAutosave as n, useFormAutosave as t };

package/dist/useStaticInputHandoff-DyYxfwv6.js

@@ -0,0 +1,77 @@
+import { useLayoutEffect, useRef, useState } from "react";
+import { useFocusRing as $32daac5f69beb98a$re_export$useFocusRing } from "react-aria/useFocusRing";
+import "react-aria/FocusScope";
+import "react-aria/private/interactions/focusSafely";
+import "react-aria/private/utils/isFocusable";
+import "react-aria/private/interactions/useFocusable";
+import "react-aria/Focusable";
+import { getFocusableTreeWalker as $32daac5f69beb98a$re_export$getFocusableTreeWalker } from "react-aria/private/focus/FocusScope";
+import "react-aria/FocusRing";
+import "react-aria/private/focus/useHasTabbableChild";
+import "react-aria/private/focus/virtualFocus";
+import "react-aria/useFocusable";
+//#region src/components/inputs/shared/useStaticInputHandoff.ts
+const useStaticInputHandoff = ({ inputRef, renderInput, setRenderInput, getFocusTarget, getPressTarget }) => {
+	const [shouldFocus, setShouldFocus] = useState(false);
+	const pendingStaticChangeRef = useRef(null);
+	const pendingStaticFocusTargetRef = useRef(null);
+	const focusFromEndRef = useRef(false);
+	const shouldReplayStaticPressRef = useRef(false);
+	useLayoutEffect(() => {
+		if (!renderInput || !shouldFocus) return;
+		const input = inputRef.current;
+		if (!input) return;
+		const pendingValue = pendingStaticChangeRef.current;
+		const focusTarget = getFocusTarget?.(input, pendingStaticFocusTargetRef.current, focusFromEndRef.current) ?? (input instanceof HTMLElement ? getStaticInputFocusTarget(input, focusFromEndRef.current) : input);
+		const replayPress = shouldReplayStaticPressRef.current;
+		pendingStaticChangeRef.current = null;
+		pendingStaticFocusTargetRef.current = null;
+		shouldReplayStaticPressRef.current = false;
+		setShouldFocus(false);
+		if (focusTarget instanceof HTMLInputElement && pendingValue != null) {
+			(Object.getOwnPropertyDescriptor(window.HTMLInputElement.prototype, "value")?.set)?.call(focusTarget, pendingValue);
+			focusTarget.dispatchEvent(new Event("input", { bubbles: true }));
+		}
+		focusTarget?.focus();
+		if (replayPress) (getPressTarget?.(input) ?? focusTarget)?.click();
+	}, [
+		getFocusTarget,
+		getPressTarget,
+		inputRef,
+		renderInput,
+		shouldFocus
+	]);
+	return {
+		renderRealInput: (focus, target, fromEnd = false) => {
+			if (!focus && shouldFocus) return;
+			focusFromEndRef.current = fromEnd;
+			pendingStaticFocusTargetRef.current = target ?? null;
+			setShouldFocus(focus);
+			setRenderInput(true);
+		},
+		replayStaticInputChange: (value) => {
+			pendingStaticChangeRef.current = value;
+			setShouldFocus(true);
+			setRenderInput(true);
+		},
+		replayStaticInputPress: () => {
+			shouldReplayStaticPressRef.current = true;
+			setShouldFocus(true);
+			setRenderInput(true);
+		}
+	};
+};
+const getStaticInputFocusTarget = (container, fromEnd = false) => {
+	const walker = $32daac5f69beb98a$re_export$getFocusableTreeWalker(container, { tabbable: true });
+	let target = walker.nextNode();
+	if (fromEnd) {
+		let next = walker.nextNode();
+		while (next) {
+			target = next;
+			next = walker.nextNode();
+		}
+	}
+	return target ?? container;
+};
+//#endregion
+export { useStaticInputHandoff as n, $32daac5f69beb98a$re_export$useFocusRing as r, getStaticInputFocusTarget as t };