@proyecto-viviana/solidaria 0.2.8 → 0.4.0

package/dist/_chunk/utils.js

@@ -0,0 +1,665 @@
+import { r as isTestEnv } from "./env.js";
+import { s as getOwnerDocument, u as getScrollParents } from "./focus.js";
+import { createEffect, createSignal, onCleanup } from "solid-js";
+import { isServer } from "solid-js/web";
+//#region src/utils/platform.ts
+function getNavigator() {
+	if (typeof window === "undefined" || window.navigator == null) return null;
+	return window.navigator;
+}
+function testPlatform(re) {
+	const nav = getNavigator();
+	if (!nav) return false;
+	return re.test(nav.platform || nav.userAgentData?.platform || "");
+}
+function testUserAgent(re) {
+	const nav = getNavigator();
+	return nav ? re.test(nav.userAgent) : false;
+}
+function isMac() {
+	return testPlatform(/^Mac/i);
+}
+function isIPhone() {
+	return testPlatform(/^iPhone/i);
+}
+function isIPad() {
+	return testPlatform(/^iPad/i) || isMac() && navigator.maxTouchPoints > 1;
+}
+function isIOS() {
+	return isIPhone() || isIPad();
+}
+function isAppleDevice() {
+	return isMac() || isIOS();
+}
+function isWebKit() {
+	return testUserAgent(/AppleWebKit/i) && !isChrome();
+}
+function isChrome() {
+	return testUserAgent(/Chrome/i);
+}
+function isAndroid() {
+	return testUserAgent(/Android/i);
+}
+function isFirefox() {
+	return testUserAgent(/Firefox/i);
+}
+//#endregion
+//#region src/utils/scrollIntoView.ts
+/**
+* Scroll-into-view utilities.
+* Based on @react-aria/utils scrollIntoView (react-aria/src/utils/scrollIntoView.ts).
+*/
+/**
+* Scrolls `scrollView` so that `element` is visible.
+* Similar to `element.scrollIntoView({block: 'nearest'})` (not supported in Edge),
+* but doesn't affect parents above `scrollView`.
+*/
+function scrollIntoView(scrollView, element, opts = {}) {
+	const { block = "nearest", inline = "nearest" } = opts;
+	if (scrollView === element) return;
+	let y = scrollView.scrollTop;
+	let x = scrollView.scrollLeft;
+	const target = element.getBoundingClientRect();
+	const view = scrollView.getBoundingClientRect();
+	const itemStyle = window.getComputedStyle(element);
+	const viewStyle = window.getComputedStyle(scrollView);
+	const root = document.scrollingElement || document.documentElement;
+	const isRoot = scrollView === root;
+	const viewTop = scrollView === root ? 0 : view.top;
+	const viewBottom = scrollView === root ? scrollView.clientHeight : view.bottom;
+	const viewLeft = scrollView === root ? 0 : view.left;
+	const viewRight = scrollView === root ? scrollView.clientWidth : view.right;
+	const scrollMarginTop = parseFloat(itemStyle.scrollMarginTop) || 0;
+	const scrollMarginBottom = parseFloat(itemStyle.scrollMarginBottom) || 0;
+	const scrollMarginLeft = parseFloat(itemStyle.scrollMarginLeft) || 0;
+	const scrollMarginRight = parseFloat(itemStyle.scrollMarginRight) || 0;
+	const scrollPaddingTop = parseFloat(viewStyle.scrollPaddingTop) || 0;
+	const scrollPaddingBottom = parseFloat(viewStyle.scrollPaddingBottom) || 0;
+	const scrollPaddingLeft = parseFloat(viewStyle.scrollPaddingLeft) || 0;
+	const scrollPaddingRight = parseFloat(viewStyle.scrollPaddingRight) || 0;
+	const borderTopWidth = parseFloat(viewStyle.borderTopWidth) || 0;
+	const borderBottomWidth = parseFloat(viewStyle.borderBottomWidth) || 0;
+	const borderLeftWidth = parseFloat(viewStyle.borderLeftWidth) || 0;
+	const borderRightWidth = parseFloat(viewStyle.borderRightWidth) || 0;
+	const scrollAreaTop = target.top - scrollMarginTop;
+	const scrollAreaBottom = target.bottom + scrollMarginBottom;
+	const scrollAreaLeft = target.left - scrollMarginLeft;
+	const scrollAreaRight = target.right + scrollMarginRight;
+	const scrollBarOffsetX = scrollView === root ? 0 : borderLeftWidth + borderRightWidth;
+	const scrollBarOffsetY = scrollView === root ? 0 : borderTopWidth + borderBottomWidth;
+	const scrollBarWidth = scrollView === root ? 0 : scrollView.offsetWidth - scrollView.clientWidth - scrollBarOffsetX;
+	const scrollBarHeight = scrollView === root ? 0 : scrollView.offsetHeight - scrollView.clientHeight - scrollBarOffsetY;
+	const scrollPortTop = viewTop + (isRoot ? 0 : borderTopWidth) + scrollPaddingTop;
+	const scrollPortBottom = viewBottom - (isRoot ? 0 : borderBottomWidth) - scrollPaddingBottom - scrollBarHeight;
+	let scrollPortLeft = viewLeft + (isRoot ? 0 : borderLeftWidth) + scrollPaddingLeft;
+	let scrollPortRight = viewRight - (isRoot ? 0 : borderRightWidth) - scrollPaddingRight;
+	if (viewStyle.direction === "rtl" && !isIOS()) scrollPortLeft += scrollBarWidth;
+	else scrollPortRight -= scrollBarWidth;
+	const shouldScrollBlock = scrollAreaTop < scrollPortTop || scrollAreaBottom > scrollPortBottom;
+	const shouldScrollInline = scrollAreaLeft < scrollPortLeft || scrollAreaRight > scrollPortRight;
+	if (shouldScrollBlock && block === "start") y += scrollAreaTop - scrollPortTop;
+	else if (shouldScrollBlock && block === "center") y += (scrollAreaTop + scrollAreaBottom) / 2 - (scrollPortTop + scrollPortBottom) / 2;
+	else if (shouldScrollBlock && block === "end") y += scrollAreaBottom - scrollPortBottom;
+	else if (shouldScrollBlock && block === "nearest") {
+		const start = scrollAreaTop - scrollPortTop;
+		const end = scrollAreaBottom - scrollPortBottom;
+		y += Math.abs(start) <= Math.abs(end) ? start : end;
+	}
+	if (shouldScrollInline && inline === "start") x += scrollAreaLeft - scrollPortLeft;
+	else if (shouldScrollInline && inline === "center") x += (scrollAreaLeft + scrollAreaRight) / 2 - (scrollPortLeft + scrollPortRight) / 2;
+	else if (shouldScrollInline && inline === "end") x += scrollAreaRight - scrollPortRight;
+	else if (shouldScrollInline && inline === "nearest") {
+		const start = scrollAreaLeft - scrollPortLeft;
+		const end = scrollAreaRight - scrollPortRight;
+		x += Math.abs(start) <= Math.abs(end) ? start : end;
+	}
+	if (isTestEnv()) {
+		scrollView.scrollLeft = x;
+		scrollView.scrollTop = y;
+		return;
+	}
+	scrollView.scrollTo({
+		left: x,
+		top: y
+	});
+}
+/**
+* Scrolls the `targetElement` so it is visible in the viewport. Accepts an optional
+* `opts.containingElement` that will be centered in the viewport prior to scrolling the
+* targetElement into view. If scrolling is prevented on the body (e.g. targetElement is in a
+* popover), this will only scroll the scroll parents of the targetElement up to but not including
+* the body itself.
+*/
+function scrollIntoViewport(targetElement, opts = {}) {
+	const { containingElement } = opts;
+	if (targetElement && targetElement.isConnected) {
+		const root = document.scrollingElement || document.documentElement;
+		if (!(window.getComputedStyle(root).overflow === "hidden")) {
+			const { left: originalLeft, top: originalTop } = targetElement.getBoundingClientRect();
+			targetElement?.scrollIntoView?.({ block: "nearest" });
+			const { left: newLeft, top: newTop } = targetElement.getBoundingClientRect();
+			if (Math.abs(originalLeft - newLeft) > 1 || Math.abs(originalTop - newTop) > 1) {
+				containingElement?.scrollIntoView?.({
+					block: "center",
+					inline: "center"
+				});
+				targetElement.scrollIntoView?.({ block: "nearest" });
+			}
+		} else {
+			const { left: originalLeft, top: originalTop } = targetElement.getBoundingClientRect();
+			let scrollParents = getScrollParents(targetElement, true);
+			for (const scrollParent of scrollParents) scrollIntoView(scrollParent, targetElement);
+			const { left: newLeft, top: newTop } = targetElement.getBoundingClientRect();
+			if (Math.abs(originalLeft - newLeft) > 1 || Math.abs(originalTop - newTop) > 1) {
+				scrollParents = containingElement ? getScrollParents(containingElement, true) : [];
+				for (const scrollParent of scrollParents) scrollIntoView(scrollParent, containingElement, {
+					block: "center",
+					inline: "center"
+				});
+				for (const scrollParent of getScrollParents(targetElement, true)) scrollIntoView(scrollParent, targetElement);
+			}
+		}
+	}
+}
+//#endregion
+//#region src/utils/geometry.ts
+/**
+* Checks if two rectangles overlap.
+*/
+function areRectanglesOverlapping(a, b) {
+	if (a.left > b.right || b.left > a.right) return false;
+	if (a.top > b.bottom || b.top > a.bottom) return false;
+	return true;
+}
+/**
+* Gets the bounding rectangle for an event point (touch/pointer).
+* Takes into account the size of the touch point.
+*/
+function getPointClientRect(point) {
+	let offsetX = 0;
+	let offsetY = 0;
+	if (point.width !== void 0 && point.width > 0) offsetX = point.width / 2;
+	else if (point.radiusX !== void 0 && point.radiusX > 0) offsetX = point.radiusX;
+	if (point.height !== void 0 && point.height > 0) offsetY = point.height / 2;
+	else if (point.radiusY !== void 0 && point.radiusY > 0) offsetY = point.radiusY;
+	return {
+		top: point.clientY - offsetY,
+		right: point.clientX + offsetX,
+		bottom: point.clientY + offsetY,
+		left: point.clientX - offsetX
+	};
+}
+/**
+* Checks if a pointer/touch point is over an element.
+*/
+function isPointOverTarget(point, target) {
+	const rect = target.getBoundingClientRect();
+	const pointRect = getPointClientRect(point);
+	return areRectanglesOverlapping({
+		top: rect.top,
+		right: rect.right,
+		bottom: rect.bottom,
+		left: rect.left
+	}, pointRect);
+}
+/**
+* Gets the first touch from a TouchEvent's targetTouches.
+*/
+function getTouchFromEvent(event) {
+	const { targetTouches } = event;
+	if (targetTouches.length > 0) return targetTouches[0];
+	return null;
+}
+/**
+* Finds a touch by its identifier in changedTouches.
+*/
+function getTouchById(event, pointerId) {
+	if (pointerId == null) return null;
+	const { changedTouches } = event;
+	for (let i = 0; i < changedTouches.length; i++) {
+		const touch = changedTouches[i];
+		if (touch.identifier === pointerId) return touch;
+	}
+	return null;
+}
+//#endregion
+//#region src/utils/events.ts
+/**
+* Event utilities for detecting virtual clicks and event handling.
+* Based on @react-aria/utils event utilities.
+*/
+/**
+* Checks if a click event was generated from a virtual source like a screen reader.
+* Virtual clicks typically have detail of 0 and may have zero coordinates.
+*/
+function isVirtualClick(event) {
+	if (event.pointerType === "" && event.isTrusted) return true;
+	if (isAndroid() && event.pointerType) return event.type === "click" && event.buttons === 1;
+	return event.detail === 0 && !event.pointerType;
+}
+/**
+* Checks if a pointer event was generated by a virtual source.
+* iOS VoiceOver fires pointer events with incorrect coordinates.
+* These events have zero width/height.
+*/
+function isVirtualPointerEvent(event) {
+	return !isAndroid() && event.width === 0 && event.height === 0 || event.width === 1 && event.height === 1 && event.pressure === 0 && event.detail === 0 && event.pointerType === "mouse";
+}
+/**
+* Creates a synthetic mouse event for programmatic clicking.
+*/
+function createMouseEvent(type, nativeEvent) {
+	const init = {
+		bubbles: true,
+		cancelable: true,
+		view: window
+	};
+	if (nativeEvent) {
+		const e = nativeEvent;
+		init.screenX = e.screenX;
+		init.screenY = e.screenY;
+		init.clientX = e.clientX;
+		init.clientY = e.clientY;
+		init.ctrlKey = e.ctrlKey;
+		init.shiftKey = e.shiftKey;
+		init.altKey = e.altKey;
+		init.metaKey = e.metaKey;
+		init.button = e.button;
+		init.buttons = e.buttons;
+		init.relatedTarget = e.relatedTarget;
+	}
+	return new MouseEvent(type, init);
+}
+/**
+* Creates a chain of event handlers that calls each in sequence.
+*/
+function chain(...callbacks) {
+	return ((...args) => {
+		for (const callback of callbacks) if (typeof callback === "function") callback(...args);
+	});
+}
+/**
+* Sets the target property on an event object.
+* Used for synthetic events where target needs to be modified.
+*/
+function setEventTarget(event, target) {
+	Object.defineProperty(event, "target", {
+		value: target,
+		writable: false,
+		configurable: true
+	});
+	Object.defineProperty(event, "currentTarget", {
+		value: target,
+		writable: false,
+		configurable: true
+	});
+}
+//#endregion
+//#region src/utils/textSelection.ts
+/**
+* Text selection management utilities.
+* Based on @react-aria/interactions textSelection utilities.
+*
+* On iOS, long press triggers text selection. The only way to prevent this
+* is to set user-select: none on the entire page. On other platforms,
+* we can just set it on the target element.
+*/
+let state = "default";
+let savedUserSelect = "";
+let modifiedElementMap = /* @__PURE__ */ new WeakMap();
+/**
+* Disables text selection on the page or element during press.
+* On iOS, applies to the entire document. On other platforms, just the target.
+*/
+function disableTextSelection(target) {
+	if (isIOS()) {
+		if (state === "default") {
+			const documentElement = getOwnerDocument(target).documentElement;
+			savedUserSelect = documentElement.style.webkitUserSelect;
+			documentElement.style.webkitUserSelect = "none";
+		}
+		state = "disabled";
+	} else if (target) {
+		const element = target;
+		if (!modifiedElementMap.has(element)) {
+			modifiedElementMap.set(element, element.style.userSelect);
+			element.style.userSelect = "none";
+		}
+	}
+}
+/**
+* Restores text selection after press ends.
+* On iOS, waits 300ms to avoid selection appearing during tap.
+*/
+function restoreTextSelection(target) {
+	if (isIOS()) {
+		if (state !== "disabled") return;
+		state = "restoring";
+		setTimeout(() => {
+			runAfterTransition(() => {
+				if (state === "restoring") {
+					const documentElement = getOwnerDocument(target).documentElement;
+					if (savedUserSelect) documentElement.style.webkitUserSelect = savedUserSelect;
+					else documentElement.style.removeProperty("-webkit-user-select");
+					savedUserSelect = "";
+					state = "default";
+				}
+			});
+		}, 300);
+	} else if (target) {
+		const element = target;
+		const savedValue = modifiedElementMap.get(element);
+		if (savedValue !== void 0) {
+			if (savedValue) element.style.userSelect = savedValue;
+			else element.style.removeProperty("user-select");
+			modifiedElementMap.delete(element);
+		}
+	}
+}
+const pendingTransitions = /* @__PURE__ */ new Set();
+let transitionTimeout = null;
+/**
+* Runs a callback after CSS transitions complete.
+* Batches multiple callbacks to avoid unnecessary layout thrashing.
+*/
+function runAfterTransition(callback) {
+	pendingTransitions.add(callback);
+	if (transitionTimeout != null) clearTimeout(transitionTimeout);
+	transitionTimeout = setTimeout(() => {
+		for (const cb of pendingTransitions) cb();
+		pendingTransitions.clear();
+		transitionTimeout = null;
+	}, 0);
+}
+//#endregion
+//#region src/utils/keyboard.ts
+/**
+* Keyboard / modifier-key helpers.
+* Based on @react-aria/utils' keyboard utilities.
+*/
+/**
+* Returns whether the platform's non-contiguous selection modifier is pressed:
+* the Command key on macOS, the Control key elsewhere. Mirrors
+* `@react-aria/utils`' `isCtrlKeyPressed`.
+*/
+function isCtrlKeyPressed(e) {
+	if (isMac()) return e.metaKey === true;
+	return e.ctrlKey === true;
+}
+//#endregion
+//#region src/utils/globalListeners.ts
+/**
+* Global listener management utility.
+* Based on @react-aria/utils useGlobalListeners hook, adapted for SolidJS.
+*
+* In SolidJS, we use onCleanup for automatic cleanup instead of useEffect return.
+*/
+/**
+* Creates a manager for global event listeners that automatically cleans up.
+* Use this in a component to register document/window level listeners
+* that will be removed when the component unmounts.
+*/
+function createGlobalListeners() {
+	const listeners = [];
+	function addGlobalListener(type, handler, options) {
+		const target = options?.isWindow ? window : document;
+		const listenerOptions = options ? {
+			capture: options.capture,
+			passive: options.passive,
+			once: options.once
+		} : void 0;
+		target.addEventListener(type, handler, listenerOptions);
+		listeners.push({
+			target,
+			type,
+			handler,
+			options: listenerOptions
+		});
+	}
+	function removeGlobalListener(type, handler, options) {
+		const target = options?.isWindow ? window : document;
+		const listenerOptions = options ? { capture: options.capture } : void 0;
+		target.removeEventListener(type, handler, listenerOptions);
+		const index = listeners.findIndex((l) => l.target === target && l.type === type && l.handler === handler && l.options?.capture === listenerOptions?.capture);
+		if (index !== -1) listeners.splice(index, 1);
+	}
+	/**
+	* Removes all registered global listeners.
+	*/
+	function removeAllGlobalListeners() {
+		for (const { target, type, handler, options } of listeners) target.removeEventListener(type, handler, options);
+		listeners.length = 0;
+	}
+	onCleanup(removeAllGlobalListeners);
+	return {
+		addGlobalListener,
+		removeGlobalListener,
+		removeAllGlobalListeners
+	};
+}
+/**
+* Simple utility to add a single global listener with automatic cleanup.
+* For one-off listeners where the full manager isn't needed.
+*/
+function addGlobalListenerOnce(type, handler, options) {
+	const target = options?.isWindow ? window : document;
+	const listenerOptions = options ? {
+		capture: options.capture,
+		passive: options.passive,
+		once: options.once
+	} : void 0;
+	target.addEventListener(type, handler, listenerOptions);
+	return () => {
+		target.removeEventListener(type, handler, listenerOptions);
+	};
+}
+//#endregion
+//#region src/utils/createDescription.ts
+/**
+* createDescription - Creates a hidden element for dynamic aria-describedby content.
+*
+* This utility creates a visually hidden element containing description text and
+* returns an aria-describedby prop pointing to it. Multiple components using the
+* same description will share the same element (reference counted).
+*
+* Port of @react-aria/utils/useDescription.
+*
+* @example
+* ```tsx
+* function SortableColumn(props) {
+*   const descriptionProps = createDescription(
+*     () => props.sortDirection ? `Sorted ${props.sortDirection}` : undefined
+*   );
+*
+*   return (
+*     <th {...descriptionProps}>
+*       {props.children}
+*     </th>
+*   );
+* }
+* ```
+*/
+let descriptionId = 0;
+const descriptionNodes = /* @__PURE__ */ new Map();
+/**
+* Creates an invisible description element and returns aria-describedby props.
+*
+* The element is created in the DOM and reference counted - multiple uses of
+* the same description text will share the same element. When all references
+* are removed, the element is cleaned up.
+*
+* @param description - Accessor that returns the description text, or undefined
+* @returns Object with aria-describedby prop (or empty object if no description)
+*
+* @example
+* ```tsx
+* const descProps = createDescription(() => 'Press Enter to submit');
+* return <button {...descProps}>Submit</button>;
+* ```
+*/
+function createDescription(description) {
+	if (isServer) return {};
+	const [id, setId] = createSignal();
+	createEffect(() => {
+		const desc = description();
+		if (!desc) {
+			setId(void 0);
+			return;
+		}
+		let node = descriptionNodes.get(desc);
+		if (!node) {
+			const newId = `solidaria-description-${descriptionId++}`;
+			setId(newId);
+			const element = document.createElement("div");
+			element.id = newId;
+			element.style.display = "none";
+			element.textContent = desc;
+			document.body.appendChild(element);
+			node = {
+				refCount: 0,
+				element
+			};
+			descriptionNodes.set(desc, node);
+		} else setId(node.element.id);
+		node.refCount++;
+		onCleanup(() => {
+			if (node && --node.refCount === 0) {
+				node.element.remove();
+				descriptionNodes.delete(desc);
+			}
+		});
+	});
+	return { get "aria-describedby"() {
+		return description() ? id() : void 0;
+	} };
+}
+/**
+* Utility to get all active description nodes (for testing).
+* @internal
+*/
+function getDescriptionNodeCount() {
+	return descriptionNodes.size;
+}
+/**
+* Utility to clear all description nodes (for testing cleanup).
+* @internal
+*/
+function clearDescriptionNodes() {
+	for (const [, node] of descriptionNodes) node.element.remove();
+	descriptionNodes.clear();
+}
+//#endregion
+//#region src/utils/animation.ts
+/**
+* Enter/exit animation primitives for Solidaria.
+*
+* A faithful SolidJS port of `react-aria`'s `useEnterAnimation` /
+* `useExitAnimation` (react-aria/src/utils/animation.ts). These drive the
+* `data-entering` / `data-exiting` render-prop flags that overlay styles key
+* their motion tokens off of (opacity/translate transitions on Modal, Popover,
+* Tooltip, …). Without them a styled overlay ships the tokens but never flips
+* the state that triggers the transition, so it appears/disappears instantly.
+*
+* Two mechanisms are covered, exactly as upstream:
+*   1. CSS `@keyframes` — the `animation` property is present while entering and
+*      removed when the animation finishes.
+*   2. CSS transitions — the initial styles apply while entering and are removed
+*      immediately, so the transition plays. Premature transitions triggered
+*      before the ready state (e.g. a popover positioned after mount) are
+*      cancelled so only the intended enter transition runs.
+*
+* SolidJS notes:
+* - Refs are passed as accessors (`() => element`) rather than React ref
+*   objects, so a signal-backed ref re-runs the effect when the element mounts.
+* - `isReady` gates the enter animation. In React the caller unmounts the
+*   overlay while closed, so the hook re-initializes per open; a Solid component
+*   often stays mounted with its overlay behind a `<Show>`, so pass
+*   `isReady={isOpen}` to defer the enter until the element actually mounts.
+* - `createEffect` replaces `useLayoutEffect`; effects never run during SSR, so
+*   the `CSSTransition` reference is only touched on the client.
+*/
+/**
+* Runs `onEnd` once the element's animations settle while `isActive` is true.
+* Mirrors the private `useAnimation` helper in react-aria's animation utils.
+*/
+function createAnimation(ref, isActive, onEnd) {
+	createEffect(() => {
+		if (!isActive()) return;
+		const element = ref();
+		if (!element) return;
+		if (!("getAnimations" in element)) {
+			onEnd();
+			return;
+		}
+		const animations = element.getAnimations();
+		if (animations.length === 0) {
+			onEnd();
+			return;
+		}
+		let canceled = false;
+		Promise.allSettled(animations.map((animation) => animation.finished)).then(() => {
+			if (!canceled) onEnd();
+		});
+		onCleanup(() => {
+			canceled = true;
+		});
+	});
+}
+/**
+* Tracks whether an element is playing its enter animation.
+*
+* Returns an accessor that is `true` while the element should carry
+* `data-entering` (its initial, pre-transition styles), then flips to `false`
+* once the animation is set up — which removes the initial styles and lets the
+* CSS transition play.
+*
+* @param ref - Accessor for the animated element.
+* @param isReady - Whether the element is ready to animate in. Defaults to
+*   `true`. Pass an `isOpen` accessor when the component stays mounted while the
+*   overlay is hidden, so the enter state does not resolve before the element
+*   mounts.
+*/
+function createEnterAnimation(ref, isReady = () => true) {
+	const [isEntering, setIsEntering] = createSignal(true);
+	const isAnimationReady = () => isEntering() && isReady();
+	createEffect(() => {
+		if (!isAnimationReady()) return;
+		const element = ref();
+		if (!element || !("getAnimations" in element)) return;
+		for (const animation of element.getAnimations()) if (animation instanceof CSSTransition) animation.cancel();
+	});
+	createAnimation(ref, isAnimationReady, () => setIsEntering(false));
+	return isAnimationReady;
+}
+/**
+* Tracks whether an element is playing its exit animation.
+*
+* Keeps the caller informed so the element can stay mounted (`isOpen ||
+* isExiting`) until its exit transition finishes. Implements the same
+* `'closed' | 'open' | 'exiting'` state machine as react-aria's
+* `useExitAnimation`, including interruption: reopening mid-exit returns to the
+* open state.
+*
+* @param ref - Accessor for the animated element.
+* @param isOpen - Whether the element is currently open.
+*/
+function createExitAnimation(ref, isOpen) {
+	const [exitState, setExitState] = createSignal(isOpen() ? "open" : "closed");
+	createEffect(() => {
+		const open = isOpen();
+		setExitState((current) => {
+			if (current === "open" && !open) return "exiting";
+			if ((current === "closed" || current === "exiting") && open) return "open";
+			return current;
+		});
+	});
+	const isExiting = () => exitState() === "exiting";
+	createAnimation(ref, isExiting, () => {
+		setExitState((state) => state === "exiting" ? "closed" : state);
+	});
+	return isExiting;
+}
+//#endregion
+export { isMac as A, isAndroid as C, isIOS as D, isFirefox as E, isIPad as O, scrollIntoViewport as S, isChrome as T, getPointClientRect as _, getDescriptionNodeCount as a, isPointOverTarget as b, isCtrlKeyPressed as c, chain as d, createMouseEvent as f, areRectanglesOverlapping as g, setEventTarget as h, createDescription as i, isWebKit as j, isIPhone as k, disableTextSelection as l, isVirtualPointerEvent as m, createExitAnimation as n, addGlobalListenerOnce as o, isVirtualClick as p, clearDescriptionNodes as r, createGlobalListeners as s, createEnterAnimation as t, restoreTextSelection as u, getTouchById as v, isAppleDevice as w, scrollIntoView as x, getTouchFromEvent as y };
+
+//# sourceMappingURL=utils.js.map