@povio/ui 5.0.0-rc.9 → 6.0.0-rc.2

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 };

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 };