@mirohq/design-system-dropdown-menu 4.4.9 → 4.4.10-dropdown-on-pointerup.1

package/dist/module.js

@@ -14,7 +14,8 @@ import { useLayoutEffect } from '@mirohq/design-system-use-layout-effect';
 import { useAriaDisabled as useAriaDisabled$1 } from '@mirohq/design-system-use-aria-disabled';
 import { ScrollArea } from '@mirohq/design-system-scroll-area';
 import { styles, Thumb } from '@mirohq/design-system-base-switch';
-import { isVirtualClick } from '@react-aria/utils';
+import { mergeProps } from '@react-aria/utils';
+import { usePress } from '@mirohq/design-system-use-press';
 import { styles as styles$1, isIconComponent } from '@mirohq/design-system-base-icon';
 
 const ItemDescription = styled(Primitive.div, {
@@ -454,16 +455,25 @@ const ScrollableContent = ({
 const DropdownContext = createContext({});
 const DropdownProvider = ({
   children,
+  open: rootOpen,
   ...restProps
-}) => /* @__PURE__ */ jsx(
-  DropdownContext.Provider,
-  {
-    value: {
-      ...restProps
-    },
-    children
-  }
-);
+}) => {
+  const [open, setOpen] = useState(rootOpen);
+  const triggerRef = useRef(null);
+  return /* @__PURE__ */ jsx(
+    DropdownContext.Provider,
+    {
+      value: {
+        ...restProps,
+        rootOpen,
+        open,
+        setOpen,
+        triggerRef
+      },
+      children
+    }
+  );
+};
 const useDropdownContext = () => useContext(DropdownContext);
 
 const Content = React.forwardRef(
@@ -480,10 +490,11 @@ const Content = React.forwardRef(
     containerSpacing = "medium",
     overflow = "visible",
     maxHeight,
+    onInteractOutside,
     children,
     ...restProps
   }, forwardRef) => {
-    const { direction } = useDropdownContext();
+    const { direction, triggerRef } = useDropdownContext();
     return /* @__PURE__ */ jsx(ContentProvider, { containerSpacing, children: /* @__PURE__ */ jsx(
       StyledContent,
       {
@@ -498,6 +509,12 @@ const Content = React.forwardRef(
         collisionPadding,
         sticky,
         hideWhenDetached,
+        onInteractOutside: (e) => {
+          if (e.target === triggerRef.current) {
+            e.preventDefault();
+          }
+          onInteractOutside == null ? void 0 : onInteractOutside(e);
+        },
         children: /* @__PURE__ */ jsx(
           ScrollableContent,
           {
@@ -703,37 +720,49 @@ const StyledTrigger = styled(RadixDropdownMenu.Trigger, {
   }
 });
 
-const Trigger = React.forwardRef(({ asChild = false, onClick, ...restProps }, forwardRef) => {
+const Trigger = React.forwardRef(({ asChild = false, ...restProps }, forwardRef) => {
   const ref = useRef(null);
-  const handleVirtualClick = (e) => {
-    var _a;
-    if ((e == null ? void 0 : e.nativeEvent) === void 0) {
-      console.error(
-        "DropdownMenu.Trigger onClick expected a MouseEvent but got different one. It usually happens due to a element used asChild with a different onClick interface.\n" + "Event: ".concat(JSON.stringify(e, null, 2))
-      );
-      return;
-    }
-    const nativeEvent = e.nativeEvent;
-    if (nativeEvent.mozInputSource === void 0) {
-      nativeEvent.mozInputSource = null;
-    }
-    if (isVirtualClick(e.nativeEvent) && ref.current !== null) {
-      const pointerDownEvent = new MouseEvent("pointerdown", {
-        bubbles: true,
-        cancelable: true
-      });
-      (_a = ref.current) == null ? void 0 : _a.dispatchEvent(pointerDownEvent);
+  const { setOpen, rootOpen, triggerRef } = useDropdownContext();
+  const { pressProps } = usePress({
+    onPress: () => {
+      if (rootOpen === void 0) {
+        setOpen((open) => !booleanify(open));
+      }
     }
-  };
+  });
+  const elementProps = mergeProps(restProps, pressProps);
   return /* @__PURE__ */ jsx(
     StyledTrigger,
     {
-      ...restProps,
+      ...elementProps,
+      onPointerDown: (e) => {
+        var _a, _b;
+        if (process.env.NODE_ENV === "test") {
+          e.preventDefault = () => null;
+          (_a = restProps.onPointerDown) == null ? void 0 : _a.call(restProps, e);
+          return;
+        }
+        (_b = elementProps.onPointerDown) == null ? void 0 : _b.call(elementProps, e);
+      },
       onClick: (e) => {
-        handleVirtualClick(e);
-        onClick == null ? void 0 : onClick(e);
+        var _a, _b;
+        if ((e == null ? void 0 : e.nativeEvent) === void 0) {
+          console.error(
+            "DropdownMenu.Trigger onClick expected a MouseEvent but got different one. It usually happens due to a element used asChild with a different onClick interface.\n" + "Event: ".concat(JSON.stringify(e, null, 2))
+          );
+          (_a = restProps.onClick) == null ? void 0 : _a.call(restProps, e);
+          return;
+        }
+        (_b = elementProps.onClick) == null ? void 0 : _b.call(elementProps, e);
       },
-      ref: mergeRefs([ref, forwardRef]),
+      onKeyDown: (e) => {
+        var _a;
+        if (!/^(Arrow|Tab|Escape)/.test(e.key)) {
+          e.preventDefault();
+        }
+        (_a = elementProps.onKeyDown) == null ? void 0 : _a.call(elementProps, e);
+      },
+      ref: mergeRefs([ref, triggerRef, forwardRef]),
       unstyled: !asChild,
       asChild
     }
@@ -884,39 +913,52 @@ const Root = ({
   defaultOpen = false,
   direction,
   interactOutside = false,
-  open,
   onOpen,
   onClose,
   ...restProps
 }) => {
   const { ignoreNextTooltip } = useBaseTooltipContext();
+  const { rootOpen, open, setOpen } = useDropdownContext();
   const prevOpen = usePrevious(open);
   useEffect(() => {
-    if (prevOpen === true && open === false) {
-      ignoreNextTooltip();
+    if (prevOpen !== open) {
+      if (open === true) {
+        onOpen == null ? void 0 : onOpen();
+      } else {
+        if (prevOpen === true) {
+          ignoreNextTooltip();
+        }
+        onClose == null ? void 0 : onClose();
+      }
     }
-  }, [ignoreNextTooltip, open, prevOpen]);
+  }, [open, prevOpen, onOpen, onClose, ignoreNextTooltip]);
   return /* @__PURE__ */ jsx(
     RadixDropdownMenu.Root,
     {
       ...restProps,
       dir: direction,
       modal: interactOutside,
-      open,
+      open: (
+        // use the root open state if it is defined
+        rootOpen != null ? rootOpen : defaultOpen && (prevOpen === void 0 || prevOpen === open) ? (
+          // only use defaultOpen in the first render then use the context open state
+          // if the open state is the same as the previous one, it is most likely a re-render and we should still use the defaultOpen
+          void 0
+        ) : (
+          // otherwise, use the user open state
+          open
+        )
+      ),
       defaultOpen,
-      onOpenChange: (newOpen) => {
-        if (!newOpen && open === void 0) {
-          ignoreNextTooltip();
-        }
-        newOpen ? onOpen == null ? void 0 : onOpen() : onClose == null ? void 0 : onClose();
-      }
+      onOpenChange: setOpen
     }
   );
 };
 const DropdownMenu = ({
   direction = "ltr",
+  open,
   ...restProps
-}) => /* @__PURE__ */ jsx(DropdownProvider, { direction, children: /* @__PURE__ */ jsx(BaseTooltipProvider, { children: /* @__PURE__ */ jsx(Root, { direction, ...restProps }) }) });
+}) => /* @__PURE__ */ jsx(DropdownProvider, { direction, open, children: /* @__PURE__ */ jsx(BaseTooltipProvider, { children: /* @__PURE__ */ jsx(Root, { direction, ...restProps }) }) });
 DropdownMenu.CheckboxItem = CheckboxItem;
 DropdownMenu.Content = Content;
 DropdownMenu.Hotkey = Hotkey;