@payloadcms/ui 4.0.0-internal.bc5cf8c → 4.0.0-internal.bf4bcce

package/dist/elements/Popup/index.js

@@ -2,42 +2,33 @@
 
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 export * as PopupList from './PopupButtonList/index.js';
-import React, { createContext, use, useCallback, useEffect, useRef, useState } from 'react';
-import { createPortal } from 'react-dom';
+import React, { createContext, use, useCallback, useEffect, useId, useRef, useState } from 'react';
 import { useEffectEvent } from '../../hooks/useEffectEvent.js';
 import { ThemeProvider } from '../../providers/Theme/index.js';
 import './index.css';
 import { PopupTrigger } from './PopupTrigger/index.js';
+import { createSubmenuScope } from './SubmenuScope.js';
+import { useSubmenuPointerIntent } from './useSubmenuPointerIntent.js';
 const baseClass = 'popup';
 const PopupContext = /*#__PURE__*/createContext(null);
 /**
  * Selector for all elements the browser considers tabbable.
  */
 const TABBABLE_SELECTOR = ['a[href]', 'button:not(:disabled)', 'input:not(:disabled):not([type="hidden"])', 'select:not(:disabled)', 'textarea:not(:disabled)', '[tabindex]', '[contenteditable]:not([contenteditable="false"])', 'audio[controls]', 'video[controls]', 'summary'].map(s => `${s}:not([tabindex="-1"])`).join(', ');
-/**
- * Returns whether the element has a `position: fixed` ancestor (e.g. an open Drawer).
- * Such popups must be positioned with `fixed` so they don't drift when the background scrolls.
- */
-const hasFixedAncestor = element => {
-  let node = element?.parentElement;
-  while (node && node !== document.body) {
-    if (window.getComputedStyle(node).position === 'fixed') {
-      return true;
-    }
-    node = node.parentElement;
-  }
-  return false;
-};
+const MENU_ITEM_SELECTOR = '[role="menuitem"], [role="menuitemcheckbox"], [role="menuitemradio"]';
+const POPUP_CONTENT_SELECTOR = `.${baseClass}__content, .${baseClass}__hidden-content`;
+const getMenuItems = popup => Array.from(popup.querySelectorAll(MENU_ITEM_SELECTOR)).filter(item => item.closest(POPUP_CONTENT_SELECTOR) === popup);
 /**
  * Component that renders a popup, as well as a button that triggers the popup.
  *
- * The popup is rendered in a portal, and is automatically positioned above / below the trigger,
+ * The popup is rendered next to its trigger in the DOM and positioned above / below it,
  * depending on the verticalAlign prop and the space available.
  */
 export const Popup = props => {
   const {
     id,
     button,
+    buttonAriaLabel,
     buttonClassName,
     buttonSize,
     buttonType = 'default',
@@ -46,11 +37,14 @@ export const Popup = props => {
     className,
     disabled,
     forceOpen,
-    horizontalAlign = 'left',
+    horizontalAlign: horizontalAlignProp,
+    hoverSubmenu = false,
     initActive = false,
     noBackground,
     onToggleClose,
     onToggleOpen,
+    popupAriaLabel,
+    popupType,
     portalClassName,
     render,
     renderButton,
@@ -63,11 +57,8 @@ export const Popup = props => {
   } = props;
   const popupRef = useRef(null);
   const triggerRef = useRef(null);
-  /**
-  * Whether the trigger is inside a `position: fixed` ancestor (e.g. a Drawer),
-  * in which case the popup is positioned with `fixed` instead of `absolute`.
-  */
-  const isFixedRef = useRef(false);
+  const generatedContentId = useId();
+  const contentId = `${id || generatedContentId}-content`;
   /**
   * Keeps track of whether the popup was opened via keyboard.
   * This is used to determine whether to autofocus the first element in the popup.
@@ -75,22 +66,74 @@ export const Popup = props => {
   */
   const openedViaKeyboardRef = useRef(false);
   const parentPopup = use(PopupContext);
-  const [mounted, setMounted] = useState(false);
+  const popupRole = popupType === true ? 'menu' : popupType || undefined;
+  const submenuScope = useState(() => createSubmenuScope())[0];
+  const isSubmenu = parentPopup?.popupRole === 'menu' && popupRole === 'menu';
+  const horizontalAlign = horizontalAlignProp ?? 'left';
+  const resolvedSide = side ?? (isSubmenu ? horizontalAlignProp === 'left' ? 'left' : 'right' : undefined);
   const [active, setActiveInternal] = useState(initActive);
   const [isOnTop, setIsOnTop] = useState(verticalAlign === 'top');
-  // Track when component is mounted to avoid SSR/client hydration mismatch
-  useEffect(() => {
-    setMounted(true);
-  }, []);
-  const setActive = useCallback((isActive, viaKeyboard = false) => {
+  const setActive = useCallback((isActive, viaKeyboard = false, coordinateParent = true) => {
     if (isActive) {
       openedViaKeyboardRef.current = viaKeyboard;
+      if (coordinateParent && isSubmenu) {
+        parentPopup.submenuScope.requestOpen({
+          id: contentId,
+          delay: false,
+          viaKeyboard
+        });
+        return;
+      }
       onToggleOpen?.(true);
     } else {
       onToggleClose?.();
+      submenuScope.closeActiveBranch();
+      parentPopup?.submenuScope.release(contentId);
     }
     setActiveInternal(isActive);
-  }, [onToggleClose, onToggleOpen]);
+  }, [contentId, isSubmenu, onToggleClose, onToggleOpen, parentPopup, submenuScope]);
+  const closePopup = useCallback(({
+    restoreFocus = true
+  } = {}) => {
+    const trigger = triggerRef.current?.querySelector('button, [tabindex="0"]');
+    setActive(false);
+    if (restoreFocus) {
+      requestAnimationFrame(() => trigger?.focus());
+    }
+  }, [setActive]);
+  const close = useCallback(() => closePopup(), [closePopup]);
+  const closePopupChain = useCallback((options = {}) => {
+    if (parentPopup) {
+      closePopup({
+        restoreFocus: false
+      });
+      parentPopup.closePopupChain(options);
+      return;
+    }
+    closePopup(options);
+  }, [closePopup, parentPopup]);
+  const openFromParent = useCallback(viaKeyboard_0 => setActive(true, viaKeyboard_0, false), [setActive]);
+  useEffect(() => {
+    if (!isSubmenu) {
+      return;
+    }
+    return parentPopup.submenuScope.register({
+      id: contentId,
+      closeBranch: () => closePopup({
+        restoreFocus: false
+      }),
+      open: openFromParent
+    });
+  }, [closePopup, contentId, isSubmenu, openFromParent, parentPopup]);
+  const pointerIntent = useSubmenuPointerIntent({
+    contentRef: popupRef,
+    enabled: isSubmenu && hoverSubmenu,
+    onClose: () => setActive(false),
+    onOpen: () => parentPopup?.submenuScope.requestOpen({
+      id: contentId,
+      delay: Boolean(parentPopup.submenuScope.activeChildId)
+    })
+  });
   // /////////////////////////////////////
   // Position Calculation
   //
@@ -99,40 +142,37 @@ export const Popup = props => {
   // styles if the calculated position differs from current position.
   // /////////////////////////////////////
   const updatePosition = useEffectEvent(() => {
-    const trigger = triggerRef.current;
+    const trigger_0 = triggerRef.current;
     const popup = popupRef.current;
-    if (!trigger || !popup) {
+    if (!trigger_0 || !popup) {
       return;
     }
-    const triggerRect = trigger.getBoundingClientRect();
+    const triggerRect = trigger_0.getBoundingClientRect();
     const popupRect = popup.getBoundingClientRect();
-    // Inside a fixed ancestor, use `fixed` (no scroll offset) so background scrolling
-    // doesn't shift the popup. Otherwise use page coordinates (absolute).
-    const useFixed = isFixedRef.current;
-    const scrollY = useFixed ? 0 : window.scrollY;
-    const scrollX = useFixed ? 0 : window.scrollX;
     // Gap between the popup and the trigger/viewport edges (in pixels)
-    const offset = 10;
+    const offset = 8;
     // Additional gap used in side mode so the child popup has breathing room from its parent
     const sideOffset = 4;
     let top;
     let left;
     let caretLeft;
-    if (side) {
+    if (resolvedSide) {
       // /////////////////////////////////////
       // Side Positioning
       // Places the popup to the left or right of the parent popup (not just the trigger),
       // top-aligned with the trigger. Flips to the opposite side if there is not enough
       // viewport space.
       // /////////////////////////////////////
-      // Top: align with trigger top, clamped to viewport
-      top = triggerRect.top + scrollY;
-      const maxTop = scrollY + window.innerHeight - popupRect.height - offset;
-      top = Math.max(scrollY + offset, Math.min(top, maxTop));
+      const scrollContainer = popup.querySelector(`:scope > .${baseClass}__scroll-container`);
+      const popupPaddingTop = scrollContainer ? Number.parseFloat(window.getComputedStyle(scrollContainer).paddingTop) || 0 : 0;
+      // Align the first menu item with the trigger by accounting for the popup's top padding.
+      top = triggerRect.top - popupPaddingTop;
+      const maxTop = window.innerHeight - popupRect.height - offset;
+      top = Math.max(offset, Math.min(top, maxTop));
       // Use the parent popup's bounding rect as the reference for left/right positioning
       // so the child appears 4px from the parent popup edge, not just the trigger button.
       const anchorRect = parentPopup?.popupRef.current ? parentPopup.popupRef.current.getBoundingClientRect() : triggerRect;
-      if (side === 'left') {
+      if (resolvedSide === 'left') {
         left = anchorRect.left - popupRect.width - sideOffset;
         if (left < offset) {
           // flip to right side
@@ -145,7 +185,7 @@ export const Popup = props => {
           left = anchorRect.left - popupRect.width - sideOffset;
         }
       }
-      left = left + scrollX;
+      left = Math.max(offset, Math.min(left, Math.max(offset, window.innerWidth - popupRect.width - offset)));
       // Caret not used in side mode; set a neutral value
       caretLeft = popupRect.width / 2;
       setIsOnTop(false);
@@ -158,23 +198,25 @@ export const Popup = props => {
       // /////////////////////////////////////
       let onTop = verticalAlign === 'top';
       if (verticalAlign === 'bottom') {
-        top = triggerRect.bottom + scrollY + offset;
+        top = triggerRect.bottom + offset;
         if (triggerRect.bottom + popupRect.height + offset > window.innerHeight) {
           // Try to flip above — only do so if there's actually enough room
-          const topIfAbove = triggerRect.top + scrollY - popupRect.height - offset;
-          if (topIfAbove >= scrollY) {
+          const topIfAbove = triggerRect.top - popupRect.height - offset;
+          if (topIfAbove >= 0) {
             top = topIfAbove;
             onTop = true;
           }
           // else: not enough room above either — keep below and let it overflow rather than going off-screen
         }
       } else {
-        top = triggerRect.top + scrollY - popupRect.height - offset;
+        top = triggerRect.top - popupRect.height - offset;
         if (triggerRect.top - popupRect.height - offset < 0) {
-          top = triggerRect.bottom + scrollY + offset;
+          top = triggerRect.bottom + offset;
           onTop = false;
         }
       }
+      const maxTop_0 = Math.max(offset, window.innerHeight - popupRect.height - offset);
+      top = Math.max(offset, Math.min(top, maxTop_0));
       setIsOnTop(onTop);
       // /////////////////////////////////////
       // Horizontal Positioning
@@ -203,9 +245,9 @@ export const Popup = props => {
     // Values are rounded to match browser's CSS precision and avoid false updates.
     // /////////////////////////////////////
     const newTop = `${Math.round(top)}px`;
-    const newLeft = `${Math.round(left + scrollX)}px`;
+    const newLeft = `${Math.round(left)}px`;
     const newCaretLeft = `${Math.round(caretLeft)}px`;
-    const newPosition = useFixed ? 'fixed' : '';
+    const newPosition = 'fixed';
     if (popup.style.position !== newPosition) {
       popup.style.position = newPosition;
     }
@@ -244,8 +286,8 @@ export const Popup = props => {
   // Keyboard Navigation
   // Handles keyboard interactions when popup is open:
   // - Escape: closes popup and returns focus to trigger
-  // - Tab/Shift+Tab: cycles through focusable items with wrapping
-  // - ArrowUp/ArrowDown: same as Shift+Tab/Tab for menu-style navigation
+  // - Tab/Shift+Tab: closes menus; dialogs retain normal document tab order
+  // - ArrowUp/ArrowDown: moves between menu items with wrapping
   // Focus is managed manually to support elements the browser might skip.
   // /////////////////////////////////////
   const handleKeyDown = useEffectEvent(e_0 => {
@@ -253,29 +295,72 @@ export const Popup = props => {
     if (!popup_0 || !active) {
       return;
     }
+    const activePopup = document.activeElement?.closest(`.${baseClass}__content`);
+    if (activePopup && activePopup !== popup_0) {
+      return;
+    }
     if (e_0.key === 'Escape') {
       e_0.preventDefault();
-      setActive(false);
-      triggerRef.current?.querySelector('button, [tabindex="0"]')?.focus();
+      e_0.stopPropagation();
+      closePopup();
+      return;
+    }
+    if (e_0.key === 'ArrowRight' && popupRole === 'menu') {
+      const trigger_1 = document.activeElement?.closest(`.${baseClass}__trigger-wrap`);
+      const nestedTrigger = trigger_1?.querySelector('button, [role="menuitem"]');
+      if (nestedTrigger) {
+        e_0.preventDefault();
+        nestedTrigger.dispatchEvent(new KeyboardEvent('keydown', {
+          bubbles: true,
+          key: 'Enter'
+        }));
+        return;
+      }
+    }
+    if (e_0.key === 'ArrowLeft' && parentPopup) {
+      e_0.preventDefault();
+      closePopup();
+      return;
+    }
+    if (e_0.key === 'Tab' && popupRole === 'menu') {
+      if (e_0.shiftKey) {
+        e_0.preventDefault();
+        closePopupChain({
+          restoreFocus: true
+        });
+        return;
+      }
+      setTimeout(closePopupChain);
       return;
     }
-    if (e_0.key === 'Tab' || e_0.key === 'ArrowDown' || e_0.key === 'ArrowUp') {
+    if (['ArrowDown', 'ArrowUp', 'End', 'Home'].includes(e_0.key)) {
+      const menuItems = getMenuItems(popup_0);
+      if (menuItems.length > 0) {
+        e_0.preventDefault();
+        const currentIndex = menuItems.findIndex(item => item === document.activeElement);
+        const nextIndex = e_0.key === 'Home' ? 0 : e_0.key === 'End' ? menuItems.length - 1 : e_0.key === 'ArrowUp' ? currentIndex <= 0 ? menuItems.length - 1 : currentIndex - 1 : currentIndex === -1 || currentIndex === menuItems.length - 1 ? 0 : currentIndex + 1;
+        menuItems.forEach((item_0, index) => item_0.setAttribute('tabindex', index === nextIndex ? '0' : '-1'));
+        menuItems[nextIndex].focus();
+        return;
+      }
+    }
+    if (e_0.key === 'ArrowDown' || e_0.key === 'ArrowUp') {
       const focusable = Array.from(popup_0.querySelectorAll(TABBABLE_SELECTOR));
       if (focusable.length === 0) {
         return;
       }
       e_0.preventDefault();
-      const currentIndex = focusable.findIndex(el => el === document.activeElement);
-      const goBackward = e_0.key === 'ArrowUp' || e_0.key === 'Tab' && e_0.shiftKey;
-      let nextIndex;
-      if (currentIndex === -1) {
-        nextIndex = goBackward ? focusable.length - 1 : 0;
+      const currentIndex_0 = focusable.findIndex(el => el === document.activeElement);
+      const goBackward = e_0.key === 'ArrowUp';
+      let nextIndex_0;
+      if (currentIndex_0 === -1) {
+        nextIndex_0 = goBackward ? focusable.length - 1 : 0;
       } else if (goBackward) {
-        nextIndex = currentIndex === 0 ? focusable.length - 1 : currentIndex - 1;
+        nextIndex_0 = currentIndex_0 === 0 ? focusable.length - 1 : currentIndex_0 - 1;
       } else {
-        nextIndex = currentIndex === focusable.length - 1 ? 0 : currentIndex + 1;
+        nextIndex_0 = currentIndex_0 === focusable.length - 1 ? 0 : currentIndex_0 + 1;
       }
-      focusable[nextIndex].focus();
+      focusable[nextIndex_0].focus();
     }
   });
   // /////////////////////////////////////
@@ -291,11 +376,14 @@ export const Popup = props => {
     // Check if the clicked element or any ancestor is an actionable element
     const actionable = target_0.closest('button, a[href], [role="button"], [role="menuitem"]');
     if (actionable && popupRef.current?.contains(actionable)) {
+      if (actionable.closest(`.${baseClass}__content`) !== popupRef.current) {
+        return;
+      }
       // Don't close if clicking a nested popup's trigger — it will manage its own open state
       if (actionable.closest(`.${baseClass}__trigger-wrap`)) {
         return;
       }
-      setActive(false);
+      closePopup();
     }
   });
   // /////////////////////////////////////
@@ -319,6 +407,11 @@ export const Popup = props => {
     if (!popup_2) {
       return;
     }
+    if (!popup_2.matches(':popover-open')) {
+      popup_2.showPopover();
+    }
+    const menuItems_0 = getMenuItems(popup_2);
+    menuItems_0.forEach((item_1, index_0) => item_1.setAttribute('tabindex', index_0 === 0 ? '0' : '-1'));
     // /////////////////////////////////////
     // Initial Position
     // Calculate and apply popup position.
@@ -333,8 +426,6 @@ export const Popup = props => {
     // (e.g. ColumnSelection popup content rendering after hidden → visible
     // class switch), which was causing incorrect flip-to-top decisions.
     // /////////////////////////////////////
-    // Decide the positioning strategy once per open.
-    isFixedRef.current = hasFixedAncestor(triggerRef.current);
     updatePosition();
     const rafId = requestAnimationFrame(() => {
       updatePosition();
@@ -347,7 +438,7 @@ export const Popup = props => {
     if (openedViaKeyboardRef.current) {
       // Use requestAnimationFrame to ensure DOM is ready.
       requestAnimationFrame(() => {
-        const firstFocusable = popup_2.querySelector(TABBABLE_SELECTOR);
+        const firstFocusable = menuItems_0[0] ?? popup_2.querySelector(TABBABLE_SELECTOR);
         firstFocusable?.focus();
       });
     }
@@ -363,7 +454,7 @@ export const Popup = props => {
       passive: true
     });
     document.addEventListener('mousedown', handleClickOutside);
-    document.addEventListener('keydown', handleKeyDown);
+    popup_2.addEventListener('keydown', handleKeyDown);
     popup_2.addEventListener('click', handleActionableClick);
     return () => {
       cancelAnimationFrame(rafId);
@@ -372,8 +463,11 @@ export const Popup = props => {
         capture: true
       });
       document.removeEventListener('mousedown', handleClickOutside);
-      document.removeEventListener('keydown', handleKeyDown);
+      popup_2.removeEventListener('keydown', handleKeyDown);
       popup_2.removeEventListener('click', handleActionableClick);
+      if (popup_2.matches(':popover-open')) {
+        popup_2.hidePopover();
+      }
     };
   }, [active]);
   useEffect(() => {
@@ -384,10 +478,14 @@ export const Popup = props => {
   const Trigger = /*#__PURE__*/_jsx(PopupTrigger, {
     active: active,
     button: button,
+    buttonAriaLabel: buttonAriaLabel,
     buttonType: buttonType,
     className: buttonClassName,
+    contentId: contentId,
     disabled: disabled,
+    isMenuItem: parentPopup?.popupRole === 'menu',
     noBackground: noBackground,
+    popupType: popupType,
     renderButton: renderButton,
     setActive: setActive,
     size: buttonSize
@@ -405,40 +503,48 @@ export const Popup = props => {
         role: "button",
         tabIndex: 0,
         children: Trigger
+      }) : hoverSubmenu && isSubmenu ? /*#__PURE__*/_jsx("div", {
+        ...pointerIntent,
+        className: `${baseClass}__submenu-hover-watch`,
+        children: Trigger
       }) : Trigger
-    }), mounted ?
-    // This ensures that components within the popup, like modals, do not unmount when the popup closes.
-    // Otherwise, modals opened from the popup will close unexpectedly when clicking within the modal, since
-    // that closes the popup due to the click outside handler.
-    /*#__PURE__*/
-    createPortal(/*#__PURE__*/_jsx(PopupContext, {
+    }), /*#__PURE__*/_jsx(PopupContext, {
       value: {
-        popupRef
+        closePopupChain,
+        popupRef,
+        popupRole,
+        submenuScope
       },
       children: /*#__PURE__*/_jsxs("div", {
-        className: active ? [`${baseClass}__content`, `${baseClass}--size-${size}`, side ? `${baseClass}--side-${side}` : isOnTop ? `${baseClass}--v-top` : `${baseClass}--v-bottom`, portalClassName].filter(Boolean).join(' ') :
+        "aria-label": popupAriaLabel,
+        className: active ? [`${baseClass}__content`, `${baseClass}--size-${size}`, resolvedSide ? `${baseClass}--side-${resolvedSide}` : isOnTop ? `${baseClass}--v-top` : `${baseClass}--v-bottom`, portalClassName].filter(Boolean).join(' ') :
         // tests do not accidentally target inactive popups.
         `${baseClass}__hidden-content`,
         "data-popup-id": id || undefined,
         "data-theme": theme === 'auto' ? undefined : theme,
+        id: contentId,
+        onMouseEnter: pointerIntent.onMouseEnter,
+        onMouseLeave: pointerIntent.onMouseLeave,
+        popover: "manual",
         ref: popupRef,
+        role: popupRole,
         children: [/*#__PURE__*/_jsx("div", {
           className: `${baseClass}__scroll-container${showScrollbar ? ` ${baseClass}__scroll-container--show-scrollbar` : ''}`,
           children: theme === 'auto' ? /*#__PURE__*/_jsxs(_Fragment, {
             children: [render?.({
-              close: () => setActive(false)
+              close
             }), children]
           }) : /*#__PURE__*/_jsxs(ThemeProvider, {
             theme: theme,
             children: [render?.({
-              close: () => setActive(false)
+              close
             }), children]
           })
-        }), caret && !side && /*#__PURE__*/_jsx("div", {
+        }), caret && !resolvedSide && /*#__PURE__*/_jsx("div", {
           className: `${baseClass}__caret`
         })]
       })
-    }), document.body) : null]
+    })]
   });
 };
 //# sourceMappingURL=index.js.map