@oracle/oraclejet-preact 20.0.4 → 20.1.0

package/es/SelectMenuGroupContext-aa1fe822.js

@@ -1,542 +0,0 @@
-/* @oracle/oraclejet-preact: undefined */
-import { jsx, jsxs, Fragment } from 'preact/jsx-runtime';
-import { useMemo, useCallback, useContext, useRef, useState, useEffect, useImperativeHandle, useLayoutEffect } from 'preact/hooks';
-import { S as Sheet } from './Sheet-f9f8a4a4.js';
-import { forwardRef, useCallback as useCallback$1 } from 'preact/compat';
-import { g as getPrevNext, a as getNVisible, b as getMenuPointerDown, c as getMenuContainerMouseLeave, d as getMenuContainerFocusMethods, e as getCloseSubmenuEvent, f as getKeyboardCloseProps, k as keyElemExtractor, h as getLastVisible, D as Dropdown, i as getIsMobile, j as isMenuChildrenFalsy, l as getMenuItemClickChangeKey, m as getOpenSubmenuEvent } from './Dropdown-019aba37.js';
-import { m as mergeProps } from './mergeProps-88ea8306.js';
-import { c as classNames } from './classNames-4e12b00d.js';
-import { u as useUser } from './useUser-06d34d19.js';
-import { menuStyles } from './UNSAFE_Menu/themes/MenuStyles.css.js';
-import { u as useTestId } from './useTestId-f24ac480.js';
-import { dropdownMenuStyles } from './UNSAFE_Menu/themes/DropdownMenuStyles.css.js';
-import { F as Flex } from './Flex-03129963.js';
-import { S as Skeleton } from './Skeleton-d6f0969e.js';
-import { menuSkeletonStyles } from './UNSAFE_Menu/themes/MenuSkeletonStyles.css.js';
-import { L as LiveRegion } from './LiveRegion-cebac18d.js';
-import { u as useTranslationBundle } from './useTranslationBundle-4822502f.js';
-import { u as useComponentTheme } from './useComponentTheme-d2f9e47f.js';
-import { MenuItemRedwoodTheme } from './UNSAFE_Menu/themes/redwood/MenuItemTheme.js';
-import { U as UNSAFE_DOM_ACCESS } from './unsafeDomAccess-453eb74e.js';
-import { T as Text } from './Text-834eb35e.js';
-import { u as useId } from './useId-03dbfdf0.js';
-import { u as usePress } from './usePress-051f5adb.js';
-import { m as mergeInterpolations } from './mergeInterpolations-30cd9a69.js';
-import { f as flexitemInterpolations } from './flexitem-7b7f7920.js';
-import { u as useInteractionStyle } from './useInteractionStyle-99e32c23.js';
-import { createContext } from 'preact';
-import { u as useToggle } from './useToggle-8b7fcefe.js';
-
-/**
- * @license
- * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
- * The Universal Permissive License (UPL), Version 1.0
- * as shown at https://oss.oracle.com/licenses/upl/
- * @ignore
- */
-/**
- * Hook for handling current key update due to user interaction including keyboard navigation.
- *
- * @param getPrev function to get the previous key based on the current key
- * @param getNext function to get the next key based on the current key
- * @param getFirstVisible function to get the key of the first available item
- * @param getLastVisible function to get the key of the last available item
- * @param onChange function to invoke if the current key has changed
- * @returns
- */
-function useMenuCurrentKey(getPrev, getNext, getFirstVisible, getLastVisible, onChange) {
-    const keyDownKeyFunctions = useMemo(() => {
-        return {
-            ArrowDown: getNext,
-            ArrowUp: getPrev,
-            Home: getFirstVisible,
-            End: getLastVisible
-        };
-    }, [getNext, getPrev, getFirstVisible, getLastVisible]);
-    const onKeyDown = useCallback((event) => {
-        if (onChange) {
-            // TODO: support horizontal layout on icon menu (left/right arrow key)
-            const keyFunction = keyDownKeyFunctions[event.key];
-            if (keyFunction && !event.shiftKey) {
-                const key = keyFunction();
-                if (key) {
-                    onChange({ key, reason: 'keyboard' });
-                }
-                event.preventDefault();
-            }
-        }
-    }, [onChange, keyDownKeyFunctions]);
-    const currentKeyProps = onChange == null ? {} : { onKeyDown };
-    return { currentKeyProps };
-}
-
-/**
- * @license
- * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
- * Licensed under The Universal Permissive License (UPL), Version 1.0
- * as shown at https://oss.oracle.com/licenses/upl/
- * @ignore
- */
-/**
- * Context used to pass menu information without having to pass it to menu children props.
- * We want to communicate information down to any interested menu item children.
- */
-const MenuContext = createContext({
-    isMobile: false,
-    onClose: () => null,
-    testId: ''
-});
-
-/**
- * @license
- * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
- * Licensed under The Universal Permissive License (UPL), Version 1.0
- * as shown at https://oss.oracle.com/licenses/upl/
- * @ignore
- */
-/**
- * Utility hook for consuming the MenuContext
- *
- * @returns The value of MenuContext provider
- */
-function useMenuContext() {
-    return useContext(MenuContext);
-}
-
-/**
- * @license
- * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
- * Licensed under The Universal Permissive License (UPL), Version 1.0
- * as shown at https://oss.oracle.com/licenses/upl/
- * @ignore
- */
-/**
- * Context used to pass menu information without having to pass it to menu children MenuContainerContextprops.
- * We want to communicate information down to any interested menu item children.
- */
-const MenuContainerContext = createContext({
-    menuContainerRef: { current: null },
-    currentKey: undefined,
-    showFocusRing: false,
-    changeKey: () => { },
-    isContainerFocused: false,
-    menuContainerGeneralInformation: {
-        current: {
-            wasMouseMoved: false,
-            lastMouseLeaveMenuItemdRelatedTarget: null
-        }
-    }
-});
-
-/*Component where general behavior is handled. Here we controled focus behavior, focus styling, submenu
-opening behavior and current active item behavior. */
-const MenuContainer = ({ children, 'aria-label': ariaLabel, currentFocus = 'menu', display, closeSubmenu, menuId, menuLevel, anchorRef }) => {
-    const { onClose, testId } = useMenuContext();
-    //Important to know direction so closeSubmenu is handled properly if needed.
-    const { direction } = useUser();
-    const menuContainerRef = useRef(null);
-    /*We share same behavior as legacy menu on mouseLeave that is:
-    1. If we mouse leave a menuItem but we still on menuContainer and we are not hovering any other menuItem, we keep
-    the focus on the menuItem and hovering style.
-    2. If we mouseLeave but next target is a submenu we open a submenu.
-    3. If we mouseLeave the container and next target is not a submenu, we reset current key and set the focus on the
-    menuContainer.If we mouseLeaved a submenuItem, submenu is closed.
-    General information used by menuItems:
-    -wasMouseMoved: Used to don't allow mouseEnter callbacks being triggered if mouse was not moved already.
-    -lastMouseLeaveValidatedRelatedTarget: We use bubbling nature of events to first check/validate the related target in onMouseLeave events of
-      menuItems. For menuItems we check if the related target is the menuContainer itself or a submenu. We validate there
-      since at this level we don't have access to any submenu. Everytime mouseEnter triggers at menuContainer we have to compare if both
-      relatedTargets are the same(menuContainer and last menuItem one), if not, this means mouse is now outside of the container.
-    */
-    const menuContainerGeneralInformation = useRef({
-        wasMouseMoved: false,
-        lastMouseLeaveMenuItemdRelatedTarget: null,
-        lastChangeKeyReason: undefined
-    });
-    //Key of the active element on this menu container
-    const [currentKey, setCurrentKey] = useState();
-    //State that represents if focused outline styles needs
-    const [showFocusRing, setShowFocusRing] = useState(false);
-    //Based on this we would include or not hovering styling. Same as legacy
-    const [isContainerFocused, setIsContainerFocused] = useState(false);
-    //Funtion triggered on blur. This is called since if focus is not anymore on the container we would need to do
-    //some validation
-    const blurFunction = () => {
-        if (!menuContainerRef.current?.contains(document.activeElement)) {
-            setShowFocusRing(false);
-            setIsContainerFocused(false);
-        }
-    };
-    const focusFunction = () => {
-        // We do this to don't have menu item with "hover" style even if particular item is focused
-        if (menuContainerGeneralInformation.current.lastChangeKeyReason === 'touch') {
-            setIsContainerFocused(false);
-        }
-        else {
-            setIsContainerFocused(true);
-        }
-    };
-    const mouseLeaveFunction = (e) => {
-        //We have to validate if new hover target was already validated correctly, if not this means mouse is now outside container
-        if (!e.relatedTarget ||
-            !e.relatedTarget.isEqualNode(menuContainerGeneralInformation.current.lastMouseLeaveMenuItemdRelatedTarget)) {
-            //We reset current key when mouse is outside the container or any submenu. This is how legacy menu works
-            changeKey({
-                key: undefined,
-                reason: 'mouseEnter'
-            });
-            //We focus menuContainer so keyboard navigation can be still used
-            menuContainerRef.current?.focus();
-        }
-    };
-    //Function used to change the currentKey
-    const changeKey = useCallback((detail) => {
-        menuContainerGeneralInformation.current.lastChangeKeyReason = detail.reason;
-        setCurrentKey(detail.key);
-        if (detail.reason === 'keyboard') {
-            setShowFocusRing(true);
-        }
-        else {
-            setShowFocusRing(false);
-        }
-    }, []);
-    //This is used since if mouse overlaps space when menu is rendered, menuItem could trigger menuEnter,
-    // which is not desirable.Once mouse was moved inside container, we could trigger mouseEnter events normally.
-    const selfDestructiveMouseMoveEvent = useCallback(() => {
-        const handler = (e) => {
-            const keyElem = keyElemExtractor(e.target);
-            const key = keyElem?.key;
-            const elem = keyElem?.elem;
-            //We will trigger this event until a menuItem is found. Usually this don't take to much to happen
-            if (key && elem) {
-                menuContainerGeneralInformation.current.wasMouseMoved = true;
-                const evt = new MouseEvent('mouseenter');
-                elem.dispatchEvent(evt);
-                menuContainerRef.current?.removeEventListener('mousemove', handler);
-            }
-        };
-        menuContainerRef.current?.addEventListener('mousemove', handler);
-    }, []);
-    const { currentKeyProps } = useMenuCurrentKey(getPrevNext(menuContainerRef.current, true, currentKey), getPrevNext(menuContainerRef.current, false, currentKey), () => getNVisible(menuContainerRef.current, 0), () => getLastVisible(menuContainerRef.current), changeKey);
-    useEffect(() => {
-        const menuContainer = menuContainerRef.current;
-        let timer;
-        /*TODO: There are some cases where is not safe to focus since
-        visibility initially is hidden at the Floating component at the initial render. Need a way to solve this in a
-        less dirty way (we are now using timeouts). More details on the descripton of JET-57353 */
-        if (currentFocus !== 'none' && menuContainer) {
-            if (currentFocus === 'menu') {
-                changeKey({ key: undefined, reason: 'click' });
-                const focusMenuContainer = () => {
-                    menuContainer.focus();
-                };
-                if (display === 'sheet') {
-                    focusMenuContainer();
-                }
-                else {
-                    focusMenuContainer();
-                }
-            }
-            else if (currentFocus === 'firstItem') {
-                const firstItem = getNVisible(menuContainerRef.current, 0);
-                if (firstItem) {
-                    changeKey({ key: firstItem, reason: 'keyboard' });
-                }
-            }
-            else if (currentFocus === 'secondItem') {
-                //This is just used in sheet menu, so no need to set a timeout
-                const item = getNVisible(menuContainerRef.current, 1);
-                if (item) {
-                    changeKey({ key: item, reason: 'keyboard' });
-                }
-            }
-            else if (currentFocus === 'secondItemDueToTouch') {
-                // We added this currentFocus value because we need to focus second item on sheet menu. Second item is same but using keyboard
-                const item = getNVisible(menuContainerRef.current, 1);
-                if (item) {
-                    changeKey({ key: item, reason: 'touch' });
-                }
-            }
-        }
-        return () => {
-            //We have to clean timers, because comp can be unmounted after finishing timeouts
-            clearTimeout(timer);
-        };
-    }, [changeKey, currentFocus, menuLevel, display, anchorRef]); // Important to notice we look for a change on the ref object, not it's current value
-    useEffect(() => {
-        selfDestructiveMouseMoveEvent();
-    }, [selfDestructiveMouseMoveEvent]);
-    const testIdProps = useTestId(testId);
-    return (jsx("div", { ...(menuId && { id: menuId }), ref: menuContainerRef, tabIndex: !currentKey && (menuLevel === 'main' || display === 'sheet') ? 0 : -1, role: "menu", "aria-label": ariaLabel, class: classNames([menuStyles.menuContainerStyle]), ...mergeProps(currentKeyProps, getKeyboardCloseProps(onClose, menuLevel), getCloseSubmenuEvent(direction, closeSubmenu), getMenuContainerFocusMethods(blurFunction, focusFunction), getMenuContainerMouseLeave(mouseLeaveFunction), getMenuPointerDown()), ...testIdProps, children: jsx(MenuContainerContext.Provider, { value: {
-                /*We use this ref on dropdownSubmenu since unhover only close the menu if menuContainer ref does not include
-                the new element that receives the hovering */
-                menuContainerRef,
-                currentKey,
-                showFocusRing,
-                changeKey,
-                menuContainerGeneralInformation,
-                isContainerFocused
-            }, children: children }) }));
-};
-
-// TODO: Would be good to share a skeleton container among multiple components. JET-73171
-function MenuSkeletonContainer({ children }) {
-    const { baseTheme } = useComponentTheme(MenuItemRedwoodTheme);
-    const containerClasses = classNames([baseTheme, menuSkeletonStyles.container]);
-    return (jsx("div", { "oj-menu-skeleton": "true", class: containerClasses, role: "presentation", children: [...Array(4)].map((_element, index) => children?.(index)) }));
-}
-const MenuSkeleton = () => {
-    useEffect(() => {
-        setTimeout(() => {
-            setIsVisible(true);
-        }, timerValue);
-    }, []);
-    const [isVisible, setIsVisible] = useState(false);
-    const translations = useTranslationBundle('@oracle/oraclejet-preact');
-    // We keep the flex container even in the first 50ms so dropdown keeps the same size since the beginning
-    return (jsxs(Fragment, { children: [isVisible && jsx(LiveRegion, { children: translations.menu_stateLoading() }), jsx(MenuSkeletonContainer, { children: () => {
-                    return (jsx(Flex, { height: "11x", align: "center", children: isVisible && jsx(Skeleton, { height: "4x" }) }));
-                } })] }));
-};
-/**
- * Allows to specify the time delay for rendering the component
- **/
-const timerValue = 50;
-
-//TODO: Start consuming PRIVATE_Dropdown. JET-53371
-/*Component used to render a dropdown menu. For now this is just rendered when device is not a phone. */
-const DropdownMenu = forwardRef(({ anchorRef, defaultPlacement, offsetValue, closeSubmenu, children, 'aria-label': ariaLabel, currentFocus, menuId, menuLevel, flipOptions, isOpen, isMenuLoading = false, minWidth }, ref) => {
-    const { onClose } = useMenuContext();
-    const outsideMousedownHandler = useCallback$1((e) => {
-        if (menuLevel === 'sub')
-            return;
-        // Outside click is not considered when menuItem was clicked
-        if (e.reason === 'outsideMousedown') {
-            const menuItemKey = keyElemExtractor(e.target)?.key;
-            if (!menuItemKey) {
-                const isAnchorClick = anchorRef.current?.contains?.(e.target) ||
-                    anchorRef.current?.[UNSAFE_DOM_ACCESS]?.contains(e.target);
-                onClose?.({ reason: isAnchorClick ? 'anchorClick' : 'outsideClick' });
-            }
-        }
-    }, [onClose, menuLevel]);
-    // TODO - Reuse a dropdown component instead of creating floating by ourselves.
-    /*
-    For this comment, we could divide menus in these categories:
-    - Dropdown menus: "Attached" to an specific element.
-    - Context menus: "Attached" to coords or an specific element.
-    We are passing anchorRef as the logicalParent of the Layer used here, even if we pass coords. So we could say
-    that we are passing an incorrect logicalParentRef for context menus. But, passing coords has no impacts either on
-    accessibility or behavior since this logical parent is only used by legacy collections for dom searching to find
-    dropdown menus. More information about that here: 
-    This comment also applies for sheet menus that in this specific context(relation between logicalParentRef
-    and menu) can be considered "dropdown menus"
-    For now using type assertion is safe enough, but it's kind of a dirty solution. This is a point that can be included
-    in near future conversation related to semantics of menus in favor of dividing dropdown and context menu:
-    
-    */
-    return (jsx(Dropdown, { minWidth: minWidth ? Math.max(DEFAULT_MENU_MIN_WIDTH, minWidth) : DEFAULT_MENU_MIN_WIDTH, onClose: outsideMousedownHandler, isOpen: isOpen, placement: defaultPlacement, anchorRef: anchorRef, flipOptions: flipOptions, offset: offsetValue, shiftOptions: {
-            mainAxis: true,
-            crossAxis: true
-        }, sizeOptions: { isMaxWidthAdjusted: true, isMaxHeightAdjusted: true, maxWidthCeiling: 460 }, children: jsx("div", { class: classNames([dropdownMenuStyles.base, menuStyles.dropdownMenuContainerStyle]), ref: ref, children: isMenuLoading ? (jsx(MenuSkeleton, {})) : (jsx(MenuContainer, { menuLevel: menuLevel, closeSubmenu: closeSubmenu, "aria-label": ariaLabel, currentFocus: currentFocus, menuId: menuId, display: "dropdown", anchorRef: anchorRef, children: children })) }) }));
-});
-const DEFAULT_MENU_MIN_WIDTH = 140;
-
-const isMobile = getIsMobile();
-// TODO: For context menu case anchorRef is changed typically when trying to opening menu in other place
-// menu initialFocus prop should react also when anchorRef is changed not just when isOpen is changed to true.
-/* Component that is exposed to final user to create a menu. Important to notice that this component is just used by
-the final user to express a main menu. It's not reused by us for submenus (we use SheetMenu and DropdownMenu directly there) */
-const Menu = ({ onClose, isOpen, testId, initialFocus = 'menu', placement, offsetValue, minWidthBehavior, anchorRef, flipOptions, ...menuProps }) => {
-    const sheetDismissHandler = useCallback(() => {
-        onClose?.({ reason: 'dismissed' });
-    }, [onClose]);
-    const isMenuLoading = isMenuChildrenFalsy(menuProps.children);
-    const menuCurrentFocus = isMenuLoading ? 'none' : initialFocus;
-    const [anchorWidth, setAnchorWidth] = useState();
-    useEffect(() => {
-        if (isOpen && minWidthBehavior === 'basedOnAnchorWidth') {
-            const obtainedAnchorWidth = anchorRef.current?.offsetWidth ||
-                anchorRef.current?.[UNSAFE_DOM_ACCESS]?.offsetWidth;
-            if (anchorWidth !== obtainedAnchorWidth) {
-                setAnchorWidth(obtainedAnchorWidth);
-            }
-        }
-    }, [isOpen, minWidthBehavior, anchorWidth]);
-    return (jsx(MenuContext.Provider, { value: { onClose, isMobile, testId }, children: jsx(Fragment, { children: isMobile ? (jsx(Fragment, { children: jsx(Sheet, { isOpen: isOpen, onClose: sheetDismissHandler, children: jsx("div", { class: classNames([menuStyles.sheetMenuContainerStyle]), children: isMenuLoading ? (jsx(MenuSkeleton, {})) : (jsx(MenuContainer, { ...menuProps, anchorRef: anchorRef, currentFocus: menuCurrentFocus, menuLevel: "main", display: "sheet" })) }) }) })) : (jsx(DropdownMenu, { ...menuProps, anchorRef: anchorRef, isMenuLoading: isMenuLoading, isOpen: isOpen, currentFocus: menuCurrentFocus, menuLevel: "main", defaultPlacement: placement, offsetValue: offsetValue, flipOptions: flipOptions || {
-                    crossAxis: true,
-                    mainAxis: true,
-                    fallbackPlacements: [
-                        'bottom-start',
-                        'bottom-end',
-                        'top-start',
-                        'top-end',
-                        'end-top',
-                        'start-top',
-                        'end-bottom',
-                        'start-bottom'
-                    ]
-                }, minWidth: anchorWidth })) }) }));
-};
-
-/**
- * @license
- * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
- * Licensed under The Universal Permissive License (UPL), Version 1.0
- * as shown at https://oss.oracle.com/licenses/upl/
- * @ignore
- */
-/**
- * Utility hook for consuming the MenuContainerContext
- *
- * @returns The value of MenuContainerContext provider
- */
-function useMenuContainerContext() {
-    return useContext(MenuContainerContext);
-}
-
-/**
- * Returns listeners and status for hover
- *
- *
- * @returns
- */
-function useSubmenuItemHover(settings) {
-    const { bool: ignore, setTrue: setIgnoreTrue, setFalse: setIgnoreFalse } = useToggle(false);
-    const startHover = (e) => {
-        if (ignore) {
-            setIgnoreFalse();
-        }
-        else {
-            settings.onMouseEnter(e);
-        }
-    };
-    const hoverProps = {
-        ontouchend: setIgnoreTrue,
-        onMouseEnter: startHover,
-        onMouseLeave: (e) => {
-            settings.onMouseLeave(e);
-        }
-    };
-    return {
-        hoverProps: hoverProps
-    };
-}
-
-function MenuItem(props) {
-    const uniqueID = useId();
-    const id = useMemo(() => `oj-menu-item-${uniqueID}`, [uniqueID]);
-    return jsx(BaseMenuItem, { ...props, role: "menuitem", type: "simple", id: id });
-}
-//TODO: We have to comeback to this and see if we create new components to represent different types on menuItems
-//instead of using type prop. It also includes a new definition on prop types. This also includes the exposing of id
-//that is used by submenus. JET-57191
-const BaseMenuItem = forwardRef(({ id, label, onAction, startIcon, endIcon, role, isChecked, isDisabled = false, variant = 'standard', type, hoverInfo, openSubmenu, menuItemLabelWeight = 'normal', isSubmenuOpen, submenuId, submenuRef, itemKey, keyboardShortcut }, ref) => {
-    const { onClose } = useMenuContext();
-    const { currentKey, changeKey, showFocusRing, menuContainerRef, menuContainerGeneralInformation, isContainerFocused } = useMenuContainerContext();
-    const menuItemRef = useRef(null);
-    useImperativeHandle(ref, () => menuItemRef.current, []);
-    const { direction } = useUser();
-    const isCurrent = currentKey === id;
-    const handleItemSelection = useCallback((e) => {
-        //We don't want to close the menu if the element is a submenu one
-        if (type !== 'submenu') {
-            onClose?.({ reason: 'itemAction' });
-        }
-        onAction?.(e);
-    }, [type, onClose, onAction]);
-    /*This hook is not used to just know is something is hover or not. Actual callbacks are run when mouse enter
-    or leave the menu item (to focus items when hovering and open submenus if the item is a submenu).  We don't use
-    useInteractionStyle hook for hovering since "hovering style" is more of a "focus" style in this context */
-    const { hoverProps } = useSubmenuItemHover({
-        onMouseEnter: (e) => {
-            if (!(hoverInfo?.hoverStatus.current.recentClose ||
-                hoverInfo?.hoverStatus.current.pendingUnhover)) {
-                if (hoverInfo && menuContainerGeneralInformation.current.wasMouseMoved) {
-                    hoverInfo.hoverStatus.current.pendingUnhover = true;
-                }
-                // Mouse needs to be already moved to trigger mouse enter event
-                if (menuContainerGeneralInformation.current.wasMouseMoved) {
-                    hoverInfo?.hoverProps['onMouseEnter'](e);
-                    changeKey({
-                        key: id,
-                        reason: 'mouseEnter'
-                    });
-                }
-            }
-        },
-        onMouseLeave: (e) => {
-            if (hoverInfo) {
-                hoverInfo.hoverStatus.current.pendingUnhover = false;
-            }
-            //We check if new hover element is part of the menuContainer or submenu is there is one
-            if (menuContainerRef.current?.contains(e.relatedTarget) ||
-                // We need to check for submenu parent element (dropdown)
-                submenuRef?.current?.parentElement?.contains(e.relatedTarget)) {
-                menuContainerGeneralInformation.current.lastMouseLeaveMenuItemdRelatedTarget =
-                    e.relatedTarget;
-            }
-        }
-    });
-    // Returning an empty handler instead of disable option since we need to prevent default behavior when using space key
-    const { pressProps } = usePress(isDisabled ? () => { } : handleItemSelection);
-    useLayoutEffect(() => {
-        if (isCurrent) {
-            menuItemRef.current?.focus();
-        }
-    }, [isCurrent]);
-    const { interactionProps } = useInteractionStyle({ isDisabled });
-    const { classes: menuItemContainerClasses, styles: { iconLabelContainer, iconContainer, startIconContainer, labelContainer, endIconContainer } } = useComponentTheme(MenuItemRedwoodTheme, {
-        current: isCurrent ? 'isCurrent' : 'notCurrent',
-        focusRing: showFocusRing ? 'isFocusRing' : 'notFocusRing',
-        variant: isDisabled ? 'disabled' : variant,
-        containerFocused: isContainerFocused ? 'isContainerFocused' : 'notContainerFocused',
-        submenuOpen: !!isSubmenuOpen ? 'isSubmenuOpen' : 'notSubmenuOpen'
-    });
-    const flexItemStyleInterpolations = mergeInterpolations([
-        ...Object.values(flexitemInterpolations)
-    ]);
-    const { class: labelContainerFlexItemClasses, ...labelContainerFlexItemStyles } = flexItemStyleInterpolations({
-        flex: '1 1 auto',
-        alignSelf: 'center'
-    });
-    const { class: iconContainerFlexItemClasses, ...iconContainerFlexItemStyles } = flexItemStyleInterpolations({
-        flex: '0 0 auto',
-        alignSelf: 'center'
-    });
-    const startIconContainerClasses = classNames([
-        iconContainerFlexItemClasses,
-        iconLabelContainer,
-        iconContainer,
-        startIconContainer
-    ]);
-    const labelContainerClasses = classNames([
-        labelContainerFlexItemClasses,
-        iconLabelContainer,
-        labelContainer
-    ]);
-    const endIconContainerClasses = classNames([
-        iconContainerFlexItemClasses,
-        iconLabelContainer,
-        iconContainer,
-        endIconContainer
-    ]);
-    return (jsx("div", { role: "presentation", children: jsxs("a", { ...(submenuId !== undefined && type === 'submenu' && { 'aria-owns': submenuId }), ref: menuItemRef, "data-oj-label": label, "data-oj-key": itemKey, class: menuItemContainerClasses, ...mergeProps(interactionProps, hoverProps, pressProps, getOpenSubmenuEvent(direction, openSubmenu), getMenuItemClickChangeKey(id, changeKey)), role: role, "data-oj-menu-item-key": id, ...(type === 'submenu' && {
-                'aria-haspopup': true,
-                'aria-expanded': menuItemLabelWeight === 'bold' || !!isSubmenuOpen
-            }), ...(isDisabled && { 'aria-disabled': true }), ...(type === 'select' && { 'aria-checked': !!isChecked }), tabIndex: isCurrent ? 0 : -1, children: [startIcon && (jsx("span", { style: iconContainerFlexItemStyles, class: startIconContainerClasses, children: startIcon })), jsx("span", { style: labelContainerFlexItemStyles, class: labelContainerClasses, children: jsx(Text, { variant: "inherit", size: "md", weight: menuItemLabelWeight, children: label }) }), (endIcon || keyboardShortcut) && (jsx("span", { style: iconContainerFlexItemStyles, class: endIconContainerClasses, children: endIcon || (jsx(Text, { variant: "inherit", size: "md", weight: "normal", children: keyboardShortcut })) }))] }) }));
-});
-
-/**
- * @license
- * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
- * Licensed under The Universal Permissive License (UPL), Version 1.0
- * as shown at https://oss.oracle.com/licenses/upl/
- * @ignore
- */
-const SelectMenuGroupContext = createContext({
-    isMultiple: false
-});
-
-export { BaseMenuItem as B, DropdownMenu as D, Menu as M, SelectMenuGroupContext as S, MenuItem as a, useMenuContext as b, MenuContainer as c, useMenuContainerContext as u };
-//# sourceMappingURL=SelectMenuGroupContext-aa1fe822.js.map