Menu

import {Menu} from "@qualcomm-ui/react/menu"

Examples

Item Customization

Compose the menu to include icons and commands.

Context Menu

Demonstrates how to trigger a menu on right-click or other context events.

Nested Menus

Compose nested menus by nesting <Menu.Root> components inside each other.

<Menu.Root>
  <Menu.Trigger>
    <Menu.Button emphasis="primary">Show Menu</Menu.Button>
  </Menu.Trigger>
  <Portal>
    <Menu.Positioner>
      <Menu.Content>
        <Menu.Item value="new-txt">New Text File</Menu.Item>
        <Menu.Item value="new-file">New File...</Menu.Item>
        <Menu.Root positioning={{gutter: 2, placement: "right-start"}}>
          <Menu.TriggerItem value="open-recent">
            Open Recent
          </Menu.TriggerItem>
          <Portal>
            <Menu.Positioner>
              <Menu.Content>
                <Menu.Item value="file-1">File 1</Menu.Item>
                <Menu.Item value="file-2">File 2</Menu.Item>
                <Menu.Item value="file-3">File 3</Menu.Item>
              </Menu.Content>
            </Menu.Positioner>
          </Portal>
        </Menu.Root>
      </Menu.Content>
    </Menu.Positioner>
  </Portal>
</Menu.Root>

Menu items can be links using polymorphic composition. Use the render prop on the <Menu.Item> to specify the element type.

<Menu.Content>
  <Menu.Item
    render={
      <a href="https://react.dev" rel="noreferrer" target="_blank" />
    }
    value="react"
  >
    <Menu.ItemStartIcon icon={ExternalLink} />
    React
  </Menu.Item>
  <Menu.Item
    render={
      <a
        href="https://angular.dev"
        rel="noreferrer"
        target="_blank"
      />
    }
    value="angular"
  >
    <Menu.ItemStartIcon icon={ExternalLink} />
    Angular
  </Menu.Item>
</Menu.Content>

Groups

Use the <Menu.ItemGroup> component to group menu items.

Item Types

There are three item types, each corresponding to one of the three types of aria menu item roles:

  • <Menu.Item>menuitem
  • <Menu.RadioItem>menuitemradio
  • <Menu.CheckboxItem>menuitemcheckbox

Checkbox Items

There are two appearance options:

  • For a checkbox appearance, render the <Menu.CheckboxItemControl> element as a child of the item.
  • Render the <Menu.ItemIndicator /> element for a simple selection indicator.
<Menu.ItemGroup>
  <Menu.ItemGroupLabel>Choose an option</Menu.ItemGroupLabel>
  <Menu.CheckboxItem value="item-1-1">
    <Menu.CheckboxItemControl />
    <Menu.ItemLabel>Option 1</Menu.ItemLabel>
  </Menu.CheckboxItem>
  <Menu.CheckboxItem value="item-1-2">
    <Menu.CheckboxItemControl />
    <Menu.ItemLabel>Option 2</Menu.ItemLabel>
  </Menu.CheckboxItem>
</Menu.ItemGroup>

<Menu.ItemGroup>
  <Menu.ItemGroupLabel>Choose an option</Menu.ItemGroupLabel>
  <Menu.CheckboxItem value="item-2-1">
    <Menu.ItemLabel>Option 1</Menu.ItemLabel>
    <Menu.ItemIndicator />
  </Menu.CheckboxItem>
  <Menu.CheckboxItem value="item-2-2">
    <Menu.ItemLabel>Option 2</Menu.ItemLabel>
    <Menu.ItemIndicator />
  </Menu.CheckboxItem>
</Menu.ItemGroup>

Checkbox Selection State

Illustrates how to manage and reflect the checked state of checkbox menu items.

<Menu.ItemGroup>
  <Menu.ItemGroupLabel>Choose an option</Menu.ItemGroupLabel>
  {items.map(({label, value}) => (
    <Menu.CheckboxItem
      key={value}
      checked={checkboxState[value] || false}
      onCheckedChange={(checked) => onChange(value, checked)}
      value={value}
    >
      <Menu.ItemLabel>{label}</Menu.ItemLabel>
      <Menu.ItemIndicator />
    </Menu.CheckboxItem>
  ))}
</Menu.ItemGroup>

Radio Group

Demonstrates how to group radio menu items so only one can be selected at a time.

Controlled State

The menu's visibility can be controlled via the open, onOpenChange, and defaultOpen props.

  • Use open to explicitly set whether the menu is open (controlled mode).
  • Use onOpenChange to be notified when the menu requests to open or close.
  • Use defaultOpen to set the initial open state when you don't need to control it yourself (uncontrolled mode).

In controlled mode, the open prop should be updated in response to onOpenChange events to reflect the desired visibility.

Placement

Configure the menu's placement using the positioning.placement prop.

Sizes

Use the size prop to control the size of the menu. The default size is md. The demo features the small (sm) size.

Anchor Point

Use the positioning.anchorPoint prop to control the anchor point of the menu.

Anchor

Avatar

Here's an example that composes the Menu with the Avatar component to display a user account menu.

Within Dialog

When using the Menu inside a Dialog, don't render the <Menu.Positioner> within a <Portal> element.

Hide When Detached

Use the positioning.hideWhenDetached prop to hide the menu when it's detached from the trigger.

Item 0
Item 1
Item 2
Item 3
Item 4
Item 5

API

PropTypeDefault
React children prop.
The positioning point for the menu. Can be set by the context menu trigger or the button trigger.
{
x: number
y: number
}
Whether to close the menu when an option is selected
boolean
true
Whether the menu is composed with other composite widgets like a combobox or tabs
boolean
true
The initial highlighted value of the menu item when rendered. Use when you don't need to control the highlighted value of the menu item.
string
The initial open state of the menu when rendered. Use when you don't need to control the open state of the menu.
boolean
The document's text/writing direction.
'ltr' | 'rtl'
'ltr'
A root node to correctly resolve document in custom environments. i.e., Iframes, Electron.
    () =>
    | Node
    | ShadowRoot
    | Document
    The controlled highlighted value of the menu item.
    string
    id attribute. If omitted, a unique identifier will be automatically generated for accessibility.
    string
    Whether to synchronize the present change immediately or defer it to the next frame
    boolean
    When true, the component will not be rendered in the DOM until it becomes visible or active.
    boolean
    false
    
    Whether to loop the keyboard navigation.
    boolean
    false
    
    Function to navigate to the selected item if it's an anchor element
      (details: {
      href: string
      node: HTMLAnchorElement
      value: string
      }) => void
      Function called when the escape key is pressed
        (
        event: KeyboardEvent,
        ) => void
        Function called when the animation ends in the closed state
        VoidFunction
        Function called when the focus is moved outside the component
          (
          event: FocusOutsideEvent,
          ) => void
          Function called when the highlighted menu item changes.
            (
            value: string,
            ) => void
            Function called when an interaction happens outside the component
              (
              event: InteractOutsideEvent,
              ) => void
              Function called when the menu opens or closes
                (
                open: boolean,
                ) => void
                Function called when the pointer is pressed down outside the component
                  (
                  event: PointerDownOutsideEvent,
                  ) => void
                  Function called when this layer is closed due to a parent layer being closed
                    (
                    event: CustomEvent<{
                    originalIndex: number
                    originalLayer: HTMLElement
                    targetIndex: number
                    targetLayer: HTMLElement
                    }>,
                    ) => void
                    Function called when a menu item is selected.
                      (
                      value: string,
                      ) => void
                      The controlled open state of the menu
                      boolean
                      The options used to dynamically position the menu
                      Whether the node is present (controlled by the user)
                      boolean
                      'sm' | 'md'
                      Whether to allow the initial presence animation.
                      boolean
                      false
                      
                      Whether the pressing printable characters should trigger typeahead navigation
                      boolean
                      true
                      
                      When true, the component will be completely removed from the DOM when it becomes inactive or hidden, rather than just being hidden with CSS.
                      boolean
                      false
                      
                      Description
                      React children prop.
                      Type
                      {
                      x: number
                      y: number
                      }
                      Description
                      The positioning point for the menu. Can be set by the context menu trigger or the button trigger.
                      Type
                      boolean
                      Description
                      Whether to close the menu when an option is selected
                      Type
                      boolean
                      Description
                      Whether the menu is composed with other composite widgets like a combobox or tabs
                      Type
                      string
                      Description
                      The initial highlighted value of the menu item when rendered. Use when you don't need to control the highlighted value of the menu item.
                      Type
                      boolean
                      Description
                      The initial open state of the menu when rendered. Use when you don't need to control the open state of the menu.
                      Type
                      'ltr' | 'rtl'
                      Description
                      The document's text/writing direction.
                      Type
                      () =>
                      | Node
                      | ShadowRoot
                      | Document
                      Description
                      A root node to correctly resolve document in custom environments. i.e., Iframes, Electron.
                        Type
                        string
                        Description
                        The controlled highlighted value of the menu item.
                        Type
                        string
                        Description
                        id attribute. If omitted, a unique identifier will be automatically generated for accessibility.
                        Type
                        boolean
                        Description
                        Whether to synchronize the present change immediately or defer it to the next frame
                        Type
                        boolean
                        Description
                        When true, the component will not be rendered in the DOM until it becomes visible or active.
                        Type
                        boolean
                        Description
                        Whether to loop the keyboard navigation.
                        Type
                        (details: {
                        href: string
                        node: HTMLAnchorElement
                        value: string
                        }) => void
                        Description
                        Function to navigate to the selected item if it's an anchor element
                          Type
                          (
                          event: KeyboardEvent,
                          ) => void
                          Description
                          Function called when the escape key is pressed
                            Type
                            VoidFunction
                            Description
                            Function called when the animation ends in the closed state
                            Type
                            (
                            event: FocusOutsideEvent,
                            ) => void
                            Description
                            Function called when the focus is moved outside the component
                              Type
                              (
                              value: string,
                              ) => void
                              Description
                              Function called when the highlighted menu item changes.
                                Type
                                (
                                event: InteractOutsideEvent,
                                ) => void
                                Description
                                Function called when an interaction happens outside the component
                                  Type
                                  (
                                  open: boolean,
                                  ) => void
                                  Description
                                  Function called when the menu opens or closes
                                    Type
                                    (
                                    event: PointerDownOutsideEvent,
                                    ) => void
                                    Description
                                    Function called when the pointer is pressed down outside the component
                                      Type
                                      (
                                      event: CustomEvent<{
                                      originalIndex: number
                                      originalLayer: HTMLElement
                                      targetIndex: number
                                      targetLayer: HTMLElement
                                      }>,
                                      ) => void
                                      Description
                                      Function called when this layer is closed due to a parent layer being closed
                                        Type
                                        (
                                        value: string,
                                        ) => void
                                        Description
                                        Function called when a menu item is selected.
                                          Type
                                          boolean
                                          Description
                                          The controlled open state of the menu
                                          Description
                                          The options used to dynamically position the menu
                                          Type
                                          boolean
                                          Description
                                          Whether the node is present (controlled by the user)
                                          Type
                                          'sm' | 'md'
                                          Type
                                          boolean
                                          Description
                                          Whether to allow the initial presence animation.
                                          Type
                                          boolean
                                          Description
                                          Whether the pressing printable characters should trigger typeahead navigation
                                          Type
                                          boolean
                                          Description
                                          When true, the component will be completely removed from the DOM when it becomes inactive or hidden, rather than just being hidden with CSS.

                                          PositioningOptions

                                          The positioning prop accepts an object with the following shape:

                                          PropTypeDefault
                                          The minimum padding between the arrow and the floating element's corner.
                                          number
                                          4
                                          
                                          The overflow boundary of the reference element
                                            () =>
                                            | 'clippingAncestors'
                                            | Element
                                            | Array<Element>
                                            | {
                                            height: number
                                            width: number
                                            x: number
                                            y: number
                                            }
                                            Whether the popover should fit the viewport.
                                            boolean
                                            Whether to flip the placement when the floating element overflows the boundary.
                                            | boolean
                                            | Array<
                                            | 'bottom'
                                            | 'bottom-end'
                                            | 'bottom-start'
                                            | 'left'
                                            | 'left-end'
                                            | 'left-start'
                                            | 'right'
                                            | 'right-end'
                                            | 'right-start'
                                            | 'top'
                                            | 'top-end'
                                            | 'top-start'
                                            >
                                            true
                                            
                                            Function that returns the anchor rect
                                              (
                                              element:
                                              | HTMLElement
                                              | VirtualElement,
                                              ) => {
                                              height?: number
                                              width?: number
                                              x?: number
                                              y?: number
                                              }
                                              The main axis offset or gap between the reference and floating element
                                              number
                                              8
                                              
                                              Whether the popover should be hidden when the reference element is detached
                                              boolean
                                              Options to activate auto-update listeners
                                              | boolean
                                              | {
                                              ancestorResize?: boolean
                                              ancestorScroll?: boolean
                                              animationFrame?: boolean
                                              elementResize?: boolean
                                              layoutShift?: boolean
                                              }
                                              true
                                              
                                              The offset of the floating element
                                              {
                                              crossAxis?: number
                                              mainAxis?: number
                                              }
                                              Function called when the placement is computed
                                                (
                                                data: ComputePositionReturn,
                                                ) => void
                                                Function called when the floating element is positioned or not
                                                  (data: {
                                                  placed: boolean
                                                  }) => void
                                                  The virtual padding around the viewport edges to check for overflow
                                                  number
                                                  Whether the floating element can overlap the reference element
                                                  boolean
                                                  false
                                                  
                                                  The initial placement of the floating element
                                                  | 'bottom'
                                                  | 'bottom-end'
                                                  | 'bottom-start'
                                                  | 'left'
                                                  | 'left-end'
                                                  | 'left-start'
                                                  | 'right'
                                                  | 'right-end'
                                                  | 'right-start'
                                                  | 'top'
                                                  | 'top-end'
                                                  | 'top-start'
                                                  'bottom'
                                                  
                                                  Whether to make the floating element same width as the reference element
                                                  boolean
                                                  The secondary axis offset or gap between the reference and floating elements
                                                  number
                                                  Whether the popover should slide when it overflows.
                                                  boolean
                                                  The strategy to use for positioning
                                                  | 'absolute'
                                                  | 'fixed'
                                                  'absolute'
                                                  
                                                  A callback that will be called when the popover needs to calculate its position.
                                                    (data: {
                                                    updatePosition: () => Promise<void>
                                                    }) => void | Promise<void>
                                                    Type
                                                    number
                                                    Description
                                                    The minimum padding between the arrow and the floating element's corner.
                                                    Type
                                                    () =>
                                                    | 'clippingAncestors'
                                                    | Element
                                                    | Array<Element>
                                                    | {
                                                    height: number
                                                    width: number
                                                    x: number
                                                    y: number
                                                    }
                                                    Description
                                                    The overflow boundary of the reference element
                                                      Type
                                                      boolean
                                                      Description
                                                      Whether the popover should fit the viewport.
                                                      Type
                                                      | boolean
                                                      | Array<
                                                      | 'bottom'
                                                      | 'bottom-end'
                                                      | 'bottom-start'
                                                      | 'left'
                                                      | 'left-end'
                                                      | 'left-start'
                                                      | 'right'
                                                      | 'right-end'
                                                      | 'right-start'
                                                      | 'top'
                                                      | 'top-end'
                                                      | 'top-start'
                                                      >
                                                      Description
                                                      Whether to flip the placement when the floating element overflows the boundary.
                                                      Type
                                                      (
                                                      element:
                                                      | HTMLElement
                                                      | VirtualElement,
                                                      ) => {
                                                      height?: number
                                                      width?: number
                                                      x?: number
                                                      y?: number
                                                      }
                                                      Description
                                                      Function that returns the anchor rect
                                                        Type
                                                        number
                                                        Description
                                                        The main axis offset or gap between the reference and floating element
                                                        Type
                                                        boolean
                                                        Description
                                                        Whether the popover should be hidden when the reference element is detached
                                                        Type
                                                        | boolean
                                                        | {
                                                        ancestorResize?: boolean
                                                        ancestorScroll?: boolean
                                                        animationFrame?: boolean
                                                        elementResize?: boolean
                                                        layoutShift?: boolean
                                                        }
                                                        Description
                                                        Options to activate auto-update listeners
                                                        Type
                                                        {
                                                        crossAxis?: number
                                                        mainAxis?: number
                                                        }
                                                        Description
                                                        The offset of the floating element
                                                        Type
                                                        (
                                                        data: ComputePositionReturn,
                                                        ) => void
                                                        Description
                                                        Function called when the placement is computed
                                                          Type
                                                          (data: {
                                                          placed: boolean
                                                          }) => void
                                                          Description
                                                          Function called when the floating element is positioned or not
                                                            Type
                                                            number
                                                            Description
                                                            The virtual padding around the viewport edges to check for overflow
                                                            Type
                                                            boolean
                                                            Description
                                                            Whether the floating element can overlap the reference element
                                                            Type
                                                            | 'bottom'
                                                            | 'bottom-end'
                                                            | 'bottom-start'
                                                            | 'left'
                                                            | 'left-end'
                                                            | 'left-start'
                                                            | 'right'
                                                            | 'right-end'
                                                            | 'right-start'
                                                            | 'top'
                                                            | 'top-end'
                                                            | 'top-start'
                                                            Description
                                                            The initial placement of the floating element
                                                            Type
                                                            boolean
                                                            Description
                                                            Whether to make the floating element same width as the reference element
                                                            Type
                                                            number
                                                            Description
                                                            The secondary axis offset or gap between the reference and floating elements
                                                            Type
                                                            boolean
                                                            Description
                                                            Whether the popover should slide when it overflows.
                                                            Type
                                                            | 'absolute'
                                                            | 'fixed'
                                                            Description
                                                            The strategy to use for positioning
                                                            Type
                                                            (data: {
                                                            updatePosition: () => Promise<void>
                                                            }) => void | Promise<void>
                                                            Description
                                                            A callback that will be called when the popover needs to calculate its position.

                                                              Element API

                                                              The following describes the individual subcomponents of the Menu component.

                                                              PropTypeDefault
                                                              React children prop.
                                                              The density of the button. Governs padding and height.
                                                              | 'default'
                                                              | 'compact'
                                                              'default'
                                                              
                                                              Controls whether the component is interactive. When true, pointer/focus events are blocked, and the component is visually dimmed.
                                                              boolean
                                                              false
                                                              
                                                              The style variant of the button. Governs colors.
                                                              | 'neutral'
                                                              | 'primary'
                                                              | 'danger'
                                                              | 'white-persistent'
                                                              | 'black-persistent'
                                                              'neutral'
                                                              
                                                              Allows you to replace the component's HTML element with a different tag or component. Learn more
                                                              | ReactElement
                                                              | ((
                                                              props: object,
                                                              ) => ReactElement)
                                                              The size of the component and its icons.
                                                              | 'sm'
                                                              | 'md'
                                                              | 'lg'
                                                              'md'
                                                              
                                                              Icon positioned before the text content. If supplied as a LucideIcon, the size will automatically match the size prop. Supply as a ReactElement for additional customization.
                                                              | LucideIcon
                                                              | ReactNode
                                                              The style variant of the button. Governs colors.
                                                              | 'fill'
                                                              | 'ghost'
                                                              | 'outline'
                                                              'fill'
                                                              
                                                              Description
                                                              React children prop.
                                                              Type
                                                              | 'default'
                                                              | 'compact'
                                                              Description
                                                              The density of the button. Governs padding and height.
                                                              Type
                                                              boolean
                                                              Description
                                                              Controls whether the component is interactive. When true, pointer/focus events are blocked, and the component is visually dimmed.
                                                              Type
                                                              | 'neutral'
                                                              | 'primary'
                                                              | 'danger'
                                                              | 'white-persistent'
                                                              | 'black-persistent'
                                                              Description
                                                              The style variant of the button. Governs colors.
                                                              Type
                                                              | ReactElement
                                                              | ((
                                                              props: object,
                                                              ) => ReactElement)
                                                              Description
                                                              Allows you to replace the component's HTML element with a different tag or component. Learn more
                                                              Type
                                                              | 'sm'
                                                              | 'md'
                                                              | 'lg'
                                                              Description
                                                              The size of the component and its icons.
                                                              Type
                                                              | LucideIcon
                                                              | ReactNode
                                                              Description
                                                              Icon positioned before the text content. If supplied as a LucideIcon, the size will automatically match the size prop. Supply as a ReactElement for additional customization.
                                                              Type
                                                              | 'fill'
                                                              | 'ghost'
                                                              | 'outline'
                                                              Description
                                                              The style variant of the button. Governs colors.
                                                              PropTypeDefault
                                                              The density of the button. Governs padding and height.
                                                              | 'default'
                                                              | 'compact'
                                                              'default'
                                                              
                                                              Controls whether the component is interactive. When true, pointer/focus events are blocked, and the component is visually dimmed.
                                                              boolean
                                                              false
                                                              
                                                              The style variant of the button. Governs colors.
                                                              | 'neutral'
                                                              | 'primary'
                                                              | 'danger'
                                                              | 'white-persistent'
                                                              | 'black-persistent'
                                                              'neutral'
                                                              
                                                              Allows you to replace the component's HTML element with a different tag or component. Learn more
                                                              | ReactElement
                                                              | ((
                                                              props: object,
                                                              ) => ReactElement)
                                                              The size of the component and its icons.
                                                              | 'sm'
                                                              | 'md'
                                                              | 'lg'
                                                              'md'
                                                              
                                                              The style variant of the button. Governs colors.
                                                              | 'fill'
                                                              | 'ghost'
                                                              | 'outline'
                                                              'fill'
                                                              
                                                              Type
                                                              | 'default'
                                                              | 'compact'
                                                              Description
                                                              The density of the button. Governs padding and height.
                                                              Type
                                                              boolean
                                                              Description
                                                              Controls whether the component is interactive. When true, pointer/focus events are blocked, and the component is visually dimmed.
                                                              Type
                                                              | 'neutral'
                                                              | 'primary'
                                                              | 'danger'
                                                              | 'white-persistent'
                                                              | 'black-persistent'
                                                              Description
                                                              The style variant of the button. Governs colors.
                                                              Type
                                                              | ReactElement
                                                              | ((
                                                              props: object,
                                                              ) => ReactElement)
                                                              Description
                                                              Allows you to replace the component's HTML element with a different tag or component. Learn more
                                                              Type
                                                              | 'sm'
                                                              | 'md'
                                                              | 'lg'
                                                              Description
                                                              The size of the component and its icons.
                                                              Type
                                                              | 'fill'
                                                              | 'ghost'
                                                              | 'outline'
                                                              Description
                                                              The style variant of the button. Governs colors.
                                                              PropType
                                                              React children prop.
                                                              Allows you to replace the component's HTML element with a different tag or component. Learn more
                                                              | ReactElement
                                                              | ((
                                                              props: object,
                                                              ) => ReactElement)
                                                              Description
                                                              React children prop.
                                                              Type
                                                              | ReactElement
                                                              | ((
                                                              props: object,
                                                              ) => ReactElement)
                                                              Description
                                                              Allows you to replace the component's HTML element with a different tag or component. Learn more
                                                              Enhances a child element to open the menu when clicked. Requires a single child element.
                                                              <Menu.Trigger>
                                                              <button>Open</button>
                                                              </Menu.Trigger>
                                                              PropType
                                                              React children Render Prop
                                                              id attribute. If omitted, a unique identifier will be automatically generated for accessibility.
                                                              string
                                                              Type
                                                              string
                                                              Description
                                                              id attribute. If omitted, a unique identifier will be automatically generated for accessibility.
                                                              PropType
                                                              The unique value of the menu item option.
                                                              string
                                                              React children prop.
                                                              Whether the menu should be closed when the option is selected.
                                                              boolean
                                                              Whether the menu item is disabled
                                                              boolean
                                                              The function to call when the item is selected
                                                                () => void
                                                                Allows you to replace the component's HTML element with a different tag or component. Learn more
                                                                | ReactElement
                                                                | ((
                                                                props: object,
                                                                ) => ReactElement)
                                                                The textual value of the option. Used in typeahead navigation of the menu. If not provided, the text content of the menu item will be used.
                                                                string
                                                                Type
                                                                string
                                                                Description
                                                                The unique value of the menu item option.
                                                                Description
                                                                React children prop.
                                                                Type
                                                                boolean
                                                                Description
                                                                Whether the menu should be closed when the option is selected.
                                                                Type
                                                                boolean
                                                                Description
                                                                Whether the menu item is disabled
                                                                Type
                                                                () => void
                                                                Description
                                                                The function to call when the item is selected
                                                                  Type
                                                                  | ReactElement
                                                                  | ((
                                                                  props: object,
                                                                  ) => ReactElement)
                                                                  Description
                                                                  Allows you to replace the component's HTML element with a different tag or component. Learn more
                                                                  Type
                                                                  string
                                                                  Description
                                                                  The textual value of the option. Used in typeahead navigation of the menu. If not provided, the text content of the menu item will be used.
                                                                  PropType
                                                                  React children prop.
                                                                  Allows you to replace the component's HTML element with a different tag or component. Learn more
                                                                  | ReactElement
                                                                  | ((
                                                                  props: object,
                                                                  ) => ReactElement)
                                                                  Description
                                                                  React children prop.
                                                                  Type
                                                                  | ReactElement
                                                                  | ((
                                                                  props: object,
                                                                  ) => ReactElement)
                                                                  Description
                                                                  Allows you to replace the component's HTML element with a different tag or component. Learn more
                                                                  PropType
                                                                  React children prop.
                                                                  Allows you to replace the component's HTML element with a different tag or component. Learn more
                                                                  | ReactElement
                                                                  | ((
                                                                  props: object,
                                                                  ) => ReactElement)
                                                                  Description
                                                                  React children prop.
                                                                  Type
                                                                  | ReactElement
                                                                  | ((
                                                                  props: object,
                                                                  ) => ReactElement)
                                                                  Description
                                                                  Allows you to replace the component's HTML element with a different tag or component. Learn more
                                                                  PropType
                                                                  React children prop.
                                                                  Allows you to replace the component's HTML element with a different tag or component. Learn more
                                                                  | ReactElement
                                                                  | ((
                                                                  props: object,
                                                                  ) => ReactElement)
                                                                  Description
                                                                  React children prop.
                                                                  Type
                                                                  | ReactElement
                                                                  | ((
                                                                  props: object,
                                                                  ) => ReactElement)
                                                                  Description
                                                                  Allows you to replace the component's HTML element with a different tag or component. Learn more
                                                                  PropType
                                                                  React children prop.
                                                                  Allows you to replace the component's HTML element with a different tag or component. Learn more
                                                                  | ReactElement
                                                                  | ((
                                                                  props: object,
                                                                  ) => ReactElement)
                                                                  Description
                                                                  React children prop.
                                                                  Type
                                                                  | ReactElement
                                                                  | ((
                                                                  props: object,
                                                                  ) => ReactElement)
                                                                  Description
                                                                  Allows you to replace the component's HTML element with a different tag or component. Learn more
                                                                  Entity not found: MenuItemControlProps
                                                                  PropType
                                                                  React children prop.
                                                                  id for this item group.
                                                                  string
                                                                  Allows you to replace the component's HTML element with a different tag or component. Learn more
                                                                  | ReactElement
                                                                  | ((
                                                                  props: object,
                                                                  ) => ReactElement)
                                                                  Description
                                                                  React children prop.
                                                                  Type
                                                                  string
                                                                  Description
                                                                  id for this item group.
                                                                  Type
                                                                  | ReactElement
                                                                  | ((
                                                                  props: object,
                                                                  ) => ReactElement)
                                                                  Description
                                                                  Allows you to replace the component's HTML element with a different tag or component. Learn more
                                                                  PropType
                                                                  React children prop.
                                                                  Allows you to replace the component's HTML element with a different tag or component. Learn more
                                                                  | ReactElement
                                                                  | ((
                                                                  props: object,
                                                                  ) => ReactElement)
                                                                  Description
                                                                  React children prop.
                                                                  Type
                                                                  | ReactElement
                                                                  | ((
                                                                  props: object,
                                                                  ) => ReactElement)
                                                                  Description
                                                                  Allows you to replace the component's HTML element with a different tag or component. Learn more
                                                                  PropType
                                                                  lucide-react icon or JSX Element.
                                                                  | LucideIcon
                                                                  | ReactNode
                                                                  React children prop.
                                                                  Allows you to replace the component's HTML element with a different tag or component. Learn more
                                                                  | ReactElement
                                                                  | ((
                                                                  props: object,
                                                                  ) => ReactElement)
                                                                  Type
                                                                  | LucideIcon
                                                                  | ReactNode
                                                                  Description
                                                                  lucide-react icon or JSX Element.
                                                                  Description
                                                                  React children prop.
                                                                  Type
                                                                  | ReactElement
                                                                  | ((
                                                                  props: object,
                                                                  ) => ReactElement)
                                                                  Description
                                                                  Allows you to replace the component's HTML element with a different tag or component. Learn more
                                                                  PropType
                                                                  React children prop.
                                                                  Allows you to replace the component's HTML element with a different tag or component. Learn more
                                                                  | ReactElement
                                                                  | ((
                                                                  props: object,
                                                                  ) => ReactElement)
                                                                  Description
                                                                  React children prop.
                                                                  Type
                                                                  | ReactElement
                                                                  | ((
                                                                  props: object,
                                                                  ) => ReactElement)
                                                                  Description
                                                                  Allows you to replace the component's HTML element with a different tag or component. Learn more
                                                                  PropType
                                                                  The value of the option
                                                                  string
                                                                  Whether the option is checked
                                                                  boolean
                                                                  React children prop.
                                                                  Whether the menu should be closed when the option is selected.
                                                                  boolean
                                                                  Whether the menu item is disabled
                                                                  boolean
                                                                  Function called when the option state is changed
                                                                    (
                                                                    checked: boolean,
                                                                    ) => void
                                                                    The function to call when the item is selected
                                                                      () => void
                                                                      Allows you to replace the component's HTML element with a different tag or component. Learn more
                                                                      | ReactElement
                                                                      | ((
                                                                      props: object,
                                                                      ) => ReactElement)
                                                                      The textual value of the option. Used in typeahead navigation of the menu. If not provided, the text content of the menu item will be used.
                                                                      string
                                                                      Type
                                                                      string
                                                                      Description
                                                                      The value of the option
                                                                      Type
                                                                      boolean
                                                                      Description
                                                                      Whether the option is checked
                                                                      Description
                                                                      React children prop.
                                                                      Type
                                                                      boolean
                                                                      Description
                                                                      Whether the menu should be closed when the option is selected.
                                                                      Type
                                                                      boolean
                                                                      Description
                                                                      Whether the menu item is disabled
                                                                      Type
                                                                      (
                                                                      checked: boolean,
                                                                      ) => void
                                                                      Description
                                                                      Function called when the option state is changed
                                                                        Type
                                                                        () => void
                                                                        Description
                                                                        The function to call when the item is selected
                                                                          Type
                                                                          | ReactElement
                                                                          | ((
                                                                          props: object,
                                                                          ) => ReactElement)
                                                                          Description
                                                                          Allows you to replace the component's HTML element with a different tag or component. Learn more
                                                                          Type
                                                                          string
                                                                          Description
                                                                          The textual value of the option. Used in typeahead navigation of the menu. If not provided, the text content of the menu item will be used.
                                                                          PropTypeDefault
                                                                          React children prop.
                                                                          <Checkbox.IndicatorIcon />
                                                                          Allows you to replace the component's HTML element with a different tag or component. Learn more
                                                                          | ReactElement
                                                                          | ((
                                                                          props: object,
                                                                          ) => ReactElement)
                                                                          Description
                                                                          React children prop.
                                                                          Type
                                                                          | ReactElement
                                                                          | ((
                                                                          props: object,
                                                                          ) => ReactElement)
                                                                          Description
                                                                          Allows you to replace the component's HTML element with a different tag or component. Learn more
                                                                          PropType
                                                                          The unique value of the menu item option.
                                                                          string
                                                                          React children prop.
                                                                          Whether the menu should be closed when the option is selected.
                                                                          boolean
                                                                          Whether the menu item is disabled
                                                                          boolean
                                                                          The function to call when the item is selected
                                                                            () => void
                                                                            Allows you to replace the component's HTML element with a different tag or component. Learn more
                                                                            | ReactElement
                                                                            | ((
                                                                            props: object,
                                                                            ) => ReactElement)
                                                                            The textual value of the option. Used in typeahead navigation of the menu. If not provided, the text content of the menu item will be used.
                                                                            string
                                                                            Type
                                                                            string
                                                                            Description
                                                                            The unique value of the menu item option.
                                                                            Description
                                                                            React children prop.
                                                                            Type
                                                                            boolean
                                                                            Description
                                                                            Whether the menu should be closed when the option is selected.
                                                                            Type
                                                                            boolean
                                                                            Description
                                                                            Whether the menu item is disabled
                                                                            Type
                                                                            () => void
                                                                            Description
                                                                            The function to call when the item is selected
                                                                              Type
                                                                              | ReactElement
                                                                              | ((
                                                                              props: object,
                                                                              ) => ReactElement)
                                                                              Description
                                                                              Allows you to replace the component's HTML element with a different tag or component. Learn more
                                                                              Type
                                                                              string
                                                                              Description
                                                                              The textual value of the option. Used in typeahead navigation of the menu. If not provided, the text content of the menu item will be used.
                                                                              PropType
                                                                              React children prop.
                                                                              Allows you to replace the component's HTML element with a different tag or component. Learn more
                                                                              | ReactElement
                                                                              | ((
                                                                              props: object,
                                                                              ) => ReactElement)
                                                                              Description
                                                                              React children prop.
                                                                              Type
                                                                              | ReactElement
                                                                              | ((
                                                                              props: object,
                                                                              ) => ReactElement)
                                                                              Description
                                                                              Allows you to replace the component's HTML element with a different tag or component. Learn more
                                                                              PropType
                                                                              React children prop.
                                                                              string
                                                                              (
                                                                              value: string,
                                                                              ) => void
                                                                              Allows you to replace the component's HTML element with a different tag or component. Learn more
                                                                              | ReactElement
                                                                              | ((
                                                                              props: object,
                                                                              ) => ReactElement)
                                                                              string
                                                                              Description
                                                                              React children prop.
                                                                              Type
                                                                              string
                                                                              Type
                                                                              (
                                                                              value: string,
                                                                              ) => void
                                                                              Type
                                                                              | ReactElement
                                                                              | ((
                                                                              props: object,
                                                                              ) => ReactElement)
                                                                              Description
                                                                              Allows you to replace the component's HTML element with a different tag or component. Learn more
                                                                              Type
                                                                              string
                                                                              PropType
                                                                              React children prop.
                                                                              Allows you to replace the component's HTML element with a different tag or component. Learn more
                                                                              | ReactElement
                                                                              | ((
                                                                              props: object,
                                                                              ) => ReactElement)
                                                                              Description
                                                                              React children prop.
                                                                              Type
                                                                              | ReactElement
                                                                              | ((
                                                                              props: object,
                                                                              ) => ReactElement)
                                                                              Description
                                                                              Allows you to replace the component's HTML element with a different tag or component. Learn more
                                                                              A menu item that triggers a submenu on hover or click. Renders a <button> element by default.
                                                                              PropTypeDefault
                                                                              The unique value of the menu item option.
                                                                              string
                                                                              React children prop.
                                                                              Whether the menu should be closed when the option is selected.
                                                                              boolean
                                                                              Whether the menu item is disabled
                                                                              boolean
                                                                              Icon to display next to the label, which indicates that this menu item is a trigger for a submenu.
                                                                              | LucideIcon
                                                                              | ReactNode
                                                                              ChevronRight
                                                                              
                                                                              The function to call when the item is selected
                                                                                () => void
                                                                                Allows you to replace the component's HTML element with a different tag or component. Learn more
                                                                                | ReactElement
                                                                                | ((
                                                                                props: object,
                                                                                ) => ReactElement)
                                                                                The textual value of the option. Used in typeahead navigation of the menu. If not provided, the text content of the menu item will be used.
                                                                                string
                                                                                Type
                                                                                string
                                                                                Description
                                                                                The unique value of the menu item option.
                                                                                Description
                                                                                React children prop.
                                                                                Type
                                                                                boolean
                                                                                Description
                                                                                Whether the menu should be closed when the option is selected.
                                                                                Type
                                                                                boolean
                                                                                Description
                                                                                Whether the menu item is disabled
                                                                                Type
                                                                                | LucideIcon
                                                                                | ReactNode
                                                                                Description
                                                                                Icon to display next to the label, which indicates that this menu item is a trigger for a submenu.
                                                                                Type
                                                                                () => void
                                                                                Description
                                                                                The function to call when the item is selected
                                                                                  Type
                                                                                  | ReactElement
                                                                                  | ((
                                                                                  props: object,
                                                                                  ) => ReactElement)
                                                                                  Description
                                                                                  Allows you to replace the component's HTML element with a different tag or component. Learn more
                                                                                  Type
                                                                                  string
                                                                                  Description
                                                                                  The textual value of the option. Used in typeahead navigation of the menu. If not provided, the text content of the menu item will be used.