@atlaskit/side-nav-items 1.0.0

package/dist/types/ui/menu-item/flyout-menu-item/flyout-menu-item-trigger.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @jsxRuntime classic
+ * @jsx jsx
+ */
+import { type ReactNode } from 'react';
+import { type COLLAPSE_ELEM_BEFORE_TYPE } from '../menu-item-signals';
+import type { MenuItemCommonProps, MenuItemOnClick } from '../types';
+export type FlyoutMenuItemTriggerProps = MenuItemCommonProps & {
+    /**
+     * `ReactNode` to be placed visually before the `children`.
+     *
+     * This `ReactNode` will be rendered visually on top of the main
+     * interactive element for the menu item. If this element does not
+     * contain an interactive element (`button` or `a`) then `pointer-events`
+     * will be set to `none` on this slot so that users can click through
+     * this element onto the main interactive element of the menu item.
+     *
+     * If you want to collapse the `elemBefore` so it takes up no space,
+     * then pass in the `COLLAPSE_ELEM_BEFORE` symbol. Keep in mind that
+     * collapsing the `elemBefore` can break visual alignment and
+     * will make it difficult for users to visually distinguish levels
+     * in the side navigation.
+     *
+     * @example
+     *
+     * ```tsx
+     * <FlyoutMenuItemTrigger elemBefore={<HomeIcon label="home" />}>Home</FlyoutMenuItemTrigger>
+     *
+     * // collapse the elemBefore
+     * <FlyoutMenuItemTrigger elemBefore={COLLAPSE_ELEM_BEFORE}>Home</FlyoutMenuItemTrigger>
+     * ```
+     */
+    elemBefore?: ReactNode | COLLAPSE_ELEM_BEFORE_TYPE;
+    /**
+     * Called when the user has clicked on the trigger.
+     *
+     * If you are controlling the open state of the flyout menu, use this to update your state.
+     */
+    onClick?: MenuItemOnClick<HTMLButtonElement>;
+};
+/**
+ * __FlyoutMenuItemTrigger__
+ *
+ * The button that toggles the flyout menu.
+ */
+export declare const FlyoutMenuItemTrigger: React.ForwardRefExoticComponent<React.PropsWithoutRef<FlyoutMenuItemTriggerProps> & React.RefAttributes<HTMLButtonElement>>;

package/dist/types/ui/menu-item/flyout-menu-item/flyout-menu-item.d.ts

@@ -0,0 +1,52 @@
+import React, { type ReactNode } from 'react';
+export type FlyoutMenuItemProps = {
+    /**
+     * Should contain `FlyoutMenuItemTrigger` and `FlyoutMenuItemContent`.
+     */
+    children: ReactNode;
+    /**
+     * ID that is assigned to the popup container element and used to associate the trigger with the content.
+     */
+    id?: string;
+    /**
+     * Whether the flyout menu is open by default.
+     *
+     * You can use this to set the default expansion state without needing to entirely control the state.
+     */
+    isDefaultOpen?: boolean;
+    /**
+     * Allows to control the open state of the flyout externally.
+     *
+     * If you are controlling the state, you should update your state using:
+     * - `onClick` on the `FlyoutMenuItemTrigger`
+     * - `onClose` on the `FlyoutMenuItemContent`
+     */
+    isOpen?: boolean;
+    /**
+     * Callback that is called when the flyout menu is opened or closed.
+     *
+     * Can be used for analytics purposes when you are not controlling the state yourself.
+     */
+    onOpenChange?: (isOpen: boolean) => void;
+};
+/**
+ * __FlyoutMenuItem__
+ *
+ * Displays content in a flyout menu, triggered by a button.
+ *
+ * The top-level component that contains the trigger and content of a flyout menu.
+ *
+ * Usage example:
+ * ```tsx
+ * <FlyoutMenuItem>
+ *   <FlyoutMenuItemTrigger>Trigger</FlyoutMenuItemTrigger>
+ *   <FlyoutMenuItemContent>
+ *     <MenuList>
+ *       <ButtonMenuItem>Item 1</ButtonMenuItem>
+ *       <ButtonMenuItem>Item 2</ButtonMenuItem>
+ *     </MenuList>
+ *   </FlyoutMenuItemContent>
+ * </FlyoutMenuItem>
+ * ```
+ */
+export declare const FlyoutMenuItem: React.ForwardRefExoticComponent<React.PropsWithoutRef<FlyoutMenuItemProps> & React.RefAttributes<HTMLDivElement>>;

package/dist/types/ui/menu-item/link-menu-item.d.ts

@@ -0,0 +1,22 @@
+import type { RouterLinkComponentProps } from '@atlaskit/app-provider';
+import type { MenuItemLinkOrButtonCommonProps, MenuItemOnClick } from './types';
+export type LinkMenuItemProps<RouterLinkConfig extends Record<string, any> = never> = MenuItemLinkOrButtonCommonProps & RouterLinkComponentProps<RouterLinkConfig> & {
+    /**
+     * Whether the menu item is selected.
+     */
+    isSelected?: boolean;
+    /**
+     * Called when the user has clicked on the trigger content.
+     */
+    onClick?: MenuItemOnClick<HTMLAnchorElement>;
+    /**
+     * The native `target` attribute for the anchor element.
+     */
+    target?: HTMLAnchorElement['target'];
+};
+/**
+ * LinkMenuItem
+ *
+ * A menu item link. It should be used within a `ul`.
+ */
+export declare const LinkMenuItem: <RouterLinkConfig extends Record<string, any> = never>(props: LinkMenuItemProps<RouterLinkConfig> & React.RefAttributes<HTMLAnchorElement>) => React.ReactElement | null;

package/dist/types/ui/menu-item/list-item.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @jsxRuntime classic
+ * @jsx jsx
+ */
+import { type ReactNode } from 'react';
+import type { StrictXCSSProp } from '@atlaskit/css';
+type ListItemProps = {
+    /**
+     * The contents of the list item.
+     */
+    children: ReactNode;
+    /**
+     * A unique string that appears as data attribute `data-testid` in the rendered code, serving as a hook for automated tests.
+     */
+    testId?: string;
+    /**
+     * Bounded style overrides.
+     */
+    xcss?: StrictXCSSProp<'display' | 'scrollMarginInline', never>;
+};
+/**
+ * __List item__
+ *
+ * A [list item](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/li) with visual styles removed.
+ */
+export declare const ListItem: React.ForwardRefExoticComponent<React.PropsWithoutRef<ListItemProps> & React.RefAttributes<HTMLDivElement>>;
+export {};

package/dist/types/ui/menu-item/list.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @jsxRuntime classic
+ * @jsx jsx
+ */
+import { type ReactNode } from 'react';
+import { type XCSSProp } from '@compiled/react';
+export type ListProps = {
+    /**
+     * The contents of the list. Should contain list items.
+     */
+    children: ReactNode;
+    /**
+     * A unique string that appears as data attribute `data-testid` in the rendered code, serving as a hook for automated tests.
+     */
+    testId?: string;
+    /**
+     * Bounded style overrides.
+     */
+    xcss?: XCSSProp<'alignItems' | 'display' | 'gap' | 'paddingInlineStart' | 'padding', never>;
+};
+/**
+ * __List__
+ *
+ * A an element with the role of `list` for semantically grouping list items.
+ *
+ * This is the internal primitive used by other external components in the navigation system.
+ */
+export declare const List: React.ForwardRefExoticComponent<React.PropsWithoutRef<ListProps> & React.RefAttributes<HTMLDivElement>>;

package/dist/types/ui/menu-item/menu-item-signals.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A symbol to collapse the `elemBefore` slot.
+ * This should be placed in the `elemBefore` prop of supported menu items.
+ */
+export declare const COLLAPSE_ELEM_BEFORE: unique symbol;
+export type COLLAPSE_ELEM_BEFORE_TYPE = typeof COLLAPSE_ELEM_BEFORE;

package/dist/types/ui/menu-item/menu-item.d.ts

@@ -0,0 +1,51 @@
+/**
+ * @jsxFrag
+ * @jsxRuntime classic
+ * @jsx jsx
+ */
+import React from 'react';
+import type { MenuItemLinkOrButtonCommonProps, MenuItemOnClick } from './types';
+/**
+ * This is being _internally_ exported so it can be used in other menu item wrapper components, like
+ * ExpandableMenuItemTrigger.
+ *
+ * This selector is used to apply hover styling on the menu item if it contains an open nested popup.
+ * It's looking for a popup trigger with `aria-hasexpanded` and `aria-haspopup` attributes. The
+ * reason for targeting the _trigger_ instead of the popup itself, is the popup might be rendered
+ * outside the menu item, e.g. if rendered in a portal.
+ *
+ * An alternative solution might involve wrapping it with a popup context and listening to the popup
+ * events through it (and applying the hover style when the popup is open). Exploring this has been
+ * captured in [BLU-3354](https://jplat.atlassian.net/browse/BLU-3354).
+ */
+export declare const nestedOpenPopupCSSSelector = "&:has([aria-expanded=\"true\"][aria-haspopup=\"true\"])";
+/**
+ * Includes all props that are used by any menu item, as MenuItembase is the base component for all menu item components.
+ *
+ * We also include additional `aria` props to support the menu item being a trigger for the FlyoutMenuItem popup and for the
+ * expanded content for ExpandableMenuItem.
+ */
+type MenuItemBaseProps<T extends HTMLAnchorElement | HTMLButtonElement> = MenuItemLinkOrButtonCommonProps & {
+    ariaControls?: string;
+    ariaExpanded?: boolean;
+    ariaHasPopup?: boolean | 'dialog';
+    href?: string | Record<string, any>;
+    /**
+     * ID attribute, passed to the interactive element (anchor/button). This is not publicly exposed, and is currently only
+     * used internally by `ExpandableMenuItemTrigger` for the `aria-labelledby` attribute.
+     */
+    id?: string;
+    isDisabled?: boolean;
+    onClick?: MenuItemOnClick<T>;
+    target?: HTMLAnchorElement['target'];
+};
+/**
+ * __MenuItemBase__
+ *
+ * The base menu item component used to compose ButtonMenuItem and LinkMenuItem.
+ *
+ * It contains a type argument `<T>`, to specify the type of the interactive element (`button` or `a`).
+ * This can be inferred from the type of the `onClick` prop.
+ */
+export declare const MenuItemBase: <T extends HTMLAnchorElement | HTMLButtonElement>(props: MenuItemBaseProps<T> & React.RefAttributes<T>) => React.ReactElement | null;
+export {};

package/dist/types/ui/menu-item/menu-list-item.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @jsxRuntime classic
+ * @jsx jsx
+ */
+import { ListItem } from './list-item';
+/**
+ * __Menu list item__
+ *
+ * A [list item](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/li) with visual styles removed.
+ */
+export declare const MenuListItem: typeof ListItem;

package/dist/types/ui/menu-item/menu-list.d.ts

@@ -0,0 +1,8 @@
+import { type ListProps } from './list';
+/**
+ * __Menu list__
+ *
+ * An [unordered list](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/ul) with visual styles removed,
+ * for semantically grouping list items.
+ */
+export declare const MenuList: React.ForwardRefExoticComponent<Omit<ListProps, 'xcss'> & React.RefAttributes<HTMLDivElement>>;

package/dist/types/ui/menu-item/top-level-spacer.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @jsxRuntime classic
+ * @jsx jsx
+ */
+/**
+ * Use this component to create visual separation between the:
+ *
+ * - global app shortcut section
+ * - 'more' button menu item
+ * - starred spaces (in Confluence)
+ *
+ * Only use this component in the top level of the menu,
+ * and exercise caution when using it in new situations.
+ *
+ * This component exists to fulfil product design requirements but has not yet
+ * been consolidated into the wider navigation system.
+ *
+ * It may not exist in the future when global apps are no longer in the side navigation.
+ */
+export declare function TopLevelSpacer(): JSX.Element;

package/dist/types/ui/menu-item/types.d.ts

@@ -0,0 +1,164 @@
+import type React from 'react';
+import type { UIAnalyticsEvent } from '@atlaskit/analytics-next';
+import { type COLLAPSE_ELEM_BEFORE_TYPE } from './menu-item-signals';
+export type MenuItemOnClick<T extends HTMLAnchorElement | HTMLButtonElement> = (event: React.MouseEvent<T>, analyticsEvent: UIAnalyticsEvent) => void;
+/**
+ * Props shared across _all_ menu item components:
+ * - MenuItemBase
+ * - LinkMenuItem
+ * - ButtonMenuItem
+ * - ExpandableMenuItemTrigger
+ * - FlyoutMenuItemTrigger
+ */
+export type MenuItemCommonProps = {
+    /**
+     * The main textual content and label of the menu item.
+     *
+     * The content will be truncated to fit into the side nav in one line.
+     *
+     * **Note:** Placing non-textual content (such as lozenges) can cause unexpected truncation behavior.
+     * Use the provided slot props such as `elemBefore` or `elemAfter` for non-textual content instead.
+     */
+    children: React.ReactNode;
+    /**
+     * A slot to render drop indicators for drag and drop operations on the menu item.
+     */
+    dropIndicator?: React.ReactNode;
+    /**
+     * Whether this menu item can be dragged. Add a drag handle to this item.
+     * You are responsible for wiring up drag and drop to the menu item.
+     *
+     *
+     * - Please be sure to make the MenuItem `ref` the `draggable` element
+     * - See our navigation drag and drop guidelines for more technical details
+     */
+    hasDragIndicator?: boolean;
+    /**
+     * An optional name used to identify events for [React UFO (Unified Frontend Observability) press interactions](https://developer.atlassian.com/platform/ufo/react-ufo/react-ufo/getting-started/#quick-start--press-interactions). For more information, see [React UFO integration into Design System components](https://go.atlassian.com/react-ufo-dst-integration).
+     */
+    interactionName?: string;
+    /**
+     * Disable tooltip for menu item content. This should only be done when there is some other way
+     * to display the full menu content and description of a menu item close by (eg with another popup)
+     */
+    isContentTooltipDisabled?: boolean;
+    /**
+     * Whether the element is being dragged. Will apply "dragging" styles to
+     * menu item.
+     */
+    isDragging?: boolean;
+    /**
+     * Indicates that the menu item is selected.
+     */
+    isSelected?: boolean;
+    /**
+     * A unique string that appears as data attribute `data-testid` in the rendered code, serving as a hook for automated tests.
+     */
+    testId?: string;
+    /**
+     * Exposes the visually complete menu item, including:
+     *
+     * - the main interactive element (exposed through `ref`)
+     * - any `elemBefore`, `elemAfter`, `actions`, or `actionsOnHover`
+     *
+     * This specifically excludes the wrapping list item,
+     * which is also exposed through either:
+     * - the `listItemRef` prop for LinkMenuItem and ButtonMenuItem
+     * - the `ref` prop for FlyoutMenuItem and ExpandableMenuItem
+     */
+    visualContentRef?: React.Ref<HTMLDivElement>;
+};
+/**
+ * Menu item grid slots. These are used in:
+ * - MenuItemBase
+ * - LinkMenuItem
+ * - ButtonMenuItem
+ * - ExpandableMenuItemTrigger
+ */
+export type MenuItemSlots = {
+    /**
+     * `ReactNode` to be placed visually after the `children`.
+     *
+     * It is intended for additional actions (e.g. IconButtons).
+     *
+     * They will not be rendered when the menu item is disabled.
+     */
+    actions?: React.ReactNode;
+    /**
+     * `ReactNode` to be placed visually after the `children` and will
+     * only be displayed on hover or focus.
+     *
+     * It is intended for additional actions (e.g. IconButtons).
+     *
+     * This `ReactNode` will replace `elemAfter` on hover or focus.
+     *
+     * They will not be rendered when the menu item is disabled.
+     *
+     * This `ReactNode` will be rendered visually on top of the main
+     * interactive element for the menu item. If this element does not
+     * contain an interactive element (`button` or `a`) then `pointer-events`
+     * will be set to `none` on this slot so that users can click through
+     * this element onto the main interactive element of the menu item.
+     */
+    actionsOnHover?: React.ReactNode;
+    /**
+     * `ReactNode` to be placed visually after the `children`.
+     *
+     * It is intended for static content (e.g. a `Lozenge`).
+     *
+     * If both `elemAfter` and `actionsOnHover` are provided, `elemAfter` will
+     * not be displayed when the item is hovered over or expanded. This is
+     * because the `actionsOnHover` will be displayed instead.
+     *
+     * This `ReactNode` will be rendered visually on top of the main
+     * interactive element for the menu item. If this element does not
+     * contain an interactive element (`button` or `a`) then `pointer-events`
+     * will be set to `none` on this slot so that users can click through
+     * this element onto the main interactive element of the menu item.
+     */
+    elemAfter?: React.ReactNode;
+    /**
+     * `ReactNode` to be placed visually before the `children`.
+     *
+     * This `ReactNode` will be rendered visually on top of the main
+     * interactive element for the menu item. If this element does not
+     * contain an interactive element (`button` or `a`) then `pointer-events`
+     * will be set to `none` on this slot so that users can click through
+     * this element onto the main interactive element of the menu item.
+     *
+     * If you want to collapse the `elemBefore` so it takes up no space,
+     * then pass in the `COLLAPSE_ELEM_BEFORE` symbol. Keep in mind that
+     * collapsing the `elemBefore` can break visual alignment and
+     * will make it difficult for users to visually distinguish levels
+     * in the side navigation.
+     *
+     * @example
+     *
+     * ```tsx
+     * <MenuItemButton elemBefore={<HomeIcon label="home" />}>Home</MenuItemButton>
+     *
+     * // collapse the elemBefore
+     * <MenuItemButton elemBefore={COLLAPSE_ELEM_BEFORE}>Home</MenuItemButton>
+     * ```
+     */
+    elemBefore?: React.ReactNode | COLLAPSE_ELEM_BEFORE_TYPE;
+};
+/**
+ * Props shared across:
+ * - MenuItemBase
+ * - LinkMenuItem
+ * - ButtonMenuItem
+ */
+export type MenuItemLinkOrButtonCommonProps = MenuItemCommonProps & MenuItemSlots & {
+    /**
+     * Additional textual content for the menu item.
+     * It is displayed underneath the main content.
+     */
+    description?: string;
+    /**
+     * Exposes the `<div role="listitem">` element that wraps the entire item.
+     *
+     * This is the root element rendered by the component.
+     */
+    listItemRef?: React.Ref<HTMLDivElement>;
+};

package/dist/types/ui/menu-item/use-scroll-menu-item-into-view.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Scrolls the element into view once it is selected, and once all its ancestors (expandable
+ * parent menu items) are expanded.
+ *
+ * Once that has happened, we don't want to scroll it into view again until it has been unselected.
+ * This is to prevent the menu item from being scrolled into view again if the user collapses a
+ * parent and then expands it again, without changing what menu item is selected.
+ */
+export declare function useScrollMenuItemIntoView({ elementRef, isSelected, }: {
+    elementRef: React.RefObject<HTMLDivElement>;
+    isSelected: boolean;
+}): void;

package/dist/types/ui/menu-section/divider.d.ts

@@ -0,0 +1,6 @@
+/**
+ * __Divider__
+ *
+ * A divider for use between menu sections.
+ */
+export declare const Divider: () => JSX.Element;

package/dist/types/ui/menu-section/menu-section-context.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Context for the current menu section. It holds a unique ID for the section, used for associating the section heading
+ * as an accessible label for the group.
+ */
+export declare const MenuSectionContext: import("react").Context<string | null>;
+export declare const useMenuSectionContext: () => string;

package/dist/types/ui/menu-section/menu-section-heading.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @jsxRuntime classic
+ * @jsx jsx
+ */
+import { type ReactNode } from 'react';
+/**
+ * __MenuSectionHeading__
+ *
+ * The label for the menu section group.
+ */
+export declare const MenuSectionHeading: ({ children, }: {
+    /**
+     * The text of the heading.
+     */
+    children: ReactNode;
+}) => JSX.Element;

package/dist/types/ui/menu-section/menu-section.d.ts

@@ -0,0 +1,41 @@
+import { type ReactNode } from 'react';
+type MenuSectionProps = {
+    /**
+     * The contents of the menu section.
+     * Should contain a `MenuSectionHeading`, and a `Divider` if appropriate.
+     */
+    children?: ReactNode;
+    /**
+     * Wraps the `MenuSection` in a `MenuListItem` so that it can validly be the child of a `MenuList`
+     *
+     * In the future this will become the default behavior, and the prop will be removed.
+     */
+    isMenuListItem?: boolean;
+    /**
+     * A unique string that appears as data attribute `data-testid` in the rendered code, serving as a hook for automated tests.
+     *
+     * It is applied to the outer rendered element.
+     *
+     * Right now, it is only applied when `isMenuListItem:true`
+     */
+    testId?: string;
+};
+/**
+ * __MenuSection__
+ *
+ * A composable component for grouping menu items, along with a heading (`MenuSectionHeading`) and a divider (`Divider`).
+ *
+ * Usage example:
+ * ```tsx
+ * <MenuSection>
+ *   <MenuSectionHeading>Section heading</MenuSectionHeading>
+ *   <MenuList>
+ *     <MenuItem>Item 1</MenuItem>
+ *     <MenuItem>Item 2</MenuItem>
+ *   </MenuList>
+ *   <Divider />
+ * </MenuSection>
+ * ```
+ */
+export declare const MenuSection: ({ children, testId, isMenuListItem, }: MenuSectionProps) => JSX.Element;
+export {};

package/dist/types-ts4.5/entry-points/button-menu-item.d.ts

@@ -0,0 +1,3 @@
+export { ButtonMenuItem, type ButtonMenuItemProps } from '../ui/menu-item/button-menu-item';
+export { COLLAPSE_ELEM_BEFORE } from '../ui/menu-item/menu-item-signals';
+export type { MenuItemOnClick } from '../ui/menu-item/types';

package/dist/types-ts4.5/entry-points/container-avatar.d.ts

@@ -0,0 +1 @@
+export { ContainerAvatar, type ContainerAvatarProps } from '../ui/menu-item/container-avatar';

package/dist/types-ts4.5/entry-points/drag-and-drop/drag-handle.d.ts

@@ -0,0 +1 @@
+export { LazyDragHandle } from '../../ui/menu-item/drag-handle/lazy-drag-handle';

package/dist/types-ts4.5/entry-points/drag-and-drop/drag-preview.d.ts

@@ -0,0 +1 @@
+export { DragPreview } from '../../ui/menu-item/drag-and-drop/drag-preview';

package/dist/types-ts4.5/entry-points/drag-and-drop/drop-indicator.d.ts

@@ -0,0 +1 @@
+export { DropIndicator, type Instruction, type Operation, } from '../../ui/menu-item/drag-and-drop/drop-indicator';

package/dist/types-ts4.5/entry-points/drag-and-drop/group-drop-indicator.d.ts

@@ -0,0 +1 @@
+export { GroupDropIndicator } from '../../ui/menu-item/drag-and-drop/group-drop-indicator';

package/dist/types-ts4.5/entry-points/drag-and-drop/hitbox.d.ts

@@ -0,0 +1 @@
+export { attachInstruction, extractInstruction, type Availability, type Operation, type Instruction, } from '../../ui/menu-item/drag-and-drop/hitbox';

package/dist/types-ts4.5/entry-points/drag-and-drop/use-menu-item-drag-and-drop.d.ts

@@ -0,0 +1 @@
+export { useMenuItemDragAndDrop, type TMenuItemDragAndDropState, } from '../../ui/menu-item/drag-and-drop/use-menu-item-drag-and-drop';

package/dist/types-ts4.5/entry-points/expandable-menu-item.d.ts

@@ -0,0 +1,4 @@
+export { ExpandableMenuItem, type ExpandableMenuItemProps, } from '../ui/menu-item/expandable-menu-item/expandable-menu-item';
+export { ExpandableMenuItemTrigger, type ExpandableMenuItemTriggerProps, } from '../ui/menu-item/expandable-menu-item/expandable-menu-item-trigger';
+export { ExpandableMenuItemContent, type ExpandableMenuItemContentProps, } from '../ui/menu-item/expandable-menu-item/expandable-menu-item-content';
+export { useIsExpanded } from '../ui/menu-item/expandable-menu-item/expandable-menu-item-context';

package/dist/types-ts4.5/entry-points/flyout-menu-item.d.ts

@@ -0,0 +1,7 @@
+export { FlyoutMenuItem, type FlyoutMenuItemProps, } from '../ui/menu-item/flyout-menu-item/flyout-menu-item';
+export { FlyoutBody, type FlyoutBodyProps } from '../ui/menu-item/flyout-menu-item/flyout-body';
+export { FlyoutMenuItemContent, type FlyoutMenuItemContentProps, } from '../ui/menu-item/flyout-menu-item/flyout-menu-item-content';
+export { FlyoutFooter, type FlyoutFooterProps, } from '../ui/menu-item/flyout-menu-item/flyout-footer';
+export { FlyoutHeader, type FlyoutHeaderProps, } from '../ui/menu-item/flyout-menu-item/flyout-header';
+export { COLLAPSE_ELEM_BEFORE } from '../ui/menu-item/menu-item-signals';
+export { FlyoutMenuItemTrigger, type FlyoutMenuItemTriggerProps, } from '../ui/menu-item/flyout-menu-item/flyout-menu-item-trigger';

package/dist/types-ts4.5/entry-points/link-menu-item.d.ts

@@ -0,0 +1,3 @@
+export { LinkMenuItem, type LinkMenuItemProps } from '../ui/menu-item/link-menu-item';
+export { COLLAPSE_ELEM_BEFORE } from '../ui/menu-item/menu-item-signals';
+export type { MenuItemOnClick } from '../ui/menu-item/types';

package/dist/types-ts4.5/entry-points/menu-list-item.d.ts

@@ -0,0 +1 @@
+export { MenuListItem } from '../ui/menu-item/menu-list-item';

package/dist/types-ts4.5/entry-points/menu-list.d.ts

@@ -0,0 +1 @@
+export { MenuList } from '../ui/menu-item/menu-list';

package/dist/types-ts4.5/entry-points/menu-section.d.ts

@@ -0,0 +1,3 @@
+export { MenuSection } from '../ui/menu-section/menu-section';
+export { MenuSectionHeading } from '../ui/menu-section/menu-section-heading';
+export { Divider } from '../ui/menu-section/divider';

package/dist/types-ts4.5/entry-points/top-level-spacer.d.ts

@@ -0,0 +1 @@
+export { TopLevelSpacer } from '../ui/menu-item/top-level-spacer';

package/dist/types-ts4.5/index.d.ts

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

package/dist/types-ts4.5/ui/menu-item/button-menu-item.d.ts

@@ -0,0 +1,42 @@
+import React from 'react';
+import type { MenuItemLinkOrButtonCommonProps, MenuItemOnClick } from './types';
+export type ButtonMenuItemProps = MenuItemLinkOrButtonCommonProps & {
+    /**
+     * Identifies the popup element that this element controls when it is used as a popup trigger.
+     * Should match the `id` of the popup content for screen readers to understand the relationship.
+     */
+    'aria-controls'?: string;
+    /**
+     * Announces to assistive technology whether the popup is currently open or closed,
+     * when this element is used as a popup trigger.
+     */
+    'aria-expanded'?: boolean;
+    /**
+     * Informs assistive technology that this element triggers a popup.
+     */
+    'aria-haspopup'?: boolean | 'dialog';
+    /**
+     * We are not using a discriminated union to enforce that the `actions` and `actionsOnHover`
+     * props are not used when `isDisabled` is true due to ergonomic type issues with `boolean`
+     * types (as oppposed to literal `true` or `false` types), e.g. if a conditional boolean
+     * variable is passed to `isDisabled`.
+     */
+    /**
+     * Whether the menu item is disabled.
+     *
+     * When disabled, content in the `actions` and `actionsOnHover` props will not be rendered.
+     *
+     * The menu item will not be interactive and will not respond to hover or focus.
+     */
+    isDisabled?: boolean;
+    /**
+     * Called when the user has clicked on the trigger content.
+     */
+    onClick?: MenuItemOnClick<HTMLButtonElement>;
+};
+/**
+ * __ButtonMenuItem__
+ *
+ * A menu item button. It should be used within a `ul`, as it renders a list item.
+ */
+export declare const ButtonMenuItem: React.ForwardRefExoticComponent<React.PropsWithoutRef<ButtonMenuItemProps> & React.RefAttributes<HTMLButtonElement>>;