@proyecto-viviana/solidaria 0.2.8 → 0.4.0

package/dist/_chunk/popover.jsx

@@ -0,0 +1,574 @@
+import { o as mergeProps } from "./env.jsx";
+import { a as useLocale } from "./createCollator.jsx";
+import { r as createPreventScroll, t as createOverlay } from "./createOverlay.jsx";
+import { n as keepVisible, t as ariaHideOutside } from "./ariaHideOutside.jsx";
+import { createEffect, createSignal, onCleanup } from "solid-js";
+//#region src/popover/calculatePosition.ts
+const AXIS = {
+	top: "top",
+	bottom: "top",
+	left: "left",
+	right: "left"
+};
+const FLIPPED_DIRECTION = {
+	top: "bottom",
+	bottom: "top",
+	left: "right",
+	right: "left"
+};
+const CROSS_AXIS = {
+	top: "left",
+	left: "top"
+};
+const AXIS_SIZE = {
+	top: "height",
+	left: "width"
+};
+const TOTAL_SIZE = {
+	width: "totalWidth",
+	height: "totalHeight"
+};
+const PARSED_PLACEMENT_CACHE = {};
+function clamp(value, min, max) {
+	return Math.min(Math.max(value, min), max);
+}
+function isWebKit() {
+	return typeof window !== "undefined" && "WebkitAppearance" in document.documentElement.style;
+}
+const getVisualViewport = () => typeof document !== "undefined" ? window.visualViewport : null;
+function getContainerDimensions(containerNode, visualViewport) {
+	let width = 0, height = 0, totalWidth = 0, totalHeight = 0, top = 0, left = 0;
+	const scroll = {};
+	const isPinchZoomedIn = (visualViewport?.scale ?? 1) > 1;
+	if (containerNode.tagName === "BODY" || containerNode.tagName === "HTML") {
+		const documentElement = document.documentElement;
+		totalWidth = documentElement.clientWidth;
+		totalHeight = documentElement.clientHeight;
+		width = visualViewport?.width ?? totalWidth;
+		height = visualViewport?.height ?? totalHeight;
+		scroll.top = documentElement.scrollTop || containerNode.scrollTop;
+		scroll.left = documentElement.scrollLeft || containerNode.scrollLeft;
+		if (visualViewport) {
+			top = visualViewport.offsetTop;
+			left = visualViewport.offsetLeft;
+		}
+	} else {
+		({width, height, top, left} = getElementOffset(containerNode, false));
+		scroll.top = containerNode.scrollTop;
+		scroll.left = containerNode.scrollLeft;
+		totalWidth = width;
+		totalHeight = height;
+	}
+	if (isWebKit() && (containerNode.tagName === "BODY" || containerNode.tagName === "HTML") && isPinchZoomedIn) {
+		scroll.top = 0;
+		scroll.left = 0;
+		top = visualViewport?.pageTop ?? 0;
+		left = visualViewport?.pageLeft ?? 0;
+	}
+	return {
+		width,
+		height,
+		totalWidth,
+		totalHeight,
+		scroll,
+		top,
+		left
+	};
+}
+function getScroll(node) {
+	return {
+		top: node.scrollTop,
+		left: node.scrollLeft,
+		width: node.scrollWidth,
+		height: node.scrollHeight
+	};
+}
+function getDelta(axis, offset, size, boundaryDimensions, containerDimensions, padding, containerOffsetWithBoundary) {
+	const containerScroll = containerDimensions.scroll[axis] ?? 0;
+	const boundarySize = boundaryDimensions[AXIS_SIZE[axis]];
+	const boundaryStartEdge = containerOffsetWithBoundary[axis] + (boundaryDimensions.scroll[AXIS[axis]] ?? 0) + padding;
+	const boundaryEndEdge = containerOffsetWithBoundary[axis] + (boundaryDimensions.scroll[AXIS[axis]] ?? 0) + boundarySize - padding;
+	const startEdgeOffset = offset - containerScroll + (boundaryDimensions.scroll[AXIS[axis]] ?? 0) + containerOffsetWithBoundary[axis] - boundaryDimensions[AXIS[axis]];
+	const endEdgeOffset = offset - containerScroll + size + (boundaryDimensions.scroll[AXIS[axis]] ?? 0) + containerOffsetWithBoundary[axis] - boundaryDimensions[AXIS[axis]];
+	if (startEdgeOffset < boundaryStartEdge) return boundaryStartEdge - startEdgeOffset;
+	else if (endEdgeOffset > boundaryEndEdge) return Math.max(boundaryEndEdge - endEdgeOffset, boundaryStartEdge - startEdgeOffset);
+	else return 0;
+}
+function getMargins(node) {
+	const style = window.getComputedStyle(node);
+	return {
+		top: parseInt(style.marginTop, 10) || 0,
+		bottom: parseInt(style.marginBottom, 10) || 0,
+		left: parseInt(style.marginLeft, 10) || 0,
+		right: parseInt(style.marginRight, 10) || 0
+	};
+}
+function parsePlacement(input) {
+	if (PARSED_PLACEMENT_CACHE[input]) return PARSED_PLACEMENT_CACHE[input];
+	const [placement, crossPlacement] = input.split(" ");
+	const resolvedCrossPlacementInput = crossPlacement ?? "center";
+	const axis = AXIS[placement] || "right";
+	const crossAxis = CROSS_AXIS[axis];
+	let resolvedCrossPlacement = "center";
+	if (AXIS[resolvedCrossPlacementInput]) resolvedCrossPlacement = resolvedCrossPlacementInput;
+	const size = AXIS_SIZE[axis];
+	const crossSize = AXIS_SIZE[crossAxis];
+	PARSED_PLACEMENT_CACHE[input] = {
+		placement,
+		crossPlacement: resolvedCrossPlacement,
+		axis,
+		crossAxis,
+		size,
+		crossSize
+	};
+	return PARSED_PLACEMENT_CACHE[input];
+}
+function computePosition(childOffset, _boundaryDimensions, overlaySize, placementInfo, offset, crossOffset, _containerOffsetWithBoundary, isContainerPositioned, arrowSize, arrowBoundaryOffset, containerDimensions) {
+	const { placement, crossPlacement, axis, crossAxis, size, crossSize } = placementInfo;
+	const position = {};
+	position[crossAxis] = childOffset[crossAxis] ?? 0;
+	if (crossPlacement === "center") position[crossAxis] += ((childOffset[crossSize] ?? 0) - (overlaySize[crossSize] ?? 0)) / 2;
+	else if (crossPlacement !== crossAxis) position[crossAxis] += (childOffset[crossSize] ?? 0) - (overlaySize[crossSize] ?? 0);
+	position[crossAxis] += crossOffset;
+	const minPosition = childOffset[crossAxis] - overlaySize[crossSize] + arrowSize + arrowBoundaryOffset;
+	const maxPosition = childOffset[crossAxis] + childOffset[crossSize] - arrowSize - arrowBoundaryOffset;
+	position[crossAxis] = clamp(position[crossAxis], minPosition, maxPosition);
+	if (placement === axis) {
+		const containerHeight = isContainerPositioned ? containerDimensions[size] : containerDimensions[TOTAL_SIZE[size]];
+		position[FLIPPED_DIRECTION[axis]] = Math.floor(containerHeight - childOffset[axis] + offset);
+	} else position[axis] = Math.floor(childOffset[axis] + childOffset[size] + offset);
+	return position;
+}
+function getMaxHeight(position, boundaryDimensions, containerOffsetWithBoundary, _isContainerPositioned, margins, padding, overlayHeight, heightGrowthDirection, containerDimensions, isContainerDescendentOfBoundary, visualViewport) {
+	const overlayTop = (position.top != null ? position.top : containerDimensions[TOTAL_SIZE.height] - (position.bottom ?? 0) - overlayHeight) - (containerDimensions.scroll.top ?? 0);
+	const boundaryToContainerTransformOffset = isContainerDescendentOfBoundary ? containerOffsetWithBoundary.top : 0;
+	const boundingRect = {
+		top: Math.max(boundaryDimensions.top + boundaryToContainerTransformOffset, (visualViewport?.offsetTop ?? boundaryDimensions.top) + boundaryToContainerTransformOffset),
+		bottom: Math.min(boundaryDimensions.top + boundaryDimensions.height + boundaryToContainerTransformOffset, (visualViewport?.offsetTop ?? 0) + (visualViewport?.height ?? 0))
+	};
+	return heightGrowthDirection !== "top" ? Math.max(0, boundingRect.bottom - overlayTop - ((margins.top ?? 0) + (margins.bottom ?? 0) + padding)) : Math.max(0, overlayTop + overlayHeight - boundingRect.top - ((margins.top ?? 0) + (margins.bottom ?? 0) + padding));
+}
+function getAvailableSpace(boundaryDimensions, containerOffsetWithBoundary, childOffset, margins, padding, placementInfo, containerDimensions, isContainerDescendentOfBoundary) {
+	const { placement, axis, size } = placementInfo;
+	if (placement === axis) return Math.max(0, childOffset[axis] - (containerDimensions.scroll[axis] ?? 0) - (boundaryDimensions[axis] + (isContainerDescendentOfBoundary ? containerOffsetWithBoundary[axis] : 0)) - (margins[axis] ?? 0) - (margins[FLIPPED_DIRECTION[axis]] ?? 0) - padding);
+	return Math.max(0, boundaryDimensions[size] + boundaryDimensions[axis] + (isContainerDescendentOfBoundary ? containerOffsetWithBoundary[axis] : 0) - childOffset[axis] - childOffset[size] + (containerDimensions.scroll[axis] ?? 0) - (margins[axis] ?? 0) - (margins[FLIPPED_DIRECTION[axis]] ?? 0) - padding);
+}
+function calculatePositionInternal(placementInput, childOffset, overlaySize, _scrollSize, margins, padding, flip, boundaryDimensions, containerDimensions, containerOffsetWithBoundary, offset, crossOffset, isContainerPositioned, userSetMaxHeight, arrowSize, arrowBoundaryOffset, isContainerDescendentOfBoundary, visualViewport) {
+	let placementInfo = parsePlacement(placementInput);
+	let { size, crossAxis, crossSize, placement, crossPlacement } = placementInfo;
+	let position = computePosition(childOffset, boundaryDimensions, overlaySize, placementInfo, offset, crossOffset, containerOffsetWithBoundary, isContainerPositioned, arrowSize, arrowBoundaryOffset, containerDimensions);
+	let normalizedOffset = offset;
+	const space = getAvailableSpace(boundaryDimensions, containerOffsetWithBoundary, childOffset, margins, padding + offset, placementInfo, containerDimensions, isContainerDescendentOfBoundary);
+	if (flip && overlaySize[size] > space) {
+		const flippedPlacementInfo = parsePlacement(`${FLIPPED_DIRECTION[placement]} ${crossPlacement}`);
+		const flippedPosition = computePosition(childOffset, boundaryDimensions, overlaySize, flippedPlacementInfo, offset, crossOffset, containerOffsetWithBoundary, isContainerPositioned, arrowSize, arrowBoundaryOffset, containerDimensions);
+		if (getAvailableSpace(boundaryDimensions, containerOffsetWithBoundary, childOffset, margins, padding + offset, flippedPlacementInfo, containerDimensions, isContainerDescendentOfBoundary) > space) {
+			placementInfo = flippedPlacementInfo;
+			position = flippedPosition;
+			normalizedOffset = offset;
+		}
+	}
+	let heightGrowthDirection = "bottom";
+	if (placementInfo.axis === "top") {
+		if (placementInfo.placement === "top") heightGrowthDirection = "top";
+		else if (placementInfo.placement === "bottom") heightGrowthDirection = "bottom";
+	} else if (placementInfo.crossAxis === "top") {
+		if (placementInfo.crossPlacement === "top") heightGrowthDirection = "bottom";
+		else if (placementInfo.crossPlacement === "bottom") heightGrowthDirection = "top";
+	}
+	let delta = getDelta(crossAxis, position[crossAxis], overlaySize[crossSize], boundaryDimensions, containerDimensions, padding, containerOffsetWithBoundary);
+	position[crossAxis] += delta;
+	let maxHeight = getMaxHeight(position, boundaryDimensions, containerOffsetWithBoundary, isContainerPositioned, margins, padding, overlaySize.height, heightGrowthDirection, containerDimensions, isContainerDescendentOfBoundary, visualViewport);
+	if (userSetMaxHeight && userSetMaxHeight < maxHeight) maxHeight = userSetMaxHeight;
+	overlaySize.height = Math.min(overlaySize.height, maxHeight);
+	position = computePosition(childOffset, boundaryDimensions, overlaySize, placementInfo, normalizedOffset, crossOffset, containerOffsetWithBoundary, isContainerPositioned, arrowSize, arrowBoundaryOffset, containerDimensions);
+	delta = getDelta(crossAxis, position[crossAxis], overlaySize[crossSize], boundaryDimensions, containerDimensions, padding, containerOffsetWithBoundary);
+	position[crossAxis] += delta;
+	const arrowPosition = {};
+	({placement, crossPlacement} = placementInfo);
+	let origin = childOffset[crossAxis] - position[crossAxis] - (margins[AXIS[crossAxis]] ?? 0);
+	let preferredArrowPosition = origin + .5 * childOffset[crossSize];
+	const arrowMinPosition = arrowSize / 2 + arrowBoundaryOffset;
+	const overlayMargin = AXIS[crossAxis] === "left" ? (margins.left ?? 0) + (margins.right ?? 0) : (margins.top ?? 0) + (margins.bottom ?? 0);
+	const arrowMaxPosition = overlaySize[crossSize] - overlayMargin - arrowSize / 2 - arrowBoundaryOffset;
+	arrowPosition[crossAxis] = clamp(clamp(preferredArrowPosition, childOffset[crossAxis] + arrowSize / 2 - (position[crossAxis] + (margins[AXIS[crossAxis]] ?? 0)), childOffset[crossAxis] + childOffset[crossSize] - arrowSize / 2 - (position[crossAxis] + (margins[AXIS[crossAxis]] ?? 0))), arrowMinPosition, arrowMaxPosition);
+	if (arrowSize) origin = arrowPosition[crossAxis];
+	else if (crossPlacement === "right" || crossPlacement === "bottom") origin += childOffset[crossSize];
+	else if (crossPlacement === "center") origin += childOffset[crossSize] / 2;
+	const crossOrigin = placement === "left" || placement === "top" ? overlaySize[size] : 0;
+	const triggerAnchorPoint = {
+		x: placement === "top" || placement === "bottom" ? origin : crossOrigin,
+		y: placement === "left" || placement === "right" ? origin : crossOrigin
+	};
+	return {
+		position,
+		maxHeight,
+		arrowOffsetLeft: arrowPosition.left,
+		arrowOffsetTop: arrowPosition.top,
+		placement,
+		triggerAnchorPoint
+	};
+}
+function getRect(node, ignoreScale) {
+	const { top, left, width: bWidth, height: bHeight } = node.getBoundingClientRect();
+	let width = bWidth;
+	let height = bHeight;
+	if (ignoreScale && node instanceof (node.ownerDocument.defaultView?.HTMLElement ?? HTMLElement)) {
+		width = node.offsetWidth;
+		height = node.offsetHeight;
+	}
+	return {
+		top,
+		left,
+		width,
+		height
+	};
+}
+function getElementOffset(node, ignoreScale, overrideRect) {
+	const { top, left, width, height } = overrideRect || getRect(node, ignoreScale);
+	const { scrollTop, scrollLeft, clientTop, clientLeft } = document.documentElement;
+	return {
+		top: top + scrollTop - clientTop,
+		left: left + scrollLeft - clientLeft,
+		width,
+		height
+	};
+}
+function getPosition(node, parent, ignoreScale, overrideRect) {
+	const style = window.getComputedStyle(node);
+	let offset;
+	if (style.position === "fixed") offset = overrideRect || getRect(node, ignoreScale);
+	else {
+		offset = getElementOffset(node, ignoreScale, overrideRect);
+		const parentOffset = getElementOffset(parent, ignoreScale);
+		const parentStyle = window.getComputedStyle(parent);
+		parentOffset.top += (parseInt(parentStyle.borderTopWidth, 10) || 0) - parent.scrollTop;
+		parentOffset.left += (parseInt(parentStyle.borderLeftWidth, 10) || 0) - parent.scrollLeft;
+		offset.top -= parentOffset.top;
+		offset.left -= parentOffset.left;
+	}
+	offset.top -= parseInt(style.marginTop, 10) || 0;
+	offset.left -= parseInt(style.marginLeft, 10) || 0;
+	return offset;
+}
+function getContainingBlock(node) {
+	let offsetParent = node.offsetParent;
+	if (offsetParent && offsetParent === document.body && window.getComputedStyle(offsetParent).position === "static" && !isContainingBlock(offsetParent)) offsetParent = document.documentElement;
+	if (offsetParent == null) {
+		offsetParent = node.parentElement;
+		while (offsetParent && !isContainingBlock(offsetParent)) offsetParent = offsetParent.parentElement;
+	}
+	return offsetParent || document.documentElement;
+}
+function isContainingBlock(node) {
+	const style = window.getComputedStyle(node);
+	return style.transform !== "none" || /transform|perspective/.test(style.willChange) || style.filter !== "none" || style.contain === "paint" || "backdropFilter" in style && style.getPropertyValue("backdrop-filter") !== "none" || "WebkitBackdropFilter" in style && style.getPropertyValue("-webkit-backdrop-filter") !== "none";
+}
+/**
+* Determines where to place the overlay with regards to the target and the position of an optional indicator.
+*/
+function calculatePosition(opts) {
+	const { placement, targetNode, overlayNode, scrollNode, padding, shouldFlip, boundaryElement, offset, crossOffset, maxHeight, arrowSize, arrowBoundaryOffset = 0, targetRect } = opts;
+	const visualViewport = getVisualViewport();
+	const container = overlayNode instanceof HTMLElement ? getContainingBlock(overlayNode) : document.documentElement;
+	const isViewportContainer = container === document.documentElement;
+	const containerPositionStyle = window.getComputedStyle(container).position;
+	const isContainerPositioned = !!containerPositionStyle && containerPositionStyle !== "static";
+	const childOffset = isViewportContainer ? getElementOffset(targetNode, false, targetRect) : getPosition(targetNode, container, false, targetRect);
+	if (!isViewportContainer) {
+		const { marginTop, marginLeft } = window.getComputedStyle(targetNode);
+		childOffset.top += parseInt(marginTop, 10) || 0;
+		childOffset.left += parseInt(marginLeft, 10) || 0;
+	}
+	const overlaySize = getElementOffset(overlayNode, true);
+	const margins = getMargins(overlayNode);
+	overlaySize.width += (margins.left ?? 0) + (margins.right ?? 0);
+	overlaySize.height += (margins.top ?? 0) + (margins.bottom ?? 0);
+	return calculatePositionInternal(placement, childOffset, overlaySize, getScroll(scrollNode), margins, padding, shouldFlip, getContainerDimensions(boundaryElement, visualViewport), getContainerDimensions(container, visualViewport), getPosition(boundaryElement, container, false), offset, crossOffset, isContainerPositioned, maxHeight, arrowSize, arrowBoundaryOffset, boundaryElement.contains(container), visualViewport);
+}
+//#endregion
+//#region src/popover/createOverlayPosition.ts
+/**
+* Handles positioning overlays like popovers and menus relative to a trigger
+* element, and updating the position when the window resizes.
+*
+* Ported from @react-aria/overlays useOverlayPosition.
+*/
+const visualViewport = typeof document !== "undefined" ? window.visualViewport : null;
+function translateRTL(position, direction) {
+	if (direction === "rtl") return position.replace("start", "right").replace("end", "left");
+	return position.replace("start", "left").replace("end", "right");
+}
+/**
+* Handles positioning overlays like popovers and menus relative to a trigger
+* element, and updating the position when the window resizes.
+*/
+function createOverlayPosition(props) {
+	const locale = useLocale();
+	const direction = () => locale().direction;
+	const arrowSize = () => props.arrowSize ?? 0;
+	const targetRef = () => props.targetRef();
+	const overlayRef = () => props.overlayRef();
+	const arrowRef = () => props.arrowRef?.() ?? null;
+	const scrollRef = () => props.scrollRef?.() ?? overlayRef();
+	const placement = () => props.placement ?? "bottom";
+	const containerPadding = () => props.containerPadding ?? 12;
+	const shouldFlip = () => props.shouldFlip ?? true;
+	const boundaryElement = () => props.boundaryElement ?? (typeof document !== "undefined" ? document.body : null);
+	const offset = () => props.offset ?? 0;
+	const crossOffset = () => props.crossOffset ?? 0;
+	const shouldUpdatePosition = () => props.shouldUpdatePosition ?? true;
+	const isOpen = () => props.isOpen ?? true;
+	const onClose = () => props.onClose;
+	const maxHeight = () => props.maxHeight;
+	const arrowBoundaryOffset = () => props.arrowBoundaryOffset ?? 0;
+	const [position, setPosition] = createSignal(null);
+	let lastScale = visualViewport?.scale;
+	createEffect(() => {
+		if (isOpen()) lastScale = visualViewport?.scale;
+	});
+	const updatePosition = () => {
+		const overlayNode = overlayRef();
+		const targetNode = targetRef();
+		const boundary = boundaryElement();
+		if (!shouldUpdatePosition() || !isOpen() || !overlayNode || !targetNode || !boundary) return;
+		if (visualViewport?.scale !== lastScale) return;
+		const scrollNode = scrollRef();
+		const arrowNode = arrowRef();
+		const overlay = overlayNode;
+		if (!maxHeight() && overlayNode) {
+			overlay.style.top = "0px";
+			overlay.style.bottom = "";
+			overlay.style.maxHeight = (window.visualViewport?.height ?? window.innerHeight) + "px";
+		}
+		const result = calculatePosition({
+			placement: translateRTL(placement(), direction()),
+			overlayNode,
+			targetNode,
+			scrollNode: scrollNode || overlayNode,
+			padding: containerPadding(),
+			shouldFlip: shouldFlip(),
+			boundaryElement: boundary,
+			offset: offset(),
+			crossOffset: crossOffset(),
+			maxHeight: maxHeight(),
+			arrowSize: arrowSize() ?? (arrowNode ? getRect(arrowNode, true).width : 0),
+			arrowBoundaryOffset: arrowBoundaryOffset(),
+			targetRect: props.getTargetRect?.(targetNode)
+		});
+		if (!result.position) return;
+		overlay.style.top = "";
+		overlay.style.bottom = "";
+		overlay.style.left = "";
+		overlay.style.right = "";
+		const pos = result.position;
+		Object.keys(pos).forEach((key) => {
+			overlay.style.setProperty(key, pos[key] + "px");
+		});
+		overlay.style.maxHeight = result.maxHeight != null ? result.maxHeight + "px" : "";
+		setPosition(result);
+	};
+	createEffect(() => {
+		shouldUpdatePosition();
+		placement();
+		overlayRef();
+		targetRef();
+		arrowRef();
+		scrollRef();
+		containerPadding();
+		shouldFlip();
+		boundaryElement();
+		offset();
+		crossOffset();
+		isOpen();
+		maxHeight();
+		arrowBoundaryOffset();
+		arrowSize();
+		updatePosition();
+	});
+	createEffect(() => {
+		if (!isOpen()) return;
+		const handleResize = () => updatePosition();
+		window.addEventListener("resize", handleResize, false);
+		onCleanup(() => {
+			window.removeEventListener("resize", handleResize, false);
+		});
+	});
+	createEffect(() => {
+		const overlayNode = overlayRef();
+		if (!overlayNode || !isOpen()) return;
+		const resizeObserver = new ResizeObserver(() => updatePosition());
+		resizeObserver.observe(overlayNode);
+		onCleanup(() => {
+			resizeObserver.disconnect();
+		});
+	});
+	createEffect(() => {
+		const targetNode = targetRef();
+		if (!targetNode || !isOpen()) return;
+		const resizeObserver = new ResizeObserver(() => updatePosition());
+		resizeObserver.observe(targetNode);
+		onCleanup(() => {
+			resizeObserver.disconnect();
+		});
+	});
+	createEffect(() => {
+		if (!isOpen()) return;
+		let timeout;
+		let isResizing = false;
+		const onResize = () => {
+			isResizing = true;
+			clearTimeout(timeout);
+			timeout = setTimeout(() => {
+				isResizing = false;
+			}, 500);
+			updatePosition();
+		};
+		const onScroll = () => {
+			if (isResizing) onResize();
+		};
+		visualViewport?.addEventListener("resize", onResize);
+		visualViewport?.addEventListener("scroll", onScroll);
+		onCleanup(() => {
+			visualViewport?.removeEventListener("resize", onResize);
+			visualViewport?.removeEventListener("scroll", onScroll);
+			clearTimeout(timeout);
+		});
+	});
+	createEffect(() => {
+		const targetNode = targetRef();
+		const closeHandler = onClose();
+		if (!targetNode || !isOpen() || !closeHandler) return;
+		const handleScroll = (e) => {
+			const target = e.target;
+			if (overlayRef()?.contains(target)) return;
+			if (target !== document.body && target !== document.documentElement && target.contains(targetNode)) closeHandler();
+		};
+		document.addEventListener("scroll", handleScroll, true);
+		onCleanup(() => {
+			document.removeEventListener("scroll", handleScroll, true);
+		});
+	});
+	return {
+		overlayProps: { get style() {
+			const current = position();
+			return {
+				position: current ? "absolute" : "fixed",
+				top: !current ? 0 : void 0,
+				left: !current ? 0 : void 0,
+				"z-index": 1e5,
+				"max-height": current?.maxHeight ?? "100vh"
+			};
+		} },
+		placement: () => position()?.placement ?? null,
+		triggerAnchorPoint: () => position()?.triggerAnchorPoint ?? null,
+		arrowProps: {
+			"aria-hidden": "true",
+			role: "presentation",
+			get style() {
+				const current = position();
+				return {
+					left: current?.arrowOffsetLeft != null ? `${current.arrowOffsetLeft}px` : void 0,
+					top: current?.arrowOffsetTop != null ? `${current.arrowOffsetTop}px` : void 0
+				};
+			}
+		},
+		updatePosition
+	};
+}
+//#endregion
+//#region src/popover/createPopover.ts
+/**
+* Provides the behavior and accessibility implementation for a popover component.
+* A popover is an overlay element positioned relative to a trigger.
+*
+* Ported from @react-aria/overlays usePopover.
+*/
+/**
+* Provides the behavior and accessibility implementation for a popover component.
+* A popover is an overlay element positioned relative to a trigger.
+*/
+function createPopover(props, state) {
+	const triggerRef = () => props.triggerRef();
+	const popoverRef = () => props.popoverRef();
+	const groupRef = () => props.groupRef?.() ?? null;
+	const isNonModal = () => props.isNonModal ?? false;
+	const isKeyboardDismissDisabled = () => props.isKeyboardDismissDisabled ?? false;
+	const shouldCloseOnInteractOutside = props.shouldCloseOnInteractOutside;
+	const isSubmenu = () => props.trigger === "SubmenuTrigger";
+	const { overlayProps, underlayProps } = createOverlay({
+		get isOpen() {
+			return state.isOpen();
+		},
+		onClose: state.close,
+		get shouldCloseOnBlur() {
+			return !isSubmenu();
+		},
+		get isDismissable() {
+			return !isNonModal() || isSubmenu();
+		},
+		get isKeyboardDismissDisabled() {
+			return isKeyboardDismissDisabled();
+		},
+		get shouldCloseOnInteractOutside() {
+			return shouldCloseOnInteractOutside;
+		}
+	}, () => groupRef() ?? popoverRef());
+	const { overlayProps: positionProps, arrowProps, placement, triggerAnchorPoint } = createOverlayPosition({
+		...props,
+		targetRef: triggerRef,
+		overlayRef: popoverRef,
+		get isOpen() {
+			return state.isOpen();
+		},
+		get onClose() {
+			return isNonModal() && !isSubmenu() ? state.close : null;
+		}
+	});
+	createPreventScroll({ get isDisabled() {
+		return isNonModal() || !state.isOpen();
+	} });
+	createEffect(() => {
+		if (state.isOpen() && popoverRef()) {
+			const element = groupRef() ?? popoverRef();
+			if (!element) return;
+			let cleanup;
+			if (isNonModal()) cleanup = keepVisible(element);
+			else cleanup = ariaHideOutside([element], { shouldUseInert: true });
+			onCleanup(() => {
+				cleanup?.();
+			});
+		}
+	});
+	const merged = mergeProps(overlayProps, positionProps);
+	return {
+		popoverProps: new Proxy(merged, {
+			get(target, key) {
+				if (key === "style") return positionProps.style;
+				return target[key];
+			},
+			has(target, key) {
+				return key in target;
+			},
+			ownKeys(target) {
+				return Reflect.ownKeys(target);
+			},
+			getOwnPropertyDescriptor(target, key) {
+				if (key === "style") return {
+					configurable: true,
+					enumerable: true,
+					get: () => positionProps.style
+				};
+				return Reflect.getOwnPropertyDescriptor(target, key);
+			}
+		}),
+		arrowProps,
+		underlayProps,
+		placement,
+		triggerAnchorPoint
+	};
+}
+//#endregion
+export { createOverlayPosition as n, calculatePosition as r, createPopover as t };
+
+//# sourceMappingURL=popover.jsx.map