@fluentui/react-menu 9.14.9 → 9.14.10

package/lib-commonjs/contexts/menuContext.js.map

@@ -1 +1 @@
-{"version":3,"sources":["menuContext.js"],"sourcesContent":["import * as React from 'react';\nimport { createContext, useContextSelector } from '@fluentui/react-context-selector';\nexport const MenuContext = createContext(undefined);\nconst menuContextDefaultValue = {\n    open: false,\n    setOpen: ()=>false,\n    checkedValues: {},\n    onCheckedValueChange: ()=>null,\n    isSubmenu: false,\n    triggerRef: {\n        current: null\n    },\n    menuPopoverRef: {\n        current: null\n    },\n    mountNode: null,\n    triggerId: '',\n    openOnContext: false,\n    openOnHover: false,\n    hasIcons: false,\n    hasCheckmarks: false,\n    inline: false,\n    persistOnItemClick: false\n};\nexport const MenuProvider = MenuContext.Provider;\nexport const useMenuContext_unstable = (selector)=>useContextSelector(MenuContext, (ctx = menuContextDefaultValue)=>selector(ctx));\n"],"names":["MenuContext","MenuProvider","useMenuContext_unstable","createContext","undefined","menuContextDefaultValue","open","setOpen","checkedValues","onCheckedValueChange","isSubmenu","triggerRef","current","menuPopoverRef","mountNode","triggerId","openOnContext","openOnHover","hasIcons","hasCheckmarks","inline","persistOnItemClick","Provider","selector","useContextSelector","ctx"],"mappings":";;;;;;;;;;;IAEaA,WAAW;eAAXA;;IAsBAC,YAAY;eAAZA;;IACAC,uBAAuB;eAAvBA;;;;iEAzBU;sCAC2B;AAC3C,MAAMF,cAAcG,IAAAA,mCAAa,EAACC;AACzC,MAAMC,0BAA0B;IAC5BC,MAAM;IACNC,SAAS,IAAI;IACbC,eAAe,CAAC;IAChBC,sBAAsB,IAAI;IAC1BC,WAAW;IACXC,YAAY;QACRC,SAAS;IACb;IACAC,gBAAgB;QACZD,SAAS;IACb;IACAE,WAAW;IACXC,WAAW;IACXC,eAAe;IACfC,aAAa;IACbC,UAAU;IACVC,eAAe;IACfC,QAAQ;IACRC,oBAAoB;AACxB;AACO,MAAMpB,eAAeD,YAAYsB,QAAQ;AACzC,MAAMpB,0BAA0B,CAACqB,WAAWC,IAAAA,wCAAkB,EAACxB,aAAa,CAACyB,MAAMpB,uBAAuB,GAAGkB,SAASE"}
+{"version":3,"sources":["menuContext.ts"],"sourcesContent":["import * as React from 'react';\nimport { createContext, useContextSelector } from '@fluentui/react-context-selector';\nimport type { ContextSelector, Context } from '@fluentui/react-context-selector';\nimport type { MenuState } from '../components/Menu/index';\n\nexport const MenuContext: Context<MenuContextValue> = createContext<MenuContextValue | undefined>(\n  undefined,\n) as Context<MenuContextValue>;\n\nconst menuContextDefaultValue: MenuContextValue = {\n  open: false,\n  setOpen: () => false,\n  checkedValues: {},\n  onCheckedValueChange: () => null,\n  isSubmenu: false,\n  triggerRef: { current: null } as unknown as React.MutableRefObject<HTMLElement>,\n  menuPopoverRef: { current: null } as unknown as React.MutableRefObject<HTMLElement>,\n  mountNode: null,\n  triggerId: '',\n  openOnContext: false,\n  openOnHover: false,\n  hasIcons: false,\n  hasCheckmarks: false,\n  inline: false,\n  persistOnItemClick: false,\n};\n\n/**\n * Context shared between Menu and its children components\n *\n * Extends and drills down MenuList props to simplify API\n */\nexport type MenuContextValue = Pick<\n  MenuState,\n  | 'openOnHover'\n  | 'openOnContext'\n  | 'triggerRef'\n  | 'menuPopoverRef'\n  | 'setOpen'\n  | 'isSubmenu'\n  | 'mountNode'\n  | 'triggerId'\n  | 'hasIcons'\n  | 'hasCheckmarks'\n  | 'persistOnItemClick'\n  | 'inline'\n  | 'checkedValues'\n  | 'onCheckedValueChange'\n> & {\n  open: boolean;\n  triggerId: string;\n  /**\n   * Default values to be checked on mount\n   * @deprecated this property is not used internally anymore,\n   * the signature remains just to avoid breaking changes\n   */\n  defaultCheckedValues?: Record<string, string[]>;\n};\n\nexport const MenuProvider = MenuContext.Provider;\n\nexport const useMenuContext_unstable = <T>(selector: ContextSelector<MenuContextValue, T>) =>\n  useContextSelector(MenuContext, (ctx = menuContextDefaultValue) => selector(ctx));\n"],"names":["MenuContext","MenuProvider","useMenuContext_unstable","createContext","undefined","menuContextDefaultValue","open","setOpen","checkedValues","onCheckedValueChange","isSubmenu","triggerRef","current","menuPopoverRef","mountNode","triggerId","openOnContext","openOnHover","hasIcons","hasCheckmarks","inline","persistOnItemClick","Provider","selector","useContextSelector","ctx"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAKaA,WAAAA;eAAAA;;IAsDAC,YAAAA;eAAAA;;IAEAC,uBAAAA;eAAAA;;;;iEA7DU;sCAC2B;AAI3C,MAAMF,cAAyCG,IAAAA,mCAAAA,EACpDC;AAGF,MAAMC,0BAA4C;IAChDC,MAAM;IACNC,SAAS,IAAM;IACfC,eAAe,CAAC;IAChBC,sBAAsB,IAAM;IAC5BC,WAAW;IACXC,YAAY;QAAEC,SAAS;IAAK;IAC5BC,gBAAgB;QAAED,SAAS;IAAK;IAChCE,WAAW;IACXC,WAAW;IACXC,eAAe;IACfC,aAAa;IACbC,UAAU;IACVC,eAAe;IACfC,QAAQ;IACRC,oBAAoB;AACtB;AAkCO,MAAMpB,eAAeD,YAAYsB,QAAQ;AAEzC,MAAMpB,0BAA0B,CAAIqB,WACzCC,IAAAA,wCAAAA,EAAmBxB,aAAa,CAACyB,MAAMpB,uBAAuB,GAAKkB,SAASE"}

package/lib-commonjs/contexts/menuGroupContext.js.map

@@ -1 +1 @@
-{"version":3,"sources":["menuGroupContext.js"],"sourcesContent":["import * as React from 'react';\nconst MenuGroupContext = React.createContext(undefined);\nconst menuGroupContextDefaultValue = {\n    headerId: ''\n};\nexport const MenuGroupContextProvider = MenuGroupContext.Provider;\nexport const useMenuGroupContext_unstable = ()=>{\n    var _React_useContext;\n    return (_React_useContext = React.useContext(MenuGroupContext)) !== null && _React_useContext !== void 0 ? _React_useContext : menuGroupContextDefaultValue;\n};\n"],"names":["MenuGroupContextProvider","useMenuGroupContext_unstable","MenuGroupContext","React","createContext","undefined","menuGroupContextDefaultValue","headerId","Provider","_React_useContext","useContext"],"mappings":";;;;;;;;;;;IAKaA,wBAAwB;eAAxBA;;IACAC,4BAA4B;eAA5BA;;;;iEANU;AACvB,MAAMC,iCAAmBC,OAAMC,aAAa,CAACC;AAC7C,MAAMC,+BAA+B;IACjCC,UAAU;AACd;AACO,MAAMP,2BAA2BE,iBAAiBM,QAAQ;AAC1D,MAAMP,+BAA+B;IACxC,IAAIQ;IACJ,OAAO,AAACA,CAAAA,oBAAoBN,OAAMO,UAAU,CAACR,iBAAgB,MAAO,QAAQO,sBAAsB,KAAK,IAAIA,oBAAoBH;AACnI"}
+{"version":3,"sources":["menuGroupContext.ts"],"sourcesContent":["import * as React from 'react';\n\nconst MenuGroupContext = React.createContext<MenuGroupContextValue | undefined>(\n  undefined,\n) as React.Context<MenuGroupContextValue>;\n\nconst menuGroupContextDefaultValue: MenuGroupContextValue = {\n  headerId: '',\n};\n\n/**\n * Context used to guarantee correct aria-relationship between header\n * and group information\n */\nexport type MenuGroupContextValue = {\n  /**\n   * Element id applied to the `MenuGroupHeader` component\n   */\n  headerId: string;\n};\n\nexport const MenuGroupContextProvider = MenuGroupContext.Provider;\nexport const useMenuGroupContext_unstable = () => React.useContext(MenuGroupContext) ?? menuGroupContextDefaultValue;\n"],"names":["MenuGroupContextProvider","useMenuGroupContext_unstable","MenuGroupContext","React","createContext","undefined","menuGroupContextDefaultValue","headerId","Provider","useContext"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAqBaA,wBAAAA;eAAAA;;IACAC,4BAAAA;eAAAA;;;;iEAtBU;AAEvB,MAAMC,iCAAmBC,OAAMC,aAAa,CAC1CC;AAGF,MAAMC,+BAAsD;IAC1DC,UAAU;AACZ;AAaO,MAAMP,2BAA2BE,iBAAiBM,QAAQ;AAC1D,MAAMP,+BAA+B;QAAME;WAAAA,CAAAA,oBAAAA,OAAMM,UAAU,CAACP,iBAAAA,MAAAA,QAAjBC,sBAAAA,KAAAA,IAAAA,oBAAsCG;AAA2B"}

package/lib-commonjs/contexts/menuListContext.js.map

@@ -1 +1 @@
-{"version":3,"sources":["menuListContext.js"],"sourcesContent":["import * as React from 'react';\nimport { createContext, useContextSelector } from '@fluentui/react-context-selector';\nexport const MenuListContext = createContext(undefined);\nconst menuListContextDefaultValue = {\n    checkedValues: {},\n    setFocusByFirstCharacter: ()=>null,\n    toggleCheckbox: ()=>null,\n    selectRadio: ()=>null,\n    hasIcons: false,\n    hasCheckmarks: false\n};\nexport const MenuListProvider = MenuListContext.Provider;\nexport const useMenuListContext_unstable = (selector)=>useContextSelector(MenuListContext, (ctx = menuListContextDefaultValue)=>selector(ctx));\n"],"names":["MenuListContext","MenuListProvider","useMenuListContext_unstable","createContext","undefined","menuListContextDefaultValue","checkedValues","setFocusByFirstCharacter","toggleCheckbox","selectRadio","hasIcons","hasCheckmarks","Provider","selector","useContextSelector","ctx"],"mappings":";;;;;;;;;;;IAEaA,eAAe;eAAfA;;IASAC,gBAAgB;eAAhBA;;IACAC,2BAA2B;eAA3BA;;;;iEAZU;sCAC2B;AAC3C,MAAMF,kBAAkBG,IAAAA,mCAAa,EAACC;AAC7C,MAAMC,8BAA8B;IAChCC,eAAe,CAAC;IAChBC,0BAA0B,IAAI;IAC9BC,gBAAgB,IAAI;IACpBC,aAAa,IAAI;IACjBC,UAAU;IACVC,eAAe;AACnB;AACO,MAAMV,mBAAmBD,gBAAgBY,QAAQ;AACjD,MAAMV,8BAA8B,CAACW,WAAWC,IAAAA,wCAAkB,EAACd,iBAAiB,CAACe,MAAMV,2BAA2B,GAAGQ,SAASE"}
+{"version":3,"sources":["menuListContext.tsx"],"sourcesContent":["import * as React from 'react';\nimport { createContext, useContextSelector } from '@fluentui/react-context-selector';\nimport type { ContextSelector, Context } from '@fluentui/react-context-selector';\nimport type { SelectableHandler } from '../selectable/index';\nimport type { MenuCheckedValueChangeData, MenuCheckedValueChangeEvent, MenuListProps } from '../components/index';\n\nexport const MenuListContext: Context<MenuListContextValue> = createContext<MenuListContextValue | undefined>(\n  undefined,\n) as Context<MenuListContextValue>;\n\nconst menuListContextDefaultValue: MenuListContextValue = {\n  checkedValues: {},\n  setFocusByFirstCharacter: () => null,\n  toggleCheckbox: () => null,\n  selectRadio: () => null,\n  hasIcons: false,\n  hasCheckmarks: false,\n};\n\n/**\n * Context shared between MenuList and its children components\n */\nexport type MenuListContextValue = Pick<MenuListProps, 'checkedValues' | 'hasIcons' | 'hasCheckmarks'> & {\n  setFocusByFirstCharacter?: (e: React.KeyboardEvent<HTMLElement>, itemEl: HTMLElement) => void;\n  toggleCheckbox?: SelectableHandler;\n  selectRadio?: SelectableHandler;\n  /**\n   * Callback when checked items change for value with a name\n   *\n   * @param event - React's original SyntheticEvent\n   * @param data - A data object with relevant information\n   *\n   * @deprecated this property is not used internally anymore,\n   * the signature remains just to avoid breaking changes\n   */\n  onCheckedValueChange?: (e: MenuCheckedValueChangeEvent, data: MenuCheckedValueChangeData) => void;\n};\n\nexport const MenuListProvider = MenuListContext.Provider;\n\nexport const useMenuListContext_unstable = <T,>(selector: ContextSelector<MenuListContextValue, T>) =>\n  useContextSelector(MenuListContext, (ctx = menuListContextDefaultValue) => selector(ctx));\n"],"names":["MenuListContext","MenuListProvider","useMenuListContext_unstable","createContext","undefined","menuListContextDefaultValue","checkedValues","setFocusByFirstCharacter","toggleCheckbox","selectRadio","hasIcons","hasCheckmarks","Provider","selector","useContextSelector","ctx"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAMaA,eAAAA;eAAAA;;IAgCAC,gBAAAA;eAAAA;;IAEAC,2BAAAA;eAAAA;;;;iEAxCU;sCAC2B;AAK3C,MAAMF,kBAAiDG,IAAAA,mCAAAA,EAC5DC;AAGF,MAAMC,8BAAoD;IACxDC,eAAe,CAAC;IAChBC,0BAA0B,IAAM;IAChCC,gBAAgB,IAAM;IACtBC,aAAa,IAAM;IACnBC,UAAU;IACVC,eAAe;AACjB;AAqBO,MAAMV,mBAAmBD,gBAAgBY,QAAQ;AAEjD,MAAMV,8BAA8B,CAAKW,WAC9CC,IAAAA,wCAAAA,EAAmBd,iBAAiB,CAACe,MAAMV,2BAA2B,GAAKQ,SAASE"}

package/lib-commonjs/contexts/menuTriggerContext.js.map

@@ -1 +1 @@
-{"version":3,"sources":["menuTriggerContext.js"],"sourcesContent":["import * as React from 'react';\n/**\n * Context used communicate with a child menu item that it is a trigger for a submenu\n */ const MenuTriggerContext = React.createContext(undefined);\nconst menuTriggerContextDefaultValue = false;\nexport const MenuTriggerContextProvider = MenuTriggerContext.Provider;\nexport const useMenuTriggerContext_unstable = ()=>{\n    var _React_useContext;\n    return (_React_useContext = React.useContext(MenuTriggerContext)) !== null && _React_useContext !== void 0 ? _React_useContext : menuTriggerContextDefaultValue;\n};\n"],"names":["MenuTriggerContextProvider","useMenuTriggerContext_unstable","MenuTriggerContext","React","createContext","undefined","menuTriggerContextDefaultValue","Provider","_React_useContext","useContext"],"mappings":";;;;;;;;;;;IAKaA,0BAA0B;eAA1BA;;IACAC,8BAA8B;eAA9BA;;;;iEANU;AACvB;;CAEC,GAAG,MAAMC,mCAAqBC,OAAMC,aAAa,CAACC;AACnD,MAAMC,iCAAiC;AAChC,MAAMN,6BAA6BE,mBAAmBK,QAAQ;AAC9D,MAAMN,iCAAiC;IAC1C,IAAIO;IACJ,OAAO,AAACA,CAAAA,oBAAoBL,OAAMM,UAAU,CAACP,mBAAkB,MAAO,QAAQM,sBAAsB,KAAK,IAAIA,oBAAoBF;AACrI"}
+{"version":3,"sources":["menuTriggerContext.ts"],"sourcesContent":["import * as React from 'react';\n\n/**\n * Context used communicate with a child menu item that it is a trigger for a submenu\n */\nconst MenuTriggerContext = React.createContext<boolean | undefined>(undefined) as React.Context<boolean>;\n\nconst menuTriggerContextDefaultValue = false;\n\nexport const MenuTriggerContextProvider = MenuTriggerContext.Provider;\nexport const useMenuTriggerContext_unstable = () =>\n  React.useContext(MenuTriggerContext) ?? menuTriggerContextDefaultValue;\n"],"names":["MenuTriggerContextProvider","useMenuTriggerContext_unstable","MenuTriggerContext","React","createContext","undefined","menuTriggerContextDefaultValue","Provider","useContext"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IASaA,0BAAAA;eAAAA;;IACAC,8BAAAA;eAAAA;;;;iEAVU;AAEvB;;CAEC,GACD,MAAMC,mCAAqBC,OAAMC,aAAa,CAAsBC;AAEpE,MAAMC,iCAAiC;AAEhC,MAAMN,6BAA6BE,mBAAmBK,QAAQ;AAC9D,MAAMN,iCAAiC;QAC5CE;WAAAA,CAAAA,oBAAAA,OAAMK,UAAU,CAACN,mBAAAA,MAAAA,QAAjBC,sBAAAA,KAAAA,IAAAA,oBAAwCG;AAA6B"}

package/lib-commonjs/index.js

@@ -9,113 +9,167 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    MenuProvider: function() {
-        return _menuContext.MenuProvider;
+    MENU_ENTER_EVENT: function() {
+        return _utils.MENU_ENTER_EVENT;
     },
-    useMenuContext_unstable: function() {
-        return _menuContext.useMenuContext_unstable;
+    Menu: function() {
+        return _Menu.Menu;
     },
-    MenuTriggerContextProvider: function() {
-        return _menuTriggerContext.MenuTriggerContextProvider;
+    MenuDivider: function() {
+        return _MenuDivider.MenuDivider;
     },
-    useMenuTriggerContext_unstable: function() {
-        return _menuTriggerContext.useMenuTriggerContext_unstable;
+    MenuGroup: function() {
+        return _MenuGroup.MenuGroup;
     },
     MenuGroupContextProvider: function() {
         return _menuGroupContext.MenuGroupContextProvider;
     },
-    useMenuGroupContext_unstable: function() {
-        return _menuGroupContext.useMenuGroupContext_unstable;
+    MenuGroupHeader: function() {
+        return _MenuGroupHeader.MenuGroupHeader;
+    },
+    MenuItem: function() {
+        return _MenuItem.MenuItem;
+    },
+    MenuItemCheckbox: function() {
+        return _MenuItemCheckbox.MenuItemCheckbox;
+    },
+    MenuItemLink: function() {
+        return _MenuItemLink.MenuItemLink;
+    },
+    MenuItemRadio: function() {
+        return _MenuItemRadio.MenuItemRadio;
+    },
+    MenuItemSwitch: function() {
+        return _MenuItemSwitch.MenuItemSwitch;
+    },
+    MenuList: function() {
+        return _MenuList.MenuList;
     },
     MenuListProvider: function() {
         return _menuListContext.MenuListProvider;
     },
-    useMenuListContext_unstable: function() {
-        return _menuListContext.useMenuListContext_unstable;
+    MenuPopover: function() {
+        return _MenuPopover.MenuPopover;
     },
-    Menu: function() {
-        return _Menu.Menu;
+    MenuProvider: function() {
+        return _menuContext.MenuProvider;
     },
-    renderMenu_unstable: function() {
-        return _Menu.renderMenu_unstable;
+    MenuSplitGroup: function() {
+        return _MenuSplitGroup.MenuSplitGroup;
     },
-    useMenuContextValues_unstable: function() {
-        return _Menu.useMenuContextValues_unstable;
+    MenuTrigger: function() {
+        return _MenuTrigger.MenuTrigger;
     },
-    useMenu_unstable: function() {
-        return _Menu.useMenu_unstable;
+    MenuTriggerContextProvider: function() {
+        return _menuTriggerContext.MenuTriggerContextProvider;
     },
-    MenuDivider: function() {
-        return _MenuDivider.MenuDivider;
+    dispatchMenuEnterEvent: function() {
+        return _utils.dispatchMenuEnterEvent;
     },
     menuDividerClassNames: function() {
         return _MenuDivider.menuDividerClassNames;
     },
-    renderMenuDivider_unstable: function() {
-        return _MenuDivider.renderMenuDivider_unstable;
+    menuGroupClassNames: function() {
+        return _MenuGroup.menuGroupClassNames;
     },
-    useMenuDividerStyles_unstable: function() {
-        return _MenuDivider.useMenuDividerStyles_unstable;
+    menuGroupHeaderClassNames: function() {
+        return _MenuGroupHeader.menuGroupHeaderClassNames;
     },
-    useMenuDivider_unstable: function() {
-        return _MenuDivider.useMenuDivider_unstable;
+    menuItemCheckboxClassNames: function() {
+        return _MenuItemCheckbox.menuItemCheckboxClassNames;
     },
-    MenuGroup: function() {
-        return _MenuGroup.MenuGroup;
+    menuItemClassNames: function() {
+        return _MenuItem.menuItemClassNames;
     },
-    menuGroupClassNames: function() {
-        return _MenuGroup.menuGroupClassNames;
+    menuItemLinkClassNames: function() {
+        return _MenuItemLink.menuItemLinkClassNames;
     },
-    renderMenuGroup_unstable: function() {
-        return _MenuGroup.renderMenuGroup_unstable;
+    menuItemRadioClassNames: function() {
+        return _MenuItemRadio.menuItemRadioClassNames;
     },
-    useMenuGroupContextValues_unstable: function() {
-        return _MenuGroup.useMenuGroupContextValues_unstable;
+    menuItemSwitchClassNames: function() {
+        return _MenuItemSwitch.menuItemSwitchClassNames;
     },
-    useMenuGroupStyles_unstable: function() {
-        return _MenuGroup.useMenuGroupStyles_unstable;
+    menuListClassNames: function() {
+        return _MenuList.menuListClassNames;
     },
-    useMenuGroup_unstable: function() {
-        return _MenuGroup.useMenuGroup_unstable;
+    menuPopoverClassNames: function() {
+        return _MenuPopover.menuPopoverClassNames;
     },
-    MenuGroupHeader: function() {
-        return _MenuGroupHeader.MenuGroupHeader;
+    menuSplitGroupClassNames: function() {
+        return _MenuSplitGroup.menuSplitGroupClassNames;
     },
-    menuGroupHeaderClassNames: function() {
-        return _MenuGroupHeader.menuGroupHeaderClassNames;
+    renderMenuDivider_unstable: function() {
+        return _MenuDivider.renderMenuDivider_unstable;
     },
     renderMenuGroupHeader_unstable: function() {
         return _MenuGroupHeader.renderMenuGroupHeader_unstable;
     },
-    useMenuGroupHeaderStyles_unstable: function() {
-        return _MenuGroupHeader.useMenuGroupHeaderStyles_unstable;
+    renderMenuGroup_unstable: function() {
+        return _MenuGroup.renderMenuGroup_unstable;
     },
-    useMenuGroupHeader_unstable: function() {
-        return _MenuGroupHeader.useMenuGroupHeader_unstable;
+    renderMenuItemCheckbox_unstable: function() {
+        return _MenuItemCheckbox.renderMenuItemCheckbox_unstable;
     },
-    MenuItem: function() {
-        return _MenuItem.MenuItem;
+    renderMenuItemLink_unstable: function() {
+        return _MenuItemLink.renderMenuItemLink_unstable;
     },
-    menuItemClassNames: function() {
-        return _MenuItem.menuItemClassNames;
+    renderMenuItemRadio_unstable: function() {
+        return _MenuItemRadio.renderMenuItemRadio_unstable;
+    },
+    renderMenuItemSwitch_unstable: function() {
+        return _MenuItemSwitch.renderMenuItemSwitch_unstable;
     },
     renderMenuItem_unstable: function() {
         return _MenuItem.renderMenuItem_unstable;
     },
-    useMenuItemStyles_unstable: function() {
-        return _MenuItem.useMenuItemStyles_unstable;
+    renderMenuList_unstable: function() {
+        return _MenuList.renderMenuList_unstable;
     },
-    useMenuItem_unstable: function() {
-        return _MenuItem.useMenuItem_unstable;
+    renderMenuPopover_unstable: function() {
+        return _MenuPopover.renderMenuPopover_unstable;
     },
-    MenuItemCheckbox: function() {
-        return _MenuItemCheckbox.MenuItemCheckbox;
+    renderMenuSplitGroup_unstable: function() {
+        return _MenuSplitGroup.renderMenuSplitGroup_unstable;
     },
-    menuItemCheckboxClassNames: function() {
-        return _MenuItemCheckbox.menuItemCheckboxClassNames;
+    renderMenuTrigger_unstable: function() {
+        return _MenuTrigger.renderMenuTrigger_unstable;
     },
-    renderMenuItemCheckbox_unstable: function() {
-        return _MenuItemCheckbox.renderMenuItemCheckbox_unstable;
+    renderMenu_unstable: function() {
+        return _Menu.renderMenu_unstable;
+    },
+    useCheckmarkStyles_unstable: function() {
+        return _index.useCheckmarkStyles_unstable;
+    },
+    useMenuContextValues_unstable: function() {
+        return _Menu.useMenuContextValues_unstable;
+    },
+    useMenuContext_unstable: function() {
+        return _menuContext.useMenuContext_unstable;
+    },
+    useMenuDividerStyles_unstable: function() {
+        return _MenuDivider.useMenuDividerStyles_unstable;
+    },
+    useMenuDivider_unstable: function() {
+        return _MenuDivider.useMenuDivider_unstable;
+    },
+    useMenuGroupContextValues_unstable: function() {
+        return _MenuGroup.useMenuGroupContextValues_unstable;
+    },
+    useMenuGroupContext_unstable: function() {
+        return _menuGroupContext.useMenuGroupContext_unstable;
+    },
+    useMenuGroupHeaderStyles_unstable: function() {
+        return _MenuGroupHeader.useMenuGroupHeaderStyles_unstable;
+    },
+    useMenuGroupHeader_unstable: function() {
+        return _MenuGroupHeader.useMenuGroupHeader_unstable;
+    },
+    useMenuGroupStyles_unstable: function() {
+        return _MenuGroup.useMenuGroupStyles_unstable;
+    },
+    useMenuGroup_unstable: function() {
+        return _MenuGroup.useMenuGroup_unstable;
     },
     useMenuItemCheckboxStyles_unstable: function() {
         return _MenuItemCheckbox.useMenuItemCheckboxStyles_unstable;
@@ -123,14 +177,11 @@ _export(exports, {
     useMenuItemCheckbox_unstable: function() {
         return _MenuItemCheckbox.useMenuItemCheckbox_unstable;
     },
-    MenuItemRadio: function() {
-        return _MenuItemRadio.MenuItemRadio;
-    },
-    menuItemRadioClassNames: function() {
-        return _MenuItemRadio.menuItemRadioClassNames;
+    useMenuItemLinkStyles_unstable: function() {
+        return _MenuItemLink.useMenuItemLinkStyles_unstable;
     },
-    renderMenuItemRadio_unstable: function() {
-        return _MenuItemRadio.renderMenuItemRadio_unstable;
+    useMenuItemLink_unstable: function() {
+        return _MenuItemLink.useMenuItemLink_unstable;
     },
     useMenuItemRadioStyles_unstable: function() {
         return _MenuItemRadio.useMenuItemRadioStyles_unstable;
@@ -138,104 +189,53 @@ _export(exports, {
     useMenuItemRadio_unstable: function() {
         return _MenuItemRadio.useMenuItemRadio_unstable;
     },
-    MenuList: function() {
-        return _MenuList.MenuList;
+    useMenuItemStyles_unstable: function() {
+        return _MenuItem.useMenuItemStyles_unstable;
     },
-    menuListClassNames: function() {
-        return _MenuList.menuListClassNames;
+    useMenuItemSwitchStyles_unstable: function() {
+        return _MenuItemSwitch.useMenuItemSwitchStyles_unstable;
     },
-    renderMenuList_unstable: function() {
-        return _MenuList.renderMenuList_unstable;
+    useMenuItemSwitch_unstable: function() {
+        return _MenuItemSwitch.useMenuItemSwitch_unstable;
+    },
+    useMenuItem_unstable: function() {
+        return _MenuItem.useMenuItem_unstable;
     },
     useMenuListContextValues_unstable: function() {
         return _MenuList.useMenuListContextValues_unstable;
     },
+    useMenuListContext_unstable: function() {
+        return _menuListContext.useMenuListContext_unstable;
+    },
     useMenuListStyles_unstable: function() {
         return _MenuList.useMenuListStyles_unstable;
     },
     useMenuList_unstable: function() {
         return _MenuList.useMenuList_unstable;
     },
-    MenuPopover: function() {
-        return _MenuPopover.MenuPopover;
-    },
-    menuPopoverClassNames: function() {
-        return _MenuPopover.menuPopoverClassNames;
-    },
-    renderMenuPopover_unstable: function() {
-        return _MenuPopover.renderMenuPopover_unstable;
-    },
     useMenuPopoverStyles_unstable: function() {
         return _MenuPopover.useMenuPopoverStyles_unstable;
     },
     useMenuPopover_unstable: function() {
         return _MenuPopover.useMenuPopover_unstable;
     },
-    MenuSplitGroup: function() {
-        return _MenuSplitGroup.MenuSplitGroup;
-    },
-    menuSplitGroupClassNames: function() {
-        return _MenuSplitGroup.menuSplitGroupClassNames;
-    },
-    renderMenuSplitGroup_unstable: function() {
-        return _MenuSplitGroup.renderMenuSplitGroup_unstable;
-    },
     useMenuSplitGroupStyles_unstable: function() {
         return _MenuSplitGroup.useMenuSplitGroupStyles_unstable;
     },
     useMenuSplitGroup_unstable: function() {
         return _MenuSplitGroup.useMenuSplitGroup_unstable;
     },
-    MenuTrigger: function() {
-        return _MenuTrigger.MenuTrigger;
-    },
-    renderMenuTrigger_unstable: function() {
-        return _MenuTrigger.renderMenuTrigger_unstable;
+    useMenuTriggerContext_unstable: function() {
+        return _menuTriggerContext.useMenuTriggerContext_unstable;
     },
     useMenuTrigger_unstable: function() {
         return _MenuTrigger.useMenuTrigger_unstable;
     },
-    useCheckmarkStyles_unstable: function() {
-        return _index.useCheckmarkStyles_unstable;
-    },
-    MenuItemLink: function() {
-        return _MenuItemLink.MenuItemLink;
-    },
-    menuItemLinkClassNames: function() {
-        return _MenuItemLink.menuItemLinkClassNames;
-    },
-    renderMenuItemLink_unstable: function() {
-        return _MenuItemLink.renderMenuItemLink_unstable;
-    },
-    useMenuItemLinkStyles_unstable: function() {
-        return _MenuItemLink.useMenuItemLinkStyles_unstable;
-    },
-    useMenuItemLink_unstable: function() {
-        return _MenuItemLink.useMenuItemLink_unstable;
-    },
-    MENU_ENTER_EVENT: function() {
-        return _utils.MENU_ENTER_EVENT;
-    },
-    dispatchMenuEnterEvent: function() {
-        return _utils.dispatchMenuEnterEvent;
+    useMenu_unstable: function() {
+        return _Menu.useMenu_unstable;
     },
     useOnMenuMouseEnter: function() {
         return _utils.useOnMenuMouseEnter;
-    },
-    MenuItemSwitch: function() {
-        return _MenuItemSwitch.MenuItemSwitch;
-    },
-    useMenuItemSwitch_unstable: function() {
-        return _MenuItemSwitch.useMenuItemSwitch_unstable;
-    },
-    useMenuItemSwitchStyles_unstable: function() {
-        return _MenuItemSwitch.useMenuItemSwitchStyles_unstable;
-    },
-    renderMenuItemSwitch_unstable: function() {
-        return _MenuItemSwitch.renderMenuItemSwitch_unstable;
-    },
-    menuItemSwitchClassNames: function() {
-        return _MenuItemSwitch.menuItemSwitchClassNames;
     }
 });
 const _menuContext = require("./contexts/menuContext");

package/lib-commonjs/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["index.js"],"sourcesContent":["export { MenuProvider, useMenuContext_unstable } from './contexts/menuContext';\nexport { MenuTriggerContextProvider, useMenuTriggerContext_unstable } from './contexts/menuTriggerContext';\nexport { MenuGroupContextProvider, useMenuGroupContext_unstable } from './contexts/menuGroupContext';\nexport { MenuListProvider, useMenuListContext_unstable } from './contexts/menuListContext';\nexport { Menu, renderMenu_unstable, useMenuContextValues_unstable, useMenu_unstable } from './Menu';\nexport { MenuDivider, menuDividerClassNames, renderMenuDivider_unstable, useMenuDividerStyles_unstable, useMenuDivider_unstable } from './MenuDivider';\nexport { MenuGroup, menuGroupClassNames, renderMenuGroup_unstable, useMenuGroupContextValues_unstable, useMenuGroupStyles_unstable, useMenuGroup_unstable } from './MenuGroup';\nexport { MenuGroupHeader, menuGroupHeaderClassNames, renderMenuGroupHeader_unstable, useMenuGroupHeaderStyles_unstable, useMenuGroupHeader_unstable } from './MenuGroupHeader';\nexport { MenuItem, menuItemClassNames, renderMenuItem_unstable, useMenuItemStyles_unstable, useMenuItem_unstable } from './MenuItem';\nexport { MenuItemCheckbox, menuItemCheckboxClassNames, renderMenuItemCheckbox_unstable, useMenuItemCheckboxStyles_unstable, useMenuItemCheckbox_unstable } from './MenuItemCheckbox';\nexport { MenuItemRadio, menuItemRadioClassNames, renderMenuItemRadio_unstable, useMenuItemRadioStyles_unstable, useMenuItemRadio_unstable } from './MenuItemRadio';\nexport { MenuList, menuListClassNames, renderMenuList_unstable, useMenuListContextValues_unstable, useMenuListStyles_unstable, useMenuList_unstable } from './MenuList';\nexport { MenuPopover, menuPopoverClassNames, renderMenuPopover_unstable, useMenuPopoverStyles_unstable, useMenuPopover_unstable } from './MenuPopover';\nexport { MenuSplitGroup, menuSplitGroupClassNames, renderMenuSplitGroup_unstable, useMenuSplitGroupStyles_unstable, useMenuSplitGroup_unstable } from './MenuSplitGroup';\nexport { MenuTrigger, renderMenuTrigger_unstable, useMenuTrigger_unstable } from './MenuTrigger';\nexport { useCheckmarkStyles_unstable } from './selectable/index';\nexport { MenuItemLink, menuItemLinkClassNames, renderMenuItemLink_unstable, useMenuItemLinkStyles_unstable, useMenuItemLink_unstable } from './MenuItemLink';\nexport { MENU_ENTER_EVENT, dispatchMenuEnterEvent, useOnMenuMouseEnter } from './utils';\nexport { MenuItemSwitch, useMenuItemSwitch_unstable, useMenuItemSwitchStyles_unstable, renderMenuItemSwitch_unstable, menuItemSwitchClassNames } from './MenuItemSwitch';\n"],"names":["MenuProvider","useMenuContext_unstable","MenuTriggerContextProvider","useMenuTriggerContext_unstable","MenuGroupContextProvider","useMenuGroupContext_unstable","MenuListProvider","useMenuListContext_unstable","Menu","renderMenu_unstable","useMenuContextValues_unstable","useMenu_unstable","MenuDivider","menuDividerClassNames","renderMenuDivider_unstable","useMenuDividerStyles_unstable","useMenuDivider_unstable","MenuGroup","menuGroupClassNames","renderMenuGroup_unstable","useMenuGroupContextValues_unstable","useMenuGroupStyles_unstable","useMenuGroup_unstable","MenuGroupHeader","menuGroupHeaderClassNames","renderMenuGroupHeader_unstable","useMenuGroupHeaderStyles_unstable","useMenuGroupHeader_unstable","MenuItem","menuItemClassNames","renderMenuItem_unstable","useMenuItemStyles_unstable","useMenuItem_unstable","MenuItemCheckbox","menuItemCheckboxClassNames","renderMenuItemCheckbox_unstable","useMenuItemCheckboxStyles_unstable","useMenuItemCheckbox_unstable","MenuItemRadio","menuItemRadioClassNames","renderMenuItemRadio_unstable","useMenuItemRadioStyles_unstable","useMenuItemRadio_unstable","MenuList","menuListClassNames","renderMenuList_unstable","useMenuListContextValues_unstable","useMenuListStyles_unstable","useMenuList_unstable","MenuPopover","menuPopoverClassNames","renderMenuPopover_unstable","useMenuPopoverStyles_unstable","useMenuPopover_unstable","MenuSplitGroup","menuSplitGroupClassNames","renderMenuSplitGroup_unstable","useMenuSplitGroupStyles_unstable","useMenuSplitGroup_unstable","MenuTrigger","renderMenuTrigger_unstable","useMenuTrigger_unstable","useCheckmarkStyles_unstable","MenuItemLink","menuItemLinkClassNames","renderMenuItemLink_unstable","useMenuItemLinkStyles_unstable","useMenuItemLink_unstable","MENU_ENTER_EVENT","dispatchMenuEnterEvent","useOnMenuMouseEnter","MenuItemSwitch","useMenuItemSwitch_unstable","useMenuItemSwitchStyles_unstable","renderMenuItemSwitch_unstable","menuItemSwitchClassNames"],"mappings":"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"}
+{"version":3,"sources":["index.ts"],"sourcesContent":["export { MenuProvider, useMenuContext_unstable } from './contexts/menuContext';\nexport type { MenuContextValue } from './contexts/menuContext';\nexport { MenuTriggerContextProvider, useMenuTriggerContext_unstable } from './contexts/menuTriggerContext';\nexport { MenuGroupContextProvider, useMenuGroupContext_unstable } from './contexts/menuGroupContext';\nexport type { MenuGroupContextValue } from './contexts/menuGroupContext';\nexport { MenuListProvider, useMenuListContext_unstable } from './contexts/menuListContext';\nexport type { MenuListContextValue } from './contexts/menuListContext';\n\nexport { Menu, renderMenu_unstable, useMenuContextValues_unstable, useMenu_unstable } from './Menu';\nexport type {\n  MenuContextValues,\n  MenuOpenChangeData,\n  MenuOpenEvent,\n  // MenuOpenEvents is deprecated but removing it would be a breaking change\n  // eslint-disable-next-line deprecation/deprecation\n  MenuOpenEvents,\n  MenuProps,\n  MenuSlots,\n  MenuState,\n} from './Menu';\nexport {\n  MenuDivider,\n  menuDividerClassNames,\n  renderMenuDivider_unstable,\n  useMenuDividerStyles_unstable,\n  useMenuDivider_unstable,\n} from './MenuDivider';\nexport type { MenuDividerProps, MenuDividerSlots, MenuDividerState } from './MenuDivider';\nexport {\n  MenuGroup,\n  menuGroupClassNames,\n  renderMenuGroup_unstable,\n  useMenuGroupContextValues_unstable,\n  useMenuGroupStyles_unstable,\n  useMenuGroup_unstable,\n} from './MenuGroup';\nexport type { MenuGroupContextValues, MenuGroupProps, MenuGroupSlots, MenuGroupState } from './MenuGroup';\nexport {\n  MenuGroupHeader,\n  menuGroupHeaderClassNames,\n  renderMenuGroupHeader_unstable,\n  useMenuGroupHeaderStyles_unstable,\n  useMenuGroupHeader_unstable,\n} from './MenuGroupHeader';\nexport type { MenuGroupHeaderProps, MenuGroupHeaderSlots, MenuGroupHeaderState } from './MenuGroupHeader';\nexport {\n  MenuItem,\n  menuItemClassNames,\n  renderMenuItem_unstable,\n  useMenuItemStyles_unstable,\n  useMenuItem_unstable,\n} from './MenuItem';\nexport type { MenuItemProps, MenuItemSlots, MenuItemState } from './MenuItem';\nexport {\n  MenuItemCheckbox,\n  menuItemCheckboxClassNames,\n  renderMenuItemCheckbox_unstable,\n  useMenuItemCheckboxStyles_unstable,\n  useMenuItemCheckbox_unstable,\n} from './MenuItemCheckbox';\nexport type { MenuItemCheckboxProps, MenuItemCheckboxState } from './MenuItemCheckbox';\nexport {\n  MenuItemRadio,\n  menuItemRadioClassNames,\n  renderMenuItemRadio_unstable,\n  useMenuItemRadioStyles_unstable,\n  useMenuItemRadio_unstable,\n} from './MenuItemRadio';\nexport type { MenuItemRadioProps, MenuItemRadioState } from './MenuItemRadio';\nexport {\n  MenuList,\n  menuListClassNames,\n  renderMenuList_unstable,\n  useMenuListContextValues_unstable,\n  useMenuListStyles_unstable,\n  useMenuList_unstable,\n} from './MenuList';\nexport type {\n  MenuCheckedValueChangeData,\n  MenuCheckedValueChangeEvent,\n  MenuListContextValues,\n  MenuListProps,\n  MenuListSlots,\n  MenuListState,\n  // UninitializedMenuListState is deprecated but removing it would be a breaking change\n  // eslint-disable-next-line deprecation/deprecation\n  UninitializedMenuListState,\n} from './MenuList';\nexport {\n  MenuPopover,\n  menuPopoverClassNames,\n  renderMenuPopover_unstable,\n  useMenuPopoverStyles_unstable,\n  useMenuPopover_unstable,\n} from './MenuPopover';\nexport type { MenuPopoverProps, MenuPopoverSlots, MenuPopoverState } from './MenuPopover';\nexport {\n  MenuSplitGroup,\n  menuSplitGroupClassNames,\n  renderMenuSplitGroup_unstable,\n  useMenuSplitGroupStyles_unstable,\n  useMenuSplitGroup_unstable,\n} from './MenuSplitGroup';\nexport type { MenuSplitGroupProps, MenuSplitGroupSlots, MenuSplitGroupState } from './MenuSplitGroup';\nexport { MenuTrigger, renderMenuTrigger_unstable, useMenuTrigger_unstable } from './MenuTrigger';\nexport type { MenuTriggerChildProps, MenuTriggerProps, MenuTriggerState } from './MenuTrigger';\n\nexport { useCheckmarkStyles_unstable } from './selectable/index';\nexport type { MenuItemSelectableProps, MenuItemSelectableState, SelectableHandler } from './selectable/index';\n\nexport {\n  MenuItemLink,\n  menuItemLinkClassNames,\n  renderMenuItemLink_unstable,\n  useMenuItemLinkStyles_unstable,\n  useMenuItemLink_unstable,\n} from './MenuItemLink';\nexport type { MenuItemLinkProps, MenuItemLinkSlots, MenuItemLinkState } from './MenuItemLink';\n\nexport { MENU_ENTER_EVENT, dispatchMenuEnterEvent, useOnMenuMouseEnter } from './utils';\nexport {\n  MenuItemSwitch,\n  useMenuItemSwitch_unstable,\n  useMenuItemSwitchStyles_unstable,\n  renderMenuItemSwitch_unstable,\n  menuItemSwitchClassNames,\n} from './MenuItemSwitch';\n\nexport type { MenuItemSwitchProps, MenuItemSwitchState, MenuItemSwitchSlots } from './MenuItemSwitch';\n"],"names":["MENU_ENTER_EVENT","Menu","MenuDivider","MenuGroup","MenuGroupContextProvider","MenuGroupHeader","MenuItem","MenuItemCheckbox","MenuItemLink","MenuItemRadio","MenuItemSwitch","MenuList","MenuListProvider","MenuPopover","MenuProvider","MenuSplitGroup","MenuTrigger","MenuTriggerContextProvider","dispatchMenuEnterEvent","menuDividerClassNames","menuGroupClassNames","menuGroupHeaderClassNames","menuItemCheckboxClassNames","menuItemClassNames","menuItemLinkClassNames","menuItemRadioClassNames","menuItemSwitchClassNames","menuListClassNames","menuPopoverClassNames","menuSplitGroupClassNames","renderMenuDivider_unstable","renderMenuGroupHeader_unstable","renderMenuGroup_unstable","renderMenuItemCheckbox_unstable","renderMenuItemLink_unstable","renderMenuItemRadio_unstable","renderMenuItemSwitch_unstable","renderMenuItem_unstable","renderMenuList_unstable","renderMenuPopover_unstable","renderMenuSplitGroup_unstable","renderMenuTrigger_unstable","renderMenu_unstable","useCheckmarkStyles_unstable","useMenuContextValues_unstable","useMenuContext_unstable","useMenuDividerStyles_unstable","useMenuDivider_unstable","useMenuGroupContextValues_unstable","useMenuGroupContext_unstable","useMenuGroupHeaderStyles_unstable","useMenuGroupHeader_unstable","useMenuGroupStyles_unstable","useMenuGroup_unstable","useMenuItemCheckboxStyles_unstable","useMenuItemCheckbox_unstable","useMenuItemLinkStyles_unstable","useMenuItemLink_unstable","useMenuItemRadioStyles_unstable","useMenuItemRadio_unstable","useMenuItemStyles_unstable","useMenuItemSwitchStyles_unstable","useMenuItemSwitch_unstable","useMenuItem_unstable","useMenuListContextValues_unstable","useMenuListContext_unstable","useMenuListStyles_unstable","useMenuList_unstable","useMenuPopoverStyles_unstable","useMenuPopover_unstable","useMenuSplitGroupStyles_unstable","useMenuSplitGroup_unstable","useMenuTriggerContext_unstable","useMenuTrigger_unstable","useMenu_unstable","useOnMenuMouseEnter"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/lib-commonjs/selectable/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["index.js"],"sourcesContent":["export * from './useCheckmarkStyles.styles';\nexport * from './types';\n"],"names":[],"mappings":";;;;;uBAAc;uBACA"}
+{"version":3,"sources":["index.ts"],"sourcesContent":["export * from './useCheckmarkStyles.styles';\nexport * from './types';\n"],"names":[],"rangeMappings":";;;;;;","mappings":";;;;;uBAAc;uBACA"}

package/lib-commonjs/selectable/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["types.js"],"sourcesContent":["import * as React from 'react';\n"],"names":[],"mappings":";;;;;iEAAuB"}
+{"version":3,"sources":["types.ts"],"sourcesContent":["import * as React from 'react';\n\nexport type SelectableHandler = (\n  e: React.MouseEvent | React.KeyboardEvent,\n  name: string,\n  value: string,\n  checked: boolean,\n) => void;\n\n/**\n * Props for selecatble menu items\n */\nexport type MenuItemSelectableProps = {\n  /**\n   * Follows input convention\n   * https://www.w3schools.com/jsref/prop_checkbox_name.asp\n   */\n  name: string;\n\n  /**\n   * Follows input convention\n   * https://www.w3schools.com/jsref/prop_checkbox_value.asp\n   */\n  value: string;\n};\n\n/**\n * State for selectable menu items\n */\nexport type MenuItemSelectableState = MenuItemSelectableProps & {\n  /**\n   * Selectable is checked\n   */\n  checked: boolean;\n};\n"],"names":[],"rangeMappings":";;;;;","mappings":";;;;;iEAAuB"}

package/lib-commonjs/selectable/useCheckmarkStyles.styles.js.map

@@ -1 +1 @@
-{"version":3,"sources":["useCheckmarkStyles.styles.js"],"sourcesContent":["import { mergeClasses, __styles } from '@griffel/react';\nconst useStyles = /*#__PURE__*/__styles({\n  root: {\n    a9b677: \"fjw5fx7\",\n    Bqenvij: \"fd461yt\",\n    Bcdw1i0: \"fd7fpy0\"\n  },\n  rootChecked: {\n    Bcdw1i0: \"f1022m68\"\n  }\n}, {\n  d: [\".fjw5fx7{width:16px;}\", \".fd461yt{height:16px;}\", \".fd7fpy0{visibility:hidden;}\", \".f1022m68{visibility:visible;}\"]\n});\n/**\n * Applies styles to a checkmark slot for selectable menu items\n *\n * @param state - should contain a `checkmark` slot\n */\nexport const useCheckmarkStyles_unstable = state => {\n  'use no memo';\n\n  const styles = useStyles();\n  if (state.checkmark) {\n    state.checkmark.className = mergeClasses(styles.root, state.checked && styles.rootChecked, state.checkmark.className);\n  }\n};\n//# sourceMappingURL=useCheckmarkStyles.styles.js.map"],"names":["useCheckmarkStyles_unstable","useStyles","__styles","root","a9b677","Bqenvij","Bcdw1i0","rootChecked","d","state","styles","checkmark","className","mergeClasses","checked"],"mappings":";;;;+BAkBaA;;;eAAAA;;;uBAlB0B;AACvC,MAAMC,YAAY,WAAW,GAAEC,IAAAA,eAAQ,EAAC;IACtCC,MAAM;QACJC,QAAQ;QACRC,SAAS;QACTC,SAAS;IACX;IACAC,aAAa;QACXD,SAAS;IACX;AACF,GAAG;IACDE,GAAG;QAAC;QAAyB;QAA0B;QAAgC;KAAiC;AAC1H;AAMO,MAAMR,8BAA8BS,CAAAA;IACzC;IAEA,MAAMC,SAAST;IACf,IAAIQ,MAAME,SAAS,EAAE;QACnBF,MAAME,SAAS,CAACC,SAAS,GAAGC,IAAAA,mBAAY,EAACH,OAAOP,IAAI,EAAEM,MAAMK,OAAO,IAAIJ,OAAOH,WAAW,EAAEE,MAAME,SAAS,CAACC,SAAS;IACtH;AACF,GACA,qDAAqD"}
+{"version":3,"sources":["useCheckmarkStyles.styles.js"],"sourcesContent":["import { mergeClasses, makeStyles } from '@griffel/react';\nconst useStyles = makeStyles({\n    root: {\n        width: '16px',\n        height: '16px',\n        visibility: 'hidden'\n    },\n    rootChecked: {\n        visibility: 'visible'\n    }\n});\n/**\n * Applies styles to a checkmark slot for selectable menu items\n *\n * @param state - should contain a `checkmark` slot\n */ export const useCheckmarkStyles_unstable = (state)=>{\n    'use no memo';\n    const styles = useStyles();\n    if (state.checkmark) {\n        state.checkmark.className = mergeClasses(styles.root, state.checked && styles.rootChecked, state.checkmark.className);\n    }\n};\n"],"names":["useCheckmarkStyles_unstable","useStyles","__styles","root","a9b677","Bqenvij","Bcdw1i0","rootChecked","d","state","styles","checkmark","className","mergeClasses","checked"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAeiBA;;;eAAAA;;;uBAfwB;AACzC,MAAMC,YAAS,WAAA,GAAGC,IAAAA,eAAA,EAAA;IAAAC,MAAA;QAAAC,QAAA;QAAAC,SAAA;QAAAC,SAAA;IAAA;IAAAC,aAAA;QAAAD,SAAA;IAAA;AAAA,GAAA;IAAAE,GAAA;QAAA;QAAA;QAAA;QAAA;KAAA;AAAA;AAcP,MAAMR,8BAA+BS,CAAAA;IAC5C;IACA,MAAMC,SAAST;IACf,IAAIQ,MAAME,SAAS,EAAE;QACjBF,MAAME,SAAS,CAACC,SAAS,GAAGC,IAAAA,mBAAY,EAACH,OAAOP,IAAI,EAAEM,MAAMK,OAAO,IAAIJ,OAAOH,WAAW,EAAEE,MAAME,SAAS,CAACC,SAAS;IACxH;AACJ"}

package/lib-commonjs/utils/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["index.js"],"sourcesContent":["export * from './useOnMenuEnter';\n"],"names":[],"mappings":";;;;;uBAAc"}
+{"version":3,"sources":["index.ts"],"sourcesContent":["export * from './useOnMenuEnter';\n"],"names":[],"rangeMappings":";;;;;","mappings":";;;;;uBAAc"}

package/lib-commonjs/utils/useIsSubmenu.js.map

@@ -1 +1 @@
-{"version":3,"sources":["useIsSubmenu.js"],"sourcesContent":["import { useHasParentContext } from '@fluentui/react-context-selector';\nimport { useMenuContext_unstable } from '../contexts/menuContext';\nimport { MenuListContext } from '../contexts/menuListContext';\n/**\n * A component can be a part of a submenu whether its menu context `isSubmenu` flag is true\n * or whether it is a part of a `MenuList`\n *\n * A simple hook to check box contexts easily\n *\n * @returns whether the component is part of a submenu\n */ export function useIsSubmenu() {\n    const menuContextValue = useMenuContext_unstable((context)=>context.isSubmenu);\n    const hasMenuListContext = useHasParentContext(MenuListContext);\n    return menuContextValue || hasMenuListContext;\n}\n"],"names":["useIsSubmenu","menuContextValue","useMenuContext_unstable","context","isSubmenu","hasMenuListContext","useHasParentContext","MenuListContext"],"mappings":";;;;+BAUoBA;;;eAAAA;;;sCAVgB;6BACI;iCACR;AAQrB,SAASA;IAChB,MAAMC,mBAAmBC,IAAAA,oCAAuB,EAAC,CAACC,UAAUA,QAAQC,SAAS;IAC7E,MAAMC,qBAAqBC,IAAAA,yCAAmB,EAACC,gCAAe;IAC9D,OAAON,oBAAoBI;AAC/B"}
+{"version":3,"sources":["useIsSubmenu.ts"],"sourcesContent":["import { useHasParentContext } from '@fluentui/react-context-selector';\nimport { useMenuContext_unstable } from '../contexts/menuContext';\nimport { MenuListContext } from '../contexts/menuListContext';\n\n/**\n * A component can be a part of a submenu whether its menu context `isSubmenu` flag is true\n * or whether it is a part of a `MenuList`\n *\n * A simple hook to check box contexts easily\n *\n * @returns whether the component is part of a submenu\n */\nexport function useIsSubmenu() {\n  const menuContextValue = useMenuContext_unstable(context => context.isSubmenu);\n  const hasMenuListContext = useHasParentContext(MenuListContext);\n\n  return menuContextValue || hasMenuListContext;\n}\n"],"names":["useIsSubmenu","menuContextValue","useMenuContext_unstable","context","isSubmenu","hasMenuListContext","useHasParentContext","MenuListContext"],"rangeMappings":";;;;;;;;;;;;;;;;;","mappings":";;;;+BAYgBA;;;eAAAA;;;sCAZoB;6BACI;iCACR;AAUzB,SAASA;IACd,MAAMC,mBAAmBC,IAAAA,oCAAAA,EAAwBC,CAAAA,UAAWA,QAAQC,SAAS;IAC7E,MAAMC,qBAAqBC,IAAAA,yCAAAA,EAAoBC,gCAAAA;IAE/C,OAAON,oBAAoBI;AAC7B"}

package/lib-commonjs/utils/useOnMenuEnter.js

@@ -12,11 +12,11 @@ _export(exports, {
     MENU_ENTER_EVENT: function() {
         return MENU_ENTER_EVENT;
     },
-    useOnMenuMouseEnter: function() {
-        return useOnMenuMouseEnter;
-    },
     dispatchMenuEnterEvent: function() {
         return dispatchMenuEnterEvent;
+    },
+    useOnMenuMouseEnter: function() {
+        return useOnMenuMouseEnter;
     }
 });
 const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");

package/lib-commonjs/utils/useOnMenuEnter.js.map

@@ -1 +1 @@
-{"version":3,"sources":["useOnMenuEnter.js"],"sourcesContent":["import * as React from 'react';\nimport { useEventCallback, elementContains } from '@fluentui/react-utilities';\n/**\n * Name of the custom event\n */ export const MENU_ENTER_EVENT = 'fuimenuenter';\n/**\n * This hook works similarly to @see useOnClickOutside\n *\n * Problem: Trying to behave the same as system menus:\n * When the mouse leaves a stack of nested menus the stack should not dismiss.\n * However if the mouse leaves a stack of menus and enters a parent menu all its children menu should dismiss.\n *\n * We don't use the native mouseenter event because it would trigger too many times in the document\n * Instead, dispatch custom DOM event from the menu so that it can bubble\n * Each nested menu can use the listener to check if the event is from a child or parent menu\n */ export const useOnMenuMouseEnter = (options)=>{\n    const { refs, callback, element, disabled } = options;\n    // Keep mouse event here because this is essentially a custom 'mouseenter' event\n    const listener = useEventCallback((ev)=>{\n        const popoverRef = refs[0];\n        const someMenuPopover = ev.target;\n        var _popoverRef_current;\n        // someMenu is a child -> will always be contained because of vParents\n        // someMenu is a parent -> will always not be contained because no vParent\n        // someMenu is the current popover -> it will contain itself\n        const isOutsidePopover = !elementContains((_popoverRef_current = popoverRef.current) !== null && _popoverRef_current !== void 0 ? _popoverRef_current : null, someMenuPopover);\n        if (isOutsidePopover && !disabled) {\n            callback(ev);\n        }\n    });\n    React.useEffect(()=>{\n        // eslint-disable-next-line eqeqeq\n        if (element == null) {\n            return;\n        }\n        if (!disabled) {\n            element.addEventListener(MENU_ENTER_EVENT, listener);\n        }\n        return ()=>{\n            element.removeEventListener(MENU_ENTER_EVENT, listener);\n        };\n    }, [\n        listener,\n        element,\n        disabled\n    ]);\n};\n/**\n * Dispatches the custom MouseEvent enter event. Similar to calling `el.click()`\n * @param el - element for the event target\n * @param nativeEvent - the native mouse event this is mapped to\n */ export const dispatchMenuEnterEvent = (el, nativeEvent)=>{\n    el.dispatchEvent(new CustomEvent(MENU_ENTER_EVENT, {\n        bubbles: true,\n        detail: {\n            nativeEvent\n        }\n    }));\n};\n"],"names":["MENU_ENTER_EVENT","useOnMenuMouseEnter","dispatchMenuEnterEvent","options","refs","callback","element","disabled","listener","useEventCallback","ev","popoverRef","someMenuPopover","target","_popoverRef_current","isOutsidePopover","elementContains","current","React","useEffect","addEventListener","removeEventListener","el","nativeEvent","dispatchEvent","CustomEvent","bubbles","detail"],"mappings":";;;;;;;;;;;IAIiBA,gBAAgB;eAAhBA;;IAWAC,mBAAmB;eAAnBA;;IAoCAC,sBAAsB;eAAtBA;;;;iEAnDM;gCAC2B;AAGvC,MAAMF,mBAAmB;AAWzB,MAAMC,sBAAsB,CAACE;IACpC,MAAM,EAAEC,IAAI,EAAEC,QAAQ,EAAEC,OAAO,EAAEC,QAAQ,EAAE,GAAGJ;IAC9C,gFAAgF;IAChF,MAAMK,WAAWC,IAAAA,gCAAgB,EAAC,CAACC;QAC/B,MAAMC,aAAaP,IAAI,CAAC,EAAE;QAC1B,MAAMQ,kBAAkBF,GAAGG,MAAM;QACjC,IAAIC;QACJ,sEAAsE;QACtE,0EAA0E;QAC1E,4DAA4D;QAC5D,MAAMC,mBAAmB,CAACC,IAAAA,+BAAe,EAAC,AAACF,CAAAA,sBAAsBH,WAAWM,OAAO,AAAD,MAAO,QAAQH,wBAAwB,KAAK,IAAIA,sBAAsB,MAAMF;QAC9J,IAAIG,oBAAoB,CAACR,UAAU;YAC/BF,SAASK;QACb;IACJ;IACAQ,OAAMC,SAAS,CAAC;QACZ,kCAAkC;QAClC,IAAIb,WAAW,MAAM;YACjB;QACJ;QACA,IAAI,CAACC,UAAU;YACXD,QAAQc,gBAAgB,CAACpB,kBAAkBQ;QAC/C;QACA,OAAO;YACHF,QAAQe,mBAAmB,CAACrB,kBAAkBQ;QAClD;IACJ,GAAG;QACCA;QACAF;QACAC;KACH;AACL;AAKW,MAAML,yBAAyB,CAACoB,IAAIC;IAC3CD,GAAGE,aAAa,CAAC,IAAIC,YAAYzB,kBAAkB;QAC/C0B,SAAS;QACTC,QAAQ;YACJJ;QACJ;IACJ;AACJ"}
+{"version":3,"sources":["useOnMenuEnter.ts"],"sourcesContent":["import * as React from 'react';\nimport { useEventCallback, elementContains } from '@fluentui/react-utilities';\nimport type { UseOnClickOrScrollOutsideOptions } from '@fluentui/react-utilities';\n\n/**\n * Name of the custom event\n */\nexport const MENU_ENTER_EVENT = 'fuimenuenter';\n\n/**\n * This hook works similarly to @see useOnClickOutside\n *\n * Problem: Trying to behave the same as system menus:\n * When the mouse leaves a stack of nested menus the stack should not dismiss.\n * However if the mouse leaves a stack of menus and enters a parent menu all its children menu should dismiss.\n *\n * We don't use the native mouseenter event because it would trigger too many times in the document\n * Instead, dispatch custom DOM event from the menu so that it can bubble\n * Each nested menu can use the listener to check if the event is from a child or parent menu\n */\nexport const useOnMenuMouseEnter = (options: UseOnClickOrScrollOutsideOptions) => {\n  const { refs, callback, element, disabled } = options;\n\n  // Keep mouse event here because this is essentially a custom 'mouseenter' event\n  const listener = useEventCallback((ev: MouseEvent) => {\n    const popoverRef = refs[0];\n    const someMenuPopover = ev.target as HTMLElement;\n\n    // someMenu is a child -> will always be contained because of vParents\n    // someMenu is a parent -> will always not be contained because no vParent\n    // someMenu is the current popover -> it will contain itself\n    const isOutsidePopover = !elementContains(popoverRef.current ?? null, someMenuPopover);\n    if (isOutsidePopover && !disabled) {\n      callback(ev);\n    }\n  });\n\n  React.useEffect(() => {\n    // eslint-disable-next-line eqeqeq\n    if (element == null) {\n      return;\n    }\n\n    /**\n     * Because `addEventListener` type override falls back to 2nd definition (evt name is unknown string literal)\n     * evt is being typed as a base class of MouseEvent -> `Event`.\n     * This type is used to override `listener` calls to make TS happy\n     */\n\n    type ListenerOverride = (evt: Event) => void;\n\n    if (!disabled) {\n      element.addEventListener(MENU_ENTER_EVENT, listener as ListenerOverride);\n    }\n\n    return () => {\n      element.removeEventListener(MENU_ENTER_EVENT, listener as ListenerOverride);\n    };\n  }, [listener, element, disabled]);\n};\n\n/**\n * Dispatches the custom MouseEvent enter event. Similar to calling `el.click()`\n * @param el - element for the event target\n * @param nativeEvent - the native mouse event this is mapped to\n */\nexport const dispatchMenuEnterEvent = (el: HTMLElement, nativeEvent: MouseEvent) => {\n  el.dispatchEvent(new CustomEvent(MENU_ENTER_EVENT, { bubbles: true, detail: { nativeEvent } }));\n};\n"],"names":["MENU_ENTER_EVENT","dispatchMenuEnterEvent","useOnMenuMouseEnter","options","refs","callback","element","disabled","listener","useEventCallback","ev","popoverRef","someMenuPopover","target","isOutsidePopover","elementContains","current","React","useEffect","addEventListener","removeEventListener","el","nativeEvent","dispatchEvent","CustomEvent","bubbles","detail"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAOaA,gBAAAA;eAAAA;;IA2DAC,sBAAAA;eAAAA;;IA9CAC,mBAAAA;eAAAA;;;;iEApBU;gCAC2B;AAM3C,MAAMF,mBAAmB;AAazB,MAAME,sBAAsB,CAACC;IAClC,MAAM,EAAEC,IAAI,EAAEC,QAAQ,EAAEC,OAAO,EAAEC,QAAQ,EAAE,GAAGJ;IAE9C,gFAAgF;IAChF,MAAMK,WAAWC,IAAAA,gCAAAA,EAAiB,CAACC;QACjC,MAAMC,aAAaP,IAAI,CAAC,EAAE;QAC1B,MAAMQ,kBAAkBF,GAAGG,MAAM;YAKSF;QAH1C,sEAAsE;QACtE,0EAA0E;QAC1E,4DAA4D;QAC5D,MAAMG,mBAAmB,CAACC,IAAAA,+BAAAA,EAAgBJ,CAAAA,sBAAAA,WAAWK,OAAO,AAAPA,MAAO,QAAlBL,wBAAAA,KAAAA,IAAAA,sBAAsB,MAAMC;QACtE,IAAIE,oBAAoB,CAACP,UAAU;YACjCF,SAASK;QACX;IACF;IAEAO,OAAMC,SAAS,CAAC;QACd,kCAAkC;QAClC,IAAIZ,WAAW,MAAM;YACnB;QACF;QAUA,IAAI,CAACC,UAAU;YACbD,QAAQa,gBAAgB,CAACnB,kBAAkBQ;QAC7C;QAEA,OAAO;YACLF,QAAQc,mBAAmB,CAACpB,kBAAkBQ;QAChD;IACF,GAAG;QAACA;QAAUF;QAASC;KAAS;AAClC;AAOO,MAAMN,yBAAyB,CAACoB,IAAiBC;IACtDD,GAAGE,aAAa,CAAC,IAAIC,YAAYxB,kBAAkB;QAAEyB,SAAS;QAAMC,QAAQ;YAAEJ;QAAY;IAAE;AAC9F"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluentui/react-menu",
-  "version": "9.14.9",
+  "version": "9.14.10",
   "description": "Fluent UI menu component",
   "main": "lib-commonjs/index.js",
   "module": "lib/index.js",
@@ -37,16 +37,16 @@
   },
   "dependencies": {
     "@fluentui/keyboard-keys": "^9.0.7",
-    "@fluentui/react-aria": "^9.13.0",
-    "@fluentui/react-context-selector": "^9.1.63",
+    "@fluentui/react-aria": "^9.13.1",
+    "@fluentui/react-context-selector": "^9.1.64",
     "@fluentui/react-icons": "^2.0.245",
-    "@fluentui/react-portal": "^9.4.29",
-    "@fluentui/react-positioning": "^9.15.4",
-    "@fluentui/react-shared-contexts": "^9.19.0",
-    "@fluentui/react-tabster": "^9.22.1",
+    "@fluentui/react-portal": "^9.4.30",
+    "@fluentui/react-positioning": "^9.15.5",
+    "@fluentui/react-shared-contexts": "^9.19.1",
+    "@fluentui/react-tabster": "^9.22.2",
     "@fluentui/react-theme": "^9.1.19",
-    "@fluentui/react-utilities": "^9.18.11",
-    "@fluentui/react-jsx-runtime": "^9.0.40",
+    "@fluentui/react-utilities": "^9.18.12",
+    "@fluentui/react-jsx-runtime": "^9.0.41",
     "@griffel/react": "^1.5.22",
     "@swc/helpers": "^0.5.1"
   },