@kommo-crm/crm-react-ui-kit 1.1.1-beta.1 → 1.1.1-beta.3

package/dist/components/ContextMenu/hooks/useContextMenuSubMenu/useContextMenuSubMenu.d.ts

@@ -6,8 +6,8 @@ export declare const useContextMenuSubMenu: ({ displayName, mode: rootMode, defa
     onOpenChange: (value: boolean) => void;
     onOpenByKeyboard: (value: boolean) => void;
     inheritedArrowColor: string | null;
-    triggerRef: import('react').RefObject<HTMLButtonElement>;
-    contentRef: import('react').RefObject<HTMLDivElement>;
+    triggerRef: import("react").RefObject<HTMLButtonElement>;
+    contentRef: import("react").RefObject<HTMLDivElement>;
     animatedOpen: boolean;
     animationDuration: number;
     hoverCloseDelay: number;

package/dist/components/ContextMenu/hooks/useContextMenuSubMenu/useContextMenuSubMenu.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useContextMenuSubMenu.d.ts","sourceRoot":"","sources":["../../../../../src/components/ContextMenu/hooks/useContextMenuSubMenu/useContextMenuSubMenu.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAI1D,OAAO,EAAE,4BAA4B,EAAE,MAAM,+BAA+B,CAAC;AAE7E,eAAO,MAAM,qBAAqB,qJAU/B,4BAA4B;;;0BAuFI,OAAO;8BAyBP,OAAO;;;;;;;;2CAxCK,OAAO;;;;;CA0KrD,CAAC"}
+{"version":3,"file":"useContextMenuSubMenu.d.ts","sourceRoot":"","sources":["../../../../../src/components/ContextMenu/hooks/useContextMenuSubMenu/useContextMenuSubMenu.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAI1D,OAAO,EAAE,4BAA4B,EAAE,MAAM,+BAA+B,CAAC;AAE7E,eAAO,MAAM,qBAAqB,qJAU/B,4BAA4B;;;0BAyFI,OAAO;8BAyBP,OAAO;;;;;;;;2CAzCK,OAAO;;;;;CA4KrD,CAAC"}

package/dist/components/ContextMenu/hooks/useContextMenuSubMenu/useContextMenuSubMenu.js

@@ -1,72 +1,216 @@
-import { useId as Q, useState as T, useRef as C, useLayoutEffect as U, useEffect as R } from "react";
-import { ContextMenuMode as l } from "../../ContextMenu.enums.js";
-import { useInheritedArrowColor as W } from "../useInheritedArrowColor/useInheritedArrowColor.js";
-import "../../../../useContentPositioning-27D32n5u.mjs";
-import "../../components/Content/Content.utils.js";
-import "../../ContextMenu.context.js";
-import { useLevelContext as X } from "../../providers/LevelProvider/LevelProvider.js";
-import { useIsTouchDevice as Y } from "../useIsTouchDevice/useIsTouchDevice.js";
-const tr = ({
-  displayName: j,
-  mode: k,
-  defaultOpen: L,
-  animationDuration: K,
-  subMenuOpen: u,
-  setSubMenuOpen: t,
-  hoverCloseDelay: d,
-  closeRootMenuImmediately: n,
-  onOpen: v
-}) => {
-  const E = Q(), [f, y] = T(u || L || !1), [V, i] = T(!1), [g, a] = T(!1), [z, H] = T(!1), [s, h] = T(!1), { activeItemId: x } = X(j), D = C(null), A = C(null), r = C(null), e = C(null), c = Y() ? l.CLICK : k, B = () => {
-    r.current && (clearTimeout(r.current), r.current = null), e.current && (clearTimeout(e.current), e.current = null);
-  }, I = (o = !1) => {
-    t == null || t(!1), y(!1), a(!1), h(!1), o && (n == null || n());
-  }, w = () => {
-    B(), c === l.HOVER || s ? (i(!1), e.current = setTimeout(() => {
-      I();
-    }, K)) : I();
-  }, q = (o = !1) => {
-    B(), i(!1), t == null || t(!1), a(!1), h(!1), o && (n == null || n());
-  }, m = (o) => {
-    c === l.CLICK && L !== void 0 || (o ? (e.current && (clearTimeout(e.current), e.current = null), (c === l.HOVER || s) && i(!0), t == null || t(!0), v == null || v(!0)) : w());
-  }, F = (o) => {
-    H(o), m == null || m(o);
-  }, G = () => {
-    H(!1), !(c !== l.HOVER && !s) && (e.current && (clearTimeout(e.current), e.current = null, i(!0)), f || (r.current && (clearTimeout(r.current), r.current = null), i(!0), t == null || t(!0)), a(!0));
-  }, J = () => {
-    H(!1), !(c !== l.HOVER && !s) && (r.current && (clearTimeout(r.current), r.current = null), a(!1));
-  }, N = () => {
-    i(!0), a(!0), h(!0);
-  };
-  U(() => {
-    u !== void 0 && i(u);
-  }, [u]), R(() => {
-    x !== E && (f || u) && q();
-  }, [x, f, E]), R(() => {
-    !f && !V || c !== l.HOVER && !s || z || (g ? r.current && (clearTimeout(r.current), r.current = null) : r.current || (r.current = setTimeout(() => {
-      w();
-    }, d)));
-  }, [c, f, g, s, d]);
-  const P = W(f, A);
-  return {
-    open: f,
-    mode: c,
-    onOpenChange: m,
-    onOpenByKeyboard: F,
-    inheritedArrowColor: P,
-    triggerRef: D,
-    contentRef: A,
-    animatedOpen: V,
-    animationDuration: K,
-    hoverCloseDelay: d,
-    temporaryHoverClose: s,
-    closeMenuImmediately: q,
-    onMouseEnter: G,
-    onMouseLeave: J,
-    enableTemporaryHoverClose: N,
-    triggerId: E
-  };
-};
-export {
-  tr as useContextMenuSubMenu
+import { useEffect, useId, useLayoutEffect, useRef, useState } from 'react';
+import { useInheritedArrowColor, useIsTouchDevice } from '..';
+import { ContextMenuMode } from '../../ContextMenu.enums';
+import { useLevelContext } from '../../providers';
+export const useContextMenuSubMenu = ({ displayName, mode: rootMode, defaultOpen, animationDuration, subMenuOpen, setSubMenuOpen, hoverCloseDelay, closeRootMenuImmediately, onOpen, }) => {
+    const triggerId = useId();
+    const [open, setOpen] = useState(subMenuOpen || defaultOpen || false);
+    const [animatedOpen, setAnimatedOpen] = useState(false);
+    const [isInsideContent, setIsInsideContent] = useState(false);
+    const [openedByKeyboard, setOpenedByKeyboard] = useState(false);
+    const [temporaryHoverClose, setTemporaryHoverClose] = useState(false);
+    const { activeItemId } = useLevelContext(displayName);
+    const triggerRef = useRef(null);
+    const contentRef = useRef(null);
+    const hoverTimeoutRef = useRef(null);
+    const closeTimerRef = useRef(null);
+    const isTouchDevice = useIsTouchDevice();
+    /**
+     * The mode of the ContextMenu.Root.
+     */
+    const mode = isTouchDevice ? ContextMenuMode.CLICK : rootMode;
+    /**
+     * Clears the timers.
+     */
+    const clearTimers = () => {
+        if (hoverTimeoutRef.current) {
+            clearTimeout(hoverTimeoutRef.current);
+            hoverTimeoutRef.current = null;
+        }
+        if (closeTimerRef.current) {
+            clearTimeout(closeTimerRef.current);
+            closeTimerRef.current = null;
+        }
+    };
+    /**
+     * Closes the menu.
+     */
+    const handleClose = (closeRootMenu = false) => {
+        setSubMenuOpen?.(false);
+        setOpen(false);
+        onOpen?.(false);
+        setIsInsideContent(false);
+        setTemporaryHoverClose(false);
+        if (closeRootMenu) {
+            closeRootMenuImmediately?.();
+        }
+    };
+    /**
+     * Requests the close of the menu.
+     */
+    const requestClose = () => {
+        clearTimers();
+        if (mode === ContextMenuMode.HOVER || temporaryHoverClose) {
+            setAnimatedOpen(false);
+            closeTimerRef.current = setTimeout(() => {
+                handleClose();
+            }, animationDuration);
+        }
+        else {
+            handleClose();
+        }
+    };
+    /**
+     * Closes the menu immediately.
+     */
+    const closeMenuImmediately = (closeRootMenu = false) => {
+        clearTimers();
+        setAnimatedOpen(false);
+        setSubMenuOpen?.(false);
+        onOpen?.(false);
+        setIsInsideContent(false);
+        setTemporaryHoverClose(false);
+        if (closeRootMenu) {
+            closeRootMenuImmediately?.();
+        }
+    };
+    /**
+     * Handles the open state change.
+     */
+    const handleOpenChange = (value) => {
+        if (mode === ContextMenuMode.CLICK && defaultOpen !== undefined) {
+            return;
+        }
+        if (value) {
+            if (closeTimerRef.current) {
+                clearTimeout(closeTimerRef.current);
+                closeTimerRef.current = null;
+            }
+            if (mode === ContextMenuMode.HOVER || temporaryHoverClose) {
+                setAnimatedOpen(true);
+            }
+            setSubMenuOpen?.(true);
+            onOpen?.(true);
+        }
+        else {
+            requestClose();
+        }
+    };
+    /**
+     * The callback function to be called when the menu is opened by keyboard.
+     */
+    const onOpenByKeyboard = (value) => {
+        setOpenedByKeyboard(value);
+        handleOpenChange?.(value);
+    };
+    /**
+     * Handles the mouse enter event.
+     */
+    const handleMouseEnter = () => {
+        setOpenedByKeyboard(false);
+        if (mode !== ContextMenuMode.HOVER && !temporaryHoverClose) {
+            return;
+        }
+        if (closeTimerRef.current) {
+            clearTimeout(closeTimerRef.current);
+            closeTimerRef.current = null;
+            setAnimatedOpen(true);
+        }
+        if (open) {
+            setIsInsideContent(true);
+        }
+        else {
+            if (hoverTimeoutRef.current) {
+                clearTimeout(hoverTimeoutRef.current);
+                hoverTimeoutRef.current = null;
+            }
+            setAnimatedOpen(true);
+            setSubMenuOpen?.(true);
+            onOpen?.(true);
+            setIsInsideContent(true);
+        }
+    };
+    /**
+     * Handles the mouse leave event.
+     */
+    const handleMouseLeave = () => {
+        setOpenedByKeyboard(false);
+        if (mode !== ContextMenuMode.HOVER && !temporaryHoverClose) {
+            return;
+        }
+        if (hoverTimeoutRef.current) {
+            clearTimeout(hoverTimeoutRef.current);
+            hoverTimeoutRef.current = null;
+        }
+        setIsInsideContent(false);
+    };
+    /**
+     * Enables the temporary hover close.
+     */
+    const enableTemporaryHoverClose = () => {
+        setAnimatedOpen(true);
+        setIsInsideContent(true);
+        setTemporaryHoverClose(true);
+    };
+    /**
+     * Synchronizes the local open state with the submenu open state.
+     */
+    useLayoutEffect(() => {
+        if (subMenuOpen !== undefined) {
+            setAnimatedOpen(subMenuOpen);
+        }
+    }, [subMenuOpen]);
+    /**
+     * Closes the submenu when the active item id changes.
+     */
+    useEffect(() => {
+        if (activeItemId !== triggerId && (open || subMenuOpen)) {
+            closeMenuImmediately();
+        }
+    }, [activeItemId, open, triggerId]);
+    /**
+     * Handles the hover close delay.
+     */
+    useEffect(() => {
+        if ((!open && !animatedOpen) ||
+            (mode !== ContextMenuMode.HOVER && !temporaryHoverClose)) {
+            return;
+        }
+        if (openedByKeyboard) {
+            return;
+        }
+        if (isInsideContent) {
+            if (hoverTimeoutRef.current) {
+                clearTimeout(hoverTimeoutRef.current);
+                hoverTimeoutRef.current = null;
+            }
+        }
+        else if (!hoverTimeoutRef.current) {
+            hoverTimeoutRef.current = setTimeout(() => {
+                requestClose();
+            }, hoverCloseDelay);
+        }
+    }, [mode, open, isInsideContent, temporaryHoverClose, hoverCloseDelay]);
+    /**
+     * Updates the inherited arrow color when the menu is open.
+     */
+    const inheritedArrowColor = useInheritedArrowColor(open, contentRef);
+    return {
+        open,
+        mode,
+        onOpenChange: handleOpenChange,
+        onOpenByKeyboard,
+        inheritedArrowColor,
+        triggerRef,
+        contentRef,
+        animatedOpen,
+        animationDuration,
+        hoverCloseDelay,
+        temporaryHoverClose,
+        closeMenuImmediately,
+        onMouseEnter: handleMouseEnter,
+        onMouseLeave: handleMouseLeave,
+        enableTemporaryHoverClose,
+        triggerId,
+    };
 };

package/dist/components/ContextMenu/hooks/useContextMenuSubMenu/useContextMenuSubMenu.types.js

@@ -1 +1 @@
-
+export {};

package/dist/components/ContextMenu/hooks/useInheritedArrowColor/useInheritedArrowColor.js

@@ -1,60 +1,113 @@
-import { useState as C, useLayoutEffect as v } from "react";
-const y = (d, a) => {
-  const [h, f] = C(
-    null
-  );
-  return v(() => {
-    if (!d)
-      return;
-    const A = requestAnimationFrame(() => {
-      const l = (t) => {
-        f(getComputedStyle(t).backgroundColor);
-      }, p = () => {
-        var m, g;
-        if (!a.current)
-          return;
-        const t = (m = a.current) == null ? void 0 : m.dataset.side, r = (g = a.current) == null ? void 0 : g.dataset.align;
-        if (!t || !r)
-          return;
-        const u = Array.from(a.current.children);
-        if (!u.length)
-          return;
-        let i = t === "bottom" || t !== "top" && r === "start" ? 0 : u.length - 1, e = u[i];
-        if (e && !(e.hasAttribute("data-arrow") && (t === "bottom" || t !== "top" && r === "start" ? i += 1 : i -= 1, e = u[i], !e)) && !(e.hasAttribute("data-label") && ["left", "right"].includes(a.current.dataset.side ?? "") && a.current.dataset.align === "start" && (t === "bottom" || t !== "top" && r === "start" ? i += 1 : i -= 1, e = u[i], !e))) {
-          if (e.getAttribute("role") === "group" && e.children) {
-            const o = Array.from(e.children);
-            e = t === "bottom" || t !== "top" && r === "start" ? o[0] : o[o.length - 1], e.hasAttribute("data-content-wrapper") && (e = t === "bottom" || t !== "top" && r === "start" ? o[1] : o[o.length - 2]);
-          }
-          return e.hasAttribute("data-item") ? e : null;
+import { useLayoutEffect, useState } from 'react';
+export const useInheritedArrowColor = (open, contentRef) => {
+    const [inheritedArrowColor, setInheritedArrowColor] = useState(null);
+    useLayoutEffect(() => {
+        if (!open) {
+            return;
         }
-      };
-      let n = null, s = null;
-      const c = () => {
-        const t = p();
-        if (!t)
-          return;
-        l(t), n && n.disconnect(), n = new MutationObserver(() => l(t)), n.observe(t, {
-          attributes: !0,
-          attributeFilter: ["style", "class", "data-highlighted", "data-state"]
+        const raf = requestAnimationFrame(() => {
+            const updateColor = (item) => {
+                setInheritedArrowColor(getComputedStyle(item).backgroundColor);
+            };
+            const resolveTargetItem = () => {
+                if (!contentRef.current) {
+                    return;
+                }
+                const side = contentRef.current?.dataset.side;
+                const align = contentRef.current?.dataset.align;
+                if (!side || !align) {
+                    return;
+                }
+                const items = Array.from(contentRef.current.children);
+                if (!items.length) {
+                    return;
+                }
+                let index = side === 'bottom' || (side !== 'top' && align === 'start')
+                    ? 0
+                    : items.length - 1;
+                let targetItem = items[index];
+                if (!targetItem) {
+                    return;
+                }
+                if (targetItem.hasAttribute('data-arrow')) {
+                    if (side === 'bottom' || (side !== 'top' && align === 'start')) {
+                        index += 1;
+                    }
+                    else {
+                        index -= 1;
+                    }
+                    targetItem = items[index];
+                    if (!targetItem) {
+                        return;
+                    }
+                }
+                if (targetItem.hasAttribute('data-label') &&
+                    ['left', 'right'].includes(contentRef.current.dataset.side ?? '') &&
+                    contentRef.current.dataset.align === 'start') {
+                    if (side === 'bottom' || (side !== 'top' && align === 'start')) {
+                        index += 1;
+                    }
+                    else {
+                        index -= 1;
+                    }
+                    targetItem = items[index];
+                    if (!targetItem) {
+                        return;
+                    }
+                }
+                if (targetItem.getAttribute('role') === 'group' &&
+                    targetItem.children) {
+                    const targetItemChildren = Array.from(targetItem.children);
+                    targetItem =
+                        side === 'bottom' || (side !== 'top' && align === 'start')
+                            ? targetItemChildren[0]
+                            : targetItemChildren[targetItemChildren.length - 1];
+                    if (targetItem.hasAttribute('data-content-wrapper')) {
+                        targetItem =
+                            side === 'bottom' || (side !== 'top' && align === 'start')
+                                ? targetItemChildren[1]
+                                : targetItemChildren[targetItemChildren.length - 2];
+                    }
+                }
+                return targetItem.hasAttribute('data-item') ? targetItem : null;
+            };
+            let itemObserver = null;
+            let themeObserver = null;
+            const handleUpdate = () => {
+                const targetItem = resolveTargetItem();
+                if (!targetItem) {
+                    return;
+                }
+                updateColor(targetItem);
+                if (itemObserver) {
+                    itemObserver.disconnect();
+                }
+                itemObserver = new MutationObserver(() => updateColor(targetItem));
+                itemObserver.observe(targetItem, {
+                    attributes: true,
+                    attributeFilter: ['style', 'class', 'data-highlighted', 'data-state'],
+                });
+                const root = document.documentElement;
+                themeObserver = new MutationObserver(() => updateColor(targetItem));
+                themeObserver.observe(root, {
+                    attributes: true,
+                    attributeFilter: ['data-crm-ui-kit-theme'],
+                });
+            };
+            handleUpdate();
+            const content = contentRef.current;
+            const sideAlignObserver = new MutationObserver(handleUpdate);
+            sideAlignObserver.observe(content, {
+                attributes: true,
+                attributeFilter: ['data-side', 'data-align'],
+            });
+            return () => {
+                itemObserver?.disconnect();
+                themeObserver?.disconnect();
+                sideAlignObserver.disconnect();
+            };
         });
-        const r = document.documentElement;
-        s = new MutationObserver(() => l(t)), s.observe(r, {
-          attributes: !0,
-          attributeFilter: ["data-crm-ui-kit-theme"]
-        });
-      };
-      c();
-      const w = a.current, b = new MutationObserver(c);
-      return b.observe(w, {
-        attributes: !0,
-        attributeFilter: ["data-side", "data-align"]
-      }), () => {
-        n == null || n.disconnect(), s == null || s.disconnect(), b.disconnect();
-      };
-    });
-    return () => cancelAnimationFrame(A);
-  }, [d]), h;
-};
-export {
-  y as useInheritedArrowColor
+        return () => cancelAnimationFrame(raf);
+    }, [open]);
+    return inheritedArrowColor;
 };

package/dist/components/ContextMenu/hooks/useIsTouchDevice/useIsTouchDevice.js

@@ -1,16 +1,27 @@
-import { useState as i, useEffect as r } from "react";
-const u = () => {
-  const [n, e] = i(() => typeof window > "u" ? !1 : "ontouchstart" in window || navigator.maxTouchPoints > 0 || // For older browsers
-  window.matchMedia && window.matchMedia("(pointer: coarse)").matches);
-  return r(() => {
-    const o = (t) => {
-      t.pointerType === "touch" ? e(!0) : t.pointerType === "mouse" && e(!1);
-    };
-    return window.addEventListener("pointerdown", o), () => {
-      window.removeEventListener("pointerdown", o);
-    };
-  }, []), n;
-};
-export {
-  u as useIsTouchDevice
+import { useEffect, useState } from 'react';
+export const useIsTouchDevice = () => {
+    const [isTouch, setIsTouch] = useState(() => {
+        if (typeof window === 'undefined') {
+            return false;
+        }
+        return ('ontouchstart' in window ||
+            navigator.maxTouchPoints > 0 ||
+            // For older browsers
+            (window.matchMedia && window.matchMedia('(pointer: coarse)').matches));
+    });
+    useEffect(() => {
+        const handlePointerDown = (event) => {
+            if (event.pointerType === 'touch') {
+                setIsTouch(true);
+            }
+            else if (event.pointerType === 'mouse') {
+                setIsTouch(false);
+            }
+        };
+        window.addEventListener('pointerdown', handlePointerDown);
+        return () => {
+            window.removeEventListener('pointerdown', handlePointerDown);
+        };
+    }, []);
+    return isTouch;
 };

package/dist/components/ContextMenu/hooks/useStopContextMenuEvents/useStopContextMenuEvents.d.ts

@@ -1,12 +1,13 @@
-export declare const useStopContextMenuEvents: () => {
-    onClick: (e: React.SyntheticEvent) => void;
-    onKeyDown: (e: React.SyntheticEvent) => void;
-    onKeyUp: (e: React.SyntheticEvent) => void;
-    onKeyPress: (e: React.SyntheticEvent) => void;
-    onPointerDown: (e: React.SyntheticEvent) => void;
-    onPointerUp: (e: React.SyntheticEvent) => void;
-    onPointerEnter: (e: React.SyntheticEvent) => void;
-    onPointerLeave: (e: React.SyntheticEvent) => void;
-    onPointerMove: (e: React.SyntheticEvent) => void;
+import { DivHandlers } from './useStopContextMenuEvents.types';
+export declare const useStopContextMenuEvents: (handlers?: Partial<DivHandlers>) => {
+    onClick: (e: import("react").MouseEvent<HTMLDivElement, MouseEvent>) => void;
+    onKeyDown: (e: import("react").KeyboardEvent<HTMLDivElement>) => void;
+    onKeyUp: (e: import("react").KeyboardEvent<HTMLDivElement>) => void;
+    onKeyPress: (e: import("react").KeyboardEvent<HTMLDivElement>) => void;
+    onPointerDown: (e: import("react").PointerEvent<HTMLDivElement>) => void;
+    onPointerUp: (e: import("react").PointerEvent<HTMLDivElement>) => void;
+    onPointerEnter: (e: import("react").PointerEvent<HTMLDivElement>) => void;
+    onPointerLeave: (e: import("react").PointerEvent<HTMLDivElement>) => void;
+    onPointerMove: (e: import("react").PointerEvent<HTMLDivElement>) => void;
 };
 //# sourceMappingURL=useStopContextMenuEvents.d.ts.map

package/dist/components/ContextMenu/hooks/useStopContextMenuEvents/useStopContextMenuEvents.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useStopContextMenuEvents.d.ts","sourceRoot":"","sources":["../../../../../src/components/ContextMenu/hooks/useStopContextMenuEvents/useStopContextMenuEvents.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,wBAAwB;iBACN,KAAK,CAAC,cAAc;mBAApB,KAAK,CAAC,cAAc;iBAApB,KAAK,CAAC,cAAc;oBAApB,KAAK,CAAC,cAAc;uBAApB,KAAK,CAAC,cAAc;qBAApB,KAAK,CAAC,cAAc;wBAApB,KAAK,CAAC,cAAc;wBAApB,KAAK,CAAC,cAAc;uBAApB,KAAK,CAAC,cAAc;CAelD,CAAC"}
+{"version":3,"file":"useStopContextMenuEvents.d.ts","sourceRoot":"","sources":["../../../../../src/components/ContextMenu/hooks/useStopContextMenuEvents/useStopContextMenuEvents.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAE/D,eAAO,MAAM,wBAAwB,cACzB,OAAO,CAAC,WAAW,CAAC;4EASd,IAAI;qEAAJ,IAAI;mEAAJ,IAAI;sEAAJ,IAAI;wEAAJ,IAAI;sEAAJ,IAAI;yEAAJ,IAAI;yEAAJ,IAAI;wEAAJ,IAAI;CAiBrB,CAAC"}

package/dist/components/ContextMenu/hooks/useStopContextMenuEvents/useStopContextMenuEvents.js

@@ -1,20 +1,21 @@
-import { useCallback as e } from "react";
-const r = () => {
-  const o = e((n) => {
-    n.stopPropagation();
-  }, []);
-  return {
-    onClick: o,
-    onKeyDown: o,
-    onKeyUp: o,
-    onKeyPress: o,
-    onPointerDown: o,
-    onPointerUp: o,
-    onPointerEnter: o,
-    onPointerLeave: o,
-    onPointerMove: o
-  };
-};
-export {
-  r as useStopContextMenuEvents
+import { useCallback } from 'react';
+export const useStopContextMenuEvents = (handlers = {}) => {
+    const stop = useCallback((e) => {
+        e.stopPropagation();
+    }, []);
+    const wrap = (userHandler) => (e) => {
+        stop(e);
+        userHandler?.(e);
+    };
+    return {
+        onClick: wrap(handlers.onClick),
+        onKeyDown: wrap(handlers.onKeyDown),
+        onKeyUp: wrap(handlers.onKeyUp),
+        onKeyPress: wrap(handlers.onKeyPress),
+        onPointerDown: wrap(handlers.onPointerDown),
+        onPointerUp: wrap(handlers.onPointerUp),
+        onPointerEnter: wrap(handlers.onPointerEnter),
+        onPointerLeave: wrap(handlers.onPointerLeave),
+        onPointerMove: wrap(handlers.onPointerMove),
+    };
 };

package/dist/components/ContextMenu/hooks/useStopContextMenuEvents/useStopContextMenuEvents.types.d.ts

@@ -0,0 +1,3 @@
+import { ComponentProps } from 'react';
+export type DivHandlers = Pick<ComponentProps<'div'>, 'onClick' | 'onKeyDown' | 'onKeyUp' | 'onKeyPress' | 'onPointerDown' | 'onPointerUp' | 'onPointerEnter' | 'onPointerLeave' | 'onPointerMove'>;
+//# sourceMappingURL=useStopContextMenuEvents.types.d.ts.map

package/dist/components/ContextMenu/hooks/useStopContextMenuEvents/useStopContextMenuEvents.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useStopContextMenuEvents.types.d.ts","sourceRoot":"","sources":["../../../../../src/components/ContextMenu/hooks/useStopContextMenuEvents/useStopContextMenuEvents.types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAEvC,MAAM,MAAM,WAAW,GAAG,IAAI,CAC5B,cAAc,CAAC,KAAK,CAAC,EACnB,SAAS,GACT,WAAW,GACX,SAAS,GACT,YAAY,GACZ,eAAe,GACf,aAAa,GACb,gBAAgB,GAChB,gBAAgB,GAChB,eAAe,CAClB,CAAC"}

package/dist/components/ContextMenu/hooks/useStopContextMenuEvents/useStopContextMenuEvents.types.js

@@ -0,0 +1 @@
+export {};

package/dist/components/ContextMenu/index.js

@@ -1,10 +1,3 @@
-import { ContextMenu as n } from "./ContextMenu.js";
-import { ContextMenuMode as x } from "./ContextMenu.enums.js";
-import "../../useContentPositioning-27D32n5u.mjs";
-import { Direction as p } from "./components/Content/Content.enums.js";
-import "./components/Content/Content.utils.js";
-export {
-  n as ContextMenu,
-  p as ContextMenuDirection,
-  x as ContextMenuMode
-};
+export { ContextMenu } from './ContextMenu';
+export { ContextMenuMode } from './ContextMenu.enums';
+export { Direction as ContextMenuDirection } from './components/Content';

package/dist/components/ContextMenu/providers/LevelProvider/LevelProvider.d.ts

@@ -5,5 +5,5 @@ import { LevelProviderContextProps } from './LevelProvider.props';
  * 1) Level-by-level positioning on the left edge, depending on the presence of the icon
  * 2) Level-by-level (For nested Sub components) pointing when working in an inactive tab
  */
-export declare const LevelProvider: import('../../../../lib/react/createComponentContext').ContextProps<LevelProviderContextProps>, useLevelContext: (consumerName: string) => LevelProviderContextProps;
+export declare const LevelProvider: import("../../../../lib/react/createComponentContext").ContextProps<LevelProviderContextProps>, useLevelContext: (consumerName: string) => LevelProviderContextProps;
 //# sourceMappingURL=LevelProvider.d.ts.map