@underverse-ui/underverse 2.0.35 → 2.0.37

package/dist/chunk-5GMQ23IU.js

@@ -0,0 +1,719 @@
+import {
+  chainEventHandlers,
+  cn,
+  mergeRefs,
+  resolveUEditorPortalContainer,
+  useUEditorPortalContainerGetter
+} from "./chunk-6XQTRIP6.js";
+
+// src/utils/radius.ts
+var STANDARD_BORDER_MODES = ["none", "sm", "md", "lg", "xl", "2xl", "3xl", "full"];
+var CUSTOM_BORDER_MAP = {
+  daewoo: "rounded",
+  infiniq: "rounded-full"
+};
+var BORDER_MODE_DOCS_TYPE = `"${STANDARD_BORDER_MODES.join('" | "')}" | "${Object.keys(CUSTOM_BORDER_MAP).join('" | "')}"`;
+function getBorderRadiusClass(borderMode = "full") {
+  if (!borderMode) return "rounded-full";
+  if (borderMode in CUSTOM_BORDER_MAP) {
+    return CUSTOM_BORDER_MAP[borderMode];
+  }
+  if (STANDARD_BORDER_MODES.includes(borderMode)) {
+    return `rounded-${borderMode}`;
+  }
+  return borderMode;
+}
+function getPanelBorderRadiusClass(borderMode = "lg") {
+  const resolved = borderMode ?? "lg";
+  if (resolved === "full" || resolved === "infiniq") {
+    return "rounded-2xl";
+  }
+  return getBorderRadiusClass(resolved);
+}
+
+// src/contexts/UnderverseConfigContext.tsx
+import * as React from "react";
+import { Fragment, jsx } from "react/jsx-runtime";
+var UnderverseUIConfigContext = React.createContext(null);
+function useUnderverseUIConfig() {
+  return React.useContext(UnderverseUIConfigContext) ?? {};
+}
+function UnderverseConfigProvider({ children, config }) {
+  if (!config) return /* @__PURE__ */ jsx(Fragment, { children });
+  return /* @__PURE__ */ jsx(UnderverseUIConfigContext.Provider, { value: config, children });
+}
+
+// src/utils/animations.ts
+import { useEffect } from "react";
+var shadcnAnimationStyles = `
+  /* ============================================
+   * DROPDOWN / POPOVER ANIMATIONS
+   * Uses spring-like cubic-bezier for natural feel
+   * ============================================ */
+  
+  /* Native-like Combobox Animation - Mimics browser default select */
+  [data-state="open"][data-combobox-dropdown] {
+    animation: comboboxOpen 150ms cubic-bezier(0.2, 0, 0, 1);
+    transform-origin: top center;
+  }
+
+  [data-state="closed"][data-combobox-dropdown] {
+    animation: comboboxClose 120ms cubic-bezier(0.4, 0, 1, 1);
+    transform-origin: top center;
+  }
+
+  @keyframes comboboxOpen {
+    0% {
+      opacity: 0;
+      transform: translateY(-4px) scaleY(0.9);
+    }
+    100% {
+      opacity: 1;
+      transform: translateY(0) scaleY(1);
+    }
+  }
+
+  @keyframes comboboxClose {
+    0% {
+      opacity: 1;
+      transform: translateY(0) scaleY(1);
+    }
+    100% {
+      opacity: 0;
+      transform: translateY(-4px) scaleY(0.9);
+    }
+  }
+
+  /* Generic dropdown open/close */
+  [data-state="open"] {
+    animation: slideDownAndFade 220ms cubic-bezier(0.16, 1, 0.3, 1);
+  }
+  
+  [data-state="closed"] {
+    animation: slideUpAndFade 180ms cubic-bezier(0.4, 0, 0.2, 1);
+  }
+  
+  @keyframes slideDownAndFade {
+    from {
+      opacity: 0;
+      transform: translateY(-4px) scale(0.98);
+    }
+    to {
+      opacity: 1;
+      transform: translateY(0) scale(1);
+    }
+  }
+  
+  @keyframes slideUpAndFade {
+    from {
+      opacity: 1;
+      transform: translateY(0) scale(1);
+    }
+    to {
+      opacity: 0;
+      transform: translateY(-4px) scale(0.98);
+    }
+  }
+  
+  /* ============================================
+   * DROPDOWN ITEMS - Native-like instant appearance
+   * ============================================ */
+
+  /* Fast staggered animation for native feel */
+  .dropdown-item {
+    opacity: 0;
+    animation: itemFadeIn 120ms cubic-bezier(0.2, 0, 0, 1) forwards;
+  }
+
+  @keyframes itemFadeIn {
+    from {
+      opacity: 0;
+      transform: translateX(-4px);
+    }
+    to {
+      opacity: 1;
+      transform: translateX(0);
+    }
+  }
+
+  /* Item stagger delays - minimal for speed */
+  .dropdown-item:nth-child(1) { animation-delay: 0ms; }
+  .dropdown-item:nth-child(2) { animation-delay: 15ms; }
+  .dropdown-item:nth-child(3) { animation-delay: 30ms; }
+  .dropdown-item:nth-child(4) { animation-delay: 45ms; }
+  .dropdown-item:nth-child(5) { animation-delay: 60ms; }
+  .dropdown-item:nth-child(6) { animation-delay: 75ms; }
+  .dropdown-item:nth-child(7) { animation-delay: 90ms; }
+  .dropdown-item:nth-child(8) { animation-delay: 105ms; }
+  .dropdown-item:nth-child(n+9) { animation-delay: 120ms; }
+
+  /* ============================================
+   * DATEPICKER ANIMATIONS
+   * ============================================ */
+
+  .datepicker-day {
+    opacity: 0;
+    animation: dayFadeIn 200ms cubic-bezier(0.16, 1, 0.3, 1) forwards;
+  }
+
+  @keyframes dayFadeIn {
+    from {
+      opacity: 0;
+      transform: scale(0.8);
+    }
+    to {
+      opacity: 1;
+      transform: scale(1);
+    }
+  }
+
+  /* ============================================
+   * TOOLTIP ANIMATIONS
+   * ============================================ */
+
+  [data-tooltip] {
+    animation: tooltipIn 150ms cubic-bezier(0.16, 1, 0.3, 1);
+  }
+
+  @keyframes tooltipIn {
+    from {
+      opacity: 0;
+      transform: scale(0.95);
+    }
+    to {
+      opacity: 1;
+      transform: scale(1);
+    }
+  }
+
+  /* ============================================
+   * MODAL / DIALOG ANIMATIONS
+   * ============================================ */
+
+  .modal-content {
+    animation: scaleIn 200ms cubic-bezier(0.34, 1.56, 0.64, 1);
+  }
+  
+  @keyframes scaleIn {
+    from {
+      opacity: 0;
+      transform: scale(0.9);
+    }
+    to {
+      opacity: 1;
+      transform: scale(1);
+    }
+  }
+  
+  /* Smooth backdrop blur transition */
+  .backdrop-animate {
+    transition: backdrop-filter 200ms ease, background-color 200ms ease;
+  }
+`;
+function ensureAnimationStylesInjected(targetDocument) {
+  const resolvedDocument = targetDocument ?? (typeof document !== "undefined" ? document : void 0);
+  if (resolvedDocument) {
+    const styleId = "shadcn-animations";
+    if (!resolvedDocument.getElementById(styleId)) {
+      const styleElement = resolvedDocument.createElement("style");
+      styleElement.id = styleId;
+      styleElement.textContent = shadcnAnimationStyles;
+      resolvedDocument.head.appendChild(styleElement);
+    }
+  }
+}
+function useShadCNAnimations(targetDocument) {
+  useEffect(() => {
+    if (targetDocument === null) return;
+    ensureAnimationStylesInjected(targetDocument);
+  }, [targetDocument]);
+}
+function injectAnimationStyles(targetDocument) {
+  ensureAnimationStylesInjected(targetDocument);
+}
+function getAnimationStyles() {
+  return shadcnAnimationStyles;
+}
+
+// src/components/Popover.tsx
+import * as React2 from "react";
+import { createPortal } from "react-dom";
+import { Fragment as Fragment2, jsx as jsx2, jsxs } from "react/jsx-runtime";
+function getTransformOrigin(side, align) {
+  if (side === "top") return `${align === "end" ? "right" : "left"} bottom`;
+  if (side === "bottom") return `${align === "end" ? "right" : "left"} top`;
+  if (side === "left") return "right top";
+  return "left top";
+}
+function normalizePlacement(placement) {
+  switch (placement) {
+    case "top":
+      return { side: "top", align: "start" };
+    case "bottom":
+      return { side: "bottom", align: "start" };
+    case "left":
+      return { side: "left", align: "start" };
+    case "right":
+      return { side: "right", align: "start" };
+    default: {
+      const [side, align] = placement.split("-");
+      return { side, align };
+    }
+  }
+}
+var clamp = (value, min, max) => Math.max(min, Math.min(max, value));
+function overflowAmount(left, width, viewportWidth, padding) {
+  const min = padding;
+  const max = viewportWidth - padding;
+  const overflowLeft = Math.max(0, min - left);
+  const overflowRight = Math.max(0, left + width - max);
+  return overflowLeft + overflowRight;
+}
+function getScrollAncestors(trigger, ownerWindow) {
+  const ancestors = [];
+  let current = trigger.parentElement;
+  while (current) {
+    try {
+      const style = ownerWindow.getComputedStyle(current);
+      const overflow = `${style.overflow} ${style.overflowX} ${style.overflowY}`;
+      if (/(auto|scroll|overlay|hidden)/.test(overflow)) ancestors.push(current);
+    } catch {
+    }
+    current = current.parentElement;
+  }
+  return ancestors;
+}
+function isFiniteRect(rect) {
+  return [rect.top, rect.right, rect.bottom, rect.left, rect.width, rect.height].every(Number.isFinite);
+}
+function isFullyOutsideViewport(rect, viewportWidth, viewportHeight) {
+  return rect.bottom < 0 || rect.right < 0 || rect.top > viewportHeight || rect.left > viewportWidth;
+}
+function computePopoverPosition(args) {
+  const { triggerRect, contentSize, placement, offset, padding, viewport, constrainToAvailableHeight } = args;
+  let { side, align } = normalizePlacement(placement);
+  const availableBelow = Math.max(0, viewport.height - padding - triggerRect.bottom - offset);
+  const availableAbove = Math.max(0, triggerRect.top - padding - offset);
+  if (side === "bottom") {
+    if (constrainToAvailableHeight) {
+      if (contentSize.height > availableBelow && availableAbove > availableBelow) side = "top";
+    } else {
+      const bottomTop = triggerRect.bottom + offset;
+      const overflowsBottom = bottomTop + contentSize.height > viewport.height - padding;
+      const topTop = triggerRect.top - offset - contentSize.height;
+      const fitsTop = topTop >= padding;
+      if (overflowsBottom && fitsTop) side = "top";
+    }
+  } else if (side === "top") {
+    if (constrainToAvailableHeight) {
+      if (contentSize.height > availableAbove && availableBelow > availableAbove) side = "bottom";
+    } else {
+      const topTop = triggerRect.top - offset - contentSize.height;
+      const overflowsTop = topTop < padding;
+      const bottomTop = triggerRect.bottom + offset;
+      const fitsBottom = bottomTop + contentSize.height <= viewport.height - padding;
+      if (overflowsTop && fitsBottom) side = "bottom";
+    }
+  } else if (side === "right") {
+    const rightLeft = triggerRect.right + offset;
+    const overflowsRight = rightLeft + contentSize.width > viewport.width - padding;
+    const leftLeft = triggerRect.left - offset - contentSize.width;
+    const fitsLeft = leftLeft >= padding;
+    if (overflowsRight && fitsLeft) side = "left";
+  } else if (side === "left") {
+    const leftLeft = triggerRect.left - offset - contentSize.width;
+    const overflowsLeft = leftLeft < padding;
+    const rightLeft = triggerRect.right + offset;
+    const fitsRight = rightLeft + contentSize.width <= viewport.width - padding;
+    if (overflowsLeft && fitsRight) side = "right";
+  }
+  let top = 0;
+  let left = 0;
+  if (side === "top" || side === "bottom") {
+    const leftStart = triggerRect.left;
+    const leftEnd = triggerRect.right - contentSize.width;
+    const startOverflow = overflowAmount(leftStart, contentSize.width, viewport.width, padding);
+    const endOverflow = overflowAmount(leftEnd, contentSize.width, viewport.width, padding);
+    if (align === "start" && startOverflow > 0 && endOverflow < startOverflow) align = "end";
+    if (align === "end" && endOverflow > 0 && startOverflow < endOverflow) align = "start";
+    left = align === "end" ? leftEnd : leftStart;
+    const availableHeight = side === "top" ? availableAbove : availableBelow;
+    const renderedHeight = constrainToAvailableHeight ? Math.min(contentSize.height, availableHeight) : contentSize.height;
+    top = side === "top" ? triggerRect.top - offset - renderedHeight : triggerRect.bottom + offset;
+    left = clamp(left, padding, viewport.width - contentSize.width - padding);
+    top = clamp(top, padding, viewport.height - renderedHeight - padding);
+    return { top, left, side, align, availableHeight };
+  }
+  top = triggerRect.top;
+  left = side === "left" ? triggerRect.left - offset - contentSize.width : triggerRect.right + offset;
+  left = clamp(left, padding, viewport.width - contentSize.width - padding);
+  top = clamp(top, padding, viewport.height - contentSize.height - padding);
+  return { top, left, side, align, availableHeight: Math.max(0, viewport.height - padding * 2) };
+}
+var Popover = ({
+  trigger,
+  children,
+  className,
+  contentClassName,
+  contentProps,
+  contentScrollable = false,
+  placement = "bottom",
+  modal = false,
+  disabled = false,
+  open,
+  onOpenChange,
+  matchTriggerWidth = false,
+  contentWidth,
+  borderMode,
+  getPortalContainer,
+  constrainToAvailableHeight = false
+}) => {
+  const isControlled = open !== void 0;
+  const [internalOpen, setInternalOpen] = React2.useState(false);
+  const triggerRef = React2.useRef(null);
+  const [triggerDocument, setTriggerDocument] = React2.useState(null);
+  const positionerRef = React2.useRef(null);
+  const panelRef = React2.useRef(null);
+  const pendingFrameRef = React2.useRef(null);
+  const closeRequestedRef = React2.useRef(false);
+  const lastAppliedRef = React2.useRef(null);
+  const globalConfig = useUnderverseUIConfig();
+  const resolvedBorderMode = borderMode ?? globalConfig.popover?.borderMode ?? globalConfig.borderMode;
+  const isOpen = isControlled ? open : internalOpen;
+  const contextGetPortalContainer = useUEditorPortalContainerGetter();
+  const requestedPortalContainer = isOpen && triggerDocument ? resolveUEditorPortalContainer(getPortalContainer, contextGetPortalContainer, triggerDocument) : null;
+  const portalContainer = requestedPortalContainer?.ownerDocument === triggerDocument ? requestedPortalContainer : triggerDocument?.body ?? null;
+  useShadCNAnimations(isOpen ? triggerDocument : null);
+  const setIsOpen = React2.useCallback(
+    (next) => {
+      if (!isControlled) setInternalOpen(next);
+      onOpenChange?.(next);
+    },
+    [isControlled, onOpenChange]
+  );
+  const offset = 4;
+  const padding = 8;
+  const initialPlacement = React2.useMemo(() => normalizePlacement(placement), [placement]);
+  const cancelScheduledPositionUpdate = React2.useCallback(() => {
+    const pending = pendingFrameRef.current;
+    if (!pending) return;
+    pendingFrameRef.current = null;
+    try {
+      pending.ownerWindow.cancelAnimationFrame(pending.frameId);
+    } catch {
+    }
+  }, []);
+  const closeWhenPositioningIsUnsafe = React2.useCallback(() => {
+    const positionerEl = positionerRef.current;
+    if (positionerEl) {
+      positionerEl.style.visibility = "hidden";
+      positionerEl.style.pointerEvents = "none";
+    }
+    if (closeRequestedRef.current) return;
+    closeRequestedRef.current = true;
+    setIsOpen(false);
+  }, [setIsOpen]);
+  const updatePosition = React2.useCallback(() => {
+    const triggerEl = triggerRef.current;
+    const positionerEl = positionerRef.current;
+    const panelEl = panelRef.current;
+    if (!triggerEl || !positionerEl || !panelEl) return;
+    const ownerDocument = triggerEl.ownerDocument;
+    const ownerWindow = ownerDocument.defaultView;
+    if (!ownerWindow || ownerWindow.closed || !triggerEl.isConnected || !positionerEl.isConnected || positionerEl.ownerDocument !== ownerDocument || panelEl.ownerDocument !== ownerDocument) {
+      closeWhenPositioningIsUnsafe();
+      return;
+    }
+    const contentEl = panelEl.firstElementChild;
+    if (!contentEl) {
+      closeWhenPositioningIsUnsafe();
+      return;
+    }
+    try {
+      const triggerRect = triggerEl.getBoundingClientRect();
+      const viewportWidth = ownerWindow.innerWidth;
+      const viewportHeight = ownerWindow.innerHeight;
+      if (!isFiniteRect(triggerRect) || !Number.isFinite(viewportWidth) || !Number.isFinite(viewportHeight) || viewportWidth <= 0 || viewportHeight <= 0 || isFullyOutsideViewport(triggerRect, viewportWidth, viewportHeight)) {
+        closeWhenPositioningIsUnsafe();
+        return;
+      }
+      const widthWanted = matchTriggerWidth ? triggerRect.width : contentWidth;
+      const widthPx = widthWanted == null ? void 0 : Math.max(0, Math.round(widthWanted));
+      if (widthPx == null) {
+        if (positionerEl.style.width) positionerEl.style.width = "";
+      } else if (positionerEl.style.width !== `${widthPx}px`) {
+        positionerEl.style.width = `${widthPx}px`;
+      }
+      const prevApplied = lastAppliedRef.current;
+      const measuredWidth = positionerEl.offsetWidth;
+      const measuredHeight = positionerEl.offsetHeight;
+      const contentRect = positionerEl.getBoundingClientRect();
+      const contentBoxWidth = measuredWidth || contentRect.width;
+      const contentBoxHeight = Math.max(measuredHeight, contentRect.height);
+      const next = computePopoverPosition({
+        triggerRect,
+        contentSize: { width: contentBoxWidth, height: contentBoxHeight },
+        placement,
+        offset,
+        padding,
+        viewport: {
+          width: viewportWidth,
+          height: viewportHeight
+        },
+        constrainToAvailableHeight
+      });
+      const top = Math.round(next.top);
+      const left = Math.round(next.left);
+      const applied = prevApplied && prevApplied.positioner === positionerEl && Math.abs(prevApplied.top - top) < 0.5 && Math.abs(prevApplied.left - left) < 0.5 && prevApplied.side === next.side && prevApplied.align === next.align && prevApplied.width === widthPx && prevApplied.availableHeight === next.availableHeight;
+      if (applied) return;
+      lastAppliedRef.current = {
+        positioner: positionerEl,
+        top,
+        left,
+        side: next.side,
+        align: next.align,
+        width: widthPx,
+        availableHeight: next.availableHeight
+      };
+      positionerEl.style.transform = `translate3d(${left}px, ${top}px, 0)`;
+      positionerEl.style.setProperty("--underverse-popover-available-height", `${next.availableHeight}px`);
+      positionerEl.dataset.side = next.side;
+      positionerEl.dataset.align = next.align;
+      panelEl.style.transformOrigin = getTransformOrigin(next.side, next.align);
+      if (positionerEl.style.visibility !== "visible") positionerEl.style.visibility = "visible";
+      if (positionerEl.style.pointerEvents !== "auto") positionerEl.style.pointerEvents = "auto";
+    } catch {
+      closeWhenPositioningIsUnsafe();
+    }
+  }, [placement, matchTriggerWidth, contentWidth, constrainToAvailableHeight, closeWhenPositioningIsUnsafe]);
+  const schedulePositionUpdate = React2.useCallback(() => {
+    if (pendingFrameRef.current) return;
+    const triggerEl = triggerRef.current;
+    const ownerWindow = triggerEl?.ownerDocument.defaultView;
+    if (!triggerEl || !ownerWindow || ownerWindow.closed) {
+      closeWhenPositioningIsUnsafe();
+      return;
+    }
+    try {
+      const frameId = ownerWindow.requestAnimationFrame(() => {
+        pendingFrameRef.current = null;
+        updatePosition();
+      });
+      pendingFrameRef.current = { ownerWindow, frameId };
+    } catch {
+      closeWhenPositioningIsUnsafe();
+    }
+  }, [closeWhenPositioningIsUnsafe, updatePosition]);
+  React2.useLayoutEffect(() => {
+    if (isOpen) {
+      closeRequestedRef.current = false;
+      return;
+    }
+    lastAppliedRef.current = null;
+    cancelScheduledPositionUpdate();
+  }, [cancelScheduledPositionUpdate, isOpen]);
+  React2.useLayoutEffect(() => {
+    if (!isOpen || !portalContainer) return;
+    updatePosition();
+    schedulePositionUpdate();
+    return cancelScheduledPositionUpdate;
+  }, [cancelScheduledPositionUpdate, isOpen, portalContainer, schedulePositionUpdate, updatePosition]);
+  React2.useEffect(() => {
+    const triggerEl = triggerRef.current;
+    const positionerEl = positionerRef.current;
+    if (!isOpen || !triggerEl || !positionerEl || !portalContainer) return;
+    const ownerDocument = triggerEl.ownerDocument;
+    const ownerWindow = ownerDocument.defaultView;
+    if (!ownerWindow || ownerWindow.closed || portalContainer.ownerDocument !== ownerDocument) {
+      closeWhenPositioningIsUnsafe();
+      return;
+    }
+    const scrollAncestors = getScrollAncestors(triggerEl, ownerWindow);
+    const passiveOptions = { passive: true };
+    for (const ancestor of scrollAncestors) {
+      ancestor.addEventListener("scroll", schedulePositionUpdate, passiveOptions);
+    }
+    ownerWindow.addEventListener("scroll", schedulePositionUpdate, passiveOptions);
+    ownerWindow.addEventListener("resize", schedulePositionUpdate);
+    ownerDocument.addEventListener("scroll", schedulePositionUpdate, { capture: true, passive: true });
+    const visualViewport = ownerWindow.visualViewport;
+    visualViewport?.addEventListener("scroll", schedulePositionUpdate, passiveOptions);
+    visualViewport?.addEventListener("resize", schedulePositionUpdate);
+    const ResizeObserverCtor = ownerWindow.ResizeObserver;
+    const resizeObserver = ResizeObserverCtor ? new ResizeObserverCtor(schedulePositionUpdate) : null;
+    resizeObserver?.observe(triggerEl);
+    resizeObserver?.observe(positionerEl);
+    const contentEl = panelRef.current?.firstElementChild;
+    if (contentEl) resizeObserver?.observe(contentEl);
+    const MutationObserverCtor = ownerWindow.MutationObserver;
+    const mutationObserver = MutationObserverCtor ? new MutationObserverCtor(() => {
+      const currentTrigger = triggerRef.current;
+      if (!currentTrigger || !currentTrigger.isConnected || currentTrigger.ownerDocument !== ownerDocument) {
+        closeWhenPositioningIsUnsafe();
+      }
+    }) : null;
+    if (mutationObserver && ownerDocument.documentElement) {
+      mutationObserver.observe(ownerDocument.documentElement, { childList: true, subtree: true });
+    }
+    schedulePositionUpdate();
+    return () => {
+      for (const ancestor of scrollAncestors) {
+        ancestor.removeEventListener("scroll", schedulePositionUpdate);
+      }
+      ownerWindow.removeEventListener("scroll", schedulePositionUpdate);
+      ownerWindow.removeEventListener("resize", schedulePositionUpdate);
+      ownerDocument.removeEventListener("scroll", schedulePositionUpdate, true);
+      visualViewport?.removeEventListener("scroll", schedulePositionUpdate);
+      visualViewport?.removeEventListener("resize", schedulePositionUpdate);
+      resizeObserver?.disconnect();
+      mutationObserver?.disconnect();
+      cancelScheduledPositionUpdate();
+    };
+  }, [
+    cancelScheduledPositionUpdate,
+    closeWhenPositioningIsUnsafe,
+    isOpen,
+    portalContainer,
+    schedulePositionUpdate
+  ]);
+  React2.useEffect(() => {
+    const triggerEl = triggerRef.current;
+    if (!isOpen || !triggerEl || !portalContainer) return;
+    const ownerDocument = triggerEl.ownerDocument;
+    const ownerWindow = ownerDocument.defaultView;
+    if (!ownerWindow || portalContainer.ownerDocument !== ownerDocument) {
+      closeWhenPositioningIsUnsafe();
+      return;
+    }
+    const handleClickOutside = (event) => {
+      const target = event.target;
+      const currentTrigger = triggerRef.current;
+      const popoverEl = positionerRef.current;
+      if (!currentTrigger || !popoverEl) return;
+      if (currentTrigger.contains(target)) return;
+      if (popoverEl.contains(target)) return;
+      if (target instanceof ownerWindow.Element && target.closest("[data-popover]")) return;
+      setIsOpen(false);
+    };
+    const handleEscape = (event) => {
+      if (event.key === "Escape") {
+        setIsOpen(false);
+      }
+    };
+    ownerDocument.addEventListener("mousedown", handleClickOutside);
+    ownerDocument.addEventListener("keydown", handleEscape);
+    return () => {
+      ownerDocument.removeEventListener("mousedown", handleClickOutside);
+      ownerDocument.removeEventListener("keydown", handleEscape);
+    };
+  }, [closeWhenPositioningIsUnsafe, isOpen, portalContainer, setIsOpen]);
+  const handleTriggerClick = () => {
+    if (!disabled) {
+      setIsOpen(!isOpen);
+    }
+  };
+  const triggerProps = trigger.props;
+  const childRef = triggerProps.ref;
+  const setTriggerNode = React2.useCallback((node) => {
+    triggerRef.current = node;
+    if (node) {
+      setTriggerDocument((currentDocument) => currentDocument === node.ownerDocument ? currentDocument : node.ownerDocument);
+    }
+  }, []);
+  const composedTriggerRef = React2.useMemo(
+    () => mergeRefs(childRef, setTriggerNode),
+    [childRef, setTriggerNode]
+  );
+  const popoverContent = isOpen && portalContainer ? createPortal(
+    /* @__PURE__ */ jsx2(
+      "div",
+      {
+        ref: positionerRef,
+        "data-popover": true,
+        style: {
+          position: "fixed",
+          top: 0,
+          left: 0,
+          transform: "translate3d(0, 0, 0)",
+          zIndex: 99999,
+          visibility: "hidden",
+          pointerEvents: "none",
+          willChange: "transform"
+        },
+        className: "z-[99999]",
+        children: /* @__PURE__ */ jsx2(
+          "div",
+          {
+            ref: panelRef,
+            "data-state": "open",
+            role: modal ? "dialog" : void 0,
+            "aria-modal": modal || void 0,
+            style: {
+              transformOrigin: getTransformOrigin(initialPlacement.side, initialPlacement.align)
+            },
+            className: cn(
+              // shadcn-like enter animation
+              "data-[state=open]:animate-in data-[state=open]:fade-in-0 data-[state=open]:zoom-in-95",
+              className
+            ),
+            children: /* @__PURE__ */ jsx2(
+              "div",
+              {
+                ...contentProps,
+                className: cn(
+                  resolvedBorderMode ? getPanelBorderRadiusClass(resolvedBorderMode) : "rounded-2xl md:rounded-3xl",
+                  "border bg-popover text-popover-foreground shadow-md",
+                  "backdrop-blur-sm bg-popover/95 border-border/60 p-4",
+                  contentProps?.className,
+                  contentClassName
+                ),
+                tabIndex: contentProps?.tabIndex ?? -1,
+                children
+              }
+            )
+          }
+        )
+      }
+    ),
+    portalContainer
+  ) : null;
+  return /* @__PURE__ */ jsxs(Fragment2, { children: [
+    (() => {
+      return React2.cloneElement(trigger, {
+        ...triggerProps,
+        ref: composedTriggerRef,
+        onClick: chainEventHandlers(
+          (e) => {
+            triggerRef.current = e.currentTarget;
+            e.preventDefault();
+            e.stopPropagation();
+            handleTriggerClick();
+          },
+          triggerProps.onClick
+        ),
+        onFocus: chainEventHandlers(
+          (e) => {
+            triggerRef.current = e.currentTarget;
+          },
+          triggerProps.onFocus
+        ),
+        "aria-expanded": isOpen,
+        "aria-haspopup": triggerProps["aria-haspopup"] ?? "dialog"
+      });
+    })(),
+    popoverContent
+  ] });
+};
+
+export {
+  getBorderRadiusClass,
+  getPanelBorderRadiusClass,
+  useUnderverseUIConfig,
+  UnderverseConfigProvider,
+  shadcnAnimationStyles,
+  useShadCNAnimations,
+  injectAnimationStyles,
+  getAnimationStyles,
+  Popover
+};
+//# sourceMappingURL=chunk-5GMQ23IU.js.map