@wix/editor-react-components 1.2153.0

package/dist/site/components/Menu/component.preview.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+import { EditorElement } from '@wix/component-protocol/schema';
+import { default as Menu } from './component';
+declare const _default: (props: React.ComponentProps<typeof Menu>) => React.JSX.Element;
+export default _default;
+export interface ManifestOverrideGetters {
+    getCurrentProps: (innerElementPath?: Array<string>) => Record<string, any>;
+    getCurrentStyles: (innerElementPath?: Array<string>) => Record<string, any>;
+    getCurrentPreset: () => string;
+}
+export declare function resolveManifestOverrides({ getCurrentPreset, getCurrentProps, getCurrentStyles, }: ManifestOverrideGetters): Partial<EditorElement>;

package/dist/site/components/Menu/components/Dropdown/Dropdown.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+import { DropdownProps } from '../../Menu.types';
+export declare const Dropdown: React.ForwardRefExoticComponent<DropdownProps & React.RefAttributes<HTMLDivElement | null>>;

package/dist/site/components/Menu/components/Dropdown/DropdownWrapper.d.ts

@@ -0,0 +1,11 @@
+import { PropsWithChildren, default as React } from 'react';
+import { MenuOrientationType } from '../../constants';
+type DropdownWrapperProps = PropsWithChildren<{
+    id: string;
+    menuOrientation?: MenuOrientationType;
+    childrenWrapperClassName?: string;
+    dataAttributes?: any;
+    className?: string;
+}>;
+export declare const DropdownWrapper: React.FC<DropdownWrapperProps>;
+export {};

package/dist/site/components/Menu/components/Dropdown/index.d.ts

@@ -0,0 +1 @@
+export * from './Dropdown';

package/dist/site/components/Menu/components/Hamburger/Hamburger.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+import { MenuProps, MenuStates } from '../../Menu.types';
+export declare const HamburgerMenu: React.FC<MenuProps & MenuStates>;

package/dist/site/components/Menu/components/Hamburger/index.d.ts

@@ -0,0 +1 @@
+export * from './Hamburger';

package/dist/site/components/Menu/components/MenuContent/MenuContent.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { IMenuContentProps } from '../../Menu.types';
+declare const MenuContent: React.FC<IMenuContentProps>;
+export default MenuContent;

package/dist/site/components/Menu/components/MenuContent/MenuItem/MenuItem.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+import { IMenuItemProps } from '../../../Menu.types';
+export declare const MenuItem: React.FC<IMenuItemProps>;

package/dist/site/components/Menu/components/MenuContent/MenuItem/MenuItemDropdownIcon.d.ts

@@ -0,0 +1,15 @@
+import { default as React } from 'react';
+export interface IMenuItemDropdownIconProps {
+    chevronButtonRef: React.RefObject<HTMLButtonElement>;
+    onClick: () => void;
+    isOpen: boolean;
+    hasSubItems: boolean;
+    hasContainer: boolean;
+    hasLink: boolean;
+    isDropdownIconOpen: boolean;
+    className?: string;
+    ariaLabel?: string;
+    srOnly: boolean;
+    submenuToggleId?: string;
+}
+export declare const MenuItemDropdownIcon: React.FC<IMenuItemDropdownIconProps>;

package/dist/site/components/Menu/components/MenuContent/MenuItem/MenuItemLabel.d.ts

@@ -0,0 +1,14 @@
+import { default as React } from 'react';
+import { IMenuItemProps } from '../../../Menu.types';
+import { DropdownAnimationNameType } from '../../../constants';
+import { AnimationState } from './useAnimationState';
+export declare const MenuItemLabel: React.FC<IMenuItemProps & {
+    hasDropdownMenu: boolean;
+    hasSubItems: boolean;
+    hasContainer: boolean;
+    chevronButtonRef: any;
+    toggleDropdown: () => void;
+    isOpen: boolean;
+    dropdownAnimationState: AnimationState<DropdownAnimationNameType>;
+    submenuToggleId?: string;
+}>;

package/dist/site/components/Menu/components/MenuContent/MenuItem/updateDropdownDomStyles.d.ts

@@ -0,0 +1,4 @@
+export declare const getWixBannerHeight: () => number;
+export declare const calculateShadowMargin: (dropdownEl: HTMLElement) => number;
+export declare const updateDropdownDomStyles: (itemEl: HTMLElement | null, wasHiddenBefore?: boolean) => void;
+export declare const resetDropdownDomStyles: (itemEl?: HTMLElement) => void;

package/dist/site/components/Menu/components/MenuContent/MenuItem/useAnimationState.d.ts

@@ -0,0 +1,24 @@
+export declare const DISABLED_ANIMATION_NAME = "none";
+export declare const AnimationPhase: {
+    readonly Enter: "enter";
+    readonly EnterActive: "enterActive";
+    readonly EnterDone: "enterDone";
+    readonly Exit: "exit";
+    readonly ExitActive: "exitActive";
+    readonly ExitDone: "exitDone";
+};
+export type AnimationPhaseType = (typeof AnimationPhase)[keyof typeof AnimationPhase];
+export type AnimationState<AnimationNameType extends string> = {
+    name: AnimationNameType;
+    phase?: AnimationPhaseType;
+};
+type AnimationConfig = {
+    duration: number;
+};
+export declare const useAnimationState: <AnimationNameType extends string>(animationConfigMap: Record<AnimationNameType, AnimationConfig>, initialAnimationState: AnimationState<AnimationNameType>) => {
+    animationState: AnimationState<AnimationNameType>;
+    initEnterAnimation: (animationName: AnimationNameType, onAnimationDone?: () => void) => void;
+    initExitAnimation: (animationName: AnimationNameType, onAnimationDone?: () => void) => void;
+    skipToEnterDone: (animationName: AnimationNameType) => void;
+};
+export {};

package/dist/site/components/Menu/components/MenuContent/MenuItem/useDropdown.d.ts

@@ -0,0 +1,16 @@
+import { DropdownAnimationNameType, MenuAnimationNameType } from '../../../constants';
+type UseDropdownProps = {
+    itemRef: React.MutableRefObject<HTMLLIElement | null>;
+    forceOpen: boolean;
+    getAnimationPackage: () => MenuAnimationNameType;
+};
+export declare const useDropdown: ({ itemRef, forceOpen, getAnimationPackage, }: UseDropdownProps) => {
+    isOpen: boolean;
+    dropdownAnimationState: import('./useAnimationState').AnimationState<DropdownAnimationNameType>;
+    showDropdown: () => void;
+    showDropdownImmediate: () => void;
+    hideDropdown: () => void;
+    toggleDropdown: () => void;
+    updateDropdownDomStyles: () => void;
+};
+export {};

package/dist/site/components/Menu/components/MenuContent/MenuItem/utils.d.ts

@@ -0,0 +1,26 @@
+import { default as React } from 'react';
+import { IMenuItemSDKAction } from '../../../../../../common/sdk/props-factories/menuItemsPropsSDKFactory';
+import { IMenuItemProps } from '../../../Menu.types';
+import { DropdownAnimationNameType, MenuAnimationNameType, MenuOrientationType, MenuVerticalDropdownDisplayType } from '../../../constants';
+import { AnimationState } from './useAnimationState';
+export declare const createSDKAction: (item: Omit<IMenuItemProps['item'], 'children'>, selected: boolean, sdkAction?: IMenuItemSDKAction) => ((e: React.MouseEvent) => void) | undefined;
+export declare const getMenuOrientation: (itemRef: React.RefObject<HTMLLIElement>) => MenuOrientationType | undefined;
+export declare const getVerticalDropdownDispaly: (itemRef: React.RefObject<HTMLLIElement>) => MenuVerticalDropdownDisplayType | undefined;
+export declare const getIsAlwaysOpen: (itemRef: React.RefObject<HTMLLIElement>) => boolean;
+type CreateEventListenersOptions = {
+    showDropdown: () => void;
+    hideDropdown: () => void;
+    itemRef: React.RefObject<HTMLLIElement>;
+    getMenuItemAnimationName: () => MenuAnimationNameType;
+    initEnterAnimation: (animationName: MenuAnimationNameType) => void;
+    initExitAnimation: (animationName: MenuAnimationNameType, onAnimationDone?: () => void) => void;
+    isOpen: boolean;
+    hasLink: boolean;
+    dropdownAnimationState: AnimationState<DropdownAnimationNameType>;
+};
+export declare const createEventListeners: ({ showDropdown, hideDropdown, itemRef, getMenuItemAnimationName, initEnterAnimation, initExitAnimation, isOpen, hasLink, dropdownAnimationState, }: CreateEventListenersOptions) => {
+    onMouseEnter: () => void;
+    onMouseLeave: () => void;
+    onBlur: (event: React.FocusEvent) => void;
+};
+export {};

package/dist/site/components/Menu/components/MenuContent/Scroll/scrollTo.d.ts

@@ -0,0 +1 @@
+export declare const scrollTo: (element: HTMLElement, moveTo: number) => void;

package/dist/site/components/Menu/components/MenuContent/Scroll/useScroll.d.ts

@@ -0,0 +1,9 @@
+export declare const useScroll: (ref: React.RefObject<HTMLElement>) => {
+    isScrollable: boolean;
+    updateScrollState: import('../../../../../../utils/performanceUtils').DebouncedFn;
+    handleOnScroll: () => void;
+    handleScrollForward: () => void;
+    handleScrollBackward: () => void;
+    isScrollBackwardButtonVisible: boolean;
+    isScrollForwardButtonVisible: boolean;
+};

package/dist/site/components/Menu/components/MenuContent/Scroll/utils.d.ts

@@ -0,0 +1,7 @@
+export declare const rootLevelMenuItemSelector: string;
+export declare const scrollPageButtonSelector = "[data-menu-scroll-action=\"page\"]";
+export declare const MINIMAL_IMPORTANT_SCROLL_DISTANCE = 15;
+export declare const scrollMenu: (menuNode: HTMLElement, direction: 'forward' | 'backward') => void;
+export declare const scrollMenuRight: (menuNode: HTMLElement) => void;
+export declare const scrollMenuLeft: (menuNode: HTMLElement) => void;
+export declare const scrollToMenuItem: (menuNode: HTMLElement, menuItem: HTMLElement, nextItem?: HTMLElement) => void;

package/dist/site/components/Menu/components/MenuContent/ScrollButton/ScrollButton.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { ScrollButtonProps } from '../../../Menu.types';
+declare const ScrollButton: React.FC<ScrollButtonProps>;
+export default ScrollButton;

package/dist/site/components/Menu/components/MenuContent/ScrollControls/ScrollControls.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+import { ScrollControlsProps } from '../../../Menu.types';
+export declare const ScrollControls: React.FC<ScrollControlsProps>;

package/dist/site/components/Menu/components/MenuContent/assets/DropdownIcon.d.ts

@@ -0,0 +1,2 @@
+import { default as React } from 'react';
+export declare const DropdownIcon: (props: React.SVGProps<SVGSVGElement>) => React.JSX.Element;

package/dist/site/components/Menu/components/Navbar/Navbar.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+import { NavbarProps } from '../../Menu.types';
+export declare const NavbarMenu: React.FC<NavbarProps>;

package/dist/site/components/Menu/components/Navbar/index.d.ts

@@ -0,0 +1 @@
+export * from './Navbar';

package/dist/site/components/Menu/components/Submenu/Submenu.d.ts

@@ -0,0 +1,4 @@
+import { SubmenuProps } from './types';
+import * as React from 'react';
+declare const Submenu: React.FC<SubmenuProps>;
+export default Submenu;

package/dist/site/components/Menu/components/Submenu/constants.d.ts

@@ -0,0 +1,9 @@
+export declare const TestIds: {
+    itemLabel: string;
+    subItemLabel: string;
+    rootLevelListItem: string;
+};
+export declare const DataHooks: {
+    readonly submenu: "submenu";
+};
+export declare const INNER_FOCUS_RING_CLASSNAME = "has-inner-focus-ring";

package/dist/site/components/Menu/components/Submenu/types.d.ts

@@ -0,0 +1,22 @@
+import { IMenuItemSDKAction } from '../../../../../common/sdk/props-factories/menuItemsPropsSDKFactory';
+export type SubmenuItemState = 'regular' | 'hover' | 'selected';
+export type SubmenuPreviewStateMap = {
+    item?: SubmenuItemState;
+    'sub-item'?: SubmenuItemState;
+};
+export type SubmenuPreviewMapperProps = {
+    partToPreviewStateMap?: SubmenuPreviewStateMap | null;
+};
+type SubmenuBaseProps = {
+    id?: string;
+    className?: string;
+    customClassNames?: Array<string>;
+    containerRootClassName?: string;
+    containerProps?: any;
+    onItemClick?: IMenuItemSDKAction;
+    onItemMouseIn?: IMenuItemSDKAction;
+    onItemMouseOut?: IMenuItemSDKAction;
+    onItemDblClick?: IMenuItemSDKAction;
+};
+export type SubmenuProps = SubmenuBaseProps & SubmenuPreviewMapperProps;
+export {};

package/dist/site/components/Menu/constants.d.ts

@@ -0,0 +1,330 @@
+export declare const MenuOrientation: {
+    readonly Horizontal: "horizontal";
+    readonly Vertical: "vertical";
+};
+export type MenuOrientationType = (typeof MenuOrientation)[keyof typeof MenuOrientation];
+export declare const VerticalDropdownDisplay: {
+    readonly AlwaysOpen: "alwaysOpen";
+    readonly ExpandCollapse: "expandCollapse";
+};
+export type MenuVerticalDropdownDisplayType = (typeof VerticalDropdownDisplay)[keyof typeof VerticalDropdownDisplay];
+export declare const DropdownAnchor: {
+    readonly menuItem: "menuItem";
+    readonly menuStretched: "menuStretched";
+    readonly menuCustomWidth: "menuCustomWidth";
+    readonly screen: "screen";
+};
+export type DropdownAnchorType = (typeof DropdownAnchor)[keyof typeof DropdownAnchor];
+export declare const MenuAnimationName: {
+    readonly None: "none";
+    readonly Calm: "calm";
+    readonly Underline: "underline";
+    readonly Wash: "wash";
+    readonly Bullet: "bullet";
+    readonly Wave: "wave";
+    readonly Bounce: "bounce";
+    readonly Tint: "tint";
+    readonly TextWash: "textWash";
+    readonly Wobble: "wobble";
+    readonly Brackets: "brackets";
+    readonly Float: "float";
+    readonly Shape: "shape";
+    readonly Expand: "expand";
+    readonly Circle: "circle";
+    readonly Shadow: "shadow";
+    readonly LineRise: "lineRise";
+    readonly Overline: "overline";
+    readonly CenterLine: "centerLine";
+    readonly Skew: "skew";
+    readonly Point: "point";
+    readonly Blur: "blur";
+};
+export type MenuAnimationNameType = (typeof MenuAnimationName)[keyof typeof MenuAnimationName];
+export declare const DropdownAnimationName: {
+    readonly None: "none";
+    readonly RevealFromTop: "revealFromTop";
+    readonly FadeIn: "fadeIn";
+};
+export type DropdownAnimationNameType = (typeof DropdownAnimationName)[keyof typeof DropdownAnimationName];
+export declare const HamburgerMenuAnimationName: {
+    readonly None: "none";
+    readonly RevealFromRight: "revealFromRight";
+    readonly FadeIn: "fadeIn";
+};
+export type HamburgerMenuAnimationNameType = (typeof HamburgerMenuAnimationName)[keyof typeof HamburgerMenuAnimationName];
+export declare const DisplayNames: {
+    root: {
+        elementDisplayName: string;
+        actions: {
+            manageMenu: string;
+            design: string;
+            settings: string;
+        };
+        customActions: {
+            format: {
+                displayName: string;
+                panel: {
+                    menu: string;
+                    orientation: string;
+                    overflowItems: {
+                        displayName: string;
+                        infoContent: string;
+                    };
+                    menuTypeOptions: {
+                        navbar: string;
+                        hamburger: string;
+                    };
+                    orientationOptions: {
+                        horizontal: string;
+                        vertical: string;
+                    };
+                    overflowOptions: {
+                        scroll: string;
+                        expandMenu: string;
+                    };
+                };
+            };
+            animatedIcon: {
+                displayName: string;
+            };
+        };
+        presets: {
+            horizontalScrollNavbar: string;
+            horizontalHugNavbar: string;
+            verticalNavbar: string;
+            hamburgerMenu: string;
+        };
+        states: {
+            hamburgerDialog: string;
+            dropdown: string;
+        };
+    };
+    navbar: {
+        elementDisplayName: string;
+        displayGroups: {
+            dividerBorderGroup: string;
+        };
+        cssCustomProperties: {
+            'vertical-dropdown-display': string;
+            'items-width': string;
+            'container-align': string;
+            'menu-items-row-gap': string;
+            'menu-items-column-gap': string;
+        };
+        actions: {
+            manageMenu: string;
+        };
+        options: {
+            alwaysOpen: string;
+            expandCollapse: string;
+            fitToText: string;
+            fillMenu: string;
+            start: string;
+            end: string;
+            top: string;
+            bottom: string;
+        };
+    };
+    item: {
+        elementDisplayName: string;
+        cssProperties: {
+            justifyContent: string;
+            background: string;
+            columnGap: string;
+            'item-icon-size': string;
+        };
+        displayGroups: {
+            iconGroup: string;
+        };
+        states: {
+            hover: string;
+            selected: string;
+        };
+    };
+    dropdown: {
+        elementDisplayName: string;
+        cssCustomProperties: {
+            anchor: string;
+            align: string;
+            'items-width': string;
+            'columns-number': string;
+            'space-above': string;
+            'horizontal-margin': string;
+            'item-position': string;
+        };
+        options: {
+            menuItem: string;
+            menuStretched: string;
+            screen: string;
+            start: string;
+            center: string;
+            end: string;
+            fitToText: string;
+            fillDropdown: string;
+            afterItems: string;
+            beforeItems: string;
+            aboveItems: string;
+            belowItems: string;
+        };
+        displayGroups: {
+            gapGroup: string;
+        };
+    };
+    dropdownItem: {
+        elementDisplayName: string;
+    };
+    dropdownSubItem: {
+        elementDisplayName: string;
+    };
+    scrollButton: {
+        elementDisplayName: string;
+        cssProperties: {
+            background: string;
+        };
+        cssCustomProperties: {
+            'scroll-button-icon-size': string;
+        };
+        displayGroups: {
+            scrollButtonGroup: string;
+        };
+    };
+    hamburgerMenu: {
+        elementDisplayName: string;
+        cssCustomProperties: {
+            'hamburger-wrapper-width': string;
+            'wrapper-position': string;
+            'menu-position': string;
+            'close-button-position': string;
+            'overlay-background': string;
+        };
+        options: {
+            third: string;
+            twoThirds: string;
+            half: string;
+            full: string;
+            start: string;
+            middle: string;
+            end: string;
+            top: string;
+            bottom: string;
+        };
+    };
+    hamburgerOpenButton: {
+        elementDisplayName: string;
+    };
+    hamburgerCloseButton: {
+        elementDisplayName: string;
+    };
+};
+export declare const selectors: {
+    menu: string;
+    navbar: string;
+    item: string;
+    dropdown: string;
+    dropdownItem: string;
+    dropdownSubItem: string;
+    scrollButton: string;
+    hamburgerMenu: string;
+    hamburgerMenuContent: string;
+    hamburgerMenuHeaderContent: string;
+    hamburgerMenuOpenButton: string;
+    hamburgerMenuCloseButton: string;
+};
+export declare const elementKeys: {
+    navbar: string;
+    hamburgerMenu: string;
+    hamburgerOpenButton: string;
+    hamburgerCloseButton: string;
+    item: string;
+    subItem: string;
+    scrollButton: string;
+    dropdown: string;
+};
+export declare const presets: {
+    horizontalScrollNavbar: string;
+    horizontalHugNavbar: string;
+    verticalNavbar: string;
+    hamburgerMenu: string;
+};
+export declare const states: {
+    dropdown: string;
+    hamburgerDialog: string;
+    hamburgerDialogDropdown: string;
+};
+export declare const DesignStates: {
+    readonly item: {
+        readonly hover: {
+            readonly displayName: string;
+            readonly className: "menu__item--hover";
+        };
+        readonly selected: {
+            readonly displayName: string;
+            readonly className: "menu__item--selected";
+        };
+    };
+    readonly dropdownItem: {
+        readonly hover: {
+            readonly displayName: "Hover";
+            readonly className: "menu__dropdown-item--hover";
+        };
+        readonly selected: {
+            readonly displayName: "Selected";
+            readonly className: "menu__dropdown-item--selected";
+        };
+    };
+    readonly dropdownSubItem: {
+        readonly hover: {
+            readonly displayName: "Hover";
+            readonly className: "menu__dropdown-sub-item--hover";
+        };
+        readonly selected: {
+            readonly displayName: "Selected";
+            readonly className: "menu__dropdown-sub-item--selected";
+        };
+    };
+    readonly scrollButton: {
+        readonly hover: {
+            readonly displayName: "Hover";
+            readonly className: "menu__scroll-button--hover";
+        };
+    };
+};
+export declare const DropdownAppliedStyleProperties: {
+    anchor: string;
+};
+export declare const DropdownAnchorPositions: {
+    readonly menuItem: "0";
+    readonly menuStretched: "1";
+    readonly screen: "2";
+};
+export declare const ARIA_LABEL_NAMESPACE = "ariaLabels";
+export declare const translationsKeys: {
+    menuNavAriaLabel: string;
+    dropdownButtonAriaLabel: string;
+};
+export type Translations = {
+    translations: {
+        dropdownButtonAriaLabel?: string;
+        menuNavAriaLabel?: string;
+    };
+};
+export declare const defaultTranslations: Translations['translations'];
+export declare const MenuParts: {
+    readonly Root: "menu-root";
+    readonly Navbar: "navbar";
+    readonly DropdownContainer: "dropdown-container";
+    readonly DropdownButton: "dropdown-button";
+    readonly DropdownIcon: "dropdown-icon";
+    readonly Label: "label";
+    readonly DropdownItem: "dropdown-item";
+    readonly DropdownItemLabel: "dropdown-item-label";
+    readonly DropdownSubItem: "dropdown-subitem";
+    readonly DropdownSubItemLabel: "dropdown-subitem-label";
+    readonly MenuItem: "menu-item";
+    readonly MenuItemContent: "menu-item-content";
+    readonly MenuItemLink: "menu-item-link";
+    readonly HamburgerMenuContainer: "hamburger-menu-container";
+    readonly HamburgerOverlay: "hamburger-overlay";
+    readonly ScrollBackwardButton: "scroll-backward-button";
+    readonly ScrollForwardButton: "scroll-forward-button";
+};

package/dist/site/components/Menu/contexts/DropdownContext.d.ts

@@ -0,0 +1,7 @@
+import { Ref } from 'react';
+export type DropdownDomStylesApplier = (itemElement?: HTMLElement, wasHiddenBefore?: boolean) => void;
+export type DropdownContextData = {
+    dropdownElementRef: Ref<HTMLDivElement | null>;
+    setDropdownDomStylesApplier: (updateDropdownDomStyles: DropdownDomStylesApplier) => void;
+};
+export declare const DropdownContext: import('react').Context<DropdownContextData>;

package/dist/site/components/Menu/contexts/MenuContext.d.ts

@@ -0,0 +1,24 @@
+import { PropsWithChildren, default as React } from 'react';
+import { MenuItemWithChildren, MenuPreviewStateMap, ActiveAnchor } from '../Menu.types';
+import { DropdownAnchorType, MenuAnimationNameType } from '../constants';
+export type MenuContextValue = {
+    items: Array<MenuItemWithChildren>;
+    partToPreviewStateMap?: MenuPreviewStateMap;
+    currentUrl: string;
+    activeAnchor?: ActiveAnchor;
+    translations: {
+        dropdownButtonAriaLabel?: string;
+        menuNavAriaLabel?: string;
+    };
+    customClassNames?: Array<string>;
+    navAriaLabel: string;
+    menuStyleId?: string;
+    getAnimationPackage: () => MenuAnimationNameType;
+    isHamburgerMenuOpened?: boolean;
+    setIsHamburgerMenuOpened?: (isOpen: boolean) => void;
+    a11yProps: React.AriaAttributes;
+    dropdownAnchor?: DropdownAnchorType;
+};
+export declare const MenuContext: React.Context<MenuContextValue>;
+export declare const useMenuContext: () => MenuContextValue;
+export declare const MenuContextProvider: React.FC<PropsWithChildren<MenuContextValue>>;

package/dist/site/components/Menu/contexts/MenuItemContext.d.ts

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+import { MenuItemProps } from '../../../../types/vendored/editor-elements-definitions';
+import { AnimationState } from '../components/MenuContent/MenuItem/useAnimationState';
+import { DropdownAnimationNameType } from '../constants';
+export type MenuItemContextValue = {
+    item: MenuItemProps;
+    currentItem?: MenuItemProps;
+    dropdownAnimationState?: AnimationState<DropdownAnimationNameType>;
+    onEscKeyDown?: () => void;
+    isOpen?: boolean;
+};
+type MenuItemContextProviderProps = React.PropsWithChildren<MenuItemContextValue>;
+export declare const MenuItemContext: React.Context<MenuItemContextValue>;
+export declare const MenuItemContextProvider: React.FC<MenuItemContextProviderProps>;
+export declare const useMenuItemContext: () => MenuItemContextValue;
+export {};