@povio/ui 3.4.0-rc.9 → 4.0.0-rc.2

package/dist/focusSafely-BDIcvqPb.js

@@ -0,0 +1,437 @@
+import { n as $caaf0dd3060ed57c$export$95185d699e05d4d7, r as $1969ac565cfec8d0$export$de79e2c695e052f3 } from "./openLink-BrfLaWo4.js";
+import { a as $d447af545b77c9f1$export$b204af158042fbac, i as $23f2114a1b82827e$export$e58f029f0fbfdb29, o as $d447af545b77c9f1$export$f21a1ffae260145a, r as $23f2114a1b82827e$export$cd4e5573fbe2b576, t as $c4867b2f328c2698$export$e5c5a5f917a5871c } from "./useLayoutEffect-DN7Dbrb9.js";
+import { a as $2add3ce32c6007eb$export$a11b0059900ceec8, i as $2add3ce32c6007eb$export$9ac100e40613ea10 } from "./platform-3R53zj-n.js";
+import $ahdqC$react, { useCallback, useContext, useRef, useState } from "react";
+//#region ../../node_modules/.bun/react-aria@3.51.0+67f6792bdf102c28/node_modules/react-aria/dist/private/utils/isElementVisible.mjs
+const $ae77152785188400$var$supportsCheckVisibility = typeof Element !== "undefined" && "checkVisibility" in Element.prototype;
+function $ae77152785188400$var$isStyleVisible(element) {
+	const windowObject = $d447af545b77c9f1$export$f21a1ffae260145a(element);
+	if (!(element instanceof windowObject.HTMLElement) && !(element instanceof windowObject.SVGElement)) return false;
+	let { display, visibility } = element.style;
+	let isVisible = display !== "none" && visibility !== "hidden" && visibility !== "collapse";
+	if (isVisible) {
+		const { getComputedStyle } = $d447af545b77c9f1$export$f21a1ffae260145a(element);
+		let { display: computedDisplay, visibility: computedVisibility } = getComputedStyle(element);
+		isVisible = computedDisplay !== "none" && computedVisibility !== "hidden" && computedVisibility !== "collapse";
+	}
+	return isVisible;
+}
+function $ae77152785188400$var$isAttributeVisible(element, childElement) {
+	return !element.hasAttribute("hidden") && !element.hasAttribute("data-react-aria-prevent-focus") && (element.nodeName === "DETAILS" && childElement && childElement.nodeName !== "SUMMARY" ? element.hasAttribute("open") : true);
+}
+function $ae77152785188400$export$e989c0fffaa6b27a(element, childElement) {
+	if ($ae77152785188400$var$supportsCheckVisibility) return element.checkVisibility({ visibilityProperty: true }) && !element.closest("[data-react-aria-prevent-focus]");
+	return element.nodeName !== "#comment" && $ae77152785188400$var$isStyleVisible(element) && $ae77152785188400$var$isAttributeVisible(element, childElement) && (!element.parentElement || $ae77152785188400$export$e989c0fffaa6b27a(element.parentElement, element));
+}
+//#endregion
+//#region ../../node_modules/.bun/react-aria@3.51.0+67f6792bdf102c28/node_modules/react-aria/dist/private/utils/isFocusable.mjs
+const $3b8b240c1bf84ab9$var$focusableElements = [
+	"input:not([disabled]):not([type=hidden])",
+	"select:not([disabled])",
+	"textarea:not([disabled])",
+	"button:not([disabled])",
+	"a[href]",
+	"area[href]",
+	"summary",
+	"iframe",
+	"object",
+	"embed",
+	"audio[controls]",
+	"video[controls]",
+	"[contenteditable]:not([contenteditable^=\"false\"])",
+	"permission"
+];
+const $3b8b240c1bf84ab9$var$FOCUSABLE_ELEMENT_SELECTOR = $3b8b240c1bf84ab9$var$focusableElements.join(":not([hidden]),") + ",[tabindex]:not([disabled]):not([hidden])";
+$3b8b240c1bf84ab9$var$focusableElements.push("[tabindex]:not([tabindex=\"-1\"]):not([disabled])");
+const $3b8b240c1bf84ab9$var$TABBABLE_ELEMENT_SELECTOR = $3b8b240c1bf84ab9$var$focusableElements.join(":not([hidden]):not([tabindex=\"-1\"]),");
+function $3b8b240c1bf84ab9$export$4c063cf1350e6fed(element, options) {
+	return element.matches($3b8b240c1bf84ab9$var$FOCUSABLE_ELEMENT_SELECTOR) && !$3b8b240c1bf84ab9$var$isInert(element) && (options?.skipVisibilityCheck || $ae77152785188400$export$e989c0fffaa6b27a(element));
+}
+function $3b8b240c1bf84ab9$export$bebd5a1431fec25d(element) {
+	return element.matches($3b8b240c1bf84ab9$var$TABBABLE_ELEMENT_SELECTOR) && $ae77152785188400$export$e989c0fffaa6b27a(element) && !$3b8b240c1bf84ab9$var$isInert(element);
+}
+function $3b8b240c1bf84ab9$var$isInert(element) {
+	let node = element;
+	while (node != null) {
+		if (node instanceof $d447af545b77c9f1$export$f21a1ffae260145a(node).HTMLElement && node.inert) return true;
+		node = node.parentElement;
+	}
+	return false;
+}
+//#endregion
+//#region ../../node_modules/.bun/react-aria@3.51.0+67f6792bdf102c28/node_modules/react-aria/dist/private/interactions/utils.mjs
+function $a92dc41f639950be$export$525bc4921d56d4a(nativeEvent) {
+	let event = nativeEvent;
+	event.nativeEvent = nativeEvent;
+	event.isDefaultPrevented = () => event.defaultPrevented;
+	event.isPropagationStopped = () => event.cancelBubble;
+	event.persist = () => {};
+	return event;
+}
+function $a92dc41f639950be$export$c2b7abe5d61ec696(event, target) {
+	Object.defineProperty(event, "target", { value: target });
+	Object.defineProperty(event, "currentTarget", { value: target });
+}
+function $a92dc41f639950be$export$715c682d09d639cc(onBlur) {
+	let stateRef = useRef({
+		isFocused: false,
+		observer: null
+	});
+	$c4867b2f328c2698$export$e5c5a5f917a5871c(() => {
+		const state = stateRef.current;
+		return () => {
+			if (state.observer) {
+				state.observer.disconnect();
+				state.observer = null;
+			}
+		};
+	}, []);
+	return useCallback((e) => {
+		let eventTarget = $23f2114a1b82827e$export$e58f029f0fbfdb29(e);
+		if (eventTarget instanceof HTMLButtonElement || eventTarget instanceof HTMLInputElement || eventTarget instanceof HTMLTextAreaElement || eventTarget instanceof HTMLSelectElement) {
+			stateRef.current.isFocused = true;
+			let target = eventTarget;
+			let onBlurHandler = (e) => {
+				stateRef.current.isFocused = false;
+				if (target.disabled) {
+					let event = $a92dc41f639950be$export$525bc4921d56d4a(e);
+					onBlur?.(event);
+				}
+				if (stateRef.current.observer) {
+					stateRef.current.observer.disconnect();
+					stateRef.current.observer = null;
+				}
+			};
+			target.addEventListener("focusout", onBlurHandler, { once: true });
+			stateRef.current.observer = new MutationObserver(() => {
+				if (stateRef.current.isFocused && target.disabled) {
+					stateRef.current.observer?.disconnect();
+					let relatedTargetEl = target === $23f2114a1b82827e$export$cd4e5573fbe2b576() ? null : $23f2114a1b82827e$export$cd4e5573fbe2b576();
+					target.dispatchEvent(new FocusEvent("blur", { relatedTarget: relatedTargetEl }));
+					target.dispatchEvent(new FocusEvent("focusout", {
+						bubbles: true,
+						relatedTarget: relatedTargetEl
+					}));
+				}
+			});
+			stateRef.current.observer.observe(target, {
+				attributes: true,
+				attributeFilter: ["disabled"]
+			});
+		}
+	}, [onBlur]);
+}
+let $a92dc41f639950be$export$fda7da73ab5d4c48 = false;
+function $a92dc41f639950be$export$cabe61c495ee3649(target) {
+	while (target && !$3b8b240c1bf84ab9$export$4c063cf1350e6fed(target, { skipVisibilityCheck: true })) target = target.parentElement;
+	let ownerWindow = $d447af545b77c9f1$export$f21a1ffae260145a(target);
+	let activeElement = ownerWindow.document.activeElement;
+	if (!activeElement || activeElement === target) return;
+	$a92dc41f639950be$export$fda7da73ab5d4c48 = true;
+	let isRefocusing = false;
+	let onBlur = (e) => {
+		if ($23f2114a1b82827e$export$e58f029f0fbfdb29(e) === activeElement || isRefocusing) e.stopImmediatePropagation();
+	};
+	let onFocusOut = (e) => {
+		if ($23f2114a1b82827e$export$e58f029f0fbfdb29(e) === activeElement || isRefocusing) {
+			e.stopImmediatePropagation();
+			if (!target && !isRefocusing) {
+				isRefocusing = true;
+				$1969ac565cfec8d0$export$de79e2c695e052f3(activeElement);
+				cleanup();
+			}
+		}
+	};
+	let onFocus = (e) => {
+		if ($23f2114a1b82827e$export$e58f029f0fbfdb29(e) === target || isRefocusing) e.stopImmediatePropagation();
+	};
+	let onFocusIn = (e) => {
+		if ($23f2114a1b82827e$export$e58f029f0fbfdb29(e) === target || isRefocusing) {
+			e.stopImmediatePropagation();
+			if (!isRefocusing) {
+				isRefocusing = true;
+				$1969ac565cfec8d0$export$de79e2c695e052f3(activeElement);
+				cleanup();
+			}
+		}
+	};
+	ownerWindow.addEventListener("blur", onBlur, true);
+	ownerWindow.addEventListener("focusout", onFocusOut, true);
+	ownerWindow.addEventListener("focusin", onFocusIn, true);
+	ownerWindow.addEventListener("focus", onFocus, true);
+	let cleanup = () => {
+		cancelAnimationFrame(raf);
+		ownerWindow.removeEventListener("blur", onBlur, true);
+		ownerWindow.removeEventListener("focusout", onFocusOut, true);
+		ownerWindow.removeEventListener("focusin", onFocusIn, true);
+		ownerWindow.removeEventListener("focus", onFocus, true);
+		$a92dc41f639950be$export$fda7da73ab5d4c48 = false;
+		isRefocusing = false;
+	};
+	let raf = requestAnimationFrame(cleanup);
+	return cleanup;
+}
+//#endregion
+//#region ../../node_modules/.bun/react-aria@3.51.0+67f6792bdf102c28/node_modules/react-aria/dist/private/utils/isVirtualEvent.mjs
+function $b5c62b033c25b96d$export$60278871457622de(event) {
+	if (event.pointerType === "" && event.isTrusted) return true;
+	if ($2add3ce32c6007eb$export$a11b0059900ceec8() && event.pointerType) return event.type === "click" && event.buttons === 1;
+	return event.detail === 0 && !event.pointerType;
+}
+function $b5c62b033c25b96d$export$29bf1b5f2c56cf63(event) {
+	return !$2add3ce32c6007eb$export$a11b0059900ceec8() && event.width === 0 && event.height === 0 || $2add3ce32c6007eb$export$a11b0059900ceec8() && event.width === 1 && event.height === 1 && event.pressure === 0 && event.detail === 0 && event.pointerType === "mouse";
+}
+//#endregion
+//#region ../../node_modules/.bun/react-aria@3.51.0+67f6792bdf102c28/node_modules/react-aria/dist/private/ssr/SSRProvider.mjs
+const $c7eafbbe1ea5834e$var$defaultContext = {
+	prefix: String(Math.round(Math.random() * 1e10)),
+	current: 0
+};
+const $c7eafbbe1ea5834e$var$SSRContext = /*#__PURE__*/ $ahdqC$react.createContext($c7eafbbe1ea5834e$var$defaultContext);
+const $c7eafbbe1ea5834e$var$IsSSRContext = /*#__PURE__*/ $ahdqC$react.createContext(false);
+let $c7eafbbe1ea5834e$var$canUseDOM = Boolean(typeof window !== "undefined" && window.document && window.document.createElement);
+let $c7eafbbe1ea5834e$var$componentIds = /* @__PURE__ */ new WeakMap();
+function $c7eafbbe1ea5834e$var$useCounter(isDisabled = false) {
+	let ctx = useContext($c7eafbbe1ea5834e$var$SSRContext);
+	let ref = useRef(null);
+	if (ref.current === null && !isDisabled) {
+		let currentOwner = $ahdqC$react.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED?.ReactCurrentOwner?.current;
+		if (currentOwner) {
+			let prevComponentValue = $c7eafbbe1ea5834e$var$componentIds.get(currentOwner);
+			if (prevComponentValue == null) $c7eafbbe1ea5834e$var$componentIds.set(currentOwner, {
+				id: ctx.current,
+				state: currentOwner.memoizedState
+			});
+			else if (currentOwner.memoizedState !== prevComponentValue.state) {
+				ctx.current = prevComponentValue.id;
+				$c7eafbbe1ea5834e$var$componentIds.delete(currentOwner);
+			}
+		}
+		ref.current = ++ctx.current;
+	}
+	return ref.current;
+}
+function $c7eafbbe1ea5834e$var$useLegacySSRSafeId(defaultId) {
+	let ctx = useContext($c7eafbbe1ea5834e$var$SSRContext);
+	if (ctx === $c7eafbbe1ea5834e$var$defaultContext && !$c7eafbbe1ea5834e$var$canUseDOM && true) console.warn("When server rendering, you must wrap your application in an <SSRProvider> to ensure consistent ids are generated between the client and server.");
+	let counter = $c7eafbbe1ea5834e$var$useCounter(!!defaultId);
+	let prefix = `react-aria${ctx.prefix}`;
+	return defaultId || `${prefix}-${counter}`;
+}
+function $c7eafbbe1ea5834e$var$useModernSSRSafeId(defaultId) {
+	let id = $ahdqC$react.useId();
+	let [didSSR] = useState($c7eafbbe1ea5834e$export$535bd6ca7f90a273());
+	let prefix = didSSR || false ? "react-aria" : `react-aria${$c7eafbbe1ea5834e$var$defaultContext.prefix}`;
+	return defaultId || `${prefix}-${id}`;
+}
+const $c7eafbbe1ea5834e$export$619500959fc48b26 = typeof $ahdqC$react["useId"] === "function" ? $c7eafbbe1ea5834e$var$useModernSSRSafeId : $c7eafbbe1ea5834e$var$useLegacySSRSafeId;
+function $c7eafbbe1ea5834e$var$getSnapshot() {
+	return false;
+}
+function $c7eafbbe1ea5834e$var$getServerSnapshot() {
+	return true;
+}
+function $c7eafbbe1ea5834e$var$subscribe(onStoreChange) {
+	return () => {};
+}
+function $c7eafbbe1ea5834e$export$535bd6ca7f90a273() {
+	if (typeof $ahdqC$react["useSyncExternalStore"] === "function") return $ahdqC$react["useSyncExternalStore"]($c7eafbbe1ea5834e$var$subscribe, $c7eafbbe1ea5834e$var$getSnapshot, $c7eafbbe1ea5834e$var$getServerSnapshot);
+	return useContext($c7eafbbe1ea5834e$var$IsSSRContext);
+}
+//#endregion
+//#region ../../node_modules/.bun/react-aria@3.51.0+67f6792bdf102c28/node_modules/react-aria/dist/private/interactions/useFocusVisible.mjs
+let $8f5a2122b0992be3$var$currentModality = null;
+const $8f5a2122b0992be3$export$901e90a13c50a14e = /* @__PURE__ */ new Set();
+let $8f5a2122b0992be3$export$d90243b58daecda7 = /* @__PURE__ */ new Map();
+let $8f5a2122b0992be3$var$hasEventBeforeFocus = false;
+let $8f5a2122b0992be3$var$hasBlurredWindowRecently = false;
+function $8f5a2122b0992be3$var$triggerChangeHandlers(modality, e) {
+	for (let handler of $8f5a2122b0992be3$export$901e90a13c50a14e) handler(modality, e);
+}
+/**
+* Helper function to determine if a KeyboardEvent is unmodified and could make keyboard focus
+* styles visible.
+*/ function $8f5a2122b0992be3$var$isValidKey(e) {
+	return !(e.metaKey || !$2add3ce32c6007eb$export$9ac100e40613ea10() && e.altKey || e.ctrlKey || e.key === "Control" || e.key === "Shift" || e.key === "Meta");
+}
+function $8f5a2122b0992be3$var$handleKeyboardEvent(e) {
+	$8f5a2122b0992be3$var$hasEventBeforeFocus = true;
+	if (!$caaf0dd3060ed57c$export$95185d699e05d4d7.isOpening && $8f5a2122b0992be3$var$isValidKey(e)) {
+		$8f5a2122b0992be3$var$currentModality = "keyboard";
+		$8f5a2122b0992be3$var$triggerChangeHandlers("keyboard", e);
+	}
+}
+function $8f5a2122b0992be3$var$handlePointerEvent(e) {
+	$8f5a2122b0992be3$var$currentModality = "pointer";
+	"pointerType" in e && e.pointerType;
+	if (e.type === "mousedown" || e.type === "pointerdown") {
+		$8f5a2122b0992be3$var$hasEventBeforeFocus = true;
+		$8f5a2122b0992be3$var$triggerChangeHandlers("pointer", e);
+	}
+}
+function $8f5a2122b0992be3$var$handleClickEvent(e) {
+	if (!$caaf0dd3060ed57c$export$95185d699e05d4d7.isOpening && $b5c62b033c25b96d$export$60278871457622de(e)) {
+		$8f5a2122b0992be3$var$hasEventBeforeFocus = true;
+		$8f5a2122b0992be3$var$currentModality = "virtual";
+	}
+}
+function $8f5a2122b0992be3$var$handleFocusEvent(e) {
+	let ownerWindow = $d447af545b77c9f1$export$f21a1ffae260145a($23f2114a1b82827e$export$e58f029f0fbfdb29(e));
+	let ownerDocument = $d447af545b77c9f1$export$b204af158042fbac($23f2114a1b82827e$export$e58f029f0fbfdb29(e));
+	if ($23f2114a1b82827e$export$e58f029f0fbfdb29(e) === ownerWindow || $23f2114a1b82827e$export$e58f029f0fbfdb29(e) === ownerDocument || $a92dc41f639950be$export$fda7da73ab5d4c48 || !e.isTrusted) return;
+	if (!$8f5a2122b0992be3$var$hasEventBeforeFocus && !$8f5a2122b0992be3$var$hasBlurredWindowRecently) {
+		$8f5a2122b0992be3$var$currentModality = "virtual";
+		$8f5a2122b0992be3$var$triggerChangeHandlers("virtual", e);
+	}
+	$8f5a2122b0992be3$var$hasEventBeforeFocus = false;
+	$8f5a2122b0992be3$var$hasBlurredWindowRecently = false;
+}
+function $8f5a2122b0992be3$var$handleWindowBlur() {
+	if ($a92dc41f639950be$export$fda7da73ab5d4c48) return;
+	$8f5a2122b0992be3$var$hasEventBeforeFocus = false;
+	$8f5a2122b0992be3$var$hasBlurredWindowRecently = true;
+}
+/**
+* Setup global event listeners to control when keyboard focus style should be visible.
+*/ function $8f5a2122b0992be3$var$setupGlobalFocusEvents(element) {
+	if (typeof window === "undefined" || typeof document === "undefined") return;
+	const windowObject = $d447af545b77c9f1$export$f21a1ffae260145a(element);
+	const documentObject = $d447af545b77c9f1$export$b204af158042fbac(element);
+	if ($8f5a2122b0992be3$export$d90243b58daecda7.get(windowObject)) return;
+	let focus = windowObject.HTMLElement.prototype.focus;
+	Reflect.defineProperty(windowObject.HTMLElement.prototype, "focus", {
+		configurable: true,
+		writable: true,
+		value: function() {
+			$8f5a2122b0992be3$var$hasEventBeforeFocus = true;
+			focus.apply(this, arguments);
+		}
+	});
+	documentObject.addEventListener("keydown", $8f5a2122b0992be3$var$handleKeyboardEvent, true);
+	documentObject.addEventListener("keyup", $8f5a2122b0992be3$var$handleKeyboardEvent, true);
+	documentObject.addEventListener("click", $8f5a2122b0992be3$var$handleClickEvent, true);
+	windowObject.addEventListener("focus", $8f5a2122b0992be3$var$handleFocusEvent, true);
+	windowObject.addEventListener("blur", $8f5a2122b0992be3$var$handleWindowBlur, false);
+	if (typeof PointerEvent !== "undefined") {
+		documentObject.addEventListener("pointerdown", $8f5a2122b0992be3$var$handlePointerEvent, true);
+		documentObject.addEventListener("pointermove", $8f5a2122b0992be3$var$handlePointerEvent, true);
+		documentObject.addEventListener("pointerup", $8f5a2122b0992be3$var$handlePointerEvent, true);
+	}
+	windowObject.addEventListener("beforeunload", () => {
+		$8f5a2122b0992be3$var$tearDownWindowFocusTracking(element);
+	}, { once: true });
+	$8f5a2122b0992be3$export$d90243b58daecda7.set(windowObject, { focus });
+}
+const $8f5a2122b0992be3$var$tearDownWindowFocusTracking = (element, loadListener) => {
+	const windowObject = $d447af545b77c9f1$export$f21a1ffae260145a(element);
+	const documentObject = $d447af545b77c9f1$export$b204af158042fbac(element);
+	if (loadListener) documentObject.removeEventListener("DOMContentLoaded", loadListener);
+	if (!$8f5a2122b0992be3$export$d90243b58daecda7.has(windowObject)) return;
+	Reflect.defineProperty(windowObject.HTMLElement.prototype, "focus", {
+		configurable: true,
+		writable: true,
+		value: $8f5a2122b0992be3$export$d90243b58daecda7.get(windowObject).focus
+	});
+	documentObject.removeEventListener("keydown", $8f5a2122b0992be3$var$handleKeyboardEvent, true);
+	documentObject.removeEventListener("keyup", $8f5a2122b0992be3$var$handleKeyboardEvent, true);
+	documentObject.removeEventListener("click", $8f5a2122b0992be3$var$handleClickEvent, true);
+	windowObject.removeEventListener("focus", $8f5a2122b0992be3$var$handleFocusEvent, true);
+	windowObject.removeEventListener("blur", $8f5a2122b0992be3$var$handleWindowBlur, false);
+	if (typeof PointerEvent !== "undefined") {
+		documentObject.removeEventListener("pointerdown", $8f5a2122b0992be3$var$handlePointerEvent, true);
+		documentObject.removeEventListener("pointermove", $8f5a2122b0992be3$var$handlePointerEvent, true);
+		documentObject.removeEventListener("pointerup", $8f5a2122b0992be3$var$handlePointerEvent, true);
+	}
+	$8f5a2122b0992be3$export$d90243b58daecda7.delete(windowObject);
+};
+function $8f5a2122b0992be3$export$2f1888112f558a7d(element) {
+	const documentObject = $d447af545b77c9f1$export$b204af158042fbac(element);
+	let loadListener;
+	if (documentObject.readyState !== "loading") $8f5a2122b0992be3$var$setupGlobalFocusEvents(element);
+	else {
+		loadListener = () => {
+			$8f5a2122b0992be3$var$setupGlobalFocusEvents(element);
+		};
+		documentObject.addEventListener("DOMContentLoaded", loadListener);
+	}
+	return () => $8f5a2122b0992be3$var$tearDownWindowFocusTracking(element, loadListener);
+}
+if (typeof document !== "undefined") $8f5a2122b0992be3$export$2f1888112f558a7d();
+function $8f5a2122b0992be3$export$630ff653c5ada6a9() {
+	return $8f5a2122b0992be3$var$currentModality;
+}
+function $8f5a2122b0992be3$export$8397ddfc504fdb9a(modality) {
+	$8f5a2122b0992be3$var$currentModality = modality;
+	$8f5a2122b0992be3$var$triggerChangeHandlers(modality, null);
+}
+//#endregion
+//#region ../../node_modules/.bun/react-aria@3.51.0+67f6792bdf102c28/node_modules/react-aria/dist/private/utils/runAfterTransition.mjs
+let $081cb5757e08788e$var$transitionsByElement = /* @__PURE__ */ new Map();
+let $081cb5757e08788e$var$transitionCallbacks = /* @__PURE__ */ new Set();
+function $081cb5757e08788e$var$setupGlobalEvents() {
+	if (typeof window === "undefined") return;
+	function isTransitionEvent(event) {
+		return "propertyName" in event;
+	}
+	let onTransitionStart = (e) => {
+		let eventTarget = $23f2114a1b82827e$export$e58f029f0fbfdb29(e);
+		if (!isTransitionEvent(e) || !eventTarget) return;
+		let transitions = $081cb5757e08788e$var$transitionsByElement.get(eventTarget);
+		if (!transitions) {
+			transitions = /* @__PURE__ */ new Set();
+			$081cb5757e08788e$var$transitionsByElement.set(eventTarget, transitions);
+			eventTarget.addEventListener("transitioncancel", onTransitionEnd, { once: true });
+		}
+		transitions.add(e.propertyName);
+	};
+	let onTransitionEnd = (e) => {
+		let eventTarget = $23f2114a1b82827e$export$e58f029f0fbfdb29(e);
+		if (!isTransitionEvent(e) || !eventTarget) return;
+		let properties = $081cb5757e08788e$var$transitionsByElement.get(eventTarget);
+		if (!properties) return;
+		properties.delete(e.propertyName);
+		if (properties.size === 0) {
+			eventTarget.removeEventListener("transitioncancel", onTransitionEnd);
+			$081cb5757e08788e$var$transitionsByElement.delete(eventTarget);
+		}
+		if ($081cb5757e08788e$var$transitionsByElement.size === 0) {
+			for (let cb of $081cb5757e08788e$var$transitionCallbacks) cb();
+			$081cb5757e08788e$var$transitionCallbacks.clear();
+		}
+	};
+	document.body.addEventListener("transitionrun", onTransitionStart);
+	document.body.addEventListener("transitionend", onTransitionEnd);
+}
+if (typeof document !== "undefined") {
+	if (document.readyState !== "loading") $081cb5757e08788e$var$setupGlobalEvents();
+	else document.addEventListener("DOMContentLoaded", $081cb5757e08788e$var$setupGlobalEvents);
+}
+/**
+* Cleans up any elements that are no longer in the document.
+* This is necessary because we can't rely on transitionend events to fire
+* for elements that are removed from the document while transitioning.
+*/ function $081cb5757e08788e$var$cleanupDetachedElements() {
+	for (const [eventTarget] of $081cb5757e08788e$var$transitionsByElement) if ("isConnected" in eventTarget && !eventTarget.isConnected) $081cb5757e08788e$var$transitionsByElement.delete(eventTarget);
+}
+function $081cb5757e08788e$export$24490316f764c430(fn) {
+	requestAnimationFrame(() => {
+		$081cb5757e08788e$var$cleanupDetachedElements();
+		if ($081cb5757e08788e$var$transitionsByElement.size === 0) fn();
+		else $081cb5757e08788e$var$transitionCallbacks.add(fn);
+	});
+}
+//#endregion
+//#region ../../node_modules/.bun/react-aria@3.51.0+67f6792bdf102c28/node_modules/react-aria/dist/private/interactions/focusSafely.mjs
+function $f192c2f16961cbe0$export$80f3e147d781571c(element) {
+	if (!element.isConnected) return;
+	const ownerDocument = $d447af545b77c9f1$export$b204af158042fbac(element);
+	if ($8f5a2122b0992be3$export$630ff653c5ada6a9() === "virtual") {
+		let lastFocusedElement = $23f2114a1b82827e$export$cd4e5573fbe2b576(ownerDocument);
+		$081cb5757e08788e$export$24490316f764c430(() => {
+			const activeElement = $23f2114a1b82827e$export$cd4e5573fbe2b576(ownerDocument);
+			if ((activeElement === lastFocusedElement || activeElement === ownerDocument.body) && element.isConnected) $1969ac565cfec8d0$export$de79e2c695e052f3(element);
+		});
+	} else $1969ac565cfec8d0$export$de79e2c695e052f3(element);
+}
+//#endregion
+export { $c7eafbbe1ea5834e$export$619500959fc48b26 as a, $a92dc41f639950be$export$525bc4921d56d4a as c, $a92dc41f639950be$export$cabe61c495ee3649 as d, $3b8b240c1bf84ab9$export$4c063cf1350e6fed as f, $c7eafbbe1ea5834e$export$535bd6ca7f90a273 as i, $a92dc41f639950be$export$715c682d09d639cc as l, $081cb5757e08788e$export$24490316f764c430 as n, $b5c62b033c25b96d$export$29bf1b5f2c56cf63 as o, $3b8b240c1bf84ab9$export$bebd5a1431fec25d as p, $8f5a2122b0992be3$export$8397ddfc504fdb9a as r, $b5c62b033c25b96d$export$60278871457622de as s, $f192c2f16961cbe0$export$80f3e147d781571c as t, $a92dc41f639950be$export$c2b7abe5d61ec696 as u };

package/dist/form.binding-DLM7NA2s.js

@@ -0,0 +1,179 @@
+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 { Store } from "@tanstack/store";
+//#region src/hooks/useForm.ts
+const disabledStores = /* @__PURE__ */ new WeakMap();
+function useForm$1({ defaultValues, disabled = false, mode = "onSubmit", onSubmitAsync, zodSchema } = {}) {
+	const submitHandlerRef = useRef(() => void 0);
+	const submitErrorHandlerRef = useRef(void 0);
+	const blurListenersRef = useRef(/* @__PURE__ */ new Set());
+	const touchedFieldsRef = useRef(/* @__PURE__ */ new Set());
+	const defaultValuesRef = useRef(defaultValues);
+	const fieldValidators = useMemo(() => {
+		return /* @__PURE__ */ new Map();
+	}, [mode, zodSchema]);
+	const formValidator = useMemo(() => {
+		if (!zodSchema) return;
+		return ({ value }) => {
+			const result = zodSchema.safeParse(value);
+			if (result.success) return;
+			return { fields: Object.fromEntries(result.error.issues.map((issue) => [pathToString(issue.path), issue.message])) };
+		};
+	}, [zodSchema]);
+	const initialDefaultValues = defaultValuesRef.current;
+	const form = useForm({
+		defaultValues: (typeof initialDefaultValues === "function" ? {} : initialDefaultValues) ?? {},
+		validators: formValidator || onSubmitAsync ? {
+			onChange: formValidator,
+			onMount: formValidator,
+			onSubmit: formValidator,
+			onSubmitAsync
+		} : void 0,
+		onSubmit: async ({ value: value_0 }) => {
+			const transformed = zodSchema ? zodSchema.parse(value_0) : value_0;
+			await submitHandlerRef.current(transformed);
+		},
+		onSubmitInvalid: ({ value: value_1, formApi }) => {
+			submitErrorHandlerRef.current?.(formApi.state.errors, value_1);
+		}
+	});
+	const originalHandleSubmit = useMemo(() => form.handleSubmit.bind(form), [form]);
+	const originalReset = useMemo(() => form.reset.bind(form), [form]);
+	const disabledStoreRef = useRef(void 0);
+	disabledStoreRef.current ??= new Store(disabled);
+	const disabledStore = disabledStoreRef.current;
+	const uiForm = form;
+	Object.defineProperty(uiForm, "disabled", {
+		configurable: true,
+		value: disabled,
+		writable: true
+	});
+	disabledStores.set(uiForm, disabledStore);
+	uiForm.getFieldValidators = (name) => {
+		const cached = fieldValidators.get(name);
+		if (cached || fieldValidators.has(name)) return cached;
+		const schema = zodSchema ? getSchemaAtPath(zodSchema, name) : void 0;
+		if (!schema || mode === "onSubmit") {
+			fieldValidators.set(name, void 0);
+			return;
+		}
+		const validate = ({ value: value_2 }) => {
+			const result_0 = schema.safeParse(value_2);
+			return result_0.success ? void 0 : result_0.error.issues[0]?.message;
+		};
+		const validators = mode === "all" ? {
+			onBlur: validate,
+			onChange: validate
+		} : mode === "onChange" ? { onChange: validate } : mode === "onBlur" ? { onBlur: validate } : {
+			onBlur: validate,
+			onChange: (props) => touchedFieldsRef.current.has(name) ? validate(props) : void 0
+		};
+		fieldValidators.set(name, validators);
+		return validators;
+	};
+	uiForm.notifyBlur = (name_0) => {
+		touchedFieldsRef.current.add(name_0);
+		for (const listener of blurListenersRef.current) listener(name_0);
+	};
+	uiForm.parseValues = (values) => zodSchema ? zodSchema.parse(values) : values;
+	uiForm.reset = (...args) => {
+		touchedFieldsRef.current.clear();
+		originalReset(...args);
+	};
+	uiForm.subscribeBlur = (listener_0) => {
+		blurListenersRef.current.add(listener_0);
+		return () => blurListenersRef.current.delete(listener_0);
+	};
+	uiForm.handleSubmit = (onValid, onInvalid) => async (event) => {
+		event?.preventDefault?.();
+		event?.stopPropagation?.();
+		submitHandlerRef.current = onValid;
+		submitErrorHandlerRef.current = onInvalid;
+		await originalHandleSubmit();
+	};
+	useEffect(() => {
+		if (typeof initialDefaultValues === "function") initialDefaultValues().then((values_0) => form.reset(values_0));
+	}, [form, initialDefaultValues]);
+	useLayoutEffect(() => {
+		if (disabledStore.state !== disabled) disabledStore.setState(() => disabled);
+	}, [disabled, disabledStore]);
+	return uiForm;
+}
+const useFormDisabled = (form) => {
+	const $ = c(2);
+	let t0;
+	if ($[0] !== form) {
+		t0 = disabledStores.get(form);
+		$[0] = form;
+		$[1] = t0;
+	} else t0 = $[1];
+	const store = t0;
+	if (!store) throw new Error("useFormDisabled must be used with a form created by useForm");
+	return useStore(store);
+};
+const useFormValue = (form, selector) => {
+	const $ = c(2);
+	let t0;
+	if ($[0] !== selector) {
+		t0 = (state) => selector(state.values);
+		$[0] = selector;
+		$[1] = t0;
+	} else t0 = $[1];
+	return useStore(form.store, t0);
+};
+const useFormState = (form, selector) => {
+	return useStore(form.store, selector);
+};
+const getSchemaAtPath = (rootSchema, path) => {
+	let schema = rootSchema;
+	for (const segment of parsePath(path)) {
+		while (schema?.unwrap && !schema.shape && !schema.element && !schema.items) schema = schema.unwrap();
+		schema = typeof segment === "number" ? schema?.element ?? schema?.items?.[segment] : schema?.shape?.[segment];
+		if (!schema) return;
+	}
+	return schema;
+};
+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 };

package/dist/form.binding-DVJ5F0JE.d.ts

@@ -0,0 +1,51 @@
+import { DeepKeys, DeepValue, ReactFormExtendedApi } from "@tanstack/react-form";
+import { z } from "zod";
+//#region src/hooks/useForm.d.ts
+type FormMode = "all" | "onBlur" | "onChange" | "onSubmit" | "onTouched";
+type FieldValidators = {
+  onBlur?: ({ value }: {
+    value: unknown;
+  }) => string | undefined;
+  onChange?: ({ value }: {
+    value: unknown;
+  }) => string | undefined;
+};
+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"> & {
+  readonly disabled: boolean;
+  getFieldValidators: (name: DeepKeys<TFieldValues>) => FieldValidators | undefined;
+  notifyBlur: (name: DeepKeys<TFieldValues>) => void;
+  parseValues: (values: TFieldValues) => unknown;
+  subscribeBlur: (listener: (name: DeepKeys<TFieldValues>) => void) => () => void;
+  handleSubmit: (onValid: FormSubmitHandler<any>, 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> {
+  /** Initial form values. Changes after mount are ignored; use `form.reset()` to replace form values. */
+  defaultValues?: NullableDefaults<TFieldValues> | AsyncDefaultValues<TFieldValues>;
+  disabled?: boolean;
+  mode?: FormMode;
+  onSubmitAsync?: (props: {
+    value: 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>> & {
+  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;
+//#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 };