@underverse-ui/underverse 2.0.21 → 2.0.23

package/dist/{chunk-MSTO23JM.js → chunk-AEMS6WGX.js}

@@ -1,7 +1,7 @@
 import {
   EmojiGridButton,
   formatEmojiCountLabel
-} from "./chunk-SBDZKVUJ.js";
+} from "./chunk-LRIRY4DG.js";
 import {
   COLUMN_RESIZE_LINE_THICKNESS,
   CellBgColorIcon,
@@ -55,7 +55,7 @@ import {
   sanitizeUEditorUrl,
   useEditorColors,
   useSharedEditorUiRenderState
-} from "./chunk-RSLY7UU2.js";
+} from "./chunk-O7AAN6W6.js";
 import {
   Tooltip,
   UEditorPortalProvider,
@@ -65,7 +65,7 @@ import {
   resolveUEditorPortalContainer,
   useSmartTranslations,
   useUEditorPortalContainerGetter
-} from "./chunk-PZCD342B.js";
+} from "./chunk-A4GUPKHM.js";
 
 // src/components/UEditor/prepare-content-for-save.ts
 var MIME_EXTENSION_MAP = {
@@ -515,7 +515,7 @@ import { NodeViewWrapper, NodeViewContent } from "@tiptap/react";
 import React from "react";
 import { jsx } from "react/jsx-runtime";
 var LazyBaseEmojiPicker = React.lazy(async () => {
-  const { EmojiPicker: EmojiPicker2 } = await import("./EmojiPicker-SFPFCRI4.js");
+  const { EmojiPicker: EmojiPicker2 } = await import("./EmojiPicker-NV3GQYWI.js");
   return { default: EmojiPicker2 };
 });
 var EmojiPicker = ({ onSelect }) => {
@@ -14504,7 +14504,7 @@ function useUEditorOutput({
 // src/components/UEditor/UEditor.tsx
 import { jsx as jsx20, jsxs as jsxs17 } from "react/jsx-runtime";
 var LazyMenuBar = React15.lazy(async () => {
-  const { MenuBar } = await import("./menu-bar-JXYQ5CH5.js");
+  const { MenuBar } = await import("./menu-bar-E7MNW6UC.js");
   return { default: MenuBar };
 });
 var UEditor = React15.forwardRef(({
@@ -14973,4 +14973,4 @@ export {
   prepareUEditorContentForSave,
   UEditor_default
 };
-//# sourceMappingURL=chunk-MSTO23JM.js.map
+//# sourceMappingURL=chunk-AEMS6WGX.js.map

package/dist/{chunk-LQCKCWVZ.js → chunk-F7MX3XXK.js}

@@ -1,6 +1,6 @@
 import {
   EmojiGridButton
-} from "./chunk-SBDZKVUJ.js";
+} from "./chunk-LRIRY4DG.js";
 import {
   EMOJI_LIST
 } from "./chunk-4TYW5K4J.js";
@@ -9,7 +9,7 @@ import {
   cn,
   formControlOutlineClass,
   useSmartTranslations
-} from "./chunk-PZCD342B.js";
+} from "./chunk-A4GUPKHM.js";
 
 // src/components/EmojiPicker.tsx
 import { useEffect, useMemo, useRef, useState } from "react";
@@ -205,4 +205,4 @@ export {
   EmojiPicker,
   EmojiPicker_default
 };
-//# sourceMappingURL=chunk-LQCKCWVZ.js.map
+//# sourceMappingURL=chunk-F7MX3XXK.js.map

package/dist/{chunk-SBDZKVUJ.js → chunk-LRIRY4DG.js}

@@ -1,6 +1,6 @@
 import {
   cn
-} from "./chunk-PZCD342B.js";
+} from "./chunk-A4GUPKHM.js";
 
 // src/components/emoji-ui.tsx
 import React from "react";
@@ -71,4 +71,4 @@ export {
   getEmojiImageUrl,
   EmojiGridButton
 };
-//# sourceMappingURL=chunk-SBDZKVUJ.js.map
+//# sourceMappingURL=chunk-LRIRY4DG.js.map

package/dist/{chunk-RSLY7UU2.js → chunk-O7AAN6W6.js}

@@ -11,7 +11,7 @@ import {
   setRefValue,
   useSmartTranslations,
   useUEditorPortalContainerGetter
-} from "./chunk-PZCD342B.js";
+} from "./chunk-A4GUPKHM.js";
 
 // src/contexts/UnderverseConfigContext.tsx
 import * as React from "react";
@@ -278,6 +278,26 @@ function overflowAmount(left, width, viewportWidth, padding) {
   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);
@@ -360,17 +380,19 @@ var Popover = ({
   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 portalContainer = isOpen ? resolveUEditorPortalContainer(getPortalContainer, contextGetPortalContainer) : null;
-  const portalDocument = portalContainer?.ownerDocument ?? null;
-  const portalWindow = portalDocument?.defaultView ?? null;
-  useShadCNAnimations(portalDocument);
+  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);
@@ -381,126 +403,205 @@ var Popover = ({
   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 || !portalWindow) return;
+    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) return;
-    const triggerRect = triggerEl.getBoundingClientRect();
-    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`;
+    if (!contentEl) {
+      closeWhenPositioningIsUnsafe();
+      return;
     }
-    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, contentEl.scrollHeight);
-    const next = computePopoverPosition({
-      triggerRect,
-      contentSize: { width: contentBoxWidth, height: contentBoxHeight },
-      placement,
-      offset,
-      padding,
-      viewport: {
-        width: portalWindow.innerWidth,
-        height: portalWindow.innerHeight
-      },
-      constrainToAvailableHeight
-    });
-    const top = Math.round(next.top);
-    const left = Math.round(next.left);
-    const applied = prevApplied && 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 = {
-      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";
-  }, [placement, matchTriggerWidth, contentWidth, portalWindow, constrainToAvailableHeight]);
+    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 || !portalWindow) return;
+    if (!isOpen || !portalContainer) return;
     updatePosition();
-    let raf1 = 0;
-    let raf2 = 0;
-    raf1 = portalWindow.requestAnimationFrame(() => {
-      updatePosition();
-      raf2 = portalWindow.requestAnimationFrame(() => updatePosition());
-    });
-    return () => {
-      portalWindow.cancelAnimationFrame(raf1);
-      portalWindow.cancelAnimationFrame(raf2);
-    };
-  }, [isOpen, portalWindow, updatePosition]);
+    schedulePositionUpdate();
+    return cancelScheduledPositionUpdate;
+  }, [cancelScheduledPositionUpdate, isOpen, portalContainer, schedulePositionUpdate, updatePosition]);
   React2.useEffect(() => {
-    if (!isOpen || !portalWindow) return;
-    let raf = 0;
-    const tick = () => {
-      updatePosition();
-      raf = portalWindow.requestAnimationFrame(tick);
-    };
-    raf = portalWindow.requestAnimationFrame(tick);
-    return () => portalWindow.cancelAnimationFrame(raf);
-  }, [isOpen, portalWindow, updatePosition]);
-  React2.useEffect(() => {
-    if (!isOpen || !portalDocument || !portalWindow) return;
-    let raf = 0;
-    const handler = () => {
-      portalWindow.cancelAnimationFrame(raf);
-      raf = portalWindow.requestAnimationFrame(() => updatePosition());
-    };
-    handler();
-    portalWindow.addEventListener("resize", handler);
-    portalWindow.addEventListener("scroll", handler, true);
-    portalDocument.addEventListener("scroll", handler, true);
+    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 () => {
-      portalWindow.cancelAnimationFrame(raf);
-      portalWindow.removeEventListener("resize", handler);
-      portalWindow.removeEventListener("scroll", handler, true);
-      portalDocument.removeEventListener("scroll", handler, true);
+      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();
     };
-  }, [isOpen, portalDocument, portalWindow, updatePosition]);
+  }, [
+    cancelScheduledPositionUpdate,
+    closeWhenPositioningIsUnsafe,
+    isOpen,
+    portalContainer,
+    schedulePositionUpdate
+  ]);
   React2.useEffect(() => {
-    if (!isOpen || !portalWindow) return;
-    const ResizeObserverCtor = portalWindow.ResizeObserver;
-    if (!ResizeObserverCtor) return;
-    const ro = new ResizeObserverCtor(() => updatePosition());
-    if (positionerRef.current) ro.observe(positionerRef.current);
-    if (triggerRef.current) ro.observe(triggerRef.current);
-    return () => ro.disconnect();
-  }, [isOpen, portalWindow, updatePosition]);
-  React2.useLayoutEffect(() => {
-    if (!isOpen) {
-      lastAppliedRef.current = null;
+    const triggerEl = triggerRef.current;
+    if (!isOpen || !triggerEl || !portalContainer) return;
+    const ownerDocument = triggerEl.ownerDocument;
+    const ownerWindow = ownerDocument.defaultView;
+    if (!ownerWindow || portalContainer.ownerDocument !== ownerDocument) {
+      closeWhenPositioningIsUnsafe();
       return;
     }
-  }, [isOpen]);
-  React2.useEffect(() => {
-    if (!isOpen || !portalDocument || !portalWindow) return;
     const handleClickOutside = (event) => {
       const target = event.target;
-      const triggerEl = triggerRef.current;
+      const currentTrigger = triggerRef.current;
       const popoverEl = positionerRef.current;
-      if (!triggerEl || !popoverEl) return;
-      if (triggerEl.contains(target)) return;
+      if (!currentTrigger || !popoverEl) return;
+      if (currentTrigger.contains(target)) return;
       if (popoverEl.contains(target)) return;
-      if (target instanceof portalWindow.Element && target.closest("[data-popover]")) return;
+      if (target instanceof ownerWindow.Element && target.closest("[data-popover]")) return;
       setIsOpen(false);
     };
     const handleEscape = (event) => {
@@ -508,18 +609,30 @@ var Popover = ({
         setIsOpen(false);
       }
     };
-    portalDocument.addEventListener("mousedown", handleClickOutside);
-    portalDocument.addEventListener("keydown", handleEscape);
+    ownerDocument.addEventListener("mousedown", handleClickOutside);
+    ownerDocument.addEventListener("keydown", handleEscape);
     return () => {
-      portalDocument.removeEventListener("mousedown", handleClickOutside);
-      portalDocument.removeEventListener("keydown", handleEscape);
+      ownerDocument.removeEventListener("mousedown", handleClickOutside);
+      ownerDocument.removeEventListener("keydown", handleEscape);
     };
-  }, [isOpen, portalDocument, portalWindow, setIsOpen]);
+  }, [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",
@@ -575,13 +688,9 @@ var Popover = ({
   ) : null;
   return /* @__PURE__ */ jsxs(Fragment2, { children: [
     (() => {
-      const triggerProps = trigger.props;
-      const childRef = triggerProps.ref;
       return React2.cloneElement(trigger, {
         ...triggerProps,
-        ref: mergeRefs(childRef, (node) => {
-          triggerRef.current = node;
-        }),
+        ref: composedTriggerRef,
         onClick: chainEventHandlers(
           (e) => {
             triggerRef.current = e.currentTarget;
@@ -660,7 +769,6 @@ var DropdownMenu = ({
   const [activeIndex, setActiveIndex] = useResettingIndex(open);
   const parentMenu = React3.useContext(DropdownMenuContext);
   const hoverCloseTimeoutRef = React3.useRef(null);
-  const getPortalContainer = useUEditorPortalContainerGetter();
   const cancelHoverClose = React3.useCallback(() => {
     if (hoverCloseTimeoutRef.current === null) return;
     clearTimeout(hoverCloseTimeoutRef.current);
@@ -693,7 +801,6 @@ var DropdownMenu = ({
     item.focus();
     item.scrollIntoView({ block: "nearest" });
   }, [getEnabledMenuItems, setActiveIndex]);
-  useShadCNAnimations();
   const globalConfig = useUnderverseUIConfig();
   const resolvedBorderMode = borderMode ?? globalConfig.dropdownMenu?.borderMode ?? globalConfig.borderMode;
   React3.useEffect(() => {
@@ -814,8 +921,11 @@ var DropdownMenu = ({
     triggerRef.current = node;
   }, [childRef]);
   const handleTriggerKeyDown = React3.useCallback((event) => {
-    const portalWindow = resolveUEditorPortalContainer(getPortalContainer)?.ownerDocument.defaultView;
-    const scheduleFrame = portalWindow?.requestAnimationFrame.bind(portalWindow) ?? requestAnimationFrame;
+    const triggerWindow = event.currentTarget.ownerDocument.defaultView;
+    const scheduleFrame = (callback) => {
+      if (triggerWindow) triggerWindow.requestAnimationFrame(callback);
+      else callback(0);
+    };
     if (!disabled) {
       if (event.key === "ArrowDown") {
         event.preventDefault();
@@ -834,7 +944,7 @@ var DropdownMenu = ({
       }
     }
     triggerOnKeyDown?.(event);
-  }, [disabled, focusMenuItem, getEnabledMenuItems, getPortalContainer, setOpen, triggerOnKeyDown]);
+  }, [disabled, focusMenuItem, getEnabledMenuItems, setOpen, triggerOnKeyDown]);
   const handleTriggerClick = React3.useCallback((event) => {
     if (openOnHover && !disabled) {
       cancelHoverClose();
@@ -4678,4 +4788,4 @@ export {
   EditorToolbar,
   UEDITOR_PROSEMIRROR_CLASS_NAME
 };
-//# sourceMappingURL=chunk-RSLY7UU2.js.map
+//# sourceMappingURL=chunk-O7AAN6W6.js.map