solid-baseui 0.1.0-alpha.0

package/dist/lib/server/FocusManager-BrbZVWME.js

@@ -0,0 +1,538 @@
+import { u as focusOut } from "./internals/reasons.js";
+import { createChangeEventDetails } from "./internals/createBaseUIEventDetails.js";
+import { c as isHTMLElement, d as isTypeableCombobox, f as isTypeableElement, i as getFloatingFocusElement, n as contains, o as isElementVisible, p as ownerDocument, r as getEventTarget, t as activeElement, u as isShadowRoot } from "./dom-Crg_2R-j.js";
+import { a as getNodeAncestors, o as getNodeChildren } from "./FloatingTree-z1JPD1dR.js";
+import { c as focusable, g as FocusGuard, h as tabbable, l as getNextTabbable, m as isTabbable, p as isOutsideFocusEvent, s as usePopupPortalContext, u as getPreviousTabbable } from "./popupStateMapping-nKoUwoke.js";
+import { applyRef, escape, memo } from "@solidjs/web";
+import { Show, createEffect, createMemo, untrack } from "solid-js";
+//#region src/internals/overlay/markOthers.ts
+var counters = {
+	inert: /* @__PURE__ */ new WeakMap(),
+	"aria-hidden": /* @__PURE__ */ new WeakMap()
+};
+var uncontrolled = {
+	inert: /* @__PURE__ */ new WeakSet(),
+	"aria-hidden": /* @__PURE__ */ new WeakSet()
+};
+var markerCounters = /* @__PURE__ */ new WeakMap();
+var lockCount = 0;
+function unwrapHost(node) {
+	if (!node) return null;
+	return isShadowRoot(node) ? node.host : unwrapHost(node.parentNode);
+}
+function correctElements(parent, targets) {
+	return targets.map((target) => {
+		if (parent.contains(target)) return target;
+		const host = unwrapHost(target);
+		return host && parent.contains(host) ? host : null;
+	}).filter((element) => element !== null);
+}
+function buildKeepSet(targets) {
+	const keep = /* @__PURE__ */ new Set();
+	targets.forEach((target) => {
+		let node = target;
+		while (node && !keep.has(node)) {
+			keep.add(node);
+			node = node.parentNode;
+		}
+	});
+	return keep;
+}
+function collectOutside(root, keep, stop) {
+	const outside = [];
+	const walk = (parent) => {
+		if (!parent || stop.has(parent)) return;
+		Array.from(parent.children).forEach((child) => {
+			if (child.localName === "script") return;
+			if (keep.has(child)) walk(child);
+			else outside.push(child);
+		});
+	};
+	walk(root);
+	return outside;
+}
+function markOthers(uncorrectedAvoidElements, options = {}) {
+	const { ariaHidden = false, inert = false, mark = true } = options;
+	const body = ownerDocument(uncorrectedAvoidElements[0]).body;
+	const avoidElements = correctElements(body, uncorrectedAvoidElements);
+	const markerTargets = mark ? collectOutside(body, buildKeepSet(avoidElements), new Set(avoidElements)) : [];
+	const marked = [];
+	const controlled = [];
+	const controlAttribute = inert ? "inert" : ariaHidden ? "aria-hidden" : null;
+	if (controlAttribute) {
+		const liveRegions = correctElements(body, Array.from(body.querySelectorAll("[aria-live]")));
+		const controlElements = avoidElements.concat(liveRegions);
+		collectOutside(body, buildKeepSet(controlElements), new Set(controlElements)).forEach((element) => {
+			const existing = element.getAttribute(controlAttribute);
+			const alreadyHidden = existing !== null && existing !== "false";
+			const count = (counters[controlAttribute].get(element) ?? 0) + 1;
+			counters[controlAttribute].set(element, count);
+			controlled.push(element);
+			if (count === 1 && alreadyHidden) uncontrolled[controlAttribute].add(element);
+			if (!alreadyHidden) element.setAttribute(controlAttribute, controlAttribute === "inert" ? "" : "true");
+		});
+	}
+	markerTargets.forEach((element) => {
+		const count = (markerCounters.get(element) ?? 0) + 1;
+		markerCounters.set(element, count);
+		marked.push(element);
+		if (count === 1) element.setAttribute("data-base-ui-inert", "");
+	});
+	lockCount += 1;
+	let cleaned = false;
+	return () => {
+		if (cleaned) return;
+		cleaned = true;
+		if (controlAttribute) controlled.forEach((element) => {
+			const count = (counters[controlAttribute].get(element) ?? 0) - 1;
+			counters[controlAttribute].set(element, count);
+			if (count === 0) {
+				if (!uncontrolled[controlAttribute].has(element)) element.removeAttribute(controlAttribute);
+				uncontrolled[controlAttribute].delete(element);
+			}
+		});
+		marked.forEach((element) => {
+			const count = (markerCounters.get(element) ?? 0) - 1;
+			markerCounters.set(element, count);
+			if (count === 0) element.removeAttribute("data-base-ui-inert");
+		});
+		lockCount -= 1;
+		if (lockCount === 0) {
+			counters = {
+				inert: /* @__PURE__ */ new WeakMap(),
+				"aria-hidden": /* @__PURE__ */ new WeakMap()
+			};
+			uncontrolled = {
+				inert: /* @__PURE__ */ new WeakSet(),
+				"aria-hidden": /* @__PURE__ */ new WeakSet()
+			};
+			markerCounters = /* @__PURE__ */ new WeakMap();
+		}
+	};
+}
+//#endregion
+//#region src/internals/overlay/FocusManager.tsx
+var PREVIOUS_FOCUS_LIMIT = 20;
+var previouslyFocusedElements = [];
+var focusFrame = 0;
+function clearDisconnectedPreviouslyFocusedElements() {
+	previouslyFocusedElements = previouslyFocusedElements.filter((entry) => entry.deref()?.isConnected);
+}
+function addPreviouslyFocusedElement(element) {
+	clearDisconnectedPreviouslyFocusedElements();
+	if (element && element.localName !== "body") {
+		previouslyFocusedElements.push(new WeakRef(element));
+		if (previouslyFocusedElements.length > PREVIOUS_FOCUS_LIMIT) previouslyFocusedElements = previouslyFocusedElements.slice(-20);
+	}
+}
+function getPreviouslyFocusedElement() {
+	clearDisconnectedPreviouslyFocusedElements();
+	return previouslyFocusedElements[previouslyFocusedElements.length - 1]?.deref();
+}
+function resolveElement(value) {
+	return typeof value === "function" ? value() : value ?? null;
+}
+function getFirstTabbableElement(container) {
+	if (!container) return null;
+	if (isTabbable(container)) return container;
+	return tabbable(container)[0] ?? container;
+}
+function handleTabIndex(floating) {
+	if (floating.hasAttribute("tabindex") && !floating.hasAttribute("data-tabindex")) return;
+	if (!floating.getAttribute("role")?.includes("dialog")) return;
+	const tabIndex = focusable(floating).some((element) => {
+		const storedTabIndex = element.getAttribute("data-tabindex") || "";
+		return isTabbable(element) || element.hasAttribute("data-tabindex") && !storedTabIndex.startsWith("-");
+	}) ? "-1" : "0";
+	if (floating.getAttribute("tabindex") !== tabIndex || floating.getAttribute("data-tabindex") !== tabIndex) {
+		floating.setAttribute("tabindex", tabIndex);
+		floating.setAttribute("data-tabindex", tabIndex);
+	}
+}
+function getEventType(event, lastInteractionType) {
+	if (event.type === "keydown" || event.type === "keyup") return "keyboard";
+	if (event.type === "focus" || event.type === "focusin" || event.type === "focusout" || event.type === "blur") return lastInteractionType || "keyboard";
+	if ("pointerType" in event) return event.pointerType || "keyboard";
+	if ("touches" in event) return "touch";
+	if (event.type.includes("mouse") || event.type === "click") return lastInteractionType || (event.detail === 0 ? "keyboard" : "mouse");
+	return "";
+}
+function isVirtualClick(event) {
+	return event.detail === 0 && !event.pointerType;
+}
+function isVirtualPointerEvent(event) {
+	return event.width === 0 && event.height === 0;
+}
+function enqueueFocus(element, options = {}) {
+	cancelAnimationFrame(focusFrame);
+	const currentFrame = requestAnimationFrame(() => {
+		if (!options.shouldFocus || options.shouldFocus()) element?.focus({ preventScroll: options.preventScroll });
+	});
+	focusFrame = currentFrame;
+	return () => {
+		if (focusFrame === currentFrame) {
+			cancelAnimationFrame(currentFrame);
+			focusFrame = 0;
+		}
+	};
+}
+function FocusManager(props) {
+	const portal = usePopupPortalContext();
+	let preventReturnFocus = false;
+	let pointerDownInsideClickTrigger = false;
+	let lastFocusedTabbable = null;
+	let closeType = "";
+	let lastInteractionType = "";
+	let pointerResetTimer;
+	let restoreFrame = 0;
+	const open = () => props.context.track().open;
+	const domReference = () => props.referenceElement?.() ?? props.context.track().domReferenceElement;
+	const floating = () => props.context.track().floatingElement;
+	const floatingFocusElement = createMemo(() => getFloatingFocusElement(floating()));
+	const disabled = () => props.disabled ?? false;
+	const modal = () => props.modal ?? true;
+	const closeOnFocusOut = () => props.closeOnFocusOut ?? true;
+	const insideElements = () => props.getInsideElements?.().filter((element) => element != null) ?? [];
+	const untrappedCombobox = () => isTypeableCombobox(domReference()) && props.initialFocus === false;
+	const tabbableContent = (container = floatingFocusElement()) => container ? tabbable(container) : [];
+	const nodeId = () => props.context.context.nodeId;
+	createEffect(() => ({
+		disabled: disabled(),
+		modal: modal(),
+		focusElement: floatingFocusElement()
+	}), (state) => {
+		if (state.disabled || !state.modal || !state.focusElement) return;
+		const documentNode = ownerDocument(state.focusElement);
+		const onKeyDown = (event) => {
+			if (event.key === "Tab" && contains(state.focusElement, activeElement(documentNode)) && tabbableContent().length === 0 && !untrappedCombobox()) {
+				event.preventDefault();
+				event.stopPropagation();
+			}
+		};
+		documentNode.addEventListener("keydown", onKeyDown);
+		return () => documentNode.removeEventListener("keydown", onKeyDown);
+	});
+	createEffect(() => ({
+		disabled: disabled(),
+		open: open(),
+		focusElement: floatingFocusElement()
+	}), (state) => {
+		if (state.disabled || !state.open || !state.focusElement) return;
+		const documentNode = ownerDocument(state.focusElement);
+		const onPointerDown = (event) => {
+			const target = getEventTarget(event);
+			lastInteractionType = event.pointerType || "keyboard";
+			if (target?.closest("[data-base-ui-click-trigger]")) {
+				pointerDownInsideClickTrigger = true;
+				clearTimeout(pointerResetTimer);
+				pointerResetTimer = setTimeout(() => {
+					pointerDownInsideClickTrigger = false;
+				});
+			}
+		};
+		const onKeyDown = () => {
+			lastInteractionType = "keyboard";
+		};
+		documentNode.addEventListener("pointerdown", onPointerDown, true);
+		documentNode.addEventListener("keydown", onKeyDown, true);
+		return () => {
+			documentNode.removeEventListener("pointerdown", onPointerDown, true);
+			documentNode.removeEventListener("keydown", onKeyDown, true);
+		};
+	});
+	createEffect(() => ({
+		disabled: disabled(),
+		closeOnFocusOut: closeOnFocusOut(),
+		reference: domReference(),
+		floating: floating(),
+		focusElement: floatingFocusElement(),
+		modal: modal(),
+		restoreFocus: props.restoreFocus,
+		tree: props.tree
+	}), (state) => {
+		if (state.disabled || !state.closeOnFocusOut || !state.reference && !state.floating) return;
+		const documentNode = ownerDocument(state.focusElement);
+		const handlePointerDown = () => {
+			pointerDownInsideClickTrigger = true;
+			clearTimeout(pointerResetTimer);
+			pointerResetTimer = setTimeout(() => {
+				pointerDownInsideClickTrigger = false;
+			});
+		};
+		const handleFocusIn = (event) => {
+			const target = getEventTarget(event);
+			if (isTabbable(target)) lastFocusedTabbable = target;
+		};
+		const handleFocusOut = (event) => {
+			const relatedTarget = event.relatedTarget;
+			const target = getEventTarget(event);
+			if (state.modal && !relatedTarget && target && contains(state.floating, target)) addPreviouslyFocusedElement(target);
+			queueMicrotask(() => {
+				const relatedIsGuard = Boolean(relatedTarget?.hasAttribute("data-base-ui-focus-guard") && [
+					portal?.beforeInside(),
+					portal?.afterInside(),
+					portal?.beforeOutside(),
+					portal?.afterOutside(),
+					resolveElement(props.previousFocusableElement),
+					resolveElement(props.nextFocusableElement)
+				].includes(relatedTarget));
+				const triggers = props.context.context.triggerElements;
+				const movedOutside = !(contains(state.reference, relatedTarget) || contains(state.floating, relatedTarget) || contains(relatedTarget, state.floating) || contains(portal?.portalNode(), relatedTarget) || insideElements().some((element) => element === relatedTarget || contains(element, relatedTarget)) || triggers.hasMatchingElement((trigger) => contains(trigger, relatedTarget)) || relatedIsGuard || state.tree && (getNodeChildren(state.tree.nodes, nodeId()).some((node) => contains(node.context?.state.floatingElement, relatedTarget) || contains(node.context?.state.domReferenceElement, relatedTarget)) || getNodeAncestors(state.tree.nodes, nodeId()).some((node) => node.context?.state.floatingElement === relatedTarget || node.context?.state.domReferenceElement === relatedTarget)));
+				if (event.currentTarget === state.reference && state.focusElement) handleTabIndex(state.focusElement);
+				if (state.restoreFocus && event.currentTarget !== state.reference && !isElementVisible(target) && activeElement(documentNode) === documentNode.body && state.focusElement) {
+					state.focusElement.focus();
+					if (state.restoreFocus === "popup") {
+						cancelAnimationFrame(restoreFrame);
+						restoreFrame = requestAnimationFrame(() => state.focusElement?.focus());
+						return;
+					}
+					const elements = tabbableContent();
+					((lastFocusedTabbable && elements.includes(lastFocusedTabbable) ? lastFocusedTabbable : null) ?? elements[elements.length - 1] ?? state.focusElement).focus();
+				}
+				if ((untrappedCombobox() || !state.modal) && relatedTarget && movedOutside && !pointerDownInsideClickTrigger && (untrappedCombobox() || relatedTarget !== getPreviouslyFocusedElement())) {
+					preventReturnFocus = true;
+					props.context.setOpen(false, createChangeEventDetails(focusOut, event));
+				}
+			});
+		};
+		if (state.reference) {
+			state.reference.addEventListener("focusout", handleFocusOut);
+			state.reference.addEventListener("pointerdown", handlePointerDown);
+		}
+		state.floating?.addEventListener("focusin", handleFocusIn);
+		state.floating?.addEventListener("focusout", handleFocusOut);
+		return () => {
+			if (state.reference) {
+				state.reference.removeEventListener("focusout", handleFocusOut);
+				state.reference.removeEventListener("pointerdown", handlePointerDown);
+			}
+			state.floating?.removeEventListener("focusin", handleFocusIn);
+			state.floating?.removeEventListener("focusout", handleFocusOut);
+		};
+	});
+	createEffect(() => ({
+		disabled: disabled(),
+		open: open(),
+		floating: floating(),
+		modal: modal(),
+		untrapped: untrappedCombobox(),
+		tree: props.tree,
+		nodeId: nodeId(),
+		portalNode: portal?.portalNode(),
+		beforeInside: portal?.beforeInside(),
+		afterInside: portal?.afterInside(),
+		beforeOutside: portal?.beforeOutside(),
+		afterOutside: portal?.afterOutside(),
+		insideElements: insideElements(),
+		domReference: domReference(),
+		previous: resolveElement(props.previousFocusableElement),
+		next: resolveElement(props.nextFocusableElement)
+	}), (state) => {
+		if (state.disabled || !state.open || !state.floating) return;
+		const portalNodes = Array.from(state.portalNode?.querySelectorAll("[data-base-ui-portal]") ?? []);
+		const ancestorCombobox = (state.tree ? getNodeAncestors(state.tree.nodes, state.nodeId) : []).find((node) => isTypeableCombobox(node.context?.state.domReferenceElement ?? null))?.context?.state.domReferenceElement;
+		const ariaCleanup = markOthers([
+			...[
+				state.portalNode,
+				state.floating,
+				...portalNodes,
+				state.beforeInside,
+				state.afterInside,
+				state.beforeOutside,
+				state.afterOutside,
+				...state.insideElements
+			].filter((element) => element != null),
+			ancestorCombobox,
+			state.previous,
+			state.next,
+			state.untrapped ? state.domReference : null
+		].filter((element) => element != null), {
+			ariaHidden: state.modal || state.untrapped,
+			mark: false
+		});
+		const markerCleanup = markOthers([
+			state.portalNode,
+			state.floating,
+			...portalNodes
+		].filter((element) => element != null));
+		return () => {
+			markerCleanup();
+			ariaCleanup();
+		};
+	});
+	createEffect(() => ({
+		open: open(),
+		disabled: disabled(),
+		focusElement: floatingFocusElement(),
+		initialFocus: props.initialFocus ?? true,
+		interactionType: props.openInteractionType ?? ""
+	}), (state) => {
+		if (!state.open || state.disabled || !state.focusElement) return;
+		closeType = "";
+		lastInteractionType = "";
+		const documentNode = ownerDocument(state.focusElement);
+		const previouslyFocused = activeElement(documentNode);
+		let cancelQueuedFocus = () => {};
+		queueMicrotask(() => {
+			const initial = state.initialFocus;
+			const resolvedValue = typeof initial === "function" ? initial(state.interactionType) : initial;
+			const resolved = isFocusRef(resolvedValue) ? resolvedValue.current : resolvedValue;
+			if (resolved === void 0 || resolved === false) return;
+			if (contains(state.focusElement, previouslyFocused)) return;
+			const getDefault = () => tabbableContent(state.focusElement)[0] ?? state.focusElement;
+			const target = (resolved === true || resolved === null ? getDefault() : resolved) ?? getDefault();
+			const hadFocusInside = contains(state.focusElement, activeElement(documentNode));
+			cancelQueuedFocus = enqueueFocus(target, {
+				preventScroll: target === state.focusElement,
+				shouldFocus: () => {
+					if (!props.context.state.open) return false;
+					if (hadFocusInside) return true;
+					const current = activeElement(documentNode);
+					return current === target || !contains(state.focusElement, current);
+				}
+			});
+		});
+		return () => cancelQueuedFocus();
+	});
+	createEffect(() => ({
+		disabled: disabled(),
+		focusElement: floatingFocusElement(),
+		interactionType: props.openInteractionType
+	}), (state) => {
+		if (state.disabled || !state.focusElement) return;
+		const documentNode = ownerDocument(state.focusElement);
+		const focusedBeforeOpen = activeElement(documentNode);
+		const preferPrevious = state.interactionType === null;
+		addPreviouslyFocusedElement(focusedBeforeOpen);
+		const onOpenChange = (details) => {
+			if (!details.open) closeType = getEventType(details.nativeEvent, lastInteractionType);
+			if (details.reason === "trigger-hover" && details.nativeEvent.type === "mouseleave") preventReturnFocus = true;
+			if (details.reason === "outside-press") {
+				if (details.nested || details.nativeEvent.type === "click" && isVirtualClick(details.nativeEvent) || "pointerType" in details.nativeEvent && isVirtualPointerEvent(details.nativeEvent)) preventReturnFocus = false;
+				else {
+					let supported = false;
+					documentNode.createElement("div").focus({ get preventScroll() {
+						supported = true;
+						return false;
+					} });
+					preventReturnFocus = !supported;
+				}
+			}
+		};
+		const unsubscribe = props.context.context.events.on("openchange", onOpenChange);
+		return () => {
+			unsubscribe();
+			const active = activeElement(documentNode);
+			const currentFloating = props.context.state.floatingElement;
+			const currentInsideElements = untrack(insideElements);
+			const currentTree = untrack(() => props.tree);
+			const focusInside = contains(currentFloating, active) || currentInsideElements.some((element) => element === active || contains(element, active)) || Boolean(currentTree && getNodeChildren(currentTree.nodes, props.context.context.nodeId, false).some((node) => contains(node.context?.state.floatingElement, active)));
+			const returnFocus = untrack(() => props.returnFocus) ?? true;
+			const resolvedValue = typeof returnFocus === "function" ? returnFocus(closeType) : returnFocus;
+			const resolved = isFocusRef(resolvedValue) ? resolvedValue.current : resolvedValue;
+			if (resolved === void 0 || resolved === false) return;
+			const currentReference = props.context.state.domReferenceElement;
+			const referenceTarget = currentReference?.isConnected ? currentReference : null;
+			const previousTarget = focusedBeforeOpen?.isConnected && focusedBeforeOpen.localName !== "body" ? focusedBeforeOpen : null;
+			const defaultTarget = (preferPrevious ? previousTarget ?? referenceTarget : referenceTarget ?? previousTarget) ?? getPreviouslyFocusedElement() ?? null;
+			const returnElement = getFirstTabbableElement(resolved === true || resolved === null ? defaultTarget : resolved);
+			queueMicrotask(() => {
+				if (!preventReturnFocus && isHTMLElement(returnElement) && (returnElement === active || active === documentNode.body || focusInside || typeof returnFocus !== "boolean")) {
+					const options = { preventScroll: true };
+					if (closeType === "keyboard") options.focusVisible = true;
+					returnElement.focus(options);
+				}
+				preventReturnFocus = false;
+			});
+		};
+	});
+	createEffect(() => ({
+		disabled: disabled(),
+		open: open(),
+		floating: floating()
+	}), (state) => {
+		if (state.disabled || state.open || !state.floating) return;
+		const active = activeElement(ownerDocument(state.floating));
+		if (isTypeableElement(active) && contains(state.floating, active)) active.blur();
+	});
+	createEffect(() => ({
+		disabled: disabled(),
+		portal,
+		modal: modal(),
+		open: open(),
+		closeOnFocusOut: closeOnFocusOut(),
+		reference: domReference()
+	}), (state) => {
+		if (state.disabled || !state.portal) return;
+		state.portal.setFocusManagerState({
+			modal: state.modal,
+			open: state.open,
+			closeOnFocusOut: state.closeOnFocusOut,
+			domReference: state.reference,
+			onOpenChange: (nextOpen, details) => props.context.setOpen(nextOpen, details)
+		});
+		return () => state.portal?.setFocusManagerState(null);
+	});
+	createEffect(() => ({
+		disabled: disabled(),
+		focusElement: floatingFocusElement()
+	}), (state) => {
+		if (!state.disabled && state.focusElement) handleTabIndex(state.focusElement);
+	});
+	const shouldRenderGuards = createMemo(() => !disabled() && (modal() ? !untrappedCombobox() : true) && Boolean(portal || modal()));
+	return [
+		Show({
+			get when() {
+				return shouldRenderGuards();
+			},
+			get children() {
+				return FocusGuard({
+					"data-type": "inside",
+					ref: [portal?.setBeforeInside, props.beforeContentGuardRef],
+					onFocus: (event) => {
+						if (modal()) {
+							const elements = tabbableContent();
+							enqueueFocus(elements[elements.length - 1]);
+						} else if (portal?.portalNode()) {
+							preventReturnFocus = false;
+							if (isOutsideFocusEvent(event, portal.portalNode())) getNextTabbable(domReference())?.focus();
+							else (resolveElement(props.previousFocusableElement) ?? portal.beforeOutside())?.focus();
+							if (closeOnFocusOut()) props.context.setOpen(false, createChangeEventDetails(focusOut, event));
+						}
+					}
+				});
+			}
+		}),
+		memo(() => {
+			return escape(props.children);
+		}),
+		Show({
+			get when() {
+				return shouldRenderGuards();
+			},
+			get children() {
+				return FocusGuard({
+					"data-type": "inside",
+					ref(r$) {
+						var _ref$ = portal?.setAfterInside;
+						typeof _ref$ === "function" || Array.isArray(_ref$) ? applyRef(_ref$, r$) : portal && (portal.setAfterInside = r$);
+					},
+					onFocus: (event) => {
+						if (modal()) enqueueFocus(tabbableContent()[0]);
+						else if (portal?.portalNode()) {
+							if (closeOnFocusOut()) preventReturnFocus = true;
+							if (isOutsideFocusEvent(event, portal.portalNode())) getPreviousTabbable(domReference())?.focus();
+							else (resolveElement(props.nextFocusableElement) ?? portal.afterOutside())?.focus();
+							if (closeOnFocusOut()) props.context.setOpen(false, createChangeEventDetails(focusOut, event));
+						}
+					}
+				});
+			}
+		})
+	];
+}
+function isFocusRef(value) {
+	return Boolean(value && typeof value === "object" && !isHTMLElement(value) && "current" in value);
+}
+//#endregion
+export { FocusManager as t };

package/dist/lib/server/FormContext-pvESt85v.js

@@ -0,0 +1,17 @@
+import { createContext, useContext } from "solid-js";
+//#region src/internals/form-context/FormContext.ts
+var EMPTY_ERRORS = Object.freeze({});
+var FormContext = createContext({
+	errors: () => EMPTY_ERRORS,
+	validationMode: () => "onSubmit",
+	submitAttempted: () => false,
+	formElement: () => null,
+	clearError: () => void 0,
+	registerField: () => () => void 0,
+	getFormValues: () => ({})
+});
+function useFormContext() {
+	return useContext(FormContext);
+}
+//#endregion
+export { useFormContext as n, FormContext as t };