Initial commit

node_modules/@fluentui/react-menu/lib-commonjs/components/Menu/Menu.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Menu", {
+    enumerable: true,
+    get: function() {
+        return Menu;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _useMenu = require("./useMenu");
+const _useMenuContextValues = require("./useMenuContextValues");
+const _renderMenu = require("./renderMenu");
+const Menu = (props)=>{
+    const state = (0, _useMenu.useMenu_unstable)(props);
+    const contextValues = (0, _useMenuContextValues.useMenuContextValues_unstable)(state);
+    return (0, _renderMenu.renderMenu_unstable)(state, contextValues);
+};
+Menu.displayName = 'Menu';

node_modules/@fluentui/react-menu/lib-commonjs/components/Menu/Menu.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/Menu/Menu.tsx"],"sourcesContent":["import * as React from 'react';\nimport { useMenu_unstable } from './useMenu';\nimport { useMenuContextValues_unstable } from './useMenuContextValues';\nimport { renderMenu_unstable } from './renderMenu';\nimport type { MenuProps } from './Menu.types';\n\n/**\n * Wrapper component that manages state for a popup MenuList and a MenuTrigger\n */\nexport const Menu: React.FC<MenuProps> = props => {\n  const state = useMenu_unstable(props);\n  const contextValues = useMenuContextValues_unstable(state);\n\n  return renderMenu_unstable(state, contextValues);\n};\n\nMenu.displayName = 'Menu';\n"],"names":["Menu","props","state","useMenu_unstable","contextValues","useMenuContextValues_unstable","renderMenu_unstable","displayName"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BASaA;;;eAAAA;;;;iEATU;yBACU;sCACa;4BACV;AAM7B,MAAMA,OAA4BC,CAAAA;IACvC,MAAMC,QAAQC,IAAAA,yBAAAA,EAAiBF;IAC/B,MAAMG,gBAAgBC,IAAAA,mDAAAA,EAA8BH;IAEpD,OAAOI,IAAAA,+BAAAA,EAAoBJ,OAAOE;AACpC;AAEAJ,KAAKO,WAAW,GAAG"}

node_modules/@fluentui/react-menu/lib-commonjs/components/Menu/Menu.types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));

node_modules/@fluentui/react-menu/lib-commonjs/components/Menu/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    Menu: function() {
+        return _Menu.Menu;
+    },
+    renderMenu_unstable: function() {
+        return _renderMenu.renderMenu_unstable;
+    },
+    useMenuContextValues_unstable: function() {
+        return _useMenuContextValues.useMenuContextValues_unstable;
+    },
+    useMenu_unstable: function() {
+        return _useMenu.useMenu_unstable;
+    }
+});
+const _Menu = require("./Menu");
+const _renderMenu = require("./renderMenu");
+const _useMenu = require("./useMenu");
+const _useMenuContextValues = require("./useMenuContextValues");

node_modules/@fluentui/react-menu/lib-commonjs/components/Menu/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/Menu/index.ts"],"sourcesContent":["export { Menu } from './Menu';\nexport type {\n  MenuContextValues,\n  MenuOpenChangeData,\n  MenuOpenEvent,\n  // eslint-disable-next-line @typescript-eslint/no-deprecated\n  MenuOpenEvents,\n  MenuProps,\n  MenuSlots,\n  MenuState,\n} from './Menu.types';\nexport { renderMenu_unstable } from './renderMenu';\nexport { useMenu_unstable } from './useMenu';\nexport { useMenuContextValues_unstable } from './useMenuContextValues';\n"],"names":["Menu","renderMenu_unstable","useMenuContextValues_unstable","useMenu_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAASA,IAAI;eAAJA,UAAI;;IAWJC,mBAAmB;eAAnBA,+BAAmB;;IAEnBC,6BAA6B;eAA7BA,mDAA6B;;IAD7BC,gBAAgB;eAAhBA,yBAAgB;;;sBAZJ;4BAWe;yBACH;sCACa"}

node_modules/@fluentui/react-menu/lib-commonjs/components/Menu/renderMenu.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "renderMenu_unstable", {
+    enumerable: true,
+    get: function() {
+        return renderMenu_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _menuContext = require("../../contexts/menuContext");
+const renderMenu_unstable = (state, contextValues)=>{
+    return /*#__PURE__*/ _react.createElement(_menuContext.MenuProvider, {
+        value: contextValues.menu
+    }, state.menuTrigger, state.open && state.menuPopover);
+};

node_modules/@fluentui/react-menu/lib-commonjs/components/Menu/renderMenu.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/Menu/renderMenu.tsx"],"sourcesContent":["import * as React from 'react';\nimport { MenuProvider } from '../../contexts/menuContext';\nimport type { MenuContextValues, MenuState } from './Menu.types';\n\n/**\n * Render the final JSX of Menu\n */\nexport const renderMenu_unstable = (state: MenuState, contextValues: MenuContextValues) => {\n  return (\n    <MenuProvider value={contextValues.menu}>\n      {state.menuTrigger}\n      {state.open && state.menuPopover}\n    </MenuProvider>\n  );\n};\n"],"names":["renderMenu_unstable","state","contextValues","React","createElement","MenuProvider","value","menu","menuTrigger","open","menuPopover"],"rangeMappings":";;;;;;;;;;;;;;;;;","mappings":";;;;+BAOaA;;;eAAAA;;;;iEAPU;6BACM;AAMtB,MAAMA,sBAAsB,CAACC,OAAkBC;IACpD,OAAA,WAAA,GACEC,OAAAC,aAAA,CAACC,yBAAAA,EAAAA;QAAaC,OAAOJ,cAAcK,IAAI;OACpCN,MAAMO,WAAW,EACjBP,MAAMQ,IAAI,IAAIR,MAAMS,WAAW;AAGtC"}

node_modules/@fluentui/react-menu/lib-commonjs/components/Menu/useMenu.js

@@ -0,0 +1,267 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useMenu_unstable", {
+    enumerable: true,
+    get: function() {
+        return useMenu_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _reactpositioning = require("@fluentui/react-positioning");
+const _reactutilities = require("@fluentui/react-utilities");
+const _reactsharedcontexts = require("@fluentui/react-shared-contexts");
+const _reacttabster = require("@fluentui/react-tabster");
+const _menuContext = require("../../contexts/menuContext");
+const _index = require("../../utils/index");
+const _useIsSubmenu = require("../../utils/useIsSubmenu");
+// If it's not possible to position the submenu in smaller viewports, try
+// and fallback to this order of positions
+const submenuFallbackPositions = [
+    'after',
+    'after-bottom',
+    'before-top',
+    'before',
+    'before-bottom',
+    'above'
+];
+const useMenu_unstable = (props)=>{
+    const isSubmenu = (0, _useIsSubmenu.useIsSubmenu)();
+    const { hoverDelay = 500, inline = false, hasCheckmarks = false, hasIcons = false, closeOnScroll = false, openOnContext = false, persistOnItemClick = false, openOnHover = isSubmenu, defaultCheckedValues, mountNode = null } = props;
+    const triggerId = (0, _reactutilities.useId)('menu');
+    const [contextTarget, setContextTarget] = (0, _reactpositioning.usePositioningMouseTarget)();
+    const positioningState = {
+        position: isSubmenu ? 'after' : 'below',
+        align: isSubmenu ? 'top' : 'start',
+        target: props.openOnContext ? contextTarget : undefined,
+        fallbackPositions: isSubmenu ? submenuFallbackPositions : undefined,
+        ...(0, _reactpositioning.resolvePositioningShorthand)(props.positioning)
+    };
+    const children = _react.Children.toArray(props.children);
+    if (process.env.NODE_ENV !== 'production') {
+        if (children.length === 0) {
+            // eslint-disable-next-line no-console
+            console.warn('Menu must contain at least one child');
+        }
+        if (children.length > 2) {
+            // eslint-disable-next-line no-console
+            console.warn('Menu must contain at most two children');
+        }
+    }
+    let menuTrigger = undefined;
+    let menuPopover = undefined;
+    if (children.length === 2) {
+        menuTrigger = children[0];
+        menuPopover = children[1];
+    } else if (children.length === 1) {
+        menuPopover = children[0];
+    }
+    const { targetRef: triggerRef, containerRef: menuPopoverRef } = (0, _reactpositioning.usePositioning)(positioningState);
+    // TODO Better way to narrow types ?
+    const [open, setOpen] = useMenuOpenState({
+        hoverDelay,
+        isSubmenu,
+        setContextTarget,
+        closeOnScroll,
+        menuPopoverRef,
+        triggerRef,
+        open: props.open,
+        defaultOpen: props.defaultOpen,
+        onOpenChange: props.onOpenChange,
+        openOnContext
+    });
+    const [checkedValues, onCheckedValueChange] = useMenuSelectableState({
+        checkedValues: props.checkedValues,
+        defaultCheckedValues,
+        onCheckedValueChange: props.onCheckedValueChange
+    });
+    return {
+        inline,
+        hoverDelay,
+        triggerId,
+        isSubmenu,
+        openOnHover,
+        contextTarget,
+        setContextTarget,
+        hasCheckmarks,
+        hasIcons,
+        closeOnScroll,
+        menuTrigger,
+        menuPopover,
+        mountNode,
+        triggerRef,
+        menuPopoverRef,
+        components: {},
+        openOnContext,
+        open,
+        setOpen,
+        checkedValues,
+        onCheckedValueChange,
+        persistOnItemClick
+    };
+};
+/**
+ * Adds appropriate state values and handlers for selectable items
+ * i.e checkboxes and radios
+ */ const useMenuSelectableState = (props)=>{
+    const [checkedValues, setCheckedValues] = (0, _reactutilities.useControllableState)({
+        state: props.checkedValues,
+        defaultState: props.defaultCheckedValues,
+        initialState: {}
+    });
+    const onCheckedValueChange = (0, _reactutilities.useEventCallback)((e, { name, checkedItems })=>{
+        var _props_onCheckedValueChange;
+        (_props_onCheckedValueChange = props.onCheckedValueChange) === null || _props_onCheckedValueChange === void 0 ? void 0 : _props_onCheckedValueChange.call(props, e, {
+            name,
+            checkedItems
+        });
+        setCheckedValues((currentValue)=>({
+                ...currentValue,
+                [name]: checkedItems
+            }));
+    });
+    return [
+        checkedValues,
+        onCheckedValueChange
+    ];
+};
+const useMenuOpenState = (state)=>{
+    'use no memo';
+    const { targetDocument } = (0, _reactsharedcontexts.useFluent_unstable)();
+    const parentSetOpen = (0, _menuContext.useMenuContext_unstable)((context)=>context.setOpen);
+    const onOpenChange = (0, _reactutilities.useEventCallback)((e, data)=>{
+        var _state_onOpenChange;
+        return (_state_onOpenChange = state.onOpenChange) === null || _state_onOpenChange === void 0 ? void 0 : _state_onOpenChange.call(state, e, data);
+    });
+    const enteringTriggerRef = _react.useRef(false);
+    const [open, setOpenState] = (0, _reactutilities.useControllableState)({
+        state: state.open,
+        defaultState: state.defaultOpen,
+        initialState: false
+    });
+    const trySetOpen = (0, _reactutilities.useEventCallback)((e, data)=>{
+        const event = e instanceof CustomEvent && e.type === _index.MENU_ENTER_EVENT ? e.detail.nativeEvent : e;
+        onOpenChange === null || onOpenChange === void 0 ? void 0 : onOpenChange(event, {
+            ...data
+        });
+        if (data.open && e.type === 'contextmenu') {
+            state.setContextTarget(e);
+        }
+        if (!data.open) {
+            state.setContextTarget(undefined);
+        }
+        if (data.bubble) {
+            parentSetOpen(e, {
+                ...data
+            });
+        }
+        setOpenState(data.open);
+    });
+    const [setOpenTimeout, clearOpenTimeout] = (0, _reactutilities.useTimeout)();
+    const setOpen = (0, _reactutilities.useEventCallback)((e, data)=>{
+        clearOpenTimeout();
+        if (!(e instanceof Event) && e.persist) {
+            // < React 17 still uses pooled synthetic events
+            e.persist();
+        }
+        if (e.type === 'mouseleave' || e.type === 'mouseenter' || e.type === 'mousemove' || e.type === _index.MENU_ENTER_EVENT) {
+            var _state_triggerRef_current;
+            if ((_state_triggerRef_current = state.triggerRef.current) === null || _state_triggerRef_current === void 0 ? void 0 : _state_triggerRef_current.contains(e.target)) {
+                enteringTriggerRef.current = e.type === 'mouseenter' || e.type === 'mousemove';
+            }
+            setOpenTimeout(()=>trySetOpen(e, data), state.hoverDelay);
+        } else {
+            trySetOpen(e, data);
+        }
+    });
+    (0, _reactutilities.useOnClickOutside)({
+        contains: _reactutilities.elementContains,
+        disabled: !open,
+        element: targetDocument,
+        refs: [
+            state.menuPopoverRef,
+            !state.openOnContext && state.triggerRef
+        ].filter(Boolean),
+        callback: (event)=>setOpen(event, {
+                open: false,
+                type: 'clickOutside',
+                event
+            })
+    });
+    // only close on scroll for context, or when closeOnScroll is specified
+    const closeOnScroll = state.openOnContext || state.closeOnScroll;
+    (0, _reactutilities.useOnScrollOutside)({
+        contains: _reactutilities.elementContains,
+        element: targetDocument,
+        callback: (event)=>setOpen(event, {
+                open: false,
+                type: 'scrollOutside',
+                event
+            }),
+        refs: [
+            state.menuPopoverRef,
+            !state.openOnContext && state.triggerRef
+        ].filter(Boolean),
+        disabled: !open || !closeOnScroll
+    });
+    (0, _index.useOnMenuMouseEnter)({
+        element: targetDocument,
+        callback: (event)=>{
+            // When moving from a menu directly back to its trigger, this handler can close the menu
+            // Explicitly check a flag to see if this situation happens
+            if (!enteringTriggerRef.current) {
+                setOpen(event, {
+                    open: false,
+                    type: 'menuMouseEnter',
+                    event
+                });
+            }
+        },
+        disabled: !open,
+        refs: [
+            state.menuPopoverRef
+        ]
+    });
+    // Manage focus for open state
+    const { findFirstFocusable } = (0, _reacttabster.useFocusFinders)();
+    const focusFirst = _react.useCallback(()=>{
+        const firstFocusable = findFirstFocusable(state.menuPopoverRef.current);
+        firstFocusable === null || firstFocusable === void 0 ? void 0 : firstFocusable.focus();
+    }, [
+        findFirstFocusable,
+        state.menuPopoverRef
+    ]);
+    const firstMount = (0, _reactutilities.useFirstMount)();
+    _react.useEffect(()=>{
+        if (open) {
+            focusFirst();
+        } else {
+            if (!firstMount) {
+                if ((targetDocument === null || targetDocument === void 0 ? void 0 : targetDocument.activeElement) === (targetDocument === null || targetDocument === void 0 ? void 0 : targetDocument.body)) {
+                    var // after any event handler (event handlers will update state and re-render).
+                    // Since the browser only performs the default behaviour for the Tab key once
+                    // keyboard events have fully bubbled up the window, the browser will move
+                    // focus to the next tabbable element before/after the trigger if needed.
+                    // If the Tab key was not pressed, focus will remain on the trigger as expected.
+                    _state_triggerRef_current;
+                    (_state_triggerRef_current = state.triggerRef.current) === null || _state_triggerRef_current === void 0 ? void 0 : _state_triggerRef_current.focus();
+                }
+            }
+        }
+    // firstMount change should not re-run this effect
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [
+        state.triggerRef,
+        state.isSubmenu,
+        open,
+        focusFirst,
+        targetDocument,
+        state.menuPopoverRef
+    ]);
+    return [
+        open,
+        setOpen
+    ];
+};

node_modules/@fluentui/react-menu/lib-commonjs/components/Menu/useMenuContextValues.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useMenuContextValues_unstable", {
+    enumerable: true,
+    get: function() {
+        return useMenuContextValues_unstable;
+    }
+});
+function useMenuContextValues_unstable(state) {
+    const { checkedValues, hasCheckmarks, hasIcons, inline, isSubmenu, menuPopoverRef, mountNode, onCheckedValueChange, open, openOnContext, openOnHover, persistOnItemClick, setOpen, triggerId, triggerRef } = state;
+    // This context is created with "@fluentui/react-context-selector", these is no sense to memoize it
+    const menu = {
+        checkedValues,
+        hasCheckmarks,
+        hasIcons,
+        inline,
+        isSubmenu,
+        menuPopoverRef,
+        mountNode,
+        onCheckedValueChange,
+        open,
+        openOnContext,
+        openOnHover,
+        persistOnItemClick,
+        setOpen,
+        triggerId,
+        triggerRef
+    };
+    return {
+        menu
+    };
+}

node_modules/@fluentui/react-menu/lib-commonjs/components/Menu/useMenuContextValues.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/Menu/useMenuContextValues.ts"],"sourcesContent":["import type { MenuContextValues, MenuState } from './Menu.types';\n\nexport function useMenuContextValues_unstable(state: MenuState): MenuContextValues {\n  const {\n    checkedValues,\n    hasCheckmarks,\n    hasIcons,\n    inline,\n    isSubmenu,\n    menuPopoverRef,\n    mountNode,\n    onCheckedValueChange,\n    open,\n    openOnContext,\n    openOnHover,\n    persistOnItemClick,\n    setOpen,\n    triggerId,\n    triggerRef,\n  } = state;\n\n  // This context is created with \"@fluentui/react-context-selector\", these is no sense to memoize it\n  const menu = {\n    checkedValues,\n    hasCheckmarks,\n    hasIcons,\n    inline,\n    isSubmenu,\n    menuPopoverRef,\n    mountNode,\n    onCheckedValueChange,\n    open,\n    openOnContext,\n    openOnHover,\n    persistOnItemClick,\n    setOpen,\n    triggerId,\n    triggerRef,\n  };\n\n  return { menu };\n}\n"],"names":["useMenuContextValues_unstable","state","checkedValues","hasCheckmarks","hasIcons","inline","isSubmenu","menuPopoverRef","mountNode","onCheckedValueChange","open","openOnContext","openOnHover","persistOnItemClick","setOpen","triggerId","triggerRef","menu"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAEgBA;;;eAAAA;;;AAAT,SAASA,8BAA8BC,KAAgB;IAC5D,MAAM,EACJC,aAAa,EACbC,aAAa,EACbC,QAAQ,EACRC,MAAM,EACNC,SAAS,EACTC,cAAc,EACdC,SAAS,EACTC,oBAAoB,EACpBC,IAAI,EACJC,aAAa,EACbC,WAAW,EACXC,kBAAkB,EAClBC,OAAO,EACPC,SAAS,EACTC,UAAU,EACX,GAAGf;IAEJ,mGAAmG;IACnG,MAAMgB,OAAO;QACXf;QACAC;QACAC;QACAC;QACAC;QACAC;QACAC;QACAC;QACAC;QACAC;QACAC;QACAC;QACAC;QACAC;QACAC;IACF;IAEA,OAAO;QAAEC;IAAK;AAChB"}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuDivider/MenuDivider.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "MenuDivider", {
+    enumerable: true,
+    get: function() {
+        return MenuDivider;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _useMenuDivider = require("./useMenuDivider");
+const _useMenuDividerStylesstyles = require("./useMenuDividerStyles.styles");
+const _renderMenuDivider = require("./renderMenuDivider");
+const _reactsharedcontexts = require("@fluentui/react-shared-contexts");
+const MenuDivider = /*#__PURE__*/ _react.forwardRef((props, ref)=>{
+    const state = (0, _useMenuDivider.useMenuDivider_unstable)(props, ref);
+    (0, _useMenuDividerStylesstyles.useMenuDividerStyles_unstable)(state);
+    (0, _reactsharedcontexts.useCustomStyleHook_unstable)('useMenuDividerStyles_unstable')(state);
+    return (0, _renderMenuDivider.renderMenuDivider_unstable)(state);
+});
+MenuDivider.displayName = 'MenuDivider';

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuDivider/MenuDivider.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/MenuDivider/MenuDivider.tsx"],"sourcesContent":["import * as React from 'react';\nimport { useMenuDivider_unstable } from './useMenuDivider';\nimport { useMenuDividerStyles_unstable } from './useMenuDividerStyles.styles';\nimport { renderMenuDivider_unstable } from './renderMenuDivider';\nimport type { MenuDividerProps } from './MenuDivider.types';\nimport type { ForwardRefComponent } from '@fluentui/react-utilities';\nimport { useCustomStyleHook_unstable } from '@fluentui/react-shared-contexts';\n\n/**\n * Define a styled MenuDivider, using the `useMenuDivider_unstable` hook.\n */\nexport const MenuDivider: ForwardRefComponent<MenuDividerProps> = React.forwardRef((props, ref) => {\n  const state = useMenuDivider_unstable(props, ref);\n\n  useMenuDividerStyles_unstable(state);\n\n  useCustomStyleHook_unstable('useMenuDividerStyles_unstable')(state);\n\n  return renderMenuDivider_unstable(state);\n});\n\nMenuDivider.displayName = 'MenuDivider';\n"],"names":["MenuDivider","React","forwardRef","props","ref","state","useMenuDivider_unstable","useMenuDividerStyles_unstable","useCustomStyleHook_unstable","renderMenuDivider_unstable","displayName"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAWaA;;;eAAAA;;;;iEAXU;gCACiB;4CACM;mCACH;qCAGC;AAKrC,MAAMA,cAAAA,WAAAA,GAAqDC,OAAMC,UAAU,CAAC,CAACC,OAAOC;IACzF,MAAMC,QAAQC,IAAAA,uCAAAA,EAAwBH,OAAOC;IAE7CG,IAAAA,yDAAAA,EAA8BF;IAE9BG,IAAAA,gDAAAA,EAA4B,iCAAiCH;IAE7D,OAAOI,IAAAA,6CAAAA,EAA2BJ;AACpC;AAEAL,YAAYU,WAAW,GAAG"}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuDivider/MenuDivider.types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuDivider/MenuDivider.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/MenuDivider/MenuDivider.types.ts"],"sourcesContent":["import type { ComponentProps, ComponentState, Slot } from '@fluentui/react-utilities';\n\nexport type MenuDividerSlots = {\n  root: Slot<'div'>;\n};\n\nexport type MenuDividerProps = ComponentProps<MenuDividerSlots>;\n\nexport type MenuDividerState = ComponentState<MenuDividerSlots>;\n"],"names":[],"rangeMappings":"","mappings":""}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuDivider/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    MenuDivider: function() {
+        return _MenuDivider.MenuDivider;
+    },
+    menuDividerClassNames: function() {
+        return _useMenuDividerStylesstyles.menuDividerClassNames;
+    },
+    renderMenuDivider_unstable: function() {
+        return _renderMenuDivider.renderMenuDivider_unstable;
+    },
+    useMenuDividerStyles_unstable: function() {
+        return _useMenuDividerStylesstyles.useMenuDividerStyles_unstable;
+    },
+    useMenuDivider_unstable: function() {
+        return _useMenuDivider.useMenuDivider_unstable;
+    }
+});
+const _MenuDivider = require("./MenuDivider");
+const _renderMenuDivider = require("./renderMenuDivider");
+const _useMenuDivider = require("./useMenuDivider");
+const _useMenuDividerStylesstyles = require("./useMenuDividerStyles.styles");

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuDivider/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/MenuDivider/index.ts"],"sourcesContent":["export type { MenuDividerProps, MenuDividerSlots, MenuDividerState } from './MenuDivider.types';\nexport { MenuDivider } from './MenuDivider';\nexport { renderMenuDivider_unstable } from './renderMenuDivider';\nexport { useMenuDivider_unstable } from './useMenuDivider';\nexport { menuDividerClassNames, useMenuDividerStyles_unstable } from './useMenuDividerStyles.styles';\n"],"names":["MenuDivider","menuDividerClassNames","renderMenuDivider_unstable","useMenuDividerStyles_unstable","useMenuDivider_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IACSA,WAAW;eAAXA,wBAAW;;IAGXC,qBAAqB;eAArBA,iDAAqB;;IAFrBC,0BAA0B;eAA1BA,6CAA0B;;IAEHC,6BAA6B;eAA7BA,yDAA6B;;IADpDC,uBAAuB;eAAvBA,uCAAuB;;;6BAFJ;mCACe;gCACH;4CAC6B"}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuDivider/renderMenuDivider.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "renderMenuDivider_unstable", {
+    enumerable: true,
+    get: function() {
+        return renderMenuDivider_unstable;
+    }
+});
+const _jsxruntime = require("@fluentui/react-jsx-runtime/jsx-runtime");
+const _reactutilities = require("@fluentui/react-utilities");
+const renderMenuDivider_unstable = (state)=>{
+    (0, _reactutilities.assertSlots)(state);
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)(state.root, {});
+};

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuDivider/renderMenuDivider.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/MenuDivider/renderMenuDivider.tsx"],"sourcesContent":["/** @jsxRuntime automatic */\n/** @jsxImportSource @fluentui/react-jsx-runtime */\nimport { assertSlots } from '@fluentui/react-utilities';\nimport { MenuDividerSlots, MenuDividerState } from './MenuDivider.types';\n\n/**\n * Redefine the render function to add slots. Reuse the menudivider structure but add\n * slots to children.\n */\nexport const renderMenuDivider_unstable = (state: MenuDividerState) => {\n  assertSlots<MenuDividerSlots>(state);\n\n  return <state.root />;\n};\n"],"names":["renderMenuDivider_unstable","state","assertSlots","_jsx","root"],"rangeMappings":";;;;;;;;;;;;;;;","mappings":";;;;+BASaA;;;eAAAA;;;4BARb;gCAC4B;AAOrB,MAAMA,6BAA6B,CAACC;IACzCC,IAAAA,2BAAAA,EAA8BD;IAE9B,OAAA,WAAA,GAAOE,IAAAA,eAAA,EAACF,MAAMG,IAAI,EAAA,CAAA;AACpB"}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuDivider/useMenuDivider.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useMenuDivider_unstable", {
+    enumerable: true,
+    get: function() {
+        return useMenuDivider_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _reactutilities = require("@fluentui/react-utilities");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const useMenuDivider_unstable = (props, ref)=>{
+    return {
+        components: {
+            root: 'div'
+        },
+        root: _reactutilities.slot.always((0, _reactutilities.getIntrinsicElementProps)('div', {
+            role: 'presentation',
+            'aria-hidden': true,
+            ...props,
+            // FIXME:
+            // `ref` is wrongly assigned to be `HTMLElement` instead of `HTMLDivElement`
+            // but since it would be a breaking change to fix it, we are casting ref to it's proper type
+            ref: ref
+        }), {
+            elementType: 'div'
+        })
+    };
+};

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuDivider/useMenuDivider.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/MenuDivider/useMenuDivider.ts"],"sourcesContent":["import { getIntrinsicElementProps, slot } from '@fluentui/react-utilities';\nimport * as React from 'react';\nimport type { MenuDividerProps, MenuDividerState } from './MenuDivider.types';\n\n/**\n * Given user props, returns state and render function for a MenuDivider.\n */\nexport const useMenuDivider_unstable = (props: MenuDividerProps, ref: React.Ref<HTMLElement>): MenuDividerState => {\n  return {\n    components: {\n      root: 'div',\n    },\n    root: slot.always(\n      getIntrinsicElementProps('div', {\n        role: 'presentation',\n        'aria-hidden': true,\n        ...props,\n        // FIXME:\n        // `ref` is wrongly assigned to be `HTMLElement` instead of `HTMLDivElement`\n        // but since it would be a breaking change to fix it, we are casting ref to it's proper type\n        ref: ref as React.Ref<HTMLDivElement>,\n      }),\n      { elementType: 'div' },\n    ),\n  };\n};\n"],"names":["useMenuDivider_unstable","props","ref","components","root","slot","always","getIntrinsicElementProps","role","elementType"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAOaA;;;eAAAA;;;;gCAPkC;iEACxB;AAMhB,MAAMA,0BAA0B,CAACC,OAAyBC;IAC/D,OAAO;QACLC,YAAY;YACVC,MAAM;QACR;QACAA,MAAMC,oBAAAA,CAAKC,MAAM,CACfC,IAAAA,wCAAAA,EAAyB,OAAO;YAC9BC,MAAM;YACN,eAAe;YACf,GAAGP,KAAK;YACR,SAAS;YACT,4EAA4E;YAC5E,4FAA4F;YAC5FC,KAAKA;QACP,IACA;YAAEO,aAAa;QAAM;IAEzB;AACF"}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuDivider/useMenuDividerStyles.styles.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    menuDividerClassNames: function() {
+        return menuDividerClassNames;
+    },
+    useMenuDividerStyles_unstable: function() {
+        return useMenuDividerStyles_unstable;
+    }
+});
+const _react = require("@griffel/react");
+const menuDividerClassNames = {
+    root: 'fui-MenuDivider'
+};
+const useStyles = /*#__PURE__*/ (0, _react.__styles)({
+    root: {
+        jrapky: 0,
+        Frg6f3: 0,
+        t21cq0: 0,
+        B6of3ja: 0,
+        B74szlk: "f8dz51a",
+        a9b677: "f14z66ap",
+        B9xav0g: 0,
+        oivjwe: 0,
+        Bn0qgzm: 0,
+        Bgfg5da: "f1facbz3"
+    }
+}, {
+    d: [
+        [
+            ".f8dz51a{margin:4px -5px 4px -5px;}",
+            {
+                p: -1
+            }
+        ],
+        ".f14z66ap{width:auto;}",
+        [
+            ".f1facbz3{border-bottom:var(--strokeWidthThin) solid var(--colorNeutralStroke2);}",
+            {
+                p: -1
+            }
+        ]
+    ]
+});
+const useMenuDividerStyles_unstable = (state)=>{
+    'use no memo';
+    const styles = useStyles();
+    state.root.className = (0, _react.mergeClasses)(menuDividerClassNames.root, styles.root, state.root.className);
+    return state;
+};

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuDivider/useMenuDividerStyles.styles.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["useMenuDividerStyles.styles.js"],"sourcesContent":["import { mergeClasses, makeStyles } from '@griffel/react';\nimport { tokens } from '@fluentui/react-theme';\nexport const menuDividerClassNames = {\n    root: 'fui-MenuDivider'\n};\nconst useStyles = makeStyles({\n    root: {\n        margin: '4px -5px 4px -5px',\n        width: 'auto',\n        borderBottom: `${tokens.strokeWidthThin} solid ${tokens.colorNeutralStroke2}`\n    }\n});\nexport const useMenuDividerStyles_unstable = (state)=>{\n    'use no memo';\n    const styles = useStyles();\n    state.root.className = mergeClasses(menuDividerClassNames.root, styles.root, state.root.className);\n    return state;\n};\n"],"names":["menuDividerClassNames","useMenuDividerStyles_unstable","root","useStyles","__styles","jrapky","Frg6f3","t21cq0","B6of3ja","B74szlk","a9b677","B9xav0g","oivjwe","Bn0qgzm","Bgfg5da","d","p","state","styles","className","mergeClasses"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAEaA,qBAAqB;eAArBA;;IAUAC,6BAA6B;eAA7BA;;;uBAZ4B;AAElC,MAAMD,wBAAwB;IACjCE,MAAM;AACV;AACA,MAAMC,YAAS,WAAA,GAAGC,IAAAA,eAAA,EAAA;IAAAF,MAAA;QAAAG,QAAA;QAAAC,QAAA;QAAAC,QAAA;QAAAC,SAAA;QAAAC,SAAA;QAAAC,QAAA;QAAAC,SAAA;QAAAC,QAAA;QAAAC,SAAA;QAAAC,SAAA;IAAA;AAAA,GAAA;IAAAC,GAAA;QAAA;YAAA;YAAA;gBAAAC,GAAA,CAAA;YAAA;SAAA;QAAA;QAAA;YAAA;YAAA;gBAAAA,GAAA,CAAA;YAAA;SAAA;KAAA;AAAA;AAOX,MAAMf,gCAAiCgB,CAAAA;IAC1C;IACA,MAAMC,SAASf;IACfc,MAAMf,IAAI,CAACiB,SAAS,GAAGC,IAAAA,mBAAY,EAACpB,sBAAsBE,IAAI,EAAEgB,OAAOhB,IAAI,EAAEe,MAAMf,IAAI,CAACiB,SAAS;IACjG,OAAOF;AACX"}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuGroup/MenuGroup.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "MenuGroup", {
+    enumerable: true,
+    get: function() {
+        return MenuGroup;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _useMenuGroup = require("./useMenuGroup");
+const _renderMenuGroup = require("./renderMenuGroup");
+const _useMenuGroupContextValues = require("./useMenuGroupContextValues");
+const _useMenuGroupStylesstyles = require("./useMenuGroupStyles.styles");
+const _reactsharedcontexts = require("@fluentui/react-shared-contexts");
+const MenuGroup = /*#__PURE__*/ _react.forwardRef((props, ref)=>{
+    const state = (0, _useMenuGroup.useMenuGroup_unstable)(props, ref);
+    const contextValues = (0, _useMenuGroupContextValues.useMenuGroupContextValues_unstable)(state);
+    (0, _useMenuGroupStylesstyles.useMenuGroupStyles_unstable)(state);
+    (0, _reactsharedcontexts.useCustomStyleHook_unstable)('useMenuGroupStyles_unstable')(state);
+    return (0, _renderMenuGroup.renderMenuGroup_unstable)(state, contextValues);
+});
+MenuGroup.displayName = 'MenuGroup';

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuGroup/MenuGroup.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/MenuGroup/MenuGroup.tsx"],"sourcesContent":["import * as React from 'react';\nimport { useMenuGroup_unstable } from './useMenuGroup';\nimport { renderMenuGroup_unstable } from './renderMenuGroup';\nimport { useMenuGroupContextValues_unstable } from './useMenuGroupContextValues';\nimport type { MenuGroupProps } from './MenuGroup.types';\nimport type { ForwardRefComponent } from '@fluentui/react-utilities';\nimport { useMenuGroupStyles_unstable } from './useMenuGroupStyles.styles';\nimport { useCustomStyleHook_unstable } from '@fluentui/react-shared-contexts';\n\n/**\n * Define a styled MenuGroup, using the `useMenuGroup_unstable` hook.\n */\nexport const MenuGroup: ForwardRefComponent<MenuGroupProps> = React.forwardRef((props, ref) => {\n  const state = useMenuGroup_unstable(props, ref);\n  const contextValues = useMenuGroupContextValues_unstable(state);\n\n  useMenuGroupStyles_unstable(state);\n\n  useCustomStyleHook_unstable('useMenuGroupStyles_unstable')(state);\n\n  return renderMenuGroup_unstable(state, contextValues);\n});\n\nMenuGroup.displayName = 'MenuGroup';\n"],"names":["MenuGroup","React","forwardRef","props","ref","state","useMenuGroup_unstable","contextValues","useMenuGroupContextValues_unstable","useMenuGroupStyles_unstable","useCustomStyleHook_unstable","renderMenuGroup_unstable","displayName"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAYaA;;;eAAAA;;;;iEAZU;8BACe;iCACG;2CACU;0CAGP;qCACA;AAKrC,MAAMA,YAAAA,WAAAA,GAAiDC,OAAMC,UAAU,CAAC,CAACC,OAAOC;IACrF,MAAMC,QAAQC,IAAAA,mCAAAA,EAAsBH,OAAOC;IAC3C,MAAMG,gBAAgBC,IAAAA,6DAAAA,EAAmCH;IAEzDI,IAAAA,qDAAAA,EAA4BJ;IAE5BK,IAAAA,gDAAAA,EAA4B,+BAA+BL;IAE3D,OAAOM,IAAAA,yCAAAA,EAAyBN,OAAOE;AACzC;AAEAP,UAAUY,WAAW,GAAG"}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuGroup/MenuGroup.types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuGroup/MenuGroup.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/MenuGroup/MenuGroup.types.ts"],"sourcesContent":["import type { ComponentProps, ComponentState, Slot } from '@fluentui/react-utilities';\nimport type { MenuGroupContextValue } from '../../contexts/menuGroupContext';\n\nexport type MenuGroupSlots = {\n  root: Slot<'div'>;\n};\n\nexport type MenuGroupProps = ComponentProps<MenuGroupSlots>;\n\nexport type MenuGroupState = ComponentState<MenuGroupSlots> & {\n  /**\n   * id applied to the DOM element of `MenuGroupHeader`\n   */\n  headerId: string;\n};\n\nexport type MenuGroupContextValues = {\n  menuGroup: MenuGroupContextValue;\n};\n"],"names":[],"rangeMappings":"","mappings":""}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuGroup/index.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    MenuGroup: function() {
+        return _MenuGroup.MenuGroup;
+    },
+    menuGroupClassNames: function() {
+        return _useMenuGroupStylesstyles.menuGroupClassNames;
+    },
+    renderMenuGroup_unstable: function() {
+        return _renderMenuGroup.renderMenuGroup_unstable;
+    },
+    useMenuGroupContextValues_unstable: function() {
+        return _useMenuGroupContextValues.useMenuGroupContextValues_unstable;
+    },
+    useMenuGroupStyles_unstable: function() {
+        return _useMenuGroupStylesstyles.useMenuGroupStyles_unstable;
+    },
+    useMenuGroup_unstable: function() {
+        return _useMenuGroup.useMenuGroup_unstable;
+    }
+});
+const _MenuGroup = require("./MenuGroup");
+const _renderMenuGroup = require("./renderMenuGroup");
+const _useMenuGroup = require("./useMenuGroup");
+const _useMenuGroupContextValues = require("./useMenuGroupContextValues");
+const _useMenuGroupStylesstyles = require("./useMenuGroupStyles.styles");

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuGroup/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/MenuGroup/index.ts"],"sourcesContent":["export type { MenuGroupContextValues, MenuGroupProps, MenuGroupSlots, MenuGroupState } from './MenuGroup.types';\nexport { MenuGroup } from './MenuGroup';\nexport { renderMenuGroup_unstable } from './renderMenuGroup';\nexport { useMenuGroup_unstable } from './useMenuGroup';\nexport { useMenuGroupContextValues_unstable } from './useMenuGroupContextValues';\nexport { menuGroupClassNames, useMenuGroupStyles_unstable } from './useMenuGroupStyles.styles';\n"],"names":["MenuGroup","menuGroupClassNames","renderMenuGroup_unstable","useMenuGroupContextValues_unstable","useMenuGroupStyles_unstable","useMenuGroup_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IACSA,SAAS;eAATA,oBAAS;;IAITC,mBAAmB;eAAnBA,6CAAmB;;IAHnBC,wBAAwB;eAAxBA,yCAAwB;;IAExBC,kCAAkC;eAAlCA,6DAAkC;;IACbC,2BAA2B;eAA3BA,qDAA2B;;IAFhDC,qBAAqB;eAArBA,mCAAqB;;;2BAFJ;iCACe;8BACH;2CACa;0CACc"}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuGroup/renderMenuGroup.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "renderMenuGroup_unstable", {
+    enumerable: true,
+    get: function() {
+        return renderMenuGroup_unstable;
+    }
+});
+const _jsxruntime = require("@fluentui/react-jsx-runtime/jsx-runtime");
+const _reactutilities = require("@fluentui/react-utilities");
+const _menuGroupContext = require("../../contexts/menuGroupContext");
+const renderMenuGroup_unstable = (state, contextValues)=>{
+    (0, _reactutilities.assertSlots)(state);
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)(_menuGroupContext.MenuGroupContextProvider, {
+        value: contextValues.menuGroup,
+        children: /*#__PURE__*/ (0, _jsxruntime.jsx)(state.root, {})
+    });
+};

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuGroup/renderMenuGroup.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/MenuGroup/renderMenuGroup.tsx"],"sourcesContent":["/** @jsxRuntime automatic */\n/** @jsxImportSource @fluentui/react-jsx-runtime */\nimport { assertSlots } from '@fluentui/react-utilities';\nimport { MenuGroupContextValues, MenuGroupSlots, MenuGroupState } from './MenuGroup.types';\nimport { MenuGroupContextProvider } from '../../contexts/menuGroupContext';\n\n/**\n * Redefine the render function to add slots. Reuse the menugroup structure but add\n * slots to children.\n */\nexport const renderMenuGroup_unstable = (state: MenuGroupState, contextValues: MenuGroupContextValues) => {\n  assertSlots<MenuGroupSlots>(state);\n\n  return (\n    <MenuGroupContextProvider value={contextValues.menuGroup}>\n      <state.root />\n    </MenuGroupContextProvider>\n  );\n};\n"],"names":["renderMenuGroup_unstable","state","contextValues","assertSlots","_jsx","MenuGroupContextProvider","value","menuGroup","root"],"rangeMappings":";;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAUaA;;;eAAAA;;;4BATb;gCAC4B;kCAEa;AAMlC,MAAMA,2BAA2B,CAACC,OAAuBC;IAC9DC,IAAAA,2BAAAA,EAA4BF;IAE5B,OAAA,WAAA,GACEG,IAAAA,eAAA,EAACC,0CAAAA,EAAAA;QAAyBC,OAAOJ,cAAcK,SAAS;kBACtD,WAAA,GAAAH,IAAAA,eAAA,EAACH,MAAMO,IAAI,EAAA,CAAA;;AAGjB"}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuGroup/useMenuGroup.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useMenuGroup_unstable", {
+    enumerable: true,
+    get: function() {
+        return useMenuGroup_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _reactutilities = require("@fluentui/react-utilities");
+function useMenuGroup_unstable(props, ref) {
+    const headerId = (0, _reactutilities.useId)('menu-group');
+    return {
+        components: {
+            root: 'div'
+        },
+        root: _reactutilities.slot.always((0, _reactutilities.getIntrinsicElementProps)('div', {
+            // FIXME:
+            // `ref` is wrongly assigned to be `HTMLElement` instead of `HTMLDivElement`
+            // but since it would be a breaking change to fix it, we are casting ref to it's proper type
+            ref: ref,
+            'aria-labelledby': headerId,
+            role: 'group',
+            ...props
+        }), {
+            elementType: 'div'
+        }),
+        headerId
+    };
+}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuGroup/useMenuGroup.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/MenuGroup/useMenuGroup.ts"],"sourcesContent":["import * as React from 'react';\nimport { getIntrinsicElementProps, useId, slot } from '@fluentui/react-utilities';\nimport { MenuGroupProps, MenuGroupState } from './MenuGroup.types';\n\n/**\n * Given user props, returns state and render function for a MenuGroup.\n */\nexport function useMenuGroup_unstable(props: MenuGroupProps, ref: React.Ref<HTMLElement>): MenuGroupState {\n  const headerId = useId('menu-group');\n\n  return {\n    components: {\n      root: 'div',\n    },\n    root: slot.always(\n      getIntrinsicElementProps('div', {\n        // FIXME:\n        // `ref` is wrongly assigned to be `HTMLElement` instead of `HTMLDivElement`\n        // but since it would be a breaking change to fix it, we are casting ref to it's proper type\n        ref: ref as React.Ref<HTMLDivElement>,\n        'aria-labelledby': headerId,\n        role: 'group',\n        ...props,\n      }),\n      { elementType: 'div' },\n    ),\n    headerId,\n  };\n}\n"],"names":["useMenuGroup_unstable","props","ref","headerId","useId","components","root","slot","always","getIntrinsicElementProps","role","elementType"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAOgBA;;;eAAAA;;;;iEAPO;gCAC+B;AAM/C,SAASA,sBAAsBC,KAAqB,EAAEC,GAA2B;IACtF,MAAMC,WAAWC,IAAAA,qBAAAA,EAAM;IAEvB,OAAO;QACLC,YAAY;YACVC,MAAM;QACR;QACAA,MAAMC,oBAAAA,CAAKC,MAAM,CACfC,IAAAA,wCAAAA,EAAyB,OAAO;YAC9B,SAAS;YACT,4EAA4E;YAC5E,4FAA4F;YAC5FP,KAAKA;YACL,mBAAmBC;YACnBO,MAAM;YACN,GAAGT,KAAK;QACV,IACA;YAAEU,aAAa;QAAM;QAEvBR;IACF;AACF"}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuGroup/useMenuGroupContextValues.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useMenuGroupContextValues_unstable", {
+    enumerable: true,
+    get: function() {
+        return useMenuGroupContextValues_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+function useMenuGroupContextValues_unstable(state) {
+    const { headerId } = state;
+    const menuGroup = _react.useMemo(()=>({
+            headerId
+        }), [
+        headerId
+    ]);
+    return {
+        menuGroup
+    };
+}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuGroup/useMenuGroupContextValues.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/MenuGroup/useMenuGroupContextValues.ts"],"sourcesContent":["import * as React from 'react';\nimport type { MenuGroupContextValues, MenuGroupState } from './MenuGroup.types';\n\nexport function useMenuGroupContextValues_unstable(state: MenuGroupState): MenuGroupContextValues {\n  const { headerId } = state;\n  const menuGroup = React.useMemo(() => ({ headerId }), [headerId]);\n\n  return { menuGroup };\n}\n"],"names":["useMenuGroupContextValues_unstable","state","headerId","menuGroup","React","useMemo"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAGgBA;;;eAAAA;;;;iEAHO;AAGhB,SAASA,mCAAmCC,KAAqB;IACtE,MAAM,EAAEC,QAAQ,EAAE,GAAGD;IACrB,MAAME,YAAYC,OAAMC,OAAO,CAAC,IAAO,CAAA;YAAEH;QAAS,CAAA,GAAI;QAACA;KAAS;IAEhE,OAAO;QAAEC;IAAU;AACrB"}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuGroup/useMenuGroupStyles.styles.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    menuGroupClassNames: function() {
+        return menuGroupClassNames;
+    },
+    useMenuGroupStyles_unstable: function() {
+        return useMenuGroupStyles_unstable;
+    }
+});
+const _react = require("@griffel/react");
+const menuGroupClassNames = {
+    root: 'fui-MenuGroup'
+};
+const useMenuGroupStyles_unstable = (state)=>{
+    'use no memo';
+    state.root.className = (0, _react.mergeClasses)(menuGroupClassNames.root, state.root.className);
+    return state;
+};

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuGroup/useMenuGroupStyles.styles.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["useMenuGroupStyles.styles.js"],"sourcesContent":["import { mergeClasses } from '@griffel/react';\nexport const menuGroupClassNames = {\n    root: 'fui-MenuGroup'\n};\nexport const useMenuGroupStyles_unstable = (state)=>{\n    'use no memo';\n    state.root.className = mergeClasses(menuGroupClassNames.root, state.root.className);\n    return state;\n};\n"],"names":["menuGroupClassNames","useMenuGroupStyles_unstable","root","state","className","mergeClasses"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IACaA,mBAAmB;eAAnBA;;IAGAC,2BAA2B;eAA3BA;;;uBAJgB;AACtB,MAAMD,sBAAsB;IAC/BE,MAAM;AACV;AACO,MAAMD,8BAA+BE,CAAAA;IACxC;IACAA,MAAMD,IAAI,CAACE,SAAS,GAAGC,IAAAA,mBAAY,EAACL,oBAAoBE,IAAI,EAAEC,MAAMD,IAAI,CAACE,SAAS;IAClF,OAAOD;AACX"}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuGroupHeader/MenuGroupHeader.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "MenuGroupHeader", {
+    enumerable: true,
+    get: function() {
+        return MenuGroupHeader;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _useMenuGroupHeader = require("./useMenuGroupHeader");
+const _useMenuGroupHeaderStylesstyles = require("./useMenuGroupHeaderStyles.styles");
+const _renderMenuGroupHeader = require("./renderMenuGroupHeader");
+const _reactsharedcontexts = require("@fluentui/react-shared-contexts");
+const MenuGroupHeader = /*#__PURE__*/ _react.forwardRef((props, ref)=>{
+    const state = (0, _useMenuGroupHeader.useMenuGroupHeader_unstable)(props, ref);
+    (0, _useMenuGroupHeaderStylesstyles.useMenuGroupHeaderStyles_unstable)(state);
+    (0, _reactsharedcontexts.useCustomStyleHook_unstable)('useMenuGroupHeaderStyles_unstable')(state);
+    return (0, _renderMenuGroupHeader.renderMenuGroupHeader_unstable)(state);
+});
+MenuGroupHeader.displayName = 'MenuGroupHeader';

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuGroupHeader/MenuGroupHeader.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/MenuGroupHeader/MenuGroupHeader.tsx"],"sourcesContent":["import * as React from 'react';\nimport { useMenuGroupHeader_unstable } from './useMenuGroupHeader';\nimport { useMenuGroupHeaderStyles_unstable } from './useMenuGroupHeaderStyles.styles';\nimport { renderMenuGroupHeader_unstable } from './renderMenuGroupHeader';\nimport type { MenuGroupHeaderProps } from './MenuGroupHeader.types';\nimport type { ForwardRefComponent } from '@fluentui/react-utilities';\nimport { useCustomStyleHook_unstable } from '@fluentui/react-shared-contexts';\n\n/**\n * Define a styled MenuGroupHeader, using the `useMenuGroupHeader_unstable` hook.\n */\nexport const MenuGroupHeader: ForwardRefComponent<MenuGroupHeaderProps> = React.forwardRef((props, ref) => {\n  const state = useMenuGroupHeader_unstable(props, ref);\n\n  useMenuGroupHeaderStyles_unstable(state);\n\n  useCustomStyleHook_unstable('useMenuGroupHeaderStyles_unstable')(state);\n\n  return renderMenuGroupHeader_unstable(state);\n});\n\nMenuGroupHeader.displayName = 'MenuGroupHeader';\n"],"names":["MenuGroupHeader","React","forwardRef","props","ref","state","useMenuGroupHeader_unstable","useMenuGroupHeaderStyles_unstable","useCustomStyleHook_unstable","renderMenuGroupHeader_unstable","displayName"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAWaA;;;eAAAA;;;;iEAXU;oCACqB;gDACM;uCACH;qCAGH;AAKrC,MAAMA,kBAAAA,WAAAA,GAA6DC,OAAMC,UAAU,CAAC,CAACC,OAAOC;IACjG,MAAMC,QAAQC,IAAAA,+CAAAA,EAA4BH,OAAOC;IAEjDG,IAAAA,iEAAAA,EAAkCF;IAElCG,IAAAA,gDAAAA,EAA4B,qCAAqCH;IAEjE,OAAOI,IAAAA,qDAAAA,EAA+BJ;AACxC;AAEAL,gBAAgBU,WAAW,GAAG"}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuGroupHeader/MenuGroupHeader.types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuGroupHeader/MenuGroupHeader.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/MenuGroupHeader/MenuGroupHeader.types.ts"],"sourcesContent":["import type { ComponentProps, ComponentState, Slot } from '@fluentui/react-utilities';\n\nexport type MenuGroupHeaderSlots = {\n  root: Slot<'div'>;\n};\n\nexport type MenuGroupHeaderProps = ComponentProps<MenuGroupHeaderSlots>;\n\nexport type MenuGroupHeaderState = ComponentState<MenuGroupHeaderSlots>;\n"],"names":[],"rangeMappings":"","mappings":""}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuGroupHeader/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    MenuGroupHeader: function() {
+        return _MenuGroupHeader.MenuGroupHeader;
+    },
+    menuGroupHeaderClassNames: function() {
+        return _useMenuGroupHeaderStylesstyles.menuGroupHeaderClassNames;
+    },
+    renderMenuGroupHeader_unstable: function() {
+        return _renderMenuGroupHeader.renderMenuGroupHeader_unstable;
+    },
+    useMenuGroupHeaderStyles_unstable: function() {
+        return _useMenuGroupHeaderStylesstyles.useMenuGroupHeaderStyles_unstable;
+    },
+    useMenuGroupHeader_unstable: function() {
+        return _useMenuGroupHeader.useMenuGroupHeader_unstable;
+    }
+});
+const _MenuGroupHeader = require("./MenuGroupHeader");
+const _renderMenuGroupHeader = require("./renderMenuGroupHeader");
+const _useMenuGroupHeader = require("./useMenuGroupHeader");
+const _useMenuGroupHeaderStylesstyles = require("./useMenuGroupHeaderStyles.styles");

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuGroupHeader/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/MenuGroupHeader/index.ts"],"sourcesContent":["export type { MenuGroupHeaderProps, MenuGroupHeaderSlots, MenuGroupHeaderState } from './MenuGroupHeader.types';\nexport { MenuGroupHeader } from './MenuGroupHeader';\nexport { renderMenuGroupHeader_unstable } from './renderMenuGroupHeader';\nexport { useMenuGroupHeader_unstable } from './useMenuGroupHeader';\nexport { menuGroupHeaderClassNames, useMenuGroupHeaderStyles_unstable } from './useMenuGroupHeaderStyles.styles';\n"],"names":["MenuGroupHeader","menuGroupHeaderClassNames","renderMenuGroupHeader_unstable","useMenuGroupHeaderStyles_unstable","useMenuGroupHeader_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IACSA,eAAe;eAAfA,gCAAe;;IAGfC,yBAAyB;eAAzBA,yDAAyB;;IAFzBC,8BAA8B;eAA9BA,qDAA8B;;IAEHC,iCAAiC;eAAjCA,iEAAiC;;IAD5DC,2BAA2B;eAA3BA,+CAA2B;;;iCAFJ;uCACe;oCACH;gDACiC"}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuGroupHeader/renderMenuGroupHeader.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "renderMenuGroupHeader_unstable", {
+    enumerable: true,
+    get: function() {
+        return renderMenuGroupHeader_unstable;
+    }
+});
+const _jsxruntime = require("@fluentui/react-jsx-runtime/jsx-runtime");
+const _reactutilities = require("@fluentui/react-utilities");
+const renderMenuGroupHeader_unstable = (state)=>{
+    (0, _reactutilities.assertSlots)(state);
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)(state.root, {});
+};

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuGroupHeader/renderMenuGroupHeader.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/MenuGroupHeader/renderMenuGroupHeader.tsx"],"sourcesContent":["/** @jsxRuntime automatic */\n/** @jsxImportSource @fluentui/react-jsx-runtime */\nimport { assertSlots } from '@fluentui/react-utilities';\nimport { MenuGroupHeaderSlots, MenuGroupHeaderState } from './MenuGroupHeader.types';\n\n/**\n * Redefine the render function to add slots. Reuse the menugroupheader structure but add\n * slots to children.\n */\nexport const renderMenuGroupHeader_unstable = (state: MenuGroupHeaderState) => {\n  assertSlots<MenuGroupHeaderSlots>(state);\n\n  return <state.root />;\n};\n"],"names":["renderMenuGroupHeader_unstable","state","assertSlots","_jsx","root"],"rangeMappings":";;;;;;;;;;;;;;;","mappings":";;;;+BASaA;;;eAAAA;;;4BARb;gCAC4B;AAOrB,MAAMA,iCAAiC,CAACC;IAC7CC,IAAAA,2BAAAA,EAAkCD;IAElC,OAAA,WAAA,GAAOE,IAAAA,eAAA,EAACF,MAAMG,IAAI,EAAA,CAAA;AACpB"}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuGroupHeader/useMenuGroupHeader.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useMenuGroupHeader_unstable", {
+    enumerable: true,
+    get: function() {
+        return useMenuGroupHeader_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _menuGroupContext = require("../../contexts/menuGroupContext");
+const _reactutilities = require("@fluentui/react-utilities");
+function useMenuGroupHeader_unstable(props, ref) {
+    const { headerId: id } = (0, _menuGroupContext.useMenuGroupContext_unstable)();
+    return {
+        components: {
+            root: 'div'
+        },
+        root: _reactutilities.slot.always((0, _reactutilities.getIntrinsicElementProps)('div', {
+            // FIXME:
+            // `ref` is wrongly assigned to be `HTMLElement` instead of `HTMLDivElement`
+            // but since it would be a breaking change to fix it, we are casting ref to it's proper type
+            ref: ref,
+            id,
+            ...props
+        }), {
+            elementType: 'div'
+        })
+    };
+}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuGroupHeader/useMenuGroupHeader.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/MenuGroupHeader/useMenuGroupHeader.ts"],"sourcesContent":["import * as React from 'react';\nimport { useMenuGroupContext_unstable } from '../../contexts/menuGroupContext';\nimport { getIntrinsicElementProps, slot } from '@fluentui/react-utilities';\nimport { MenuGroupHeaderProps, MenuGroupHeaderState } from './MenuGroupHeader.types';\n\n/**\n * Given user props, returns state and render function for a MenuGroupHeader.\n */\nexport function useMenuGroupHeader_unstable(\n  props: MenuGroupHeaderProps,\n  ref: React.Ref<HTMLElement>,\n): MenuGroupHeaderState {\n  const { headerId: id } = useMenuGroupContext_unstable();\n\n  return {\n    components: {\n      root: 'div',\n    },\n    root: slot.always(\n      getIntrinsicElementProps('div', {\n        // FIXME:\n        // `ref` is wrongly assigned to be `HTMLElement` instead of `HTMLDivElement`\n        // but since it would be a breaking change to fix it, we are casting ref to it's proper type\n        ref: ref as React.Ref<HTMLDivElement>,\n        id,\n        ...props,\n      }),\n      { elementType: 'div' },\n    ),\n  };\n}\n"],"names":["useMenuGroupHeader_unstable","props","ref","headerId","id","useMenuGroupContext_unstable","components","root","slot","always","getIntrinsicElementProps","elementType"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAQgBA;;;eAAAA;;;;iEARO;kCACsB;gCACE;AAMxC,SAASA,4BACdC,KAA2B,EAC3BC,GAA2B;IAE3B,MAAM,EAAEC,UAAUC,EAAE,EAAE,GAAGC,IAAAA,8CAAAA;IAEzB,OAAO;QACLC,YAAY;YACVC,MAAM;QACR;QACAA,MAAMC,oBAAAA,CAAKC,MAAM,CACfC,IAAAA,wCAAAA,EAAyB,OAAO;YAC9B,SAAS;YACT,4EAA4E;YAC5E,4FAA4F;YAC5FR,KAAKA;YACLE;YACA,GAAGH,KAAK;QACV,IACA;YAAEU,aAAa;QAAM;IAEzB;AACF"}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuGroupHeader/useMenuGroupHeaderStyles.styles.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    menuGroupHeaderClassNames: function() {
+        return menuGroupHeaderClassNames;
+    },
+    useMenuGroupHeaderStyles_unstable: function() {
+        return useMenuGroupHeaderStyles_unstable;
+    }
+});
+const _react = require("@griffel/react");
+const menuGroupHeaderClassNames = {
+    root: 'fui-MenuGroupHeader'
+};
+const useStyles = /*#__PURE__*/ (0, _react.__styles)({
+    root: {
+        Be2twd7: "fy9rknc",
+        sj55zd: "f11d4kpn",
+        uwmqm3: [
+            "f177v4lu",
+            "f19lj068"
+        ],
+        z189sj: [
+            "f19lj068",
+            "f177v4lu"
+        ],
+        Bhrd7zp: "fl43uef",
+        Bqenvij: "f1d2rq10",
+        mc9l5x: "f22iagw",
+        Bt984gj: "f122n59"
+    }
+}, {
+    d: [
+        ".fy9rknc{font-size:var(--fontSizeBase200);}",
+        ".f11d4kpn{color:var(--colorNeutralForeground3);}",
+        ".f177v4lu{padding-left:8px;}",
+        ".f19lj068{padding-right:8px;}",
+        ".fl43uef{font-weight:var(--fontWeightSemibold);}",
+        ".f1d2rq10{height:32px;}",
+        ".f22iagw{display:flex;}",
+        ".f122n59{align-items:center;}"
+    ]
+});
+const useMenuGroupHeaderStyles_unstable = (state)=>{
+    'use no memo';
+    const styles = useStyles();
+    state.root.className = (0, _react.mergeClasses)(menuGroupHeaderClassNames.root, styles.root, state.root.className);
+    return state;
+};

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuGroupHeader/useMenuGroupHeaderStyles.styles.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["useMenuGroupHeaderStyles.styles.js"],"sourcesContent":["import { mergeClasses, makeStyles } from '@griffel/react';\nimport { tokens } from '@fluentui/react-theme';\nexport const menuGroupHeaderClassNames = {\n    root: 'fui-MenuGroupHeader'\n};\nconst useStyles = makeStyles({\n    root: {\n        fontSize: tokens.fontSizeBase200,\n        color: tokens.colorNeutralForeground3,\n        paddingLeft: '8px',\n        paddingRight: '8px',\n        fontWeight: tokens.fontWeightSemibold,\n        height: '32px',\n        display: 'flex',\n        alignItems: 'center'\n    }\n});\nexport const useMenuGroupHeaderStyles_unstable = (state)=>{\n    'use no memo';\n    const styles = useStyles();\n    state.root.className = mergeClasses(menuGroupHeaderClassNames.root, styles.root, state.root.className);\n    return state;\n};\n"],"names":["menuGroupHeaderClassNames","useMenuGroupHeaderStyles_unstable","root","useStyles","__styles","Be2twd7","sj55zd","uwmqm3","z189sj","Bhrd7zp","Bqenvij","mc9l5x","Bt984gj","d","state","styles","className","mergeClasses"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAEaA,yBAAyB;eAAzBA;;IAeAC,iCAAiC;eAAjCA;;;uBAjB4B;AAElC,MAAMD,4BAA4B;IACrCE,MAAM;AACV;AACA,MAAMC,YAAS,WAAA,GAAGC,IAAAA,eAAA,EAAA;IAAAF,MAAA;QAAAG,SAAA;QAAAC,QAAA;QAAAC,QAAA;YAAA;YAAA;SAAA;QAAAC,QAAA;YAAA;YAAA;SAAA;QAAAC,SAAA;QAAAC,SAAA;QAAAC,QAAA;QAAAC,SAAA;IAAA;AAAA,GAAA;IAAAC,GAAA;QAAA;QAAA;QAAA;QAAA;QAAA;QAAA;QAAA;QAAA;KAAA;AAAA;AAYX,MAAMZ,oCAAqCa,CAAAA;IAC9C;IACA,MAAMC,SAASZ;IACfW,MAAMZ,IAAI,CAACc,SAAS,GAAGC,IAAAA,mBAAY,EAACjB,0BAA0BE,IAAI,EAAEa,OAAOb,IAAI,EAAEY,MAAMZ,IAAI,CAACc,SAAS;IACrG,OAAOF;AACX"}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItem/MenuItem.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "MenuItem", {
+    enumerable: true,
+    get: function() {
+        return MenuItem;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _useMenuItem = require("./useMenuItem");
+const _renderMenuItem = require("./renderMenuItem");
+const _useMenuItemStylesstyles = require("./useMenuItemStyles.styles");
+const _reactsharedcontexts = require("@fluentui/react-shared-contexts");
+const MenuItem = /*#__PURE__*/ _react.forwardRef((props, ref)=>{
+    const state = (0, _useMenuItem.useMenuItem_unstable)(props, ref);
+    (0, _useMenuItemStylesstyles.useMenuItemStyles_unstable)(state);
+    (0, _reactsharedcontexts.useCustomStyleHook_unstable)('useMenuItemStyles_unstable')(state);
+    return (0, _renderMenuItem.renderMenuItem_unstable)(state);
+});
+MenuItem.displayName = 'MenuItem';

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItem/MenuItem.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/MenuItem/MenuItem.tsx"],"sourcesContent":["import * as React from 'react';\nimport { useMenuItem_unstable } from './useMenuItem';\nimport { renderMenuItem_unstable } from './renderMenuItem';\nimport { useMenuItemStyles_unstable } from './useMenuItemStyles.styles';\nimport type { MenuItemProps } from './MenuItem.types';\nimport type { ForwardRefComponent } from '@fluentui/react-utilities';\nimport { useCustomStyleHook_unstable } from '@fluentui/react-shared-contexts';\n\n/**\n * Define a styled MenuItem, using the `useMenuItem_unstable` and `useMenuItemStyles_unstable` hook.\n */\nexport const MenuItem: ForwardRefComponent<MenuItemProps> = React.forwardRef((props, ref) => {\n  const state = useMenuItem_unstable(props, ref);\n\n  useMenuItemStyles_unstable(state);\n\n  useCustomStyleHook_unstable('useMenuItemStyles_unstable')(state);\n\n  return renderMenuItem_unstable(state);\n});\n\nMenuItem.displayName = 'MenuItem';\n"],"names":["MenuItem","React","forwardRef","props","ref","state","useMenuItem_unstable","useMenuItemStyles_unstable","useCustomStyleHook_unstable","renderMenuItem_unstable","displayName"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAWaA;;;eAAAA;;;;iEAXU;6BACc;gCACG;yCACG;qCAGC;AAKrC,MAAMA,WAAAA,WAAAA,GAA+CC,OAAMC,UAAU,CAAC,CAACC,OAAOC;IACnF,MAAMC,QAAQC,IAAAA,iCAAAA,EAAqBH,OAAOC;IAE1CG,IAAAA,mDAAAA,EAA2BF;IAE3BG,IAAAA,gDAAAA,EAA4B,8BAA8BH;IAE1D,OAAOI,IAAAA,uCAAAA,EAAwBJ;AACjC;AAEAL,SAASU,WAAW,GAAG"}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItem/MenuItem.types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItem/MenuItem.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/MenuItem/MenuItem.types.ts"],"sourcesContent":["import type { ComponentProps, ComponentState, Slot } from '@fluentui/react-utilities';\n\nexport type MenuItemSlots = {\n  root: Slot<'div'>;\n\n  /**\n   * Icon slot rendered before children content\n   */\n  icon?: Slot<'span'>;\n\n  /**\n   * A helper slot for alignment when a menu item is used with selectable menuitems\n   * Avoid using this slot as a replacement for MenuItemCheckbox and MenuItemRadio components\n   */\n  checkmark?: Slot<'span'>;\n\n  /**\n   * Icon slot that shows the indicator for a submenu\n   */\n  submenuIndicator?: Slot<'span'>;\n\n  /**\n   * Component children are placed in this slot\n   * Avoid using the `children` property in this slot in favour of Component children whenever possible\n   */\n  content?: Slot<'span'>;\n\n  /**\n   * Secondary content rendered opposite the primary content (e.g Shortcut text)\n   */\n  secondaryContent?: Slot<'span'>;\n\n  /**\n   * Additional descriptor to main content that creates a multiline layout\n   */\n  subText?: Slot<'span'>;\n};\n\nexport type MenuItemProps = Omit<ComponentProps<Partial<MenuItemSlots>>, 'content'> &\n  Pick<Partial<MenuItemSlots>, 'content'> & {\n    /**\n     * If the menu item is a trigger for a submenu\n     *\n     * @default false\n     */\n    hasSubmenu?: boolean;\n\n    /**\n     * Clicking on the menu item will not dismiss an open menu\n     *\n     * @default false\n     */\n    persistOnClick?: boolean;\n\n    disabled?: boolean;\n    /**\n     * @deprecated this property does nothing.\n     * disabled focusable is by default by simply using `disabled` property\n     */\n    disabledFocusable?: boolean;\n  };\n\nexport type MenuItemState = ComponentState<MenuItemSlots> &\n  Required<Pick<MenuItemProps, 'disabled' | 'hasSubmenu' | 'persistOnClick'>>;\n"],"names":[],"rangeMappings":"","mappings":""}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItem/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    MenuItem: function() {
+        return _MenuItem.MenuItem;
+    },
+    menuItemClassNames: function() {
+        return _useMenuItemStylesstyles.menuItemClassNames;
+    },
+    renderMenuItem_unstable: function() {
+        return _renderMenuItem.renderMenuItem_unstable;
+    },
+    useMenuItemStyles_unstable: function() {
+        return _useMenuItemStylesstyles.useMenuItemStyles_unstable;
+    },
+    useMenuItem_unstable: function() {
+        return _useMenuItem.useMenuItem_unstable;
+    }
+});
+const _MenuItem = require("./MenuItem");
+const _renderMenuItem = require("./renderMenuItem");
+const _useMenuItem = require("./useMenuItem");
+const _useMenuItemStylesstyles = require("./useMenuItemStyles.styles");

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItem/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/MenuItem/index.ts"],"sourcesContent":["export { MenuItem } from './MenuItem';\nexport type { MenuItemProps, MenuItemSlots, MenuItemState } from './MenuItem.types';\nexport { renderMenuItem_unstable } from './renderMenuItem';\nexport { useMenuItem_unstable } from './useMenuItem';\nexport { menuItemClassNames, useMenuItemStyles_unstable } from './useMenuItemStyles.styles';\n"],"names":["MenuItem","menuItemClassNames","renderMenuItem_unstable","useMenuItemStyles_unstable","useMenuItem_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAASA,QAAQ;eAARA,kBAAQ;;IAIRC,kBAAkB;eAAlBA,2CAAkB;;IAFlBC,uBAAuB;eAAvBA,uCAAuB;;IAEHC,0BAA0B;eAA1BA,mDAA0B;;IAD9CC,oBAAoB;eAApBA,iCAAoB;;;0BAHJ;gCAEe;6BACH;yCAC0B"}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItem/renderMenuItem.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "renderMenuItem_unstable", {
+    enumerable: true,
+    get: function() {
+        return renderMenuItem_unstable;
+    }
+});
+const _jsxruntime = require("@fluentui/react-jsx-runtime/jsx-runtime");
+const _reactutilities = require("@fluentui/react-utilities");
+const renderMenuItem_unstable = (state)=>{
+    (0, _reactutilities.assertSlots)(state);
+    return /*#__PURE__*/ (0, _jsxruntime.jsxs)(state.root, {
+        children: [
+            state.checkmark && /*#__PURE__*/ (0, _jsxruntime.jsx)(state.checkmark, {}),
+            state.icon && /*#__PURE__*/ (0, _jsxruntime.jsx)(state.icon, {}),
+            state.content && /*#__PURE__*/ (0, _jsxruntime.jsxs)(state.content, {
+                children: [
+                    state.content.children,
+                    state.subText && /*#__PURE__*/ (0, _jsxruntime.jsx)(state.subText, {})
+                ]
+            }),
+            state.secondaryContent && /*#__PURE__*/ (0, _jsxruntime.jsx)(state.secondaryContent, {}),
+            state.submenuIndicator && /*#__PURE__*/ (0, _jsxruntime.jsx)(state.submenuIndicator, {})
+        ]
+    });
+};

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItem/renderMenuItem.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/MenuItem/renderMenuItem.tsx"],"sourcesContent":["/** @jsxRuntime automatic */\n/** @jsxImportSource @fluentui/react-jsx-runtime */\nimport { assertSlots } from '@fluentui/react-utilities';\nimport type { MenuItemSlots, MenuItemState } from './MenuItem.types';\n\n/**\n * Function that renders the final JSX of the component\n */\nexport const renderMenuItem_unstable = (state: MenuItemState) => {\n  assertSlots<MenuItemSlots>(state);\n\n  return (\n    <state.root>\n      {state.checkmark && <state.checkmark />}\n      {state.icon && <state.icon />}\n      {state.content && (\n        <state.content>\n          {state.content.children}\n          {state.subText && <state.subText />}\n        </state.content>\n      )}\n      {state.secondaryContent && <state.secondaryContent />}\n      {state.submenuIndicator && <state.submenuIndicator />}\n    </state.root>\n  );\n};\n"],"names":["renderMenuItem_unstable","state","assertSlots","_jsxs","root","checkmark","_jsx","icon","content","children","subText","secondaryContent","submenuIndicator"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAQaA;;;eAAAA;;;4BAPb;gCAC4B;AAMrB,MAAMA,0BAA0B,CAACC;IACtCC,IAAAA,2BAAAA,EAA2BD;IAE3B,OAAA,WAAA,GACEE,IAAAA,gBAAA,EAACF,MAAMG,IAAI,EAAA;;YACRH,MAAMI,SAAS,IAAA,WAAA,GAAIC,IAAAA,eAAA,EAACL,MAAMI,SAAS,EAAA,CAAA;YACnCJ,MAAMM,IAAI,IAAA,WAAA,GAAID,IAAAA,eAAA,EAACL,MAAMM,IAAI,EAAA,CAAA;YACzBN,MAAMO,OAAO,IAAA,WAAA,GACZL,IAAAA,gBAAA,EAACF,MAAMO,OAAO,EAAA;;oBACXP,MAAMO,OAAO,CAACC,QAAQ;oBACtBR,MAAMS,OAAO,IAAA,WAAA,GAAIJ,IAAAA,eAAA,EAACL,MAAMS,OAAO,EAAA,CAAA;;;YAGnCT,MAAMU,gBAAgB,IAAA,WAAA,GAAIL,IAAAA,eAAA,EAACL,MAAMU,gBAAgB,EAAA,CAAA;YACjDV,MAAMW,gBAAgB,IAAA,WAAA,GAAIN,IAAAA,eAAA,EAACL,MAAMW,gBAAgB,EAAA,CAAA;;;AAGxD"}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItem/useCharacterSearch.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useCharacterSearch", {
+    enumerable: true,
+    get: function() {
+        return useCharacterSearch;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _menuListContext = require("../../contexts/menuListContext");
+const useCharacterSearch = (state, ref)=>{
+    'use no memo';
+    const setFocusByFirstCharacter = (0, _menuListContext.useMenuListContext_unstable)((context)=>context.setFocusByFirstCharacter);
+    const { onKeyDown: originalOnKeyDown } = state.root;
+    state.root.onKeyDown = (e)=>{
+        var _e_key;
+        originalOnKeyDown === null || originalOnKeyDown === void 0 ? void 0 : originalOnKeyDown(e);
+        if (((_e_key = e.key) === null || _e_key === void 0 ? void 0 : _e_key.length) > 1) {
+            return;
+        }
+        if (ref.current) {
+            setFocusByFirstCharacter === null || setFocusByFirstCharacter === void 0 ? void 0 : setFocusByFirstCharacter(e, ref.current);
+        }
+    };
+    return state;
+};

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItem/useCharacterSearch.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/MenuItem/useCharacterSearch.ts"],"sourcesContent":["import * as React from 'react';\nimport { useMenuListContext_unstable } from '../../contexts/menuListContext';\nimport type { MenuItemState } from '../../components/index';\nimport type { ARIAButtonElementIntersection } from '@fluentui/react-aria';\n\nexport const useCharacterSearch = (state: MenuItemState, ref: React.RefObject<HTMLElement>) => {\n  'use no memo';\n\n  const setFocusByFirstCharacter = useMenuListContext_unstable(context => context.setFocusByFirstCharacter);\n\n  const { onKeyDown: originalOnKeyDown } = state.root;\n\n  state.root.onKeyDown = (e: React.KeyboardEvent<ARIAButtonElementIntersection>) => {\n    originalOnKeyDown?.(e);\n\n    if (e.key?.length > 1) {\n      return;\n    }\n\n    if (ref.current) {\n      setFocusByFirstCharacter?.(e, ref.current);\n    }\n  };\n\n  return state;\n};\n"],"names":["useCharacterSearch","state","ref","setFocusByFirstCharacter","useMenuListContext_unstable","context","onKeyDown","originalOnKeyDown","root","e","key","length","current"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAKaA;;;eAAAA;;;;iEALU;iCACqB;AAIrC,MAAMA,qBAAqB,CAACC,OAAsBC;IACvD;IAEA,MAAMC,2BAA2BC,IAAAA,4CAAAA,EAA4BC,CAAAA,UAAWA,QAAQF,wBAAwB;IAExG,MAAM,EAAEG,WAAWC,iBAAiB,EAAE,GAAGN,MAAMO,IAAI;IAEnDP,MAAMO,IAAI,CAACF,SAAS,GAAG,CAACG;YAGlBA;QAFJF,sBAAAA,QAAAA,sBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,kBAAoBE;QAEpB,IAAIA,CAAAA,CAAAA,SAAAA,EAAEC,GAAG,AAAHA,MAAG,QAALD,WAAAA,KAAAA,IAAAA,KAAAA,IAAAA,OAAOE,MAAM,AAANA,IAAS,GAAG;YACrB;QACF;QAEA,IAAIT,IAAIU,OAAO,EAAE;YACfT,6BAAAA,QAAAA,6BAAAA,KAAAA,IAAAA,KAAAA,IAAAA,yBAA2BM,GAAGP,IAAIU,OAAO;QAC3C;IACF;IAEA,OAAOX;AACT"}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItem/useMenuItem.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useMenuItem_unstable", {
+    enumerable: true,
+    get: function() {
+        return useMenuItem_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _reactutilities = require("@fluentui/react-utilities");
+const _reactsharedcontexts = require("@fluentui/react-shared-contexts");
+const _useCharacterSearch = require("./useCharacterSearch");
+const _menuTriggerContext = require("../../contexts/menuTriggerContext");
+const _reacticons = require("@fluentui/react-icons");
+const _menuListContext = require("../../contexts/menuListContext");
+const _menuContext = require("../../contexts/menuContext");
+const _reactaria = require("@fluentui/react-aria");
+const _keyboardkeys = require("@fluentui/keyboard-keys");
+const _menuSplitGroupContext = require("../../contexts/menuSplitGroupContext");
+const ChevronRightIcon = (0, _reacticons.bundleIcon)(_reacticons.ChevronRightFilled, _reacticons.ChevronRightRegular);
+const ChevronLeftIcon = (0, _reacticons.bundleIcon)(_reacticons.ChevronLeftFilled, _reacticons.ChevronLeftRegular);
+const useMenuItem_unstable = (props, ref)=>{
+    const isSubmenuTrigger = (0, _menuTriggerContext.useMenuTriggerContext_unstable)();
+    const persistOnClickContext = (0, _menuContext.useMenuContext_unstable)((context)=>context.persistOnItemClick);
+    const { as = 'div', disabled = false, hasSubmenu = isSubmenuTrigger, persistOnClick = persistOnClickContext } = props;
+    const { hasIcons, hasCheckmarks } = useIconAndCheckmarkAlignment({
+        hasSubmenu
+    });
+    const setOpen = (0, _menuContext.useMenuContext_unstable)((context)=>context.setOpen);
+    useNotifySplitItemMultiline({
+        multiline: !!props.subText,
+        hasSubmenu
+    });
+    const { dir } = (0, _reactsharedcontexts.useFluent_unstable)();
+    const innerRef = _react.useRef(null);
+    const dismissedWithKeyboardRef = _react.useRef(false);
+    const state = {
+        hasSubmenu,
+        disabled,
+        persistOnClick,
+        components: {
+            root: 'div',
+            icon: 'span',
+            checkmark: 'span',
+            submenuIndicator: 'span',
+            content: 'span',
+            secondaryContent: 'span',
+            subText: 'span'
+        },
+        root: _reactutilities.slot.always((0, _reactutilities.getIntrinsicElementProps)(as, (0, _reactaria.useARIAButtonProps)(as, {
+            role: 'menuitem',
+            ...props,
+            disabled: false,
+            disabledFocusable: disabled,
+            ref: (0, _reactutilities.useMergedRefs)(ref, innerRef),
+            onKeyDown: (0, _reactutilities.useEventCallback)((event)=>{
+                var _props_onKeyDown;
+                (_props_onKeyDown = props.onKeyDown) === null || _props_onKeyDown === void 0 ? void 0 : _props_onKeyDown.call(props, event);
+                if (!event.isDefaultPrevented() && (event.key === _keyboardkeys.Space || event.key === _keyboardkeys.Enter)) {
+                    dismissedWithKeyboardRef.current = true;
+                }
+            }),
+            onMouseMove: (0, _reactutilities.useEventCallback)((event)=>{
+                var _props_onMouseMove;
+                if (event.currentTarget.ownerDocument.activeElement !== event.currentTarget) {
+                    var _innerRef_current;
+                    (_innerRef_current = innerRef.current) === null || _innerRef_current === void 0 ? void 0 : _innerRef_current.focus();
+                }
+                (_props_onMouseMove = props.onMouseMove) === null || _props_onMouseMove === void 0 ? void 0 : _props_onMouseMove.call(props, event);
+            }),
+            onClick: (0, _reactutilities.useEventCallback)((event)=>{
+                var _props_onClick;
+                if (!hasSubmenu && !persistOnClick) {
+                    setOpen(event, {
+                        open: false,
+                        keyboard: dismissedWithKeyboardRef.current,
+                        bubble: true,
+                        type: 'menuItemClick',
+                        event
+                    });
+                    dismissedWithKeyboardRef.current = false;
+                }
+                (_props_onClick = props.onClick) === null || _props_onClick === void 0 ? void 0 : _props_onClick.call(props, event);
+            })
+        })), {
+            elementType: 'div'
+        }),
+        icon: _reactutilities.slot.optional(props.icon, {
+            renderByDefault: hasIcons,
+            elementType: 'span'
+        }),
+        checkmark: _reactutilities.slot.optional(props.checkmark, {
+            renderByDefault: hasCheckmarks,
+            elementType: 'span'
+        }),
+        submenuIndicator: _reactutilities.slot.optional(props.submenuIndicator, {
+            renderByDefault: hasSubmenu,
+            defaultProps: {
+                children: dir === 'ltr' ? /*#__PURE__*/ _react.createElement(ChevronRightIcon, null) : /*#__PURE__*/ _react.createElement(ChevronLeftIcon, null)
+            },
+            elementType: 'span'
+        }),
+        content: _reactutilities.slot.optional(props.content, {
+            renderByDefault: !!props.children,
+            defaultProps: {
+                children: props.children
+            },
+            elementType: 'span'
+        }),
+        secondaryContent: _reactutilities.slot.optional(props.secondaryContent, {
+            elementType: 'span'
+        }),
+        subText: _reactutilities.slot.optional(props.subText, {
+            elementType: 'span'
+        })
+    };
+    (0, _useCharacterSearch.useCharacterSearch)(state, innerRef);
+    return state;
+};
+/**
+ * MenuSplitGroup needs to apply extra styles when its main item is in multiline layout mode
+ * Notify the parent MenuSplitGroup so that it can handle this case
+ */ const useNotifySplitItemMultiline = (options)=>{
+    const { hasSubmenu, multiline } = options;
+    const isSplitItemTrigger = (0, _menuSplitGroupContext.useIsInMenuSplitGroup)() && hasSubmenu;
+    const { setMultiline } = (0, _menuSplitGroupContext.useMenuSplitGroupContext_unstable)();
+    (0, _reactutilities.useIsomorphicLayoutEffect)(()=>{
+        if (!isSplitItemTrigger) {
+            setMultiline(multiline);
+        }
+    }, [
+        setMultiline,
+        multiline,
+        isSplitItemTrigger
+    ]);
+};
+const useIconAndCheckmarkAlignment = (options)=>{
+    const { hasSubmenu } = options;
+    const hasIcons = (0, _menuListContext.useMenuListContext_unstable)((context)=>context.hasIcons);
+    const hasCheckmarks = (0, _menuListContext.useMenuListContext_unstable)((context)=>context.hasCheckmarks);
+    const isSplitItemTrigger = (0, _menuSplitGroupContext.useIsInMenuSplitGroup)() && hasSubmenu;
+    return {
+        hasIcons: hasIcons && !isSplitItemTrigger,
+        hasCheckmarks: hasCheckmarks && !isSplitItemTrigger
+    };
+};

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItem/useMenuItemStyles.styles.js

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    menuItemClassNames: function() {
+        return menuItemClassNames;
+    },
+    useMenuItemStyles_unstable: function() {
+        return useMenuItemStyles_unstable;
+    }
+});
+const _react = require("@griffel/react");
+const _index = require("../../selectable/index");
+const menuItemClassNames = {
+    root: 'fui-MenuItem',
+    icon: 'fui-MenuItem__icon',
+    checkmark: 'fui-MenuItem__checkmark',
+    submenuIndicator: 'fui-MenuItem__submenuIndicator',
+    content: 'fui-MenuItem__content',
+    secondaryContent: 'fui-MenuItem__secondaryContent',
+    subText: 'fui-MenuItem__subText'
+};
+const useRootBaseStyles = /*#__PURE__*/ (0, _react.__resetStyles)("rfoezjv", "r8lt3v0", {
+    r: [
+        ".rfoezjv{border-radius:var(--borderRadiusMedium);position:relative;color:var(--colorNeutralForeground2);background-color:var(--colorNeutralBackground1);padding-right:var(--spacingVerticalSNudge);padding-left:var(--spacingVerticalSNudge);padding-top:var(--spacingVerticalSNudge);padding-bottom:var(--spacingVerticalSNudge);box-sizing:border-box;max-width:290px;min-height:32px;flex-shrink:0;display:flex;align-items:start;font-size:var(--fontSizeBase300);cursor:pointer;gap:4px;-webkit-user-select:none;-moz-user-select:none;user-select:none;}",
+        ".rfoezjv:hover{background-color:var(--colorNeutralBackground1Hover);color:var(--colorNeutralForeground2Hover);}",
+        ".rfoezjv:hover .fui-Icon-filled{display:inline;}",
+        ".rfoezjv:hover .fui-Icon-regular{display:none;}",
+        ".rfoezjv:hover .fui-MenuItem__icon{color:var(--colorNeutralForeground2BrandSelected);}",
+        ".rfoezjv:hover .fui-MenuItem__subText{color:var(--colorNeutralForeground3Hover);}",
+        ".rfoezjv:hover:active{background-color:var(--colorNeutralBackground1Pressed);color:var(--colorNeutralForeground2Pressed);}",
+        ".rfoezjv:hover:active .fui-MenuItem__subText{color:var(--colorNeutralForeground3Pressed);}",
+        ".rfoezjv:focus{outline-style:none;}",
+        ".rfoezjv:focus-visible{outline-style:none;}",
+        ".rfoezjv[data-fui-focus-visible]{border-top-color:transparent;border-right-color:transparent;border-bottom-color:transparent;border-left-color:transparent;}",
+        ".rfoezjv[data-fui-focus-visible]::after{content:\"\";position:absolute;pointer-events:none;z-index:1;border:2px solid var(--colorStrokeFocus2);border-radius:var(--borderRadiusMedium);top:calc(2px * -1);right:calc(2px * -1);bottom:calc(2px * -1);left:calc(2px * -1);}",
+        ".r8lt3v0{border-radius:var(--borderRadiusMedium);position:relative;color:var(--colorNeutralForeground2);background-color:var(--colorNeutralBackground1);padding-left:var(--spacingVerticalSNudge);padding-right:var(--spacingVerticalSNudge);padding-top:var(--spacingVerticalSNudge);padding-bottom:var(--spacingVerticalSNudge);box-sizing:border-box;max-width:290px;min-height:32px;flex-shrink:0;display:flex;align-items:start;font-size:var(--fontSizeBase300);cursor:pointer;gap:4px;-webkit-user-select:none;-moz-user-select:none;user-select:none;}",
+        ".r8lt3v0:hover{background-color:var(--colorNeutralBackground1Hover);color:var(--colorNeutralForeground2Hover);}",
+        ".r8lt3v0:hover .fui-Icon-filled{display:inline;}",
+        ".r8lt3v0:hover .fui-Icon-regular{display:none;}",
+        ".r8lt3v0:hover .fui-MenuItem__icon{color:var(--colorNeutralForeground2BrandSelected);}",
+        ".r8lt3v0:hover .fui-MenuItem__subText{color:var(--colorNeutralForeground3Hover);}",
+        ".r8lt3v0:hover:active{background-color:var(--colorNeutralBackground1Pressed);color:var(--colorNeutralForeground2Pressed);}",
+        ".r8lt3v0:hover:active .fui-MenuItem__subText{color:var(--colorNeutralForeground3Pressed);}",
+        ".r8lt3v0:focus{outline-style:none;}",
+        ".r8lt3v0:focus-visible{outline-style:none;}",
+        ".r8lt3v0[data-fui-focus-visible]{border-top-color:transparent;border-left-color:transparent;border-bottom-color:transparent;border-right-color:transparent;}",
+        ".r8lt3v0[data-fui-focus-visible]::after{content:\"\";position:absolute;pointer-events:none;z-index:1;border:2px solid var(--colorStrokeFocus2);border-radius:var(--borderRadiusMedium);top:calc(2px * -1);left:calc(2px * -1);bottom:calc(2px * -1);right:calc(2px * -1);}"
+    ],
+    s: [
+        "@media (forced-colors: active){.rfoezjv:hover{background-color:Canvas;border-color:Highlight;color:Highlight;}.rfoezjv:focus{outline-style:none;}.rfoezjv:focus-visible{outline-style:none;}.rfoezjv[data-fui-focus-visible]{border-top-color:transparent;border-right-color:transparent;border-bottom-color:transparent;border-left-color:transparent;}@media (forced-colors: active){.rfoezjv[data-fui-focus-visible]::after{border-top-color:Highlight;border-right-color:Highlight;border-bottom-color:Highlight;border-left-color:Highlight;}}.rfoezjv[data-fui-focus-visible]::after{content:\"\";position:absolute;pointer-events:none;z-index:1;border:2px solid Highlight;border-radius:var(--borderRadiusMedium);top:calc(2px * -1);right:calc(2px * -1);bottom:calc(2px * -1);left:calc(2px * -1);}}",
+        "@media (forced-colors: active){.rfoezjv[data-fui-focus-visible]::after{border-top-color:Highlight;border-right-color:Highlight;border-bottom-color:Highlight;border-left-color:Highlight;}}",
+        "@media (forced-colors: active){.r8lt3v0:hover{background-color:Canvas;border-color:Highlight;color:Highlight;}.r8lt3v0:focus{outline-style:none;}.r8lt3v0:focus-visible{outline-style:none;}.r8lt3v0[data-fui-focus-visible]{border-top-color:transparent;border-left-color:transparent;border-bottom-color:transparent;border-right-color:transparent;}@media (forced-colors: active){.r8lt3v0[data-fui-focus-visible]::after{border-top-color:Highlight;border-left-color:Highlight;border-bottom-color:Highlight;border-right-color:Highlight;}}.r8lt3v0[data-fui-focus-visible]::after{content:\"\";position:absolute;pointer-events:none;z-index:1;border:2px solid Highlight;border-radius:var(--borderRadiusMedium);top:calc(2px * -1);left:calc(2px * -1);bottom:calc(2px * -1);right:calc(2px * -1);}}",
+        "@media (forced-colors: active){.r8lt3v0[data-fui-focus-visible]::after{border-top-color:Highlight;border-left-color:Highlight;border-bottom-color:Highlight;border-right-color:Highlight;}}"
+    ]
+});
+const useContentBaseStyles = /*#__PURE__*/ (0, _react.__resetStyles)("r1ls86vo", "rpbc5dr", [
+    ".r1ls86vo{padding-left:2px;padding-right:2px;background-color:transparent;flex-grow:1;}",
+    ".rpbc5dr{padding-right:2px;padding-left:2px;background-color:transparent;flex-grow:1;}"
+]);
+const useSecondaryContentBaseStyles = /*#__PURE__*/ (0, _react.__resetStyles)("r12mwwux", "r1ewgu5j", [
+    ".r12mwwux{padding-left:2px;padding-right:2px;font-family:var(--fontFamilyBase);font-size:var(--fontSizeBase200);font-weight:var(--fontWeightRegular);line-height:var(--lineHeightBase300);color:var(--colorNeutralForeground3);}",
+    ".r12mwwux:hover{color:var(--colorNeutralForeground3Hover);}",
+    ".r12mwwux:focus{color:var(--colorNeutralForeground3Hover);}",
+    ".r1ewgu5j{padding-right:2px;padding-left:2px;font-family:var(--fontFamilyBase);font-size:var(--fontSizeBase200);font-weight:var(--fontWeightRegular);line-height:var(--lineHeightBase300);color:var(--colorNeutralForeground3);}",
+    ".r1ewgu5j:hover{color:var(--colorNeutralForeground3Hover);}",
+    ".r1ewgu5j:focus{color:var(--colorNeutralForeground3Hover);}"
+]);
+const useIconBaseStyles = /*#__PURE__*/ (0, _react.__resetStyles)("ro9koqv", null, [
+    ".ro9koqv{width:20px;height:20px;font-size:20px;line-height:0;align-items:center;display:inline-flex;justify-content:center;flex-shrink:0;}"
+]);
+const useSubmenuIndicatorBaseStyles = /*#__PURE__*/ (0, _react.__resetStyles)("r9c34qo", null, [
+    ".r9c34qo{width:20px;height:20px;font-size:20px;line-height:0;align-items:center;display:inline-flex;justify-content:center;}"
+]);
+const useSubtextBaseStyles = /*#__PURE__*/ (0, _react.__resetStyles)("rk2ppru", null, [
+    ".rk2ppru{font-family:var(--fontFamilyBase);font-size:var(--fontSizeBase100);font-weight:var(--fontWeightRegular);line-height:var(--lineHeightBase100);color:var(--colorNeutralForeground3);}"
+]);
+const useStyles = /*#__PURE__*/ (0, _react.__styles)({
+    checkmark: {
+        B6of3ja: "fmnzpld"
+    },
+    splitItemMain: {
+        Bh6795r: "fqerorx"
+    },
+    splitItemTrigger: {
+        Btl43ni: [
+            "f1ozlkrg",
+            "f10ostut"
+        ],
+        Beyfa6y: [
+            "f1deotkl",
+            "f1krrbdw"
+        ],
+        uwmqm3: [
+            "f1cnd47f",
+            "fhxju0i"
+        ],
+        Ftih45: "f1wl9k8s",
+        Ccq8qp: "f1yn80uh",
+        Baz25je: "f68mna0",
+        cmx5o7: "f1p5zmk"
+    },
+    disabled: {
+        sj55zd: "f1s2aq7o",
+        Bi91k9c: "fvgxktp",
+        Jwef8y: "f1ijtazh",
+        eoavqd: "fphbwmw",
+        Bk3fhr4: "f19vpps7",
+        Bmfj8id: "fv5swzo",
+        Bg7n49j: "f1q1x1ba",
+        B2d53fq: "fcvwxyo",
+        iro3zm: "f1to34ca",
+        t0hwav: "ft33916",
+        Bbusuzp: "f1dcs8yz",
+        ze5xyy: "f1kc2mi9",
+        Bqrx1nm: "fkavljg",
+        Bctn1xl: "fk56vqo",
+        h5esng: "ff3wi9b",
+        Bh6z0a4: "f1ikwg0d",
+        Bh953qp: "f10l1t5h"
+    }
+}, {
+    d: [
+        ".fmnzpld{margin-top:2px;}",
+        ".fqerorx{flex-grow:1;}",
+        ".f1ozlkrg{border-top-left-radius:0;}",
+        ".f10ostut{border-top-right-radius:0;}",
+        ".f1deotkl{border-bottom-left-radius:0;}",
+        ".f1krrbdw{border-bottom-right-radius:0;}",
+        ".f1cnd47f{padding-left:0;}",
+        ".fhxju0i{padding-right:0;}",
+        ".f1wl9k8s::before{content:\"\";}",
+        ".f1yn80uh::before{width:var(--strokeWidthThin);}",
+        ".f68mna0::before{height:24px;}",
+        ".f1p5zmk::before{background-color:var(--colorNeutralStroke1);}",
+        ".f1s2aq7o{color:var(--colorNeutralForegroundDisabled);}"
+    ],
+    h: [
+        ".fvgxktp:hover{color:var(--colorNeutralForegroundDisabled);}",
+        ".f1ijtazh:hover{background-color:var(--colorNeutralBackground1);}",
+        ".fphbwmw:hover{cursor:not-allowed;}",
+        ".f19vpps7:hover .fui-Icon-filled{display:none;}",
+        ".fv5swzo:hover .fui-Icon-regular{display:inline;}",
+        ".f1q1x1ba:hover .fui-MenuItem__icon{color:var(--colorNeutralForegroundDisabled);}",
+        ".fcvwxyo:hover:active{color:var(--colorNeutralForegroundDisabled);}",
+        ".f1to34ca:hover:active{background-color:var(--colorNeutralBackground1);}"
+    ],
+    f: [
+        ".ft33916:focus{color:var(--colorNeutralForegroundDisabled);}"
+    ],
+    m: [
+        [
+            "@media (forced-colors: active){.f1dcs8yz{color:GrayText;}}",
+            {
+                m: "(forced-colors: active)"
+            }
+        ],
+        [
+            "@media (forced-colors: active){.f1kc2mi9:hover{color:GrayText;}}",
+            {
+                m: "(forced-colors: active)"
+            }
+        ],
+        [
+            "@media (forced-colors: active){.fkavljg:hover{background-color:Canvas;}}",
+            {
+                m: "(forced-colors: active)"
+            }
+        ],
+        [
+            "@media (forced-colors: active){.fk56vqo:hover .fui-MenuItem__icon{color:GrayText;}}",
+            {
+                m: "(forced-colors: active)"
+            }
+        ],
+        [
+            "@media (forced-colors: active){.ff3wi9b:hover .fui-MenuItem__icon{background-color:Canvas;}}",
+            {
+                m: "(forced-colors: active)"
+            }
+        ],
+        [
+            "@media (forced-colors: active){.f1ikwg0d:focus{color:GrayText;}}",
+            {
+                m: "(forced-colors: active)"
+            }
+        ],
+        [
+            "@media (forced-colors: active){.f10l1t5h:focus{background-color:Canvas;}}",
+            {
+                m: "(forced-colors: active)"
+            }
+        ]
+    ]
+});
+const useMultilineStyles = /*#__PURE__*/ (0, _react.__styles)({
+    content: {
+        mc9l5x: "f22iagw",
+        Beiy3e4: "f1vx9l62"
+    },
+    secondaryContent: {
+        qb2dma: "f7nlbp4"
+    },
+    submenuIndicator: {
+        qb2dma: "f7nlbp4"
+    }
+}, {
+    d: [
+        ".f22iagw{display:flex;}",
+        ".f1vx9l62{flex-direction:column;}",
+        ".f7nlbp4{align-self:center;}"
+    ]
+});
+const useMenuItemStyles_unstable = (state)=>{
+    'use no memo';
+    const styles = useStyles();
+    const rootBaseStyles = useRootBaseStyles();
+    const contentBaseStyles = useContentBaseStyles();
+    const secondaryContentBaseStyles = useSecondaryContentBaseStyles();
+    const iconBaseStyles = useIconBaseStyles();
+    const submenuIndicatorBaseStyles = useSubmenuIndicatorBaseStyles();
+    const multilineStyles = useMultilineStyles();
+    const subtextBaseStyles = useSubtextBaseStyles();
+    const multiline = !!state.subText;
+    state.root.className = (0, _react.mergeClasses)(menuItemClassNames.root, rootBaseStyles, state.disabled && styles.disabled, state.root.className);
+    if (state.content) {
+        state.content.className = (0, _react.mergeClasses)(menuItemClassNames.content, contentBaseStyles, state.content.className, multiline && multilineStyles.content);
+    }
+    if (state.checkmark) {
+        state.checkmark.className = (0, _react.mergeClasses)(menuItemClassNames.checkmark, styles.checkmark, state.checkmark.className);
+    }
+    if (state.secondaryContent) {
+        state.secondaryContent.className = (0, _react.mergeClasses)(menuItemClassNames.secondaryContent, !state.disabled && secondaryContentBaseStyles, state.secondaryContent.className, multiline && multilineStyles.secondaryContent);
+    }
+    if (state.icon) {
+        state.icon.className = (0, _react.mergeClasses)(menuItemClassNames.icon, iconBaseStyles, state.icon.className);
+    }
+    if (state.submenuIndicator) {
+        state.submenuIndicator.className = (0, _react.mergeClasses)(menuItemClassNames.submenuIndicator, submenuIndicatorBaseStyles, state.submenuIndicator.className, multiline && multilineStyles.submenuIndicator);
+    }
+    if (state.subText) {
+        state.subText.className = (0, _react.mergeClasses)(menuItemClassNames.subText, state.subText.className, subtextBaseStyles);
+    }
+    (0, _index.useCheckmarkStyles_unstable)(state);
+    return state;
+};

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItemCheckbox/MenuItemCheckbox.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "MenuItemCheckbox", {
+    enumerable: true,
+    get: function() {
+        return MenuItemCheckbox;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _useMenuItemCheckbox = require("./useMenuItemCheckbox");
+const _renderMenuItemCheckbox = require("./renderMenuItemCheckbox");
+const _useMenuItemCheckboxStylesstyles = require("./useMenuItemCheckboxStyles.styles");
+const _reactsharedcontexts = require("@fluentui/react-shared-contexts");
+const MenuItemCheckbox = /*#__PURE__*/ _react.forwardRef((props, ref)=>{
+    const state = (0, _useMenuItemCheckbox.useMenuItemCheckbox_unstable)(props, ref);
+    (0, _useMenuItemCheckboxStylesstyles.useMenuItemCheckboxStyles_unstable)(state);
+    (0, _reactsharedcontexts.useCustomStyleHook_unstable)('useMenuItemCheckboxStyles_unstable')(state);
+    return (0, _renderMenuItemCheckbox.renderMenuItemCheckbox_unstable)(state);
+});
+MenuItemCheckbox.displayName = 'MenuItemCheckbox';

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItemCheckbox/MenuItemCheckbox.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/MenuItemCheckbox/MenuItemCheckbox.tsx"],"sourcesContent":["import * as React from 'react';\nimport { useMenuItemCheckbox_unstable } from './useMenuItemCheckbox';\nimport { renderMenuItemCheckbox_unstable } from './renderMenuItemCheckbox';\nimport { useMenuItemCheckboxStyles_unstable } from './useMenuItemCheckboxStyles.styles';\nimport type { MenuItemCheckboxProps } from './MenuItemCheckbox.types';\nimport type { ForwardRefComponent } from '@fluentui/react-utilities';\nimport { useCustomStyleHook_unstable } from '@fluentui/react-shared-contexts';\n\n/**\n * Define a styled MenuItemCheckbox, using the `useMenuItemCheckbox_unstable` hook.\n */\nexport const MenuItemCheckbox: ForwardRefComponent<MenuItemCheckboxProps> = React.forwardRef((props, ref) => {\n  const state = useMenuItemCheckbox_unstable(props, ref);\n\n  useMenuItemCheckboxStyles_unstable(state);\n\n  useCustomStyleHook_unstable('useMenuItemCheckboxStyles_unstable')(state);\n\n  return renderMenuItemCheckbox_unstable(state);\n});\n\nMenuItemCheckbox.displayName = 'MenuItemCheckbox';\n"],"names":["MenuItemCheckbox","React","forwardRef","props","ref","state","useMenuItemCheckbox_unstable","useMenuItemCheckboxStyles_unstable","useCustomStyleHook_unstable","renderMenuItemCheckbox_unstable","displayName"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAWaA;;;eAAAA;;;;iEAXU;qCACsB;wCACG;iDACG;qCAGP;AAKrC,MAAMA,mBAAAA,WAAAA,GAA+DC,OAAMC,UAAU,CAAC,CAACC,OAAOC;IACnG,MAAMC,QAAQC,IAAAA,iDAAAA,EAA6BH,OAAOC;IAElDG,IAAAA,mEAAAA,EAAmCF;IAEnCG,IAAAA,gDAAAA,EAA4B,sCAAsCH;IAElE,OAAOI,IAAAA,uDAAAA,EAAgCJ;AACzC;AAEAL,iBAAiBU,WAAW,GAAG"}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItemCheckbox/MenuItemCheckbox.types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItemCheckbox/MenuItemCheckbox.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/MenuItemCheckbox/MenuItemCheckbox.types.ts"],"sourcesContent":["import type { MenuItemSelectableProps, MenuItemSelectableState } from '../../selectable/index';\nimport type { MenuItemProps, MenuItemState } from '../MenuItem/MenuItem.types';\n\nexport type MenuItemCheckboxProps = MenuItemProps & MenuItemSelectableProps;\n\nexport type MenuItemCheckboxState = MenuItemState & MenuItemSelectableState;\n"],"names":[],"rangeMappings":"","mappings":""}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItemCheckbox/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    MenuItemCheckbox: function() {
+        return _MenuItemCheckbox.MenuItemCheckbox;
+    },
+    menuItemCheckboxClassNames: function() {
+        return _useMenuItemCheckboxStylesstyles.menuItemCheckboxClassNames;
+    },
+    renderMenuItemCheckbox_unstable: function() {
+        return _renderMenuItemCheckbox.renderMenuItemCheckbox_unstable;
+    },
+    useMenuItemCheckboxStyles_unstable: function() {
+        return _useMenuItemCheckboxStylesstyles.useMenuItemCheckboxStyles_unstable;
+    },
+    useMenuItemCheckbox_unstable: function() {
+        return _useMenuItemCheckbox.useMenuItemCheckbox_unstable;
+    }
+});
+const _MenuItemCheckbox = require("./MenuItemCheckbox");
+const _renderMenuItemCheckbox = require("./renderMenuItemCheckbox");
+const _useMenuItemCheckbox = require("./useMenuItemCheckbox");
+const _useMenuItemCheckboxStylesstyles = require("./useMenuItemCheckboxStyles.styles");

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItemCheckbox/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/MenuItemCheckbox/index.ts"],"sourcesContent":["export type { MenuItemCheckboxProps, MenuItemCheckboxState } from './MenuItemCheckbox.types';\nexport { MenuItemCheckbox } from './MenuItemCheckbox';\nexport { renderMenuItemCheckbox_unstable } from './renderMenuItemCheckbox';\nexport { useMenuItemCheckbox_unstable } from './useMenuItemCheckbox';\nexport { menuItemCheckboxClassNames, useMenuItemCheckboxStyles_unstable } from './useMenuItemCheckboxStyles.styles';\n"],"names":["MenuItemCheckbox","menuItemCheckboxClassNames","renderMenuItemCheckbox_unstable","useMenuItemCheckboxStyles_unstable","useMenuItemCheckbox_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IACSA,gBAAgB;eAAhBA,kCAAgB;;IAGhBC,0BAA0B;eAA1BA,2DAA0B;;IAF1BC,+BAA+B;eAA/BA,uDAA+B;;IAEHC,kCAAkC;eAAlCA,mEAAkC;;IAD9DC,4BAA4B;eAA5BA,iDAA4B;;;kCAFJ;wCACe;qCACH;iDACkC"}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItemCheckbox/renderMenuItemCheckbox.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "renderMenuItemCheckbox_unstable", {
+    enumerable: true,
+    get: function() {
+        return renderMenuItemCheckbox_unstable;
+    }
+});
+const _jsxruntime = require("@fluentui/react-jsx-runtime/jsx-runtime");
+const _reactutilities = require("@fluentui/react-utilities");
+const renderMenuItemCheckbox_unstable = (state)=>{
+    (0, _reactutilities.assertSlots)(state);
+    return /*#__PURE__*/ (0, _jsxruntime.jsxs)(state.root, {
+        children: [
+            state.checkmark && /*#__PURE__*/ (0, _jsxruntime.jsx)(state.checkmark, {}),
+            state.icon && /*#__PURE__*/ (0, _jsxruntime.jsx)(state.icon, {}),
+            state.content && /*#__PURE__*/ (0, _jsxruntime.jsxs)(state.content, {
+                children: [
+                    state.content.children,
+                    state.subText && /*#__PURE__*/ (0, _jsxruntime.jsx)(state.subText, {})
+                ]
+            }),
+            state.secondaryContent && /*#__PURE__*/ (0, _jsxruntime.jsx)(state.secondaryContent, {})
+        ]
+    });
+};

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItemCheckbox/renderMenuItemCheckbox.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/MenuItemCheckbox/renderMenuItemCheckbox.tsx"],"sourcesContent":["/** @jsxRuntime automatic */\n/** @jsxImportSource @fluentui/react-jsx-runtime */\nimport { assertSlots } from '@fluentui/react-utilities';\nimport type { MenuItemCheckboxState } from './MenuItemCheckbox.types';\nimport type { MenuItemSlots } from '../MenuItem/MenuItem.types';\n\n/** Function that renders the final JSX of the component  */\nexport const renderMenuItemCheckbox_unstable = (state: MenuItemCheckboxState) => {\n  assertSlots<MenuItemSlots>(state);\n\n  return (\n    <state.root>\n      {state.checkmark && <state.checkmark />}\n      {state.icon && <state.icon />}\n      {state.content && (\n        <state.content>\n          {state.content.children}\n          {state.subText && <state.subText />}\n        </state.content>\n      )}\n      {state.secondaryContent && <state.secondaryContent />}\n    </state.root>\n  );\n};\n"],"names":["renderMenuItemCheckbox_unstable","state","assertSlots","_jsxs","root","checkmark","_jsx","icon","content","children","subText","secondaryContent"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAOaA;;;eAAAA;;;4BANb;gCAC4B;AAKrB,MAAMA,kCAAkC,CAACC;IAC9CC,IAAAA,2BAAAA,EAA2BD;IAE3B,OAAA,WAAA,GACEE,IAAAA,gBAAA,EAACF,MAAMG,IAAI,EAAA;;YACRH,MAAMI,SAAS,IAAA,WAAA,GAAIC,IAAAA,eAAA,EAACL,MAAMI,SAAS,EAAA,CAAA;YACnCJ,MAAMM,IAAI,IAAA,WAAA,GAAID,IAAAA,eAAA,EAACL,MAAMM,IAAI,EAAA,CAAA;YACzBN,MAAMO,OAAO,IAAA,WAAA,GACZL,IAAAA,gBAAA,EAACF,MAAMO,OAAO,EAAA;;oBACXP,MAAMO,OAAO,CAACC,QAAQ;oBACtBR,MAAMS,OAAO,IAAA,WAAA,GAAIJ,IAAAA,eAAA,EAACL,MAAMS,OAAO,EAAA,CAAA;;;YAGnCT,MAAMU,gBAAgB,IAAA,WAAA,GAAIL,IAAAA,eAAA,EAACL,MAAMU,gBAAgB,EAAA,CAAA;;;AAGxD"}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItemCheckbox/useMenuItemCheckbox.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useMenuItemCheckbox_unstable", {
+    enumerable: true,
+    get: function() {
+        return useMenuItemCheckbox_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _reactutilities = require("@fluentui/react-utilities");
+const _reacticons = require("@fluentui/react-icons");
+const _menuListContext = require("../../contexts/menuListContext");
+const _useMenuItem = require("../MenuItem/useMenuItem");
+const useMenuItemCheckbox_unstable = (props, ref)=>{
+    const toggleCheckbox = (0, _menuListContext.useMenuListContext_unstable)((context)=>context.toggleCheckbox);
+    const { name, value } = props;
+    const checked = (0, _menuListContext.useMenuListContext_unstable)((context)=>{
+        var _context_checkedValues;
+        const checkedItems = ((_context_checkedValues = context.checkedValues) === null || _context_checkedValues === void 0 ? void 0 : _context_checkedValues[name]) || [];
+        return checkedItems.indexOf(value) !== -1;
+    });
+    const state = {
+        ...(0, _useMenuItem.useMenuItem_unstable)({
+            role: 'menuitemcheckbox',
+            persistOnClick: true,
+            ...props,
+            'aria-checked': checked,
+            checkmark: _reactutilities.slot.optional(props.checkmark, {
+                defaultProps: {
+                    children: /*#__PURE__*/ _react.createElement(_reacticons.Checkmark16Filled, null)
+                },
+                renderByDefault: true,
+                elementType: 'span'
+            }),
+            onClick: (e)=>{
+                var _props_onClick;
+                toggleCheckbox === null || toggleCheckbox === void 0 ? void 0 : toggleCheckbox(e, name, value, checked);
+                (_props_onClick = props.onClick) === null || _props_onClick === void 0 ? void 0 : _props_onClick.call(props, e);
+            }
+        }, ref),
+        name,
+        value,
+        checked
+    };
+    return state;
+};

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItemCheckbox/useMenuItemCheckbox.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/MenuItemCheckbox/useMenuItemCheckbox.tsx"],"sourcesContent":["import * as React from 'react';\nimport { slot } from '@fluentui/react-utilities';\nimport { Checkmark16Filled } from '@fluentui/react-icons';\nimport { useMenuListContext_unstable } from '../../contexts/menuListContext';\nimport { useMenuItem_unstable } from '../MenuItem/useMenuItem';\nimport type { MenuItemCheckboxProps, MenuItemCheckboxState } from './MenuItemCheckbox.types';\nimport type { ARIAButtonElement, ARIAButtonElementIntersection } from '@fluentui/react-aria';\n\n/** Returns the props and state required to render the component */\nexport const useMenuItemCheckbox_unstable = (\n  props: MenuItemCheckboxProps,\n  ref: React.Ref<ARIAButtonElement<'div'>>,\n): MenuItemCheckboxState => {\n  const toggleCheckbox = useMenuListContext_unstable(context => context.toggleCheckbox);\n  const { name, value } = props;\n\n  const checked = useMenuListContext_unstable(context => {\n    const checkedItems = context.checkedValues?.[name] || [];\n    return checkedItems.indexOf(value) !== -1;\n  });\n\n  const state: MenuItemCheckboxState = {\n    ...useMenuItem_unstable(\n      {\n        role: 'menuitemcheckbox',\n        persistOnClick: true,\n        ...props,\n        'aria-checked': checked,\n        checkmark: slot.optional(props.checkmark, {\n          defaultProps: { children: <Checkmark16Filled /> },\n          renderByDefault: true,\n          elementType: 'span',\n        }),\n        onClick: (e: React.MouseEvent<ARIAButtonElementIntersection<'div'>>) => {\n          toggleCheckbox?.(e, name, value, checked);\n          props.onClick?.(e);\n        },\n      },\n      ref,\n    ),\n    name,\n    value,\n    checked,\n  };\n\n  return state;\n};\n"],"names":["useMenuItemCheckbox_unstable","props","ref","toggleCheckbox","useMenuListContext_unstable","context","name","value","checked","checkedItems","checkedValues","indexOf","state","useMenuItem_unstable","role","persistOnClick","checkmark","slot","optional","defaultProps","children","React","createElement","Checkmark16Filled","renderByDefault","elementType","onClick","e"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BASaA;;;eAAAA;;;;iEATU;gCACF;4BACa;iCACU;6BACP;AAK9B,MAAMA,+BAA+B,CAC1CC,OACAC;IAEA,MAAMC,iBAAiBC,IAAAA,4CAAAA,EAA4BC,CAAAA,UAAWA,QAAQF,cAAc;IACpF,MAAM,EAAEG,IAAI,EAAEC,KAAK,EAAE,GAAGN;IAExB,MAAMO,UAAUJ,IAAAA,4CAAAA,EAA4BC,CAAAA;YACrBA;QAArB,MAAMI,eAAeJ,CAAAA,CAAAA,yBAAAA,QAAQK,aAAa,AAAbA,MAAa,QAArBL,2BAAAA,KAAAA,IAAAA,KAAAA,IAAAA,sBAAuB,CAACC,KAAK,AAALA,KAAS,EAAE;QACxD,OAAOG,aAAaE,OAAO,CAACJ,WAAW,CAAC;IAC1C;IAEA,MAAMK,QAA+B;QACnC,GAAGC,IAAAA,iCAAAA,EACD;YACEC,MAAM;YACNC,gBAAgB;YAChB,GAAGd,KAAK;YACR,gBAAgBO;YAChBQ,WAAWC,oBAAAA,CAAKC,QAAQ,CAACjB,MAAMe,SAAS,EAAE;gBACxCG,cAAc;oBAAEC,UAAAA,WAAAA,GAAUC,OAAAC,aAAA,CAACC,6BAAAA,EAAAA;gBAAqB;gBAChDC,iBAAiB;gBACjBC,aAAa;YACf;YACAC,SAAS,CAACC;oBAER1B;gBADAE,mBAAAA,QAAAA,mBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,eAAiBwB,GAAGrB,MAAMC,OAAOC;gBACjCP,CAAAA,iBAAAA,MAAMyB,OAAO,AAAPA,MAAO,QAAbzB,mBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,eAAAA,IAAAA,CAAAA,OAAgB0B;YAClB;QACF,GACAzB,IACD;QACDI;QACAC;QACAC;IACF;IAEA,OAAOI;AACT"}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItemCheckbox/useMenuItemCheckboxStyles.styles.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    menuItemCheckboxClassNames: function() {
+        return menuItemCheckboxClassNames;
+    },
+    useMenuItemCheckboxStyles_unstable: function() {
+        return useMenuItemCheckboxStyles_unstable;
+    }
+});
+const _react = require("@griffel/react");
+const _index = require("../../selectable/index");
+const _useMenuItemStylesstyles = require("../MenuItem/useMenuItemStyles.styles");
+const menuItemCheckboxClassNames = {
+    root: 'fui-MenuItemCheckbox',
+    icon: 'fui-MenuItemCheckbox__icon',
+    checkmark: 'fui-MenuItemCheckbox__checkmark',
+    content: 'fui-MenuItemCheckbox__content',
+    secondaryContent: 'fui-MenuItemCheckbox__secondaryContent',
+    subText: 'fui-MenuItemCheckbox__subText'
+};
+const useMenuItemCheckboxStyles_unstable = (state)=>{
+    'use no memo';
+    state.root.className = (0, _react.mergeClasses)(menuItemCheckboxClassNames.root, state.root.className);
+    if (state.content) {
+        state.content.className = (0, _react.mergeClasses)(menuItemCheckboxClassNames.content, state.content.className);
+    }
+    if (state.secondaryContent) {
+        state.secondaryContent.className = (0, _react.mergeClasses)(menuItemCheckboxClassNames.secondaryContent, state.secondaryContent.className);
+    }
+    if (state.icon) {
+        state.icon.className = (0, _react.mergeClasses)(menuItemCheckboxClassNames.icon, state.icon.className);
+    }
+    if (state.checkmark) {
+        state.checkmark.className = (0, _react.mergeClasses)(menuItemCheckboxClassNames.checkmark, state.checkmark.className);
+    }
+    if (state.subText) {
+        state.subText.className = (0, _react.mergeClasses)(menuItemCheckboxClassNames.subText, state.subText.className);
+    }
+    (0, _useMenuItemStylesstyles.useMenuItemStyles_unstable)(state);
+    (0, _index.useCheckmarkStyles_unstable)(state);
+    return state;
+};

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItemCheckbox/useMenuItemCheckboxStyles.styles.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["useMenuItemCheckboxStyles.styles.js"],"sourcesContent":["import { mergeClasses } from '@griffel/react';\nimport { useCheckmarkStyles_unstable } from '../../selectable/index';\nimport { useMenuItemStyles_unstable } from '../MenuItem/useMenuItemStyles.styles';\nexport const menuItemCheckboxClassNames = {\n    root: 'fui-MenuItemCheckbox',\n    icon: 'fui-MenuItemCheckbox__icon',\n    checkmark: 'fui-MenuItemCheckbox__checkmark',\n    content: 'fui-MenuItemCheckbox__content',\n    secondaryContent: 'fui-MenuItemCheckbox__secondaryContent',\n    subText: 'fui-MenuItemCheckbox__subText'\n};\nexport const useMenuItemCheckboxStyles_unstable = (state)=>{\n    'use no memo';\n    state.root.className = mergeClasses(menuItemCheckboxClassNames.root, state.root.className);\n    if (state.content) {\n        state.content.className = mergeClasses(menuItemCheckboxClassNames.content, state.content.className);\n    }\n    if (state.secondaryContent) {\n        state.secondaryContent.className = mergeClasses(menuItemCheckboxClassNames.secondaryContent, state.secondaryContent.className);\n    }\n    if (state.icon) {\n        state.icon.className = mergeClasses(menuItemCheckboxClassNames.icon, state.icon.className);\n    }\n    if (state.checkmark) {\n        state.checkmark.className = mergeClasses(menuItemCheckboxClassNames.checkmark, state.checkmark.className);\n    }\n    if (state.subText) {\n        state.subText.className = mergeClasses(menuItemCheckboxClassNames.subText, state.subText.className);\n    }\n    useMenuItemStyles_unstable(state);\n    useCheckmarkStyles_unstable(state);\n    return state;\n};\n"],"names":["menuItemCheckboxClassNames","useMenuItemCheckboxStyles_unstable","root","icon","checkmark","content","secondaryContent","subText","state","className","mergeClasses","useMenuItemStyles_unstable","useCheckmarkStyles_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAGaA,0BAA0B;eAA1BA;;IAQAC,kCAAkC;eAAlCA;;;uBAXgB;uBACe;yCACD;AACpC,MAAMD,6BAA6B;IACtCE,MAAM;IACNC,MAAM;IACNC,WAAW;IACXC,SAAS;IACTC,kBAAkB;IAClBC,SAAS;AACb;AACO,MAAMN,qCAAsCO,CAAAA;IAC/C;IACAA,MAAMN,IAAI,CAACO,SAAS,GAAGC,IAAAA,mBAAY,EAACV,2BAA2BE,IAAI,EAAEM,MAAMN,IAAI,CAACO,SAAS;IACzF,IAAID,MAAMH,OAAO,EAAE;QACfG,MAAMH,OAAO,CAACI,SAAS,GAAGC,IAAAA,mBAAY,EAACV,2BAA2BK,OAAO,EAAEG,MAAMH,OAAO,CAACI,SAAS;IACtG;IACA,IAAID,MAAMF,gBAAgB,EAAE;QACxBE,MAAMF,gBAAgB,CAACG,SAAS,GAAGC,IAAAA,mBAAY,EAACV,2BAA2BM,gBAAgB,EAAEE,MAAMF,gBAAgB,CAACG,SAAS;IACjI;IACA,IAAID,MAAML,IAAI,EAAE;QACZK,MAAML,IAAI,CAACM,SAAS,GAAGC,IAAAA,mBAAY,EAACV,2BAA2BG,IAAI,EAAEK,MAAML,IAAI,CAACM,SAAS;IAC7F;IACA,IAAID,MAAMJ,SAAS,EAAE;QACjBI,MAAMJ,SAAS,CAACK,SAAS,GAAGC,IAAAA,mBAAY,EAACV,2BAA2BI,SAAS,EAAEI,MAAMJ,SAAS,CAACK,SAAS;IAC5G;IACA,IAAID,MAAMD,OAAO,EAAE;QACfC,MAAMD,OAAO,CAACE,SAAS,GAAGC,IAAAA,mBAAY,EAACV,2BAA2BO,OAAO,EAAEC,MAAMD,OAAO,CAACE,SAAS;IACtG;IACAE,IAAAA,mDAA0B,EAACH;IAC3BI,IAAAA,kCAA2B,EAACJ;IAC5B,OAAOA;AACX"}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItemLink/MenuItemLink.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "MenuItemLink", {
+    enumerable: true,
+    get: function() {
+        return MenuItemLink;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _useMenuItemLink = require("./useMenuItemLink");
+const _renderMenuItemLink = require("./renderMenuItemLink");
+const _useMenuItemLinkStylesstyles = require("./useMenuItemLinkStyles.styles");
+const _reactsharedcontexts = require("@fluentui/react-shared-contexts");
+const MenuItemLink = /*#__PURE__*/ _react.forwardRef((props, ref)=>{
+    const state = (0, _useMenuItemLink.useMenuItemLink_unstable)(props, ref);
+    (0, _useMenuItemLinkStylesstyles.useMenuItemLinkStyles_unstable)(state);
+    (0, _reactsharedcontexts.useCustomStyleHook_unstable)('useMenuItemLinkStyles_unstable')(state);
+    return (0, _renderMenuItemLink.renderMenuItemLink_unstable)(state);
+});
+MenuItemLink.displayName = 'MenuItemLink';

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItemLink/MenuItemLink.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/MenuItemLink/MenuItemLink.tsx"],"sourcesContent":["import * as React from 'react';\nimport { useMenuItemLink_unstable } from './useMenuItemLink';\nimport { renderMenuItemLink_unstable } from './renderMenuItemLink';\nimport { useMenuItemLinkStyles_unstable } from './useMenuItemLinkStyles.styles';\nimport type { MenuItemLinkProps } from './MenuItemLink.types';\nimport type { ForwardRefComponent } from '@fluentui/react-utilities';\nimport { useCustomStyleHook_unstable } from '@fluentui/react-shared-contexts';\n\n/**\n * MenuItemLink component\n */\nexport const MenuItemLink: ForwardRefComponent<MenuItemLinkProps> = React.forwardRef((props, ref) => {\n  const state = useMenuItemLink_unstable(props, ref);\n\n  useMenuItemLinkStyles_unstable(state);\n\n  useCustomStyleHook_unstable('useMenuItemLinkStyles_unstable')(state);\n\n  return renderMenuItemLink_unstable(state);\n});\n\nMenuItemLink.displayName = 'MenuItemLink';\n"],"names":["MenuItemLink","React","forwardRef","props","ref","state","useMenuItemLink_unstable","useMenuItemLinkStyles_unstable","useCustomStyleHook_unstable","renderMenuItemLink_unstable","displayName"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAWaA;;;eAAAA;;;;iEAXU;iCACkB;oCACG;6CACG;qCAGH;AAKrC,MAAMA,eAAAA,WAAAA,GAAuDC,OAAMC,UAAU,CAAC,CAACC,OAAOC;IAC3F,MAAMC,QAAQC,IAAAA,yCAAAA,EAAyBH,OAAOC;IAE9CG,IAAAA,2DAAAA,EAA+BF;IAE/BG,IAAAA,gDAAAA,EAA4B,kCAAkCH;IAE9D,OAAOI,IAAAA,+CAAAA,EAA4BJ;AACrC;AAEAL,aAAaU,WAAW,GAAG"}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItemLink/MenuItemLink.types.js

@@ -0,0 +1,6 @@
+/**
+ * State used in rendering MenuItemLink
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItemLink/MenuItemLink.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/MenuItemLink/MenuItemLink.types.ts"],"sourcesContent":["import type { ComponentProps, ComponentState, Slot } from '@fluentui/react-utilities';\nimport { MenuItemProps, MenuItemSlots } from '../MenuItem/MenuItem.types';\n\nexport type MenuItemLinkSlots = {\n  root: Slot<'a'>;\n} & Pick<MenuItemSlots, 'icon' | 'content' | 'secondaryContent' | 'checkmark'>;\n\n/**\n * MenuItemLink Props\n */\nexport type MenuItemLinkProps = ComponentProps<MenuItemLinkSlots> & Pick<MenuItemProps, 'disabled'> & { href: string };\n\n/**\n * State used in rendering MenuItemLink\n */\nexport type MenuItemLinkState = ComponentState<MenuItemLinkSlots>;\n"],"names":[],"rangeMappings":";;","mappings":"AAYA;;CAEC"}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItemLink/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    MenuItemLink: function() {
+        return _MenuItemLink.MenuItemLink;
+    },
+    menuItemLinkClassNames: function() {
+        return _useMenuItemLinkStylesstyles.menuItemLinkClassNames;
+    },
+    renderMenuItemLink_unstable: function() {
+        return _renderMenuItemLink.renderMenuItemLink_unstable;
+    },
+    useMenuItemLinkStyles_unstable: function() {
+        return _useMenuItemLinkStylesstyles.useMenuItemLinkStyles_unstable;
+    },
+    useMenuItemLink_unstable: function() {
+        return _useMenuItemLink.useMenuItemLink_unstable;
+    }
+});
+const _MenuItemLink = require("./MenuItemLink");
+const _renderMenuItemLink = require("./renderMenuItemLink");
+const _useMenuItemLink = require("./useMenuItemLink");
+const _useMenuItemLinkStylesstyles = require("./useMenuItemLinkStyles.styles");

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItemLink/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/MenuItemLink/index.ts"],"sourcesContent":["export { MenuItemLink } from './MenuItemLink';\nexport type { MenuItemLinkProps, MenuItemLinkSlots, MenuItemLinkState } from './MenuItemLink.types';\nexport { renderMenuItemLink_unstable } from './renderMenuItemLink';\nexport { useMenuItemLink_unstable } from './useMenuItemLink';\nexport { menuItemLinkClassNames, useMenuItemLinkStyles_unstable } from './useMenuItemLinkStyles.styles';\n"],"names":["MenuItemLink","menuItemLinkClassNames","renderMenuItemLink_unstable","useMenuItemLinkStyles_unstable","useMenuItemLink_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAASA,YAAY;eAAZA,0BAAY;;IAIZC,sBAAsB;eAAtBA,mDAAsB;;IAFtBC,2BAA2B;eAA3BA,+CAA2B;;IAEHC,8BAA8B;eAA9BA,2DAA8B;;IADtDC,wBAAwB;eAAxBA,yCAAwB;;;8BAHJ;oCAEe;iCACH;6CAC8B"}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItemLink/renderMenuItemLink.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "renderMenuItemLink_unstable", {
+    enumerable: true,
+    get: function() {
+        return renderMenuItemLink_unstable;
+    }
+});
+const _jsxruntime = require("@fluentui/react-jsx-runtime/jsx-runtime");
+const _reactutilities = require("@fluentui/react-utilities");
+const renderMenuItemLink_unstable = (state)=>{
+    (0, _reactutilities.assertSlots)(state);
+    // TODO Add additional slots in the appropriate place
+    return /*#__PURE__*/ (0, _jsxruntime.jsxs)(state.root, {
+        children: [
+            state.checkmark && /*#__PURE__*/ (0, _jsxruntime.jsx)(state.checkmark, {}),
+            state.icon && /*#__PURE__*/ (0, _jsxruntime.jsx)(state.icon, {}),
+            state.content && /*#__PURE__*/ (0, _jsxruntime.jsx)(state.content, {}),
+            state.secondaryContent && /*#__PURE__*/ (0, _jsxruntime.jsx)(state.secondaryContent, {})
+        ]
+    });
+};

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItemLink/renderMenuItemLink.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/MenuItemLink/renderMenuItemLink.tsx"],"sourcesContent":["/** @jsxRuntime automatic */\n/** @jsxImportSource @fluentui/react-jsx-runtime */\nimport { assertSlots } from '@fluentui/react-utilities';\nimport type { MenuItemLinkState, MenuItemLinkSlots } from './MenuItemLink.types';\n\n/**\n * Render the final JSX of MenuItemLink\n */\nexport const renderMenuItemLink_unstable = (state: MenuItemLinkState) => {\n  assertSlots<MenuItemLinkSlots>(state);\n\n  // TODO Add additional slots in the appropriate place\n  return (\n    <state.root>\n      {state.checkmark && <state.checkmark />}\n      {state.icon && <state.icon />}\n      {state.content && <state.content />}\n      {state.secondaryContent && <state.secondaryContent />}\n    </state.root>\n  );\n};\n"],"names":["renderMenuItemLink_unstable","state","assertSlots","_jsxs","root","checkmark","_jsx","icon","content","secondaryContent"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAQaA;;;eAAAA;;;4BAPb;gCAC4B;AAMrB,MAAMA,8BAA8B,CAACC;IAC1CC,IAAAA,2BAAAA,EAA+BD;IAE/B,qDAAqD;IACrD,OAAA,WAAA,GACEE,IAAAA,gBAAA,EAACF,MAAMG,IAAI,EAAA;;YACRH,MAAMI,SAAS,IAAA,WAAA,GAAIC,IAAAA,eAAA,EAACL,MAAMI,SAAS,EAAA,CAAA;YACnCJ,MAAMM,IAAI,IAAA,WAAA,GAAID,IAAAA,eAAA,EAACL,MAAMM,IAAI,EAAA,CAAA;YACzBN,MAAMO,OAAO,IAAA,WAAA,GAAIF,IAAAA,eAAA,EAACL,MAAMO,OAAO,EAAA,CAAA;YAC/BP,MAAMQ,gBAAgB,IAAA,WAAA,GAAIH,IAAAA,eAAA,EAACL,MAAMQ,gBAAgB,EAAA,CAAA;;;AAGxD"}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItemLink/useMenuItemLink.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useMenuItemLink_unstable", {
+    enumerable: true,
+    get: function() {
+        return useMenuItemLink_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _reactutilities = require("@fluentui/react-utilities");
+const _useMenuItem = require("../MenuItem/useMenuItem");
+const useMenuItemLink_unstable = (props, ref)=>{
+    // casting because the root slot changes from div to a
+    const baseState = (0, _useMenuItem.useMenuItem_unstable)(props, null);
+    // FIXME: casting because the root slot changes from div to a,
+    // ideal solution would be to extract common logic from useMenuItem_unstable root
+    // and use it in both without assuming element type
+    const _props = {
+        ...props,
+        ...baseState.root,
+        ref,
+        tabIndex: props.tabIndex
+    };
+    return {
+        ...baseState,
+        components: {
+            ...baseState.components,
+            root: 'a'
+        },
+        root: _reactutilities.slot.always((0, _reactutilities.getIntrinsicElementProps)('a', {
+            role: 'menuitem',
+            ..._props
+        }), {
+            elementType: 'a'
+        })
+    };
+};

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItemLink/useMenuItemLink.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/MenuItemLink/useMenuItemLink.ts"],"sourcesContent":["import * as React from 'react';\nimport { ExtractSlotProps, Slot, getIntrinsicElementProps, slot } from '@fluentui/react-utilities';\nimport type { MenuItemLinkProps, MenuItemLinkState } from './MenuItemLink.types';\nimport { useMenuItem_unstable } from '../MenuItem/useMenuItem';\nimport { MenuItemProps } from '../MenuItem/MenuItem.types';\n\n/**\n * Create the state required to render MenuItemLink.\n *\n * The returned state can be modified with hooks such as useMenuItemLinkStyles_unstable,\n * before being passed to renderMenuItemLink_unstable.\n *\n * @param props - props from this instance of MenuItemLink\n * @param ref - reference to root HTMLElement of MenuItemLink\n */\nexport const useMenuItemLink_unstable = (\n  props: MenuItemLinkProps,\n  ref: React.Ref<HTMLAnchorElement>,\n): MenuItemLinkState => {\n  // casting because the root slot changes from div to a\n  const baseState = useMenuItem_unstable(props as MenuItemProps, null);\n  // FIXME: casting because the root slot changes from div to a,\n  // ideal solution would be to extract common logic from useMenuItem_unstable root\n  // and use it in both without assuming element type\n  const _props = { ...props, ...(baseState.root as ExtractSlotProps<Slot<'a'>>), ref, tabIndex: props.tabIndex };\n\n  return {\n    ...baseState,\n    components: {\n      ...baseState.components,\n      root: 'a',\n    },\n    root: slot.always(\n      getIntrinsicElementProps('a', {\n        role: 'menuitem',\n        ..._props,\n      }),\n      { elementType: 'a' },\n    ),\n  };\n};\n"],"names":["useMenuItemLink_unstable","props","ref","baseState","useMenuItem_unstable","_props","root","tabIndex","components","slot","always","getIntrinsicElementProps","role","elementType"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAeaA;;;eAAAA;;;;iEAfU;gCACgD;6BAElC;AAY9B,MAAMA,2BAA2B,CACtCC,OACAC;IAEA,sDAAsD;IACtD,MAAMC,YAAYC,IAAAA,iCAAAA,EAAqBH,OAAwB;IAC/D,8DAA8D;IAC9D,iFAAiF;IACjF,mDAAmD;IACnD,MAAMI,SAAS;QAAE,GAAGJ,KAAK;QAAE,GAAIE,UAAUG,IAAI;QAAkCJ;QAAKK,UAAUN,MAAMM,QAAQ;IAAC;IAE7G,OAAO;QACL,GAAGJ,SAAS;QACZK,YAAY;YACV,GAAGL,UAAUK,UAAU;YACvBF,MAAM;QACR;QACAA,MAAMG,oBAAAA,CAAKC,MAAM,CACfC,IAAAA,wCAAAA,EAAyB,KAAK;YAC5BC,MAAM;YACN,GAAGP,MAAM;QACX,IACA;YAAEQ,aAAa;QAAI;IAEvB;AACF"}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItemLink/useMenuItemLinkStyles.styles.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    menuItemLinkClassNames: function() {
+        return menuItemLinkClassNames;
+    },
+    useMenuItemLinkStyles_unstable: function() {
+        return useMenuItemLinkStyles_unstable;
+    }
+});
+const _react = require("@griffel/react");
+const _useMenuItemStylesstyles = require("../MenuItem/useMenuItemStyles.styles");
+const menuItemLinkClassNames = {
+    root: 'fui-MenuItemLink',
+    icon: 'fui-MenuItemLink__icon',
+    checkmark: 'fui-MenuItemLink__checkmark',
+    content: 'fui-MenuItemLink__content',
+    secondaryContent: 'fui-MenuItemLink__secondaryContent'
+};
+/**
+ * Styles for the root slot
+ */ const useStyles = /*#__PURE__*/ (0, _react.__styles)({
+    resetLink: {
+        w71qe1: "f1iuv45f",
+        Bkioxbp: "f9pkogg",
+        I8pafv: "foe20s3",
+        dvvfom: "f1kn6jj"
+    }
+}, {
+    d: [
+        ".f1iuv45f{text-decoration-line:none;}",
+        ".f9pkogg{text-decoration-thickness:initial;}",
+        ".foe20s3{text-decoration-style:initial;}",
+        ".f1kn6jj{text-decoration-color:initial;}"
+    ]
+});
+const useMenuItemLinkStyles_unstable = (state)=>{
+    'use no memo';
+    (0, _useMenuItemStylesstyles.useMenuItemStyles_unstable)(state);
+    const styles = useStyles();
+    state.root.className = (0, _react.mergeClasses)(menuItemLinkClassNames.root, styles.resetLink, state.root.className);
+    if (state.icon) {
+        state.icon.className = (0, _react.mergeClasses)(menuItemLinkClassNames.icon, state.icon.className);
+    }
+    if (state.content) {
+        state.content.className = (0, _react.mergeClasses)(menuItemLinkClassNames.content, state.content.className);
+    }
+    if (state.secondaryContent) {
+        state.secondaryContent.className = (0, _react.mergeClasses)(menuItemLinkClassNames.secondaryContent, state.secondaryContent.className);
+    }
+    if (state.checkmark) {
+        state.checkmark.className = (0, _react.mergeClasses)(menuItemLinkClassNames.checkmark, state.checkmark.className);
+    }
+    return state;
+};

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItemLink/useMenuItemLinkStyles.styles.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["useMenuItemLinkStyles.styles.js"],"sourcesContent":["import { makeStyles, mergeClasses } from '@griffel/react';\nimport { useMenuItemStyles_unstable } from '../MenuItem/useMenuItemStyles.styles';\nexport const menuItemLinkClassNames = {\n    root: 'fui-MenuItemLink',\n    icon: 'fui-MenuItemLink__icon',\n    checkmark: 'fui-MenuItemLink__checkmark',\n    content: 'fui-MenuItemLink__content',\n    secondaryContent: 'fui-MenuItemLink__secondaryContent'\n};\n/**\n * Styles for the root slot\n */ const useStyles = makeStyles({\n    resetLink: {\n        textDecorationLine: 'none',\n        textDecorationThickness: 'initial',\n        textDecorationStyle: 'initial',\n        textDecorationColor: 'initial'\n    }\n});\n/**\n * Apply styling to the MenuItemLink slots based on the state\n */ export const useMenuItemLinkStyles_unstable = (state)=>{\n    'use no memo';\n    useMenuItemStyles_unstable(state);\n    const styles = useStyles();\n    state.root.className = mergeClasses(menuItemLinkClassNames.root, styles.resetLink, state.root.className);\n    if (state.icon) {\n        state.icon.className = mergeClasses(menuItemLinkClassNames.icon, state.icon.className);\n    }\n    if (state.content) {\n        state.content.className = mergeClasses(menuItemLinkClassNames.content, state.content.className);\n    }\n    if (state.secondaryContent) {\n        state.secondaryContent.className = mergeClasses(menuItemLinkClassNames.secondaryContent, state.secondaryContent.className);\n    }\n    if (state.checkmark) {\n        state.checkmark.className = mergeClasses(menuItemLinkClassNames.checkmark, state.checkmark.className);\n    }\n    return state;\n};\n"],"names":["menuItemLinkClassNames","useMenuItemLinkStyles_unstable","root","icon","checkmark","content","secondaryContent","useStyles","__styles","resetLink","w71qe1","Bkioxbp","I8pafv","dvvfom","d","state","useMenuItemStyles_unstable","styles","className","mergeClasses"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAEaA,sBAAsB;eAAtBA;;IAmBIC,8BAA8B;eAA9BA;;;uBArBwB;yCACE;AACpC,MAAMD,yBAAyB;IAClCE,MAAM;IACNC,MAAM;IACNC,WAAW;IACXC,SAAS;IACTC,kBAAkB;AACtB;AACA;;CAEA,GAAI,MAAMC,YAAS,WAAA,GAAGC,IAAAA,eAAA,EAAA;IAAAC,WAAA;QAAAC,QAAA;QAAAC,SAAA;QAAAC,QAAA;QAAAC,QAAA;IAAA;AAAA,GAAA;IAAAC,GAAA;QAAA;QAAA;QAAA;QAAA;KAAA;AAAA;AAUX,MAAMb,iCAAkCc,CAAAA;IAC/C;IACAC,IAAAA,mDAA0B,EAACD;IAC3B,MAAME,SAASV;IACfQ,MAAMb,IAAI,CAACgB,SAAS,GAAGC,IAAAA,mBAAY,EAACnB,uBAAuBE,IAAI,EAAEe,OAAOR,SAAS,EAAEM,MAAMb,IAAI,CAACgB,SAAS;IACvG,IAAIH,MAAMZ,IAAI,EAAE;QACZY,MAAMZ,IAAI,CAACe,SAAS,GAAGC,IAAAA,mBAAY,EAACnB,uBAAuBG,IAAI,EAAEY,MAAMZ,IAAI,CAACe,SAAS;IACzF;IACA,IAAIH,MAAMV,OAAO,EAAE;QACfU,MAAMV,OAAO,CAACa,SAAS,GAAGC,IAAAA,mBAAY,EAACnB,uBAAuBK,OAAO,EAAEU,MAAMV,OAAO,CAACa,SAAS;IAClG;IACA,IAAIH,MAAMT,gBAAgB,EAAE;QACxBS,MAAMT,gBAAgB,CAACY,SAAS,GAAGC,IAAAA,mBAAY,EAACnB,uBAAuBM,gBAAgB,EAAES,MAAMT,gBAAgB,CAACY,SAAS;IAC7H;IACA,IAAIH,MAAMX,SAAS,EAAE;QACjBW,MAAMX,SAAS,CAACc,SAAS,GAAGC,IAAAA,mBAAY,EAACnB,uBAAuBI,SAAS,EAAEW,MAAMX,SAAS,CAACc,SAAS;IACxG;IACA,OAAOH;AACX"}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItemRadio/MenuItemRadio.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "MenuItemRadio", {
+    enumerable: true,
+    get: function() {
+        return MenuItemRadio;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _useMenuItemRadio = require("./useMenuItemRadio");
+const _renderMenuItemRadio = require("./renderMenuItemRadio");
+const _useMenuItemRadioStylesstyles = require("./useMenuItemRadioStyles.styles");
+const _reactsharedcontexts = require("@fluentui/react-shared-contexts");
+const MenuItemRadio = /*#__PURE__*/ _react.forwardRef((props, ref)=>{
+    const state = (0, _useMenuItemRadio.useMenuItemRadio_unstable)(props, ref);
+    (0, _useMenuItemRadioStylesstyles.useMenuItemRadioStyles_unstable)(state);
+    (0, _reactsharedcontexts.useCustomStyleHook_unstable)('useMenuItemRadioStyles_unstable')(state);
+    return (0, _renderMenuItemRadio.renderMenuItemRadio_unstable)(state);
+});
+MenuItemRadio.displayName = 'MenuItemRadio';

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItemRadio/MenuItemRadio.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/MenuItemRadio/MenuItemRadio.tsx"],"sourcesContent":["import * as React from 'react';\nimport { useMenuItemRadio_unstable } from './useMenuItemRadio';\nimport { renderMenuItemRadio_unstable } from './renderMenuItemRadio';\nimport { useMenuItemRadioStyles_unstable } from './useMenuItemRadioStyles.styles';\nimport type { MenuItemRadioProps } from './MenuItemRadio.types';\nimport type { ForwardRefComponent } from '@fluentui/react-utilities';\nimport { useCustomStyleHook_unstable } from '@fluentui/react-shared-contexts';\n\n/**\n * Define a styled MenuItemRadio, using the `useMenuItemRadio_unstable` hook.\n */\nexport const MenuItemRadio: ForwardRefComponent<MenuItemRadioProps> = React.forwardRef((props, ref) => {\n  const state = useMenuItemRadio_unstable(props, ref);\n\n  useMenuItemRadioStyles_unstable(state);\n\n  useCustomStyleHook_unstable('useMenuItemRadioStyles_unstable')(state);\n\n  return renderMenuItemRadio_unstable(state);\n});\n\nMenuItemRadio.displayName = 'MenuItemRadio';\n"],"names":["MenuItemRadio","React","forwardRef","props","ref","state","useMenuItemRadio_unstable","useMenuItemRadioStyles_unstable","useCustomStyleHook_unstable","renderMenuItemRadio_unstable","displayName"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAWaA;;;eAAAA;;;;iEAXU;kCACmB;qCACG;8CACG;qCAGJ;AAKrC,MAAMA,gBAAAA,WAAAA,GAAyDC,OAAMC,UAAU,CAAC,CAACC,OAAOC;IAC7F,MAAMC,QAAQC,IAAAA,2CAAAA,EAA0BH,OAAOC;IAE/CG,IAAAA,6DAAAA,EAAgCF;IAEhCG,IAAAA,gDAAAA,EAA4B,mCAAmCH;IAE/D,OAAOI,IAAAA,iDAAAA,EAA6BJ;AACtC;AAEAL,cAAcU,WAAW,GAAG"}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItemRadio/MenuItemRadio.types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItemRadio/MenuItemRadio.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/MenuItemRadio/MenuItemRadio.types.ts"],"sourcesContent":["import type { MenuItemSelectableProps, MenuItemSelectableState } from '../../selectable/index';\nimport type { MenuItemProps, MenuItemState } from '../MenuItem/MenuItem.types';\n\nexport type MenuItemRadioProps = MenuItemProps & MenuItemSelectableProps;\n\nexport type MenuItemRadioState = MenuItemState & MenuItemSelectableState;\n"],"names":[],"rangeMappings":"","mappings":""}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItemRadio/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    MenuItemRadio: function() {
+        return _MenuItemRadio.MenuItemRadio;
+    },
+    menuItemRadioClassNames: function() {
+        return _useMenuItemRadioStylesstyles.menuItemRadioClassNames;
+    },
+    renderMenuItemRadio_unstable: function() {
+        return _renderMenuItemRadio.renderMenuItemRadio_unstable;
+    },
+    useMenuItemRadioStyles_unstable: function() {
+        return _useMenuItemRadioStylesstyles.useMenuItemRadioStyles_unstable;
+    },
+    useMenuItemRadio_unstable: function() {
+        return _useMenuItemRadio.useMenuItemRadio_unstable;
+    }
+});
+const _MenuItemRadio = require("./MenuItemRadio");
+const _renderMenuItemRadio = require("./renderMenuItemRadio");
+const _useMenuItemRadio = require("./useMenuItemRadio");
+const _useMenuItemRadioStylesstyles = require("./useMenuItemRadioStyles.styles");

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItemRadio/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/MenuItemRadio/index.ts"],"sourcesContent":["export type { MenuItemRadioProps, MenuItemRadioState } from './MenuItemRadio.types';\nexport { MenuItemRadio } from './MenuItemRadio';\nexport { renderMenuItemRadio_unstable } from './renderMenuItemRadio';\nexport { useMenuItemRadio_unstable } from './useMenuItemRadio';\nexport { menuItemRadioClassNames, useMenuItemRadioStyles_unstable } from './useMenuItemRadioStyles.styles';\n"],"names":["MenuItemRadio","menuItemRadioClassNames","renderMenuItemRadio_unstable","useMenuItemRadioStyles_unstable","useMenuItemRadio_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IACSA,aAAa;eAAbA,4BAAa;;IAGbC,uBAAuB;eAAvBA,qDAAuB;;IAFvBC,4BAA4B;eAA5BA,iDAA4B;;IAEHC,+BAA+B;eAA/BA,6DAA+B;;IADxDC,yBAAyB;eAAzBA,2CAAyB;;;+BAFJ;qCACe;kCACH;8CAC+B"}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItemRadio/renderMenuItemRadio.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "renderMenuItemRadio_unstable", {
+    enumerable: true,
+    get: function() {
+        return renderMenuItemRadio_unstable;
+    }
+});
+const _jsxruntime = require("@fluentui/react-jsx-runtime/jsx-runtime");
+const _reactutilities = require("@fluentui/react-utilities");
+const renderMenuItemRadio_unstable = (state)=>{
+    (0, _reactutilities.assertSlots)(state);
+    return /*#__PURE__*/ (0, _jsxruntime.jsxs)(state.root, {
+        children: [
+            state.checkmark && /*#__PURE__*/ (0, _jsxruntime.jsx)(state.checkmark, {}),
+            state.icon && /*#__PURE__*/ (0, _jsxruntime.jsx)(state.icon, {}),
+            state.content && /*#__PURE__*/ (0, _jsxruntime.jsxs)(state.content, {
+                children: [
+                    state.content.children,
+                    state.subText && /*#__PURE__*/ (0, _jsxruntime.jsx)(state.subText, {})
+                ]
+            }),
+            state.secondaryContent && /*#__PURE__*/ (0, _jsxruntime.jsx)(state.secondaryContent, {})
+        ]
+    });
+};

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItemRadio/renderMenuItemRadio.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/MenuItemRadio/renderMenuItemRadio.tsx"],"sourcesContent":["/** @jsxRuntime automatic */\n/** @jsxImportSource @fluentui/react-jsx-runtime */\nimport { assertSlots } from '@fluentui/react-utilities';\nimport type { MenuItemRadioState } from './MenuItemRadio.types';\nimport type { MenuItemSlots } from '../MenuItem/MenuItem.types';\n\n/**\n * Redefine the render function to add slots. Reuse the menuitemradio structure but add\n * slots to children.\n */\nexport const renderMenuItemRadio_unstable = (state: MenuItemRadioState) => {\n  assertSlots<MenuItemSlots>(state);\n\n  return (\n    <state.root>\n      {state.checkmark && <state.checkmark />}\n      {state.icon && <state.icon />}\n      {state.content && (\n        <state.content>\n          {state.content.children}\n          {state.subText && <state.subText />}\n        </state.content>\n      )}\n      {state.secondaryContent && <state.secondaryContent />}\n    </state.root>\n  );\n};\n"],"names":["renderMenuItemRadio_unstable","state","assertSlots","_jsxs","root","checkmark","_jsx","icon","content","children","subText","secondaryContent"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAUaA;;;eAAAA;;;4BATb;gCAC4B;AAQrB,MAAMA,+BAA+B,CAACC;IAC3CC,IAAAA,2BAAAA,EAA2BD;IAE3B,OAAA,WAAA,GACEE,IAAAA,gBAAA,EAACF,MAAMG,IAAI,EAAA;;YACRH,MAAMI,SAAS,IAAA,WAAA,GAAIC,IAAAA,eAAA,EAACL,MAAMI,SAAS,EAAA,CAAA;YACnCJ,MAAMM,IAAI,IAAA,WAAA,GAAID,IAAAA,eAAA,EAACL,MAAMM,IAAI,EAAA,CAAA;YACzBN,MAAMO,OAAO,IAAA,WAAA,GACZL,IAAAA,gBAAA,EAACF,MAAMO,OAAO,EAAA;;oBACXP,MAAMO,OAAO,CAACC,QAAQ;oBACtBR,MAAMS,OAAO,IAAA,WAAA,GAAIJ,IAAAA,eAAA,EAACL,MAAMS,OAAO,EAAA,CAAA;;;YAGnCT,MAAMU,gBAAgB,IAAA,WAAA,GAAIL,IAAAA,eAAA,EAACL,MAAMU,gBAAgB,EAAA,CAAA;;;AAGxD"}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItemRadio/useMenuItemRadio.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useMenuItemRadio_unstable", {
+    enumerable: true,
+    get: function() {
+        return useMenuItemRadio_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _reactutilities = require("@fluentui/react-utilities");
+const _reacticons = require("@fluentui/react-icons");
+const _menuListContext = require("../../contexts/menuListContext");
+const _useMenuItem = require("../MenuItem/useMenuItem");
+const useMenuItemRadio_unstable = (props, ref)=>{
+    const { name, value } = props;
+    const checked = (0, _menuListContext.useMenuListContext_unstable)((context)=>{
+        var _context_checkedValues;
+        const checkedItems = ((_context_checkedValues = context.checkedValues) === null || _context_checkedValues === void 0 ? void 0 : _context_checkedValues[name]) || [];
+        return checkedItems.indexOf(value) !== -1;
+    });
+    const selectRadio = (0, _menuListContext.useMenuListContext_unstable)((context)=>context.selectRadio);
+    return {
+        ...(0, _useMenuItem.useMenuItem_unstable)({
+            ...props,
+            role: 'menuitemradio',
+            'aria-checked': checked,
+            checkmark: _reactutilities.slot.optional(props.checkmark, {
+                defaultProps: {
+                    children: /*#__PURE__*/ _react.createElement(_reacticons.Checkmark16Filled, null)
+                },
+                renderByDefault: true,
+                elementType: 'span'
+            }),
+            onClick: (e)=>{
+                var _props_onClick;
+                selectRadio === null || selectRadio === void 0 ? void 0 : selectRadio(e, name, value, checked);
+                (_props_onClick = props.onClick) === null || _props_onClick === void 0 ? void 0 : _props_onClick.call(props, e);
+            }
+        }, ref),
+        checked,
+        name,
+        value
+    };
+};

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItemRadio/useMenuItemRadio.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/MenuItemRadio/useMenuItemRadio.tsx"],"sourcesContent":["import * as React from 'react';\nimport { slot } from '@fluentui/react-utilities';\nimport { Checkmark16Filled } from '@fluentui/react-icons';\nimport { useMenuListContext_unstable } from '../../contexts/menuListContext';\nimport { useMenuItem_unstable } from '../MenuItem/useMenuItem';\nimport type { MenuItemRadioProps, MenuItemRadioState } from './MenuItemRadio.types';\nimport type { ARIAButtonElement, ARIAButtonElementIntersection } from '@fluentui/react-aria';\n\n/**\n * Given user props, returns state and render function for a MenuItemRadio.\n */\nexport const useMenuItemRadio_unstable = (\n  props: MenuItemRadioProps,\n  ref: React.Ref<ARIAButtonElement<'div'>>,\n): MenuItemRadioState => {\n  const { name, value } = props;\n\n  const checked = useMenuListContext_unstable(context => {\n    const checkedItems = context.checkedValues?.[name] || [];\n    return checkedItems.indexOf(value) !== -1;\n  });\n\n  const selectRadio = useMenuListContext_unstable(context => context.selectRadio);\n\n  return {\n    ...useMenuItem_unstable(\n      {\n        ...props,\n        role: 'menuitemradio',\n        'aria-checked': checked,\n        checkmark: slot.optional(props.checkmark, {\n          defaultProps: { children: <Checkmark16Filled /> },\n          renderByDefault: true,\n          elementType: 'span',\n        }),\n        onClick: (e: React.MouseEvent<ARIAButtonElementIntersection<'div'>>) => {\n          selectRadio?.(e, name, value, checked);\n          props.onClick?.(e);\n        },\n      },\n      ref,\n    ),\n    checked,\n    name,\n    value,\n  };\n};\n"],"names":["useMenuItemRadio_unstable","props","ref","name","value","checked","useMenuListContext_unstable","context","checkedItems","checkedValues","indexOf","selectRadio","useMenuItem_unstable","role","checkmark","slot","optional","defaultProps","children","React","createElement","Checkmark16Filled","renderByDefault","elementType","onClick","e"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAWaA;;;eAAAA;;;;iEAXU;gCACF;4BACa;iCACU;6BACP;AAO9B,MAAMA,4BAA4B,CACvCC,OACAC;IAEA,MAAM,EAAEC,IAAI,EAAEC,KAAK,EAAE,GAAGH;IAExB,MAAMI,UAAUC,IAAAA,4CAAAA,EAA4BC,CAAAA;YACrBA;QAArB,MAAMC,eAAeD,CAAAA,CAAAA,yBAAAA,QAAQE,aAAa,AAAbA,MAAa,QAArBF,2BAAAA,KAAAA,IAAAA,KAAAA,IAAAA,sBAAuB,CAACJ,KAAK,AAALA,KAAS,EAAE;QACxD,OAAOK,aAAaE,OAAO,CAACN,WAAW,CAAC;IAC1C;IAEA,MAAMO,cAAcL,IAAAA,4CAAAA,EAA4BC,CAAAA,UAAWA,QAAQI,WAAW;IAE9E,OAAO;QACL,GAAGC,IAAAA,iCAAAA,EACD;YACE,GAAGX,KAAK;YACRY,MAAM;YACN,gBAAgBR;YAChBS,WAAWC,oBAAAA,CAAKC,QAAQ,CAACf,MAAMa,SAAS,EAAE;gBACxCG,cAAc;oBAAEC,UAAAA,WAAAA,GAAUC,OAAAC,aAAA,CAACC,6BAAAA,EAAAA;gBAAqB;gBAChDC,iBAAiB;gBACjBC,aAAa;YACf;YACAC,SAAS,CAACC;oBAERxB;gBADAU,gBAAAA,QAAAA,gBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,YAAcc,GAAGtB,MAAMC,OAAOC;gBAC9BJ,CAAAA,iBAAAA,MAAMuB,OAAO,AAAPA,MAAO,QAAbvB,mBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,eAAAA,IAAAA,CAAAA,OAAgBwB;YAClB;QACF,GACAvB,IACD;QACDG;QACAF;QACAC;IACF;AACF"}

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItemRadio/useMenuItemRadioStyles.styles.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    menuItemRadioClassNames: function() {
+        return menuItemRadioClassNames;
+    },
+    useMenuItemRadioStyles_unstable: function() {
+        return useMenuItemRadioStyles_unstable;
+    }
+});
+const _react = require("@griffel/react");
+const _index = require("../../selectable/index");
+const _useMenuItemStylesstyles = require("../MenuItem/useMenuItemStyles.styles");
+const menuItemRadioClassNames = {
+    root: 'fui-MenuItemRadio',
+    icon: 'fui-MenuItemRadio__icon',
+    checkmark: 'fui-MenuItemRadio__checkmark',
+    content: 'fui-MenuItemRadio__content',
+    secondaryContent: 'fui-MenuItemRadio__secondaryContent',
+    subText: 'fui-MenuItemRadio__subText'
+};
+const useMenuItemRadioStyles_unstable = (state)=>{
+    'use no memo';
+    state.root.className = (0, _react.mergeClasses)(menuItemRadioClassNames.root, state.root.className);
+    if (state.content) {
+        state.content.className = (0, _react.mergeClasses)(menuItemRadioClassNames.content, state.content.className);
+    }
+    if (state.secondaryContent) {
+        state.secondaryContent.className = (0, _react.mergeClasses)(menuItemRadioClassNames.secondaryContent, state.secondaryContent.className);
+    }
+    if (state.icon) {
+        state.icon.className = (0, _react.mergeClasses)(menuItemRadioClassNames.icon, state.icon.className);
+    }
+    if (state.checkmark) {
+        state.checkmark.className = (0, _react.mergeClasses)(menuItemRadioClassNames.checkmark, state.checkmark.className);
+    }
+    if (state.subText) {
+        state.subText.className = (0, _react.mergeClasses)(menuItemRadioClassNames.subText, state.subText.className);
+    }
+    (0, _useMenuItemStylesstyles.useMenuItemStyles_unstable)(state);
+    (0, _index.useCheckmarkStyles_unstable)(state);
+};

node_modules/@fluentui/react-menu/lib-commonjs/components/MenuItemRadio/useMenuItemRadioStyles.styles.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["useMenuItemRadioStyles.styles.js"],"sourcesContent":["import { mergeClasses } from '@griffel/react';\nimport { useCheckmarkStyles_unstable } from '../../selectable/index';\nimport { useMenuItemStyles_unstable } from '../MenuItem/useMenuItemStyles.styles';\nexport const menuItemRadioClassNames = {\n    root: 'fui-MenuItemRadio',\n    icon: 'fui-MenuItemRadio__icon',\n    checkmark: 'fui-MenuItemRadio__checkmark',\n    content: 'fui-MenuItemRadio__content',\n    secondaryContent: 'fui-MenuItemRadio__secondaryContent',\n    subText: 'fui-MenuItemRadio__subText'\n};\nexport const useMenuItemRadioStyles_unstable = (state)=>{\n    'use no memo';\n    state.root.className = mergeClasses(menuItemRadioClassNames.root, state.root.className);\n    if (state.content) {\n        state.content.className = mergeClasses(menuItemRadioClassNames.content, state.content.className);\n    }\n    if (state.secondaryContent) {\n        state.secondaryContent.className = mergeClasses(menuItemRadioClassNames.secondaryContent, state.secondaryContent.className);\n    }\n    if (state.icon) {\n        state.icon.className = mergeClasses(menuItemRadioClassNames.icon, state.icon.className);\n    }\n    if (state.checkmark) {\n        state.checkmark.className = mergeClasses(menuItemRadioClassNames.checkmark, state.checkmark.className);\n    }\n    if (state.subText) {\n        state.subText.className = mergeClasses(menuItemRadioClassNames.subText, state.subText.className);\n    }\n    useMenuItemStyles_unstable(state);\n    useCheckmarkStyles_unstable(state);\n};\n"],"names":["menuItemRadioClassNames","useMenuItemRadioStyles_unstable","root","icon","checkmark","content","secondaryContent","subText","state","className","mergeClasses","useMenuItemStyles_unstable","useCheckmarkStyles_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAGaA,uBAAuB;eAAvBA;;IAQAC,+BAA+B;eAA/BA;;;uBAXgB;uBACe;yCACD;AACpC,MAAMD,0BAA0B;IACnCE,MAAM;IACNC,MAAM;IACNC,WAAW;IACXC,SAAS;IACTC,kBAAkB;IAClBC,SAAS;AACb;AACO,MAAMN,kCAAmCO,CAAAA;IAC5C;IACAA,MAAMN,IAAI,CAACO,SAAS,GAAGC,IAAAA,mBAAY,EAACV,wBAAwBE,IAAI,EAAEM,MAAMN,IAAI,CAACO,SAAS;IACtF,IAAID,MAAMH,OAAO,EAAE;QACfG,MAAMH,OAAO,CAACI,SAAS,GAAGC,IAAAA,mBAAY,EAACV,wBAAwBK,OAAO,EAAEG,MAAMH,OAAO,CAACI,SAAS;IACnG;IACA,IAAID,MAAMF,gBAAgB,EAAE;QACxBE,MAAMF,gBAAgB,CAACG,SAAS,GAAGC,IAAAA,mBAAY,EAACV,wBAAwBM,gBAAgB,EAAEE,MAAMF,gBAAgB,CAACG,SAAS;IAC9H;IACA,IAAID,MAAML,IAAI,EAAE;QACZK,MAAML,IAAI,CAACM,SAAS,GAAGC,IAAAA,mBAAY,EAACV,wBAAwBG,IAAI,EAAEK,MAAML,IAAI,CAACM,SAAS;IAC1F;IACA,IAAID,MAAMJ,SAAS,EAAE;QACjBI,MAAMJ,SAAS,CAACK,SAAS,GAAGC,IAAAA,mBAAY,EAACV,wBAAwBI,SAAS,EAAEI,MAAMJ,SAAS,CAACK,SAAS;IACzG;IACA,IAAID,MAAMD,OAAO,EAAE;QACfC,MAAMD,OAAO,CAACE,SAAS,GAAGC,IAAAA,mBAAY,EAACV,wBAAwBO,OAAO,EAAEC,MAAMD,OAAO,CAACE,SAAS;IACnG;IACAE,IAAAA,mDAA0B,EAACH;IAC3BI,IAAAA,kCAA2B,EAACJ;AAChC"}