@tamagui/popover 2.7.7 → 3.0.0-beta.643.1

package/dist/cjs/Popover.native.cjs

@@ -0,0 +1,603 @@
+"use strict";
+
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: () => from[key],
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Popover_exports = {};
+__export(Popover_exports, {
+	Popover: () => Popover,
+	PopoverAnchor: () => PopoverAnchor,
+	PopoverArrow: () => PopoverArrow,
+	PopoverClose: () => PopoverClose,
+	PopoverContent: () => PopoverContent,
+	PopoverContext: () => PopoverContext,
+	PopoverContextProvider: () => PopoverContextProvider,
+	PopoverTrigger: () => PopoverTrigger,
+	PopoverTriggerContext: () => PopoverTriggerContext,
+	PopoverZIndexContext: () => PopoverZIndexContext,
+	closeLastOpenedPopover: () => closeLastOpenedPopover,
+	closeOpenPopovers: () => closeOpenPopovers,
+	hasOpenPopovers: () => hasOpenPopovers,
+	usePopoverContext: () => usePopoverContext,
+	usePopoverOpen: () => usePopoverOpen,
+	usePopoverTriggerContext: () => usePopoverTriggerContext,
+	usePopoverTriggerSetup: () => usePopoverTriggerSetup
+});
+module.exports = __toCommonJS(Popover_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+require("@tamagui/polyfill-dev");
+var import_adapt = require("@tamagui/adapt");
+var import_animate = require("@tamagui/animate");
+var import_animate_presence = require("@tamagui/animate-presence");
+var import_compose_refs = require("@tamagui/compose-refs");
+var import_constants = require("@tamagui/constants");
+var import_core = require("@tamagui/core");
+var import_dismissable = require("@tamagui/dismissable");
+var import_floating = require("@tamagui/floating");
+var import_focus_scope = require("@tamagui/focus-scope");
+var import_helpers = require("@tamagui/helpers");
+var import_popper = require("@tamagui/popper");
+var import_portal = require("@tamagui/portal");
+require("@tamagui/remove-scroll");
+var import_scroll_view = require("@tamagui/scroll-view");
+var import_stacks = require("@tamagui/stacks");
+var import_use_controllable_state = require("@tamagui/use-controllable-state");
+var React = __toESM(require("react"), 1);
+var import_useFloatingContext = require("./useFloatingContext.native.js");
+var needsRepropagation = (0, import_portal.needsPortalRepropagation)();
+var openPopovers = /* @__PURE__ */ new Set();
+var hasOpenPopovers = function() {
+	return openPopovers.size > 0;
+};
+var closeOpenPopovers = function() {
+	if (openPopovers.size === 0) return false;
+	openPopovers.forEach(function(setOpen) {
+		return setOpen(false);
+	});
+	return true;
+};
+var closeLastOpenedPopover = function() {
+	if (openPopovers.size === 0) return false;
+	var last = Array.from(openPopovers).pop();
+	if (last) {
+		last(false);
+		return true;
+	}
+	return false;
+};
+var PopoverContext = (0, import_core.createStyledContext)({}, "Popover__");
+var PopoverZIndexContext = /* @__PURE__ */ React.createContext(void 0);
+var PopoverTriggerContext = (0, import_core.createStyledContext)({}, "PopoverTrigger__");
+var usePopoverContext = PopoverContext.useStyledContext;
+var usePopoverTriggerContext = PopoverTriggerContext.useStyledContext;
+function usePopoverOpen(scope) {
+	return usePopoverContext(scope).open;
+}
+function usePopoverTriggerSetup(open) {
+	var triggerStateSettersRef = React.useRef(/* @__PURE__ */ new Map());
+	var activeTriggerIdRef = React.useRef(null);
+	var setActiveTrigger = (0, import_core.useEvent)(function(id) {
+		var prevId = activeTriggerIdRef.current;
+		if (prevId === id) return;
+		if (prevId) {
+			var _triggerStateSettersRef_current_get;
+			(_triggerStateSettersRef_current_get = triggerStateSettersRef.current.get(prevId)) === null || _triggerStateSettersRef_current_get === void 0 || _triggerStateSettersRef_current_get(false);
+		}
+		activeTriggerIdRef.current = id;
+		if (id && open) {
+			var _triggerStateSettersRef_current_get1;
+			(_triggerStateSettersRef_current_get1 = triggerStateSettersRef.current.get(id)) === null || _triggerStateSettersRef_current_get1 === void 0 || _triggerStateSettersRef_current_get1(true);
+		}
+	});
+	var registerTrigger = (0, import_core.useEvent)(function(id, setOpenState) {
+		triggerStateSettersRef.current.set(id, setOpenState);
+		setOpenState(activeTriggerIdRef.current === id && open);
+	});
+	var unregisterTrigger = (0, import_core.useEvent)(function(id) {
+		triggerStateSettersRef.current.delete(id);
+		if (activeTriggerIdRef.current === id) activeTriggerIdRef.current = null;
+	});
+	React.useEffect(function() {
+		if (!open) {
+			setActiveTrigger(null);
+			return;
+		}
+		var activeId = activeTriggerIdRef.current;
+		if (activeId) {
+			var _triggerStateSettersRef_current_get;
+			(_triggerStateSettersRef_current_get = triggerStateSettersRef.current.get(activeId)) === null || _triggerStateSettersRef_current_get === void 0 || _triggerStateSettersRef_current_get(true);
+		}
+	}, [open, setActiveTrigger]);
+	return {
+		setActiveTrigger,
+		registerTrigger,
+		unregisterTrigger
+	};
+}
+var PopoverContextProvider = /* @__PURE__ */ React.memo(function(param) {
+	var { scope, children, open, onOpenChange, onOpenToggle, triggerRef, id = "", contentId, hasCustomAnchor = false, onCustomAnchorAdd = voidFn, onCustomAnchorRemove = voidFn, anchorTo, adaptScope, breakpointActive, keepChildrenMounted, disableDismissable, hoverable } = param;
+	var [branches] = React.useState(function() {
+		return /* @__PURE__ */ new Set();
+	});
+	var { setActiveTrigger, registerTrigger, unregisterTrigger } = usePopoverTriggerSetup(open);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(PopoverContext.Provider, {
+		scope,
+		popoverScope: scope,
+		adaptScope,
+		id,
+		contentId,
+		triggerRef,
+		open,
+		onOpenChange,
+		onOpenToggle,
+		hasCustomAnchor,
+		onCustomAnchorAdd,
+		onCustomAnchorRemove,
+		anchorTo,
+		branches,
+		breakpointActive,
+		keepChildrenMounted,
+		disableDismissable,
+		hoverable,
+		children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(PopoverTriggerContext.Provider, {
+			scope,
+			triggerRef,
+			hasCustomAnchor,
+			anchorTo,
+			branches,
+			onOpenToggle,
+			setActiveTrigger,
+			registerTrigger,
+			unregisterTrigger,
+			children
+		})
+	});
+});
+var voidFn = function() {};
+var PopoverAnchor = /* @__PURE__ */ React.memo((0, import_core.createRefComponent)(function PopoverAnchor2(props, forwardedRef) {
+	var { scope, ...rest } = props;
+	var { onCustomAnchorAdd, onCustomAnchorRemove } = usePopoverContext(scope) || {};
+	React.useEffect(function() {
+		onCustomAnchorAdd();
+		return function() {
+			return onCustomAnchorRemove();
+		};
+	}, [onCustomAnchorAdd, onCustomAnchorRemove]);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_popper.PopperAnchor, {
+		scope,
+		...rest,
+		ref: forwardedRef
+	});
+}));
+var PopoverTrigger = /* @__PURE__ */ React.memo((0, import_core.createRefComponent)(function PopoverTrigger2(props, forwardedRef) {
+	var { scope, disablePressTrigger, ...rest } = props;
+	var triggerContext = usePopoverTriggerContext(scope);
+	var triggerId = React.useId();
+	var [open, setOpen] = React.useState(false);
+	var anchorTo = triggerContext.anchorTo;
+	var triggerElRef = React.useRef(null);
+	var composedTriggerRef = (0, import_compose_refs.useComposedRefs)(forwardedRef, triggerElRef);
+	var { registerTrigger, unregisterTrigger } = triggerContext;
+	React.useEffect(function() {
+		registerTrigger(triggerId, setOpen);
+		return function() {
+			unregisterTrigger(triggerId);
+		};
+	}, [
+		registerTrigger,
+		unregisterTrigger,
+		triggerId
+	]);
+	if (!rest.children) return null;
+	var activateSelf = function() {
+		triggerContext.setActiveTrigger(triggerId);
+		var el = triggerElRef.current;
+		if (el) triggerContext.triggerRef.current = el;
+	};
+	var trigger = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_core.View, {
+		"aria-expanded": open,
+		"data-state": getState(open),
+		...rest,
+		ref: composedTriggerRef,
+		onPress: (0, import_helpers.composeEventHandlers)(rest.onPress, function() {
+			if (disablePressTrigger) return;
+			triggerContext.setActiveTrigger(open ? null : triggerId);
+			triggerContext.onOpenToggle();
+		}),
+		onMouseEnter: (0, import_helpers.composeEventHandlers)(rest.onMouseEnter, activateSelf),
+		onPressIn: (0, import_helpers.composeEventHandlers)(rest.onPressIn, activateSelf),
+		onFocus: (0, import_helpers.composeEventHandlers)(rest.onFocus, activateSelf)
+	});
+	var virtualRef = React.useMemo(function() {
+		if (!anchorTo) return null;
+		return { current: {
+			getBoundingClientRect: function() {
+				return import_constants.isWeb ? DOMRect.fromRect(anchorTo) : anchorTo;
+			},
+			...!import_constants.isWeb && {
+				measure: function(c) {
+					return c(anchorTo === null || anchorTo === void 0 ? void 0 : anchorTo.x, anchorTo === null || anchorTo === void 0 ? void 0 : anchorTo.y, anchorTo === null || anchorTo === void 0 ? void 0 : anchorTo.width, anchorTo === null || anchorTo === void 0 ? void 0 : anchorTo.height);
+				},
+				measureInWindow: function(c) {
+					return c(anchorTo === null || anchorTo === void 0 ? void 0 : anchorTo.x, anchorTo === null || anchorTo === void 0 ? void 0 : anchorTo.y, anchorTo === null || anchorTo === void 0 ? void 0 : anchorTo.width, anchorTo === null || anchorTo === void 0 ? void 0 : anchorTo.height);
+				}
+			}
+		} };
+	}, [
+		triggerContext.anchorTo,
+		anchorTo === null || anchorTo === void 0 ? void 0 : anchorTo.x,
+		anchorTo === null || anchorTo === void 0 ? void 0 : anchorTo.y,
+		anchorTo === null || anchorTo === void 0 ? void 0 : anchorTo.height,
+		anchorTo === null || anchorTo === void 0 ? void 0 : anchorTo.width
+	]);
+	var wrappedTrigger = import_constants.isWeb ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_dismissable.DismissableBranch, {
+		branches: triggerContext.branches,
+		children: trigger
+	}) : trigger;
+	return triggerContext.hasCustomAnchor ? wrappedTrigger : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_popper.PopperAnchor, {
+		...virtualRef && { virtualRef },
+		scope,
+		asChild: true,
+		children: wrappedTrigger
+	});
+}));
+var PopoverContent = (0, import_core.createStyledHOC)(import_popper.PopperContentFrame, function PopoverContent2(props, forwardedRef) {
+	var { trapFocus, enableRemoveScroll = false, zIndex: zIndexProp, scope, forceMount, ...contentImplProps } = props;
+	var context = usePopoverContext(scope);
+	var adaptContext = (0, import_adapt.useAdaptContext)(context.adaptScope);
+	var zIndexFromContext = React.useContext(PopoverZIndexContext);
+	var zIndex = zIndexProp !== null && zIndexProp !== void 0 ? zIndexProp : zIndexFromContext;
+	var open = usePopoverOpen(scope);
+	var contentRef = React.useRef(null);
+	var composedRefs = (0, import_compose_refs.useComposedRefs)(forwardedRef, contentRef);
+	var isRightClickOutsideRef = React.useRef(false);
+	var [isFullyHidden, setIsFullyHidden] = React.useState(!open);
+	(0, import_constants.useIsomorphicLayoutEffect)(function() {
+		if (open && isFullyHidden) setIsFullyHidden(false);
+	}, [open, isFullyHidden]);
+	if (!forceMount && !context.keepChildrenMounted) {
+		if (context.breakpointActive) {
+			if (!open && adaptContext.targetFullyHidden) return null;
+		} else if (isFullyHidden && !open) return null;
+	}
+	var _contentImplProps_pointerEvents;
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(PopoverPortal, {
+		passThrough: context.breakpointActive,
+		context,
+		open,
+		visuallyActive: open || !isFullyHidden,
+		zIndex,
+		children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_core.View, {
+			passThrough: context.breakpointActive,
+			pointerEvents: open ? (_contentImplProps_pointerEvents = contentImplProps.pointerEvents) !== null && _contentImplProps_pointerEvents !== void 0 ? _contentImplProps_pointerEvents : "auto" : "none",
+			children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(PopoverContentImpl, {
+				...contentImplProps,
+				context,
+				open,
+				forceMount,
+				enableRemoveScroll,
+				ref: composedRefs,
+				setIsFullyHidden,
+				scope,
+				trapFocus: trapFocus !== null && trapFocus !== void 0 ? trapFocus : open,
+				disableOutsidePointerEvents: true,
+				onCloseAutoFocus: props.onCloseAutoFocus === false ? void 0 : (0, import_helpers.composeEventHandlers)(props.onCloseAutoFocus, function(event) {
+					var _context_triggerRef_current;
+					if (event.isCanceled) return;
+					event.cancel();
+					if (!isRightClickOutsideRef.current) (_context_triggerRef_current = context.triggerRef.current) === null || _context_triggerRef_current === void 0 || _context_triggerRef_current.focus();
+				}),
+				onPointerDownOutside: (0, import_helpers.composeEventHandlers)(props.onPointerDownOutside, function(event) {
+					var originalEvent = event.event;
+					if (!originalEvent) return;
+					var ctrlLeftClick = originalEvent.button === 0 && originalEvent.ctrlKey === true;
+					isRightClickOutsideRef.current = originalEvent.button === 2 || ctrlLeftClick;
+				}, { checkDefaultPrevented: false }),
+				onFocusOutside: (0, import_helpers.composeEventHandlers)(props.onFocusOutside, function(event) {
+					if (trapFocus !== null && trapFocus !== void 0 ? trapFocus : open) event.cancel();
+				}, { checkDefaultPrevented: false })
+			})
+		})
+	});
+});
+var useParentContexts = function(scope) {
+	var context = usePopoverContext(scope);
+	var triggerContext = usePopoverTriggerContext(scope);
+	return {
+		popperContext: (0, import_popper.usePopperContext)(scope),
+		adaptContext: (0, import_adapt.useAdaptContext)(context.adaptScope),
+		context,
+		triggerContext
+	};
+};
+function RepropagateParentContexts(param) {
+	var { adaptContext, children, context, triggerContext, popperContext } = param;
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_popper.PopperProvider, {
+		scope: context.popoverScope,
+		...popperContext,
+		children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(PopoverContext.Provider, {
+			scope: context.popoverScope,
+			...context,
+			children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(PopoverTriggerContext.Provider, {
+				scope: context.popoverScope,
+				...triggerContext,
+				children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_adapt.ProvideAdaptContext, {
+					...adaptContext,
+					children
+				})
+			})
+		})
+	});
+}
+var PortalAdaptSafe = function(param) {
+	"use no memo";
+	var { children, context } = param;
+	if (needsRepropagation) {
+		var parentContexts = useParentContexts(context.popoverScope);
+		return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_adapt.AdaptPortalContents, {
+			scope: context.adaptScope,
+			children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(RepropagateParentContexts, {
+				...parentContexts,
+				children
+			})
+		});
+	}
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_adapt.AdaptPortalContents, {
+		scope: context.adaptScope,
+		children
+	});
+};
+function PopoverPortal(param) {
+	"use no memo";
+	var { context, open, visuallyActive, zIndex, passThrough, children, onPress } = param;
+	var content = children;
+	if (needsRepropagation) {
+		var parentContexts = useParentContexts(context.popoverScope);
+		content = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(RepropagateParentContexts, {
+			...parentContexts,
+			children: content
+		});
+	}
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_portal.Portal, {
+		passThrough,
+		stackZIndex: true,
+		zIndex,
+		hidden: !visuallyActive,
+		children: [!!open && !context.breakpointActive && !context.hoverable && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_stacks.YStack, {
+			position: "absolute",
+			inset: 0,
+			onPress: (0, import_helpers.composeEventHandlers)(onPress, context.onOpenToggle)
+		}), content]
+	});
+}
+var PopoverContentImpl = (0, import_core.createRefComponent)(function PopoverContentImpl2(props, forwardedRef) {
+	var { trapFocus, scope, onOpenAutoFocus, onCloseAutoFocus, disableOutsidePointerEvents, disableFocusScope, onEscapeKeyDown, onPointerDownOutside, onFocusOutside, onInteractOutside, children, enableRemoveScroll, freezeContentsWhenHidden, setIsFullyHidden, lazyMount, forceUnmount, forceMount, context, open, alwaysDisable, ...contentProps } = props;
+	var { disableDismissable } = context;
+	var keepChildrenMounted = context.keepChildrenMounted || forceMount;
+	var handleExitComplete = React.useCallback(function() {
+		setIsFullyHidden === null || setIsFullyHidden === void 0 || setIsFullyHidden(true);
+	}, [setIsFullyHidden]);
+	var contents = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_animate_presence.ResetPresence, {
+		disable: context.breakpointActive,
+		children
+	});
+	React.useCallback(function() {
+		context.onOpenChange(false, "press");
+	}, [context]);
+	if (!context.breakpointActive) {}
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_animate.Animate, {
+		type: "presence",
+		present: Boolean(open),
+		keepChildrenMounted: Boolean(keepChildrenMounted),
+		onExitComplete: handleExitComplete,
+		lazyMount,
+		passThrough: context.breakpointActive,
+		children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_popper.PopperContent, {
+			scope,
+			"data-state": getState(open),
+			id: context.contentId,
+			ref: forwardedRef,
+			passThrough: context.breakpointActive,
+			...contentProps,
+			children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(PortalAdaptSafe, {
+				context,
+				children: contents
+			})
+		}, context.contentId)
+	});
+});
+var PopoverClose = (0, import_core.createRefComponent)(function PopoverClose2(props, forwardedRef) {
+	var { scope, className, ...rest } = props;
+	var context = usePopoverContext(scope);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_stacks.YStack, {
+		...rest,
+		ref: forwardedRef,
+		className: `is_PopoverClose ${className || ""}`.trim(),
+		onPress: (0, import_helpers.composeEventHandlers)(props.onPress, function() {
+			var _context_onOpenChange;
+			return context === null || context === void 0 ? void 0 : (_context_onOpenChange = context.onOpenChange) === null || _context_onOpenChange === void 0 ? void 0 : _context_onOpenChange.call(context, false, "press");
+		})
+	});
+});
+var PopoverArrow = (0, import_core.createStyledHOC)(import_popper.PopperArrowFrame, function PopoverArrow2(props, forwardedRef) {
+	var { scope, className, ...rest } = props;
+	var context = usePopoverContext(scope);
+	if ((0, import_adapt.useAdaptIsActive)(context.adaptScope)) return null;
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_popper.PopperArrow, {
+		scope,
+		className: `is_PopoverArrow ${className || ""}`.trim(),
+		...rest,
+		ref: forwardedRef
+	});
+});
+var PopoverScrollView = (0, import_core.createRefComponent)(function(param, ref) {
+	var { scope, ...props } = param;
+	var context = usePopoverContext(scope);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_scroll_view.ScrollView, {
+		ref,
+		pointerEvents: context.breakpointActive ? "none" : void 0,
+		scrollEnabled: !context.breakpointActive,
+		passThrough: context.breakpointActive,
+		...props
+	});
+});
+var DEFAULT_SCOPE = "";
+var Popover = (0, import_helpers.withStaticProperties)((0, import_core.createRefComponent)(function Popover2(param, ref) {
+	var { scope = DEFAULT_SCOPE, ...props } = param;
+	var id = React.useId();
+	var adaptScope = `PopoverAdapt${scope}`;
+	var { open: openProp, defaultOpen, onOpenChange } = props;
+	var viaRef = React.useRef(void 0);
+	var [open, setOpen] = (0, import_use_controllable_state.useControllableState)({
+		prop: openProp,
+		defaultProp: defaultOpen || false,
+		onChange: function(val) {
+			onOpenChange === null || onOpenChange === void 0 || onOpenChange(val, viaRef.current);
+		}
+	});
+	var handleOpenChange = (0, import_core.useEvent)(function(val, via) {
+		viaRef.current = via;
+		setOpen(val);
+	});
+	React.useEffect(function() {
+		if (!open) return;
+		openPopovers.add(setOpen);
+		return function() {
+			openPopovers.delete(setOpen);
+		};
+	}, [open, setOpen]);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_adapt.AdaptParent, {
+		scope: adaptScope,
+		open,
+		onOpenChange: setOpen,
+		children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(PopoverInner, {
+			adaptScope,
+			ref,
+			id,
+			scope,
+			open,
+			setOpen,
+			handleOpenChange,
+			...props
+		})
+	});
+}), {
+	Anchor: PopoverAnchor,
+	Arrow: PopoverArrow,
+	Trigger: PopoverTrigger,
+	Content: PopoverContent,
+	Close: PopoverClose,
+	Adapt: import_adapt.Adapt,
+	ScrollView: PopoverScrollView,
+	FocusScope: import_focus_scope.FocusScopeController
+});
+var PopoverInner = (0, import_core.createRefComponent)(function PopoverInner2(props, forwardedRef) {
+	var { children, open: _openProp, defaultOpen: _defaultOpen, onOpenChange: _onOpenChange, scope = DEFAULT_SCOPE, keepChildrenMounted: keepChildrenMountedProp, hoverable, disableFocus, disableDismissable, zIndex, id, adaptScope, open, setOpen, handleOpenChange, ...restProps } = props;
+	var triggerRef = React.useRef(null);
+	var [hasCustomAnchor, setHasCustomAnchor] = React.useState(false);
+	var [keepChildrenMounted] = (0, import_use_controllable_state.useControllableState)({
+		prop: keepChildrenMountedProp,
+		defaultProp: false,
+		transition: keepChildrenMountedProp === "lazy"
+	});
+	var isAdapted = (0, import_adapt.useAdaptIsActive)(adaptScope);
+	var floatingContext = (0, import_useFloatingContext.useFloatingContext)({
+		open,
+		setOpen: handleOpenChange,
+		disable: isAdapted,
+		hoverable,
+		disableFocus
+	});
+	var [anchorTo, setAnchorToRaw] = React.useState();
+	var setAnchorTo = (0, import_core.useCreateShallowSetState)(setAnchorToRaw);
+	React.useImperativeHandle(forwardedRef, function() {
+		return {
+			anchorTo: setAnchorTo,
+			toggle: function() {
+				return setOpen(function(prev) {
+					return !prev;
+				});
+			},
+			open: function() {
+				return setOpen(true);
+			},
+			close: function() {
+				return setOpen(false);
+			},
+			setOpen
+		};
+	});
+	var contentId = React.useId();
+	var onOpenToggle = (0, import_core.useEvent)(function() {
+		if (open && isAdapted) return;
+		setOpen(!open);
+	});
+	var onCustomAnchorAdd = React.useCallback(function() {
+		return setHasCustomAnchor(true);
+	}, []);
+	var onCustomAnchorRemove = React.useCallback(function() {
+		return setHasCustomAnchor(false);
+	}, []);
+	var contents = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_popper.Popper, {
+		open,
+		passThrough: isAdapted,
+		scope,
+		stayInFrame: true,
+		...restProps,
+		children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(PopoverContextProvider, {
+			scope,
+			open,
+			onOpenChange: handleOpenChange,
+			onOpenToggle,
+			triggerRef,
+			id,
+			contentId,
+			hasCustomAnchor,
+			onCustomAnchorAdd,
+			onCustomAnchorRemove,
+			anchorTo,
+			adaptScope,
+			breakpointActive: isAdapted,
+			keepChildrenMounted,
+			disableDismissable,
+			hoverable,
+			children
+		})
+	});
+	var result = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: import_constants.isWeb ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_floating.FloatingOverrideContext.Provider, {
+		value: floatingContext,
+		children: contents
+	}) : contents });
+	if (zIndex !== void 0) return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(PopoverZIndexContext.Provider, {
+		value: zIndex,
+		children: result
+	});
+	return result;
+});
+function getState(open) {
+	return open ? "open" : "closed";
+}