# Context Menu (/cloud/headless/context-menu)



{/* Generated by scripts/sync-base-ui-reference.mjs. Edit the script, not this file. */}

## In Nyte [#in-nyte]

```ts title="Import"
import { ContextMenu } from "@nyte-ai/ui/context-menu";
```

`@nyte-ai/ui/context-menu` re-exports the Base UI namespace unchanged. There is no Nyte styling on
this subpath; the consumer owns every class, StyleX style, and layout decision. Base UI owns the
interaction model, keyboard handling, focus management, and ARIA below.

Consumed by:

* `desktop/src/renderer/src/components/menu.tsx`

The rest of this page is Base UI's documentation for `@base-ui/react/context-menu`, reproduced
verbatim under the MIT license, © Material-UI SAS. Component paths in examples refer to the Base UI
package; in Nyte, import from the subpath above.

## Usage guidelines [#usage-guidelines]

* **Use context menus as an enhancement**: Don't make a context menu the only way to perform actions. Users may not discover or be able to open a context menu, especially on touch devices or with assistive technology. Always provide visible controls for the actions that are available in the context menu.

## Anatomy [#anatomy]

Import the components and place them together:

```jsx title="Anatomy"
import { ContextMenu } from '@base-ui/react/context-menu';

<ContextMenu.Root>
  <ContextMenu.Trigger />
  <ContextMenu.Portal>
    <ContextMenu.Backdrop />
    <ContextMenu.Positioner>
      <ContextMenu.Popup>
        <ContextMenu.Arrow />
        <ContextMenu.Item />
        <ContextMenu.LinkItem />
        <ContextMenu.Separator />

        <ContextMenu.SubmenuRoot>
          <ContextMenu.SubmenuTrigger />
        </ContextMenu.SubmenuRoot>

        <ContextMenu.Group>
          <ContextMenu.GroupLabel />
        </ContextMenu.Group>

        <ContextMenu.RadioGroup>
          <ContextMenu.RadioItem>
            <ContextMenu.RadioItemIndicator />
          </ContextMenu.RadioItem>
        </ContextMenu.RadioGroup>

        <ContextMenu.CheckboxItem>
          <ContextMenu.CheckboxItemIndicator />
        </ContextMenu.CheckboxItem>
      </ContextMenu.Popup>
    </ContextMenu.Positioner>
  </ContextMenu.Portal>
</ContextMenu.Root>;
```

## Examples [#examples]

[Menu](/react/components/menu#examples) displays additional demos, many of which apply to the context menu as well.

### Using with Menu [#using-with-menu]

A context menu should supplement a primary way to perform the same actions. This image card exposes actions through a visible menu button and reuses them in the context menu for right-click and long-press users.

### Nested menu [#nested-menu]

To create a submenu, create a `<ContextMenu.SubmenuRoot>` inside the parent context menu. Use the `<ContextMenu.SubmenuTrigger>` part for the menu item that opens the nested menu.

## API reference [#api-reference]

### Root [#root]

A component that creates a context menu activated by right clicking or long pressing.
Doesn't render its own HTML element.

**Root Props:**

| Prop                 | Type                                                                           | Default      | Description                                                                                                                                                                                                |
| :------------------- | :----------------------------------------------------------------------------- | :----------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| defaultOpen          | `boolean`                                                                      | `false`      | Whether the menu is initially open. To render a controlled menu, use the `open` prop instead.                                                                                                              |
| open                 | `boolean`                                                                      | -            | Whether the menu is currently open.                                                                                                                                                                        |
| onOpenChange         | `((open: boolean, eventDetails: ContextMenu.Root.ChangeEventDetails) => void)` | -            | Event handler called when the menu is opened or closed.                                                                                                                                                    |
| highlightItemOnHover | `boolean`                                                                      | `true`       | Whether moving the pointer over items should highlight them.&#xA;Disabling this prop allows CSS `:hover` to be differentiated from the `:focus` (`data-highlighted`) state.                                |
| actionsRef           | `React.RefObject<MenuRoot.Actions \| null>`                                    | -            | A ref to imperative actions. `unmount`: Manually unmounts the menu.&#xA;Call this after any externally controlled closing animation finishes.`close`: When specified, the menu can be closed imperatively. |
| loopFocus            | `boolean`                                                                      | `true`       | Whether to loop keyboard focus back to the first item&#xA;when the end of the list is reached while using the arrow keys.                                                                                  |
| onOpenChangeComplete | `((open: boolean) => void)`                                                    | -            | Event handler called after any animations complete when the menu is opened or closed.                                                                                                                      |
| disabled             | `boolean`                                                                      | `false`      | Whether the component should ignore user interaction.                                                                                                                                                      |
| orientation          | `MenuRoot.Orientation`                                                         | `'vertical'` | The visual orientation of the menu.&#xA;Controls whether roving focus uses up/down or left/right arrow keys.                                                                                               |
| children             | `React.ReactNode`                                                              | -            | -                                                                                                                                                                                                          |

### Root.Props [#rootprops]

Re-export of [Root](#root) props.

### Root.State [#rootstate]

```typescript
type ContextMenuRootState = {};
```

### Root.Actions [#rootactions]

```typescript
type ContextMenuRootActions = { unmount: () => void; close: () => void };
```

### Root.ChangeEventReason [#rootchangeeventreason]

```typescript
type ContextMenuRootChangeEventReason =
  | 'trigger-hover'
  | 'trigger-focus'
  | 'trigger-press'
  | 'outside-press'
  | 'focus-out'
  | 'list-navigation'
  | 'escape-key'
  | 'item-press'
  | 'close-press'
  | 'sibling-open'
  | 'cancel-open'
  | 'imperative-action'
  | 'none';
```

### Root.ChangeEventDetails [#rootchangeeventdetails]

```typescript
type ContextMenuRootChangeEventDetails = (
  | { reason: 'trigger-hover'; event: MouseEvent }
  | { reason: 'trigger-focus'; event: FocusEvent }
  | { reason: 'trigger-press'; event: MouseEvent | PointerEvent | TouchEvent | KeyboardEvent }
  | { reason: 'outside-press'; event: MouseEvent | PointerEvent | TouchEvent }
  | { reason: 'focus-out'; event: FocusEvent | KeyboardEvent }
  | { reason: 'list-navigation'; event: KeyboardEvent }
  | { reason: 'escape-key'; event: KeyboardEvent }
  | { reason: 'item-press'; event: MouseEvent | PointerEvent | KeyboardEvent }
  | { reason: 'close-press'; event: MouseEvent | PointerEvent | KeyboardEvent }
  | { reason: 'sibling-open'; event: Event }
  | { reason: 'cancel-open'; event: MouseEvent }
  | { reason: 'imperative-action'; event: Event }
  | { reason: 'none'; event: Event }
) & {
  /** Cancels Base UI from handling the event. */
  cancel: () => void;
  /** Allows the event to propagate in cases where Base UI will stop the propagation. */
  allowPropagation: () => void;
  /** Indicates whether the event has been canceled. */
  isCanceled: boolean;
  /** Indicates whether the event is allowed to propagate. */
  isPropagationAllowed: boolean;
  /** The element that triggered the event, if applicable. */
  trigger: Element | undefined;
};
```

### Trigger [#trigger]

An area that opens the menu on right click or long press.
Renders a `<div>` element.

**Trigger Props:**

| Prop      | Type                                                                                              | Default | Description                                                                                                                                                                                   |
| :-------- | :------------------------------------------------------------------------------------------------ | :------ | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| className | `string \| ((state: ContextMenu.Trigger.State) => string \| undefined)`                           | -       | CSS class applied to the element, or a function that&#xA;returns a class based on the component's state.                                                                                      |
| style     | `React.CSSProperties \| ((state: ContextMenu.Trigger.State) => React.CSSProperties \| undefined)` | -       | Style applied to the element, or a function that&#xA;returns a style object based on the component's state.                                                                                   |
| render    | `ReactElement \| ((props: HTMLProps, state: ContextMenu.Trigger.State) => ReactElement)`          | -       | Allows you to replace the component's HTML element&#xA;with a different tag, or compose it with another component. Accepts a `ReactElement` or a function that returns the element to render. |

**Trigger Data Attributes:**

| Attribute       | Type | Description                                          |
| :-------------- | :--- | :--------------------------------------------------- |
| data-popup-open | -    | Present when the corresponding context menu is open. |
| data-pressed    | -    | Present when the corresponding context menu is open. |

### Trigger.Props [#triggerprops]

Re-export of [Trigger](#trigger) props.

### Trigger.State [#triggerstate]

```typescript
type ContextMenuTriggerState = {
  /** Whether the context menu is currently open. */
  open: boolean;
};
```

### Portal [#portal]

A portal element that moves the popup to a different part of the DOM.
By default, the portal element is appended to `<body>`.
Renders a `<div>` element.

**Portal Props:**

| Prop        | Type                                                                                             | Default | Description                                                                                                                                                                                   |
| :---------- | :----------------------------------------------------------------------------------------------- | :------ | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| container   | `HTMLElement \| ShadowRoot \| React.RefObject<HTMLElement \| ShadowRoot \| null> \| null`        | -       | A parent element to render the portal element into.                                                                                                                                           |
| className   | `string \| ((state: ContextMenu.Portal.State) => string \| undefined)`                           | -       | CSS class applied to the element, or a function that&#xA;returns a class based on the component's state.                                                                                      |
| style       | `React.CSSProperties \| ((state: ContextMenu.Portal.State) => React.CSSProperties \| undefined)` | -       | Style applied to the element, or a function that&#xA;returns a style object based on the component's state.                                                                                   |
| keepMounted | `boolean`                                                                                        | `false` | Whether to keep the portal mounted in the DOM while the popup is hidden.                                                                                                                      |
| render      | `ReactElement \| ((props: HTMLProps, state: ContextMenu.Portal.State) => ReactElement)`          | -       | Allows you to replace the component's HTML element&#xA;with a different tag, or compose it with another component. Accepts a `ReactElement` or a function that returns the element to render. |

### Portal.Props [#portalprops]

Re-export of [Portal](#portal) props.

### Portal.State [#portalstate]

```typescript
type ContextMenuPortalState = {};
```

### Backdrop [#backdrop]

An overlay displayed beneath the menu popup.
Renders a `<div>` element.

**Backdrop Props:**

| Prop      | Type                                                                                               | Default | Description                                                                                                                                                                                   |
| :-------- | :------------------------------------------------------------------------------------------------- | :------ | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| className | `string \| ((state: ContextMenu.Backdrop.State) => string \| undefined)`                           | -       | CSS class applied to the element, or a function that&#xA;returns a class based on the component's state.                                                                                      |
| style     | `React.CSSProperties \| ((state: ContextMenu.Backdrop.State) => React.CSSProperties \| undefined)` | -       | Style applied to the element, or a function that&#xA;returns a style object based on the component's state.                                                                                   |
| render    | `ReactElement \| ((props: HTMLProps, state: ContextMenu.Backdrop.State) => ReactElement)`          | -       | Allows you to replace the component's HTML element&#xA;with a different tag, or compose it with another component. Accepts a `ReactElement` or a function that returns the element to render. |

**Backdrop Data Attributes:**

| Attribute           | Type | Description                                |
| :------------------ | :--- | :----------------------------------------- |
| data-open           | -    | Present when the menu is open.             |
| data-closed         | -    | Present when the menu is closed.           |
| data-starting-style | -    | Present when the menu begins animating in. |
| data-ending-style   | -    | Present when the menu is animating out.    |

### Backdrop.Props [#backdropprops]

Re-export of [Backdrop](#backdrop) props.

### Backdrop.State [#backdropstate]

```typescript
type ContextMenuBackdropState = {
  /** Whether the menu is currently open. */
  open: boolean;
  /** The transition status of the component. */
  transitionStatus: TransitionStatus;
};
```

### Positioner [#positioner]

Positions the context menu popup against the pointer or a custom anchor.
Renders a `<div>` element.

**Positioner Props:**

| Prop                  | Type                                                                                                                 | Default                | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| :-------------------- | :------------------------------------------------------------------------------------------------------------------- | :--------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| disableAnchorTracking | `boolean`                                                                                                            | `false`                | Whether to disable the popup from tracking any layout shift of its positioning anchor.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| align                 | `Align`                                                                                                              | `'start'`              | How to align the popup relative to the specified side.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| alignOffset           | `number \| OffsetFunction`                                                                                           | -                      | Additional offset along the alignment axis in pixels.&#xA;Also accepts a function that returns the offset to read the dimensions of the anchor&#xA;and positioner elements, along with its side and alignment. The function takes a `data` object parameter with the following properties: `data.anchor`: the dimensions of the anchor element with properties `width` and `height`.`data.positioner`: the dimensions of the positioner element with properties `width` and `height`.`data.side`: which side of the anchor element the positioner is aligned against.`data.align`: how the positioner is aligned relative to the specified side. Defaults to `2` for root context menus when `side` is not specified and `align` is not&#xA;`'center'`. Otherwise, it defaults to `0`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| side                  | `Side`                                                                                                               | `'bottom'`             | Which side of the anchor element to align the popup against.&#xA;May automatically change to avoid collisions. Submenus default to `'inline-end'`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| sideOffset            | `number \| OffsetFunction`                                                                                           | -                      | Distance between the anchor and the popup in pixels.&#xA;Also accepts a function that returns the distance to read the dimensions of the anchor&#xA;and positioner elements, along with its side and alignment. The function takes a `data` object parameter with the following properties: `data.anchor`: the dimensions of the anchor element with properties `width` and `height`.`data.positioner`: the dimensions of the positioner element with properties `width` and `height`.`data.side`: which side of the anchor element the positioner is aligned against.`data.align`: how the positioner is aligned relative to the specified side. Defaults to `-5` for root context menus when `side` is not specified and `align` is not&#xA;`'center'`. Otherwise, it defaults to `0`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| arrowPadding          | `number`                                                                                                             | -                      | Minimum distance to maintain between the arrow and the edges of the popup. Root context menus always use `0`. Submenus default to `5`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| anchor                | `Element \| VirtualElement \| React.RefObject<Element \| null> \| (() => Element \| VirtualElement \| null) \| null` | -                      | An element to position the popup against.&#xA;By default, root context menus are positioned at the pointer, and submenus are positioned&#xA;against their trigger.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| collisionAvoidance    | `CollisionAvoidance`                                                                                                 | -                      | Determines how to handle collisions when positioning the popup. `side` controls overflow on the preferred placement axis (`top`/`bottom` or `left`/`right`): `'flip'`: keep the requested side when it fits; otherwise try the opposite side&#xA;(`top` and `bottom`, or `left` and `right`).`'shift'`: never change side; keep the requested side and move the popup within&#xA;the clipping boundary so it stays visible.`'none'`: do not correct side-axis overflow. `align` controls overflow on the alignment axis (`start`/`center`/`end`): `'flip'`: keep side, but swap `start` and `end` when the requested alignment overflows.`'shift'`: keep side and requested alignment, then nudge the popup along the&#xA;alignment axis to fit.`'none'`: do not correct alignment-axis overflow. `fallbackAxisSide` controls fallback behavior on the perpendicular axis when the&#xA;preferred axis cannot fit: `'start'`: allow perpendicular fallback and try the logical start side first&#xA;(`top` before `bottom`, or `left` before `right` in LTR).`'end'`: allow perpendicular fallback and try the logical end side first&#xA;(`bottom` before `top`, or `right` before `left` in LTR).`'none'`: do not fallback to the perpendicular axis. When `side` is `'shift'`, explicitly setting `align` only supports `'shift'` or `'none'`.&#xA;If `align` is omitted, it defaults to `'flip'`. |
| collisionBoundary     | `Boundary`                                                                                                           | `'clipping-ancestors'` | An element or a rectangle that delimits the area that the popup is confined to.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| collisionPadding      | `Padding`                                                                                                            | `5`                    | Additional space to maintain from the edge of the collision boundary.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| sticky                | `boolean`                                                                                                            | `false`                | Whether to maintain the popup in the viewport after&#xA;the anchor element was scrolled out of view.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| className             | `string \| ((state: ContextMenu.Positioner.State) => string \| undefined)`                                           | -                      | CSS class applied to the element, or a function that&#xA;returns a class based on the component's state.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| style                 | `React.CSSProperties \| ((state: ContextMenu.Positioner.State) => React.CSSProperties \| undefined)`                 | -                      | Style applied to the element, or a function that&#xA;returns a style object based on the component's state.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| render                | `ReactElement \| ((props: HTMLProps, state: ContextMenu.Positioner.State) => ReactElement)`                          | -                      | Allows you to replace the component's HTML element&#xA;with a different tag, or compose it with another component. Accepts a `ReactElement` or a function that returns the element to render.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |

**`alignOffset` Prop Example:**

```jsx
<ContextMenu.Positioner
  alignOffset={({ side, anchor }) => {
    return side === 'top' || side === 'bottom' ? anchor.width : anchor.height;
  }}
/>
```

**`sideOffset` Prop Example:**

```jsx
<ContextMenu.Positioner
  sideOffset={({ side, anchor }) => {
    return side === 'top' || side === 'bottom' ? anchor.height : anchor.width;
  }}
/>
```

**`collisionAvoidance` Prop Example:**

```jsx
<Positioner
  collisionAvoidance={{
    side: 'shift',
    align: 'shift',
    fallbackAxisSide: 'none',
  }}
/>
```

**Positioner Data Attributes:**

| Attribute          | Type                                                                       | Description                                                          |
| :----------------- | :------------------------------------------------------------------------- | :------------------------------------------------------------------- |
| data-open          | -                                                                          | Present when the menu popup is open.                                 |
| data-closed        | -                                                                          | Present when the menu popup is closed.                               |
| data-anchor-hidden | -                                                                          | Present when the anchor is hidden.                                   |
| data-align         | `'start' \| 'center' \| 'end'`                                             | Indicates how the popup is aligned relative to the specified side.   |
| data-side          | `'top' \| 'bottom' \| 'left' \| 'right' \| 'inline-end' \| 'inline-start'` | Indicates which side the popup is positioned relative to the anchor. |

**Positioner CSS Variables:**

| Variable              | Type     | Description                                                                                                                    |
| :-------------------- | :------- | :----------------------------------------------------------------------------------------------------------------------------- |
| `--anchor-height`     | `number` | The anchor's height.                                                                                                           |
| `--anchor-width`      | `number` | The anchor's width.                                                                                                            |
| `--available-height`  | `number` | The available height between the anchor and the edge of the viewport.                                                          |
| `--available-width`   | `number` | The available width between the anchor and the edge of the viewport.                                                           |
| `--positioner-height` | `number` | The height of the menu's positioner.&#xA;It is important to set `height` to this value when using CSS to animate size changes. |
| `--positioner-width`  | `number` | The width of the menu's positioner.&#xA;It is important to set `width` to this value when using CSS to animate size changes.   |
| `--transform-origin`  | `string` | The coordinates that this element is anchored to. Used for animations and transitions.                                         |

### Positioner.Props [#positionerprops]

Re-export of [Positioner](#positioner) props.

### Positioner.State [#positionerstate]

```typescript
type ContextMenuPositionerState = {
  /** Whether the menu is currently open. */
  open: boolean;
  /** The side of the anchor the component is placed on. */
  side: Side;
  /** The alignment of the component relative to the anchor. */
  align: Align;
  /** Whether the anchor element is hidden. */
  anchorHidden: boolean;
  /** Whether the component is nested. */
  nested: boolean;
  /** Whether CSS transitions should be disabled. */
  instant: string | undefined;
};
```

### Popup [#popup]

A container for the menu items.
Renders a `<div>` element.

**Popup Props:**

| Prop       | Type                                                                                                                          | Default | Description                                                                                                                                                                                                                                                                                                                                                                                                              |
| :--------- | :---------------------------------------------------------------------------------------------------------------------------- | :------ | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| finalFocus | `boolean \| React.RefObject<HTMLElement \| null> \| ((closeType: InteractionType) => boolean \| void \| HTMLElement \| null)` | -       | Determines the element to focus when the menu is closed. `false`: Do not move focus.`true`: Move focus based on the default behavior (trigger or previously focused element).`RefObject`: Move focus to the ref element.`function`: Called with the interaction type (`mouse`, `touch`, `pen`, or `keyboard`).&#xA;Return an element to focus, `true` to use the default behavior, or `false`/`undefined` to do nothing. |
| children   | `React.ReactNode`                                                                                                             | -       | -                                                                                                                                                                                                                                                                                                                                                                                                                        |
| className  | `string \| ((state: ContextMenu.Popup.State) => string \| undefined)`                                                         | -       | CSS class applied to the element, or a function that&#xA;returns a class based on the component's state.                                                                                                                                                                                                                                                                                                                 |
| style      | `React.CSSProperties \| ((state: ContextMenu.Popup.State) => React.CSSProperties \| undefined)`                               | -       | Style applied to the element, or a function that&#xA;returns a style object based on the component's state.                                                                                                                                                                                                                                                                                                              |
| render     | `ReactElement \| ((props: HTMLProps, state: ContextMenu.Popup.State) => ReactElement)`                                        | -       | Allows you to replace the component's HTML element&#xA;with a different tag, or compose it with another component. Accepts a `ReactElement` or a function that returns the element to render.                                                                                                                                                                                                                            |

**Popup Data Attributes:**

| Attribute           | Type                                                                       | Description                                                          |
| :------------------ | :------------------------------------------------------------------------- | :------------------------------------------------------------------- |
| data-open           | -                                                                          | Present when the menu is open.                                       |
| data-closed         | -                                                                          | Present when the menu is closed.                                     |
| data-align          | `'start' \| 'center' \| 'end'`                                             | Indicates how the popup is aligned relative to specified side.       |
| data-instant        | `'click' \| 'dismiss' \| 'group' \| 'trigger-change'`                      | Present if animations should be instant.                             |
| data-side           | `'top' \| 'bottom' \| 'left' \| 'right' \| 'inline-end' \| 'inline-start'` | Indicates which side the popup is positioned relative to the anchor. |
| data-starting-style | -                                                                          | Present when the menu begins animating in.                           |
| data-ending-style   | -                                                                          | Present when the menu is animating out.                              |

### Popup.Props [#popupprops]

Re-export of [Popup](#popup) props.

### Popup.State [#popupstate]

```typescript
type ContextMenuPopupState = {
  /** The transition status of the component. */
  transitionStatus: TransitionStatus;
  /** The side of the anchor the component is placed on. */
  side: Side;
  /** The alignment of the component relative to the anchor. */
  align: Align;
  /** Whether the menu is currently open. */
  open: boolean;
  /** Whether the component is nested. */
  nested: boolean;
  /** Whether transitions should be skipped. */
  instant: 'dismiss' | 'click' | 'group' | 'trigger-change' | undefined;
};
```

### Arrow [#arrow]

Displays an element positioned against the menu anchor.
Renders a `<div>` element.

**Arrow Props:**

| Prop      | Type                                                                                            | Default | Description                                                                                                                                                                                   |
| :-------- | :---------------------------------------------------------------------------------------------- | :------ | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| className | `string \| ((state: ContextMenu.Arrow.State) => string \| undefined)`                           | -       | CSS class applied to the element, or a function that&#xA;returns a class based on the component's state.                                                                                      |
| style     | `React.CSSProperties \| ((state: ContextMenu.Arrow.State) => React.CSSProperties \| undefined)` | -       | Style applied to the element, or a function that&#xA;returns a style object based on the component's state.                                                                                   |
| render    | `ReactElement \| ((props: HTMLProps, state: ContextMenu.Arrow.State) => ReactElement)`          | -       | Allows you to replace the component's HTML element&#xA;with a different tag, or compose it with another component. Accepts a `ReactElement` or a function that returns the element to render. |

**Arrow Data Attributes:**

| Attribute       | Type                                                                       | Description                                                          |
| :-------------- | :------------------------------------------------------------------------- | :------------------------------------------------------------------- |
| data-open       | -                                                                          | Present when the menu popup is open.                                 |
| data-closed     | -                                                                          | Present when the menu popup is closed.                               |
| data-uncentered | -                                                                          | Present when the menu arrow is uncentered.                           |
| data-align      | `'start' \| 'center' \| 'end'`                                             | Indicates how the popup is aligned relative to specified side.       |
| data-side       | `'top' \| 'bottom' \| 'left' \| 'right' \| 'inline-end' \| 'inline-start'` | Indicates which side the popup is positioned relative to the anchor. |

### Arrow\.Props [#arrowprops]

Re-export of [Arrow](#arrow) props.

### Arrow\.State [#arrowstate]

```typescript
type ContextMenuArrowState = {
  /** Whether the menu is currently open. */
  open: boolean;
  /** The side of the anchor the component is placed on. */
  side: Side;
  /** The alignment of the component relative to the anchor. */
  align: Align;
  /** Whether the arrow cannot be centered on the anchor. */
  uncentered: boolean;
};
```

### Item [#item]

An individual interactive item in the menu.
Renders a `<div>` element.

**Item Props:**

| Prop         | Type                                                                                           | Default | Description                                                                                                                                                                                   |
| :----------- | :--------------------------------------------------------------------------------------------- | :------ | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| label        | `string`                                                                                       | -       | Overrides the text label to use when the item is matched during keyboard text navigation.                                                                                                     |
| onClick      | `((event: BaseUIEvent<React.MouseEvent<HTMLDivElement, MouseEvent>>) => void)`                 | -       | The click handler for the menu item.                                                                                                                                                          |
| closeOnClick | `boolean`                                                                                      | `true`  | Whether to close the menu when the item is clicked.                                                                                                                                           |
| nativeButton | `boolean`                                                                                      | `false` | Whether the component renders a native `<button>` element when replacing it&#xA;via the `render` prop.&#xA;Set to `true` if the rendered element is a native button.                          |
| disabled     | `boolean`                                                                                      | `false` | Whether the component should ignore user interaction.                                                                                                                                         |
| className    | `string \| ((state: ContextMenu.Item.State) => string \| undefined)`                           | -       | CSS class applied to the element, or a function that&#xA;returns a class based on the component's state.                                                                                      |
| style        | `React.CSSProperties \| ((state: ContextMenu.Item.State) => React.CSSProperties \| undefined)` | -       | Style applied to the element, or a function that&#xA;returns a style object based on the component's state.                                                                                   |
| render       | `ReactElement \| ((props: HTMLProps, state: ContextMenu.Item.State) => ReactElement)`          | -       | Allows you to replace the component's HTML element&#xA;with a different tag, or compose it with another component. Accepts a `ReactElement` or a function that returns the element to render. |

**Item Data Attributes:**

| Attribute        | Type | Description                                |
| :--------------- | :--- | :----------------------------------------- |
| data-highlighted | -    | Present when the menu item is highlighted. |
| data-disabled    | -    | Present when the menu item is disabled.    |

### Item.Props [#itemprops]

Re-export of [Item](#item) props.

### Item.State [#itemstate]

```typescript
type ContextMenuItemState = {
  /** Whether the item should ignore user interaction. */
  disabled: boolean;
  /** Whether the item is highlighted. */
  highlighted: boolean;
};
```

### Group [#group]

Groups related menu items with the corresponding label.
Renders a `<div>` element.

**Group Props:**

| Prop      | Type                                                                                            | Default | Description                                                                                                                                                                                   |
| :-------- | :---------------------------------------------------------------------------------------------- | :------ | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| children  | `React.ReactNode`                                                                               | -       | The content of the component.                                                                                                                                                                 |
| className | `string \| ((state: ContextMenu.Group.State) => string \| undefined)`                           | -       | CSS class applied to the element, or a function that&#xA;returns a class based on the component's state.                                                                                      |
| style     | `React.CSSProperties \| ((state: ContextMenu.Group.State) => React.CSSProperties \| undefined)` | -       | Style applied to the element, or a function that&#xA;returns a style object based on the component's state.                                                                                   |
| render    | `ReactElement \| ((props: HTMLProps, state: ContextMenu.Group.State) => ReactElement)`          | -       | Allows you to replace the component's HTML element&#xA;with a different tag, or compose it with another component. Accepts a `ReactElement` or a function that returns the element to render. |

### Group.Props [#groupprops]

Re-export of [Group](#group) props.

### Group.State [#groupstate]

```typescript
type ContextMenuGroupState = {};
```

### GroupLabel [#grouplabel]

An accessible label that is automatically associated with its parent group.
Renders a `<div>` element.

**GroupLabel Props:**

| Prop      | Type                                                                                                 | Default | Description                                                                                                                                                                                   |
| :-------- | :--------------------------------------------------------------------------------------------------- | :------ | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| className | `string \| ((state: ContextMenu.GroupLabel.State) => string \| undefined)`                           | -       | CSS class applied to the element, or a function that&#xA;returns a class based on the component's state.                                                                                      |
| style     | `React.CSSProperties \| ((state: ContextMenu.GroupLabel.State) => React.CSSProperties \| undefined)` | -       | Style applied to the element, or a function that&#xA;returns a style object based on the component's state.                                                                                   |
| render    | `ReactElement \| ((props: HTMLProps, state: ContextMenu.GroupLabel.State) => ReactElement)`          | -       | Allows you to replace the component's HTML element&#xA;with a different tag, or compose it with another component. Accepts a `ReactElement` or a function that returns the element to render. |

### GroupLabel.Props [#grouplabelprops]

Re-export of [GroupLabel](#grouplabel) props.

### GroupLabel.State [#grouplabelstate]

```typescript
type ContextMenuGroupLabelState = {};
```

### Separator [#separator]

A separator element accessible to screen readers.
Renders a `<div>` element.

**Separator Props:**

| Prop        | Type                                                                                   | Default        | Description                                                                                                                                                                                   |
| :---------- | :------------------------------------------------------------------------------------- | :------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| orientation | `Orientation`                                                                          | `'horizontal'` | The orientation of the separator.                                                                                                                                                             |
| className   | `string \| ((state: SeparatorState) => string \| undefined)`                           | -              | CSS class applied to the element, or a function that&#xA;returns a class based on the component's state.                                                                                      |
| style       | `React.CSSProperties \| ((state: SeparatorState) => React.CSSProperties \| undefined)` | -              | Style applied to the element, or a function that&#xA;returns a style object based on the component's state.                                                                                   |
| render      | `ReactElement \| ((props: HTMLProps, state: SeparatorState) => ReactElement)`          | -              | Allows you to replace the component's HTML element&#xA;with a different tag, or compose it with another component. Accepts a `ReactElement` or a function that returns the element to render. |

### Separator.Props [#separatorprops]

Re-export of [Separator](#separator) props.

### Separator.State [#separatorstate]

```typescript
type ContextMenuSeparatorState = {
  /** The orientation of the separator. */
  orientation: Orientation;
};
```

### SubmenuRoot [#submenuroot]

Groups all parts of a submenu.
Doesn't render its own HTML element.

**SubmenuRoot Props:**

| Prop                 | Type                                                                                  | Default      | Description                                                                                                                                                                                                |
| :------------------- | :------------------------------------------------------------------------------------ | :----------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| defaultOpen          | `boolean`                                                                             | `false`      | Whether the menu is initially open. To render a controlled menu, use the `open` prop instead.                                                                                                              |
| open                 | `boolean`                                                                             | -            | Whether the menu is currently open.                                                                                                                                                                        |
| onOpenChange         | `((open: boolean, eventDetails: ContextMenu.SubmenuRoot.ChangeEventDetails) => void)` | -            | Event handler called when the menu is opened or closed.                                                                                                                                                    |
| highlightItemOnHover | `boolean`                                                                             | `true`       | Whether moving the pointer over items should highlight them.&#xA;Disabling this prop allows CSS `:hover` to be differentiated from the `:focus` (`data-highlighted`) state.                                |
| actionsRef           | `React.RefObject<MenuRoot.Actions \| null>`                                           | -            | A ref to imperative actions. `unmount`: Manually unmounts the menu.&#xA;Call this after any externally controlled closing animation finishes.`close`: When specified, the menu can be closed imperatively. |
| closeParentOnEsc     | `boolean`                                                                             | `false`      | When in a submenu, determines whether pressing the Escape key&#xA;closes the entire menu, or only the current child menu.                                                                                  |
| loopFocus            | `boolean`                                                                             | `true`       | Whether to loop keyboard focus back to the first item&#xA;when the end of the list is reached while using the arrow keys.                                                                                  |
| onOpenChangeComplete | `((open: boolean) => void)`                                                           | -            | Event handler called after any animations complete when the menu is opened or closed.                                                                                                                      |
| disabled             | `boolean`                                                                             | `false`      | Whether the component should ignore user interaction.                                                                                                                                                      |
| orientation          | `MenuRoot.Orientation`                                                                | `'vertical'` | The visual orientation of the menu.&#xA;Controls whether roving focus uses up/down or left/right arrow keys.                                                                                               |
| children             | `React.ReactNode`                                                                     | -            | The content of the submenu.                                                                                                                                                                                |

### SubmenuRoot.Props [#submenurootprops]

Re-export of [SubmenuRoot](#submenuroot) props.

### SubmenuRoot.State [#submenurootstate]

```typescript
type ContextMenuSubmenuRootState = {};
```

### SubmenuRoot.ChangeEventReason [#submenurootchangeeventreason]

```typescript
type ContextMenuSubmenuRootChangeEventReason =
  | 'trigger-hover'
  | 'trigger-focus'
  | 'trigger-press'
  | 'outside-press'
  | 'focus-out'
  | 'list-navigation'
  | 'escape-key'
  | 'item-press'
  | 'close-press'
  | 'sibling-open'
  | 'cancel-open'
  | 'imperative-action'
  | 'none';
```

### SubmenuRoot.ChangeEventDetails [#submenurootchangeeventdetails]

```typescript
type ContextMenuSubmenuRootChangeEventDetails = (
  | { reason: 'trigger-hover'; event: MouseEvent }
  | { reason: 'trigger-focus'; event: FocusEvent }
  | { reason: 'trigger-press'; event: MouseEvent | PointerEvent | TouchEvent | KeyboardEvent }
  | { reason: 'outside-press'; event: MouseEvent | PointerEvent | TouchEvent }
  | { reason: 'focus-out'; event: FocusEvent | KeyboardEvent }
  | { reason: 'list-navigation'; event: KeyboardEvent }
  | { reason: 'escape-key'; event: KeyboardEvent }
  | { reason: 'item-press'; event: MouseEvent | PointerEvent | KeyboardEvent }
  | { reason: 'close-press'; event: MouseEvent | PointerEvent | KeyboardEvent }
  | { reason: 'sibling-open'; event: Event }
  | { reason: 'cancel-open'; event: MouseEvent }
  | { reason: 'imperative-action'; event: Event }
  | { reason: 'none'; event: Event }
) & {
  /** Cancels Base UI from handling the event. */
  cancel: () => void;
  /** Allows the event to propagate in cases where Base UI will stop the propagation. */
  allowPropagation: () => void;
  /** Indicates whether the event has been canceled. */
  isCanceled: boolean;
  /** Indicates whether the event is allowed to propagate. */
  isPropagationAllowed: boolean;
  /** The element that triggered the event, if applicable. */
  trigger: Element | undefined;
  preventUnmountOnClose: preventUnmountOnClose;
};
```

### SubmenuTrigger [#submenutrigger]

A menu item that opens a submenu.
Renders a `<div>` element.

**SubmenuTrigger Props:**

| Prop         | Type                                                                                                     | Default | Description                                                                                                                                                                                   |
| :----------- | :------------------------------------------------------------------------------------------------------- | :------ | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| label        | `string`                                                                                                 | -       | Overrides the text label to use when the item is matched during keyboard text navigation.                                                                                                     |
| onClick      | `((event: BaseUIEvent<React.MouseEvent<HTMLDivElement, MouseEvent>>) => void)`                           | -       | -                                                                                                                                                                                             |
| nativeButton | `boolean`                                                                                                | `false` | Whether the component renders a native `<button>` element when replacing it&#xA;via the `render` prop.&#xA;Set to `true` if the rendered element is a native button.                          |
| disabled     | `boolean`                                                                                                | `false` | Whether the component should ignore user interaction.                                                                                                                                         |
| openOnHover  | `boolean`                                                                                                | `true`  | Whether the menu should also open when the trigger is hovered.                                                                                                                                |
| delay        | `number`                                                                                                 | `100`   | How long to wait before the menu may be opened on hover. Specified in milliseconds. Requires the `openOnHover` prop.                                                                          |
| closeDelay   | `number`                                                                                                 | `0`     | How long to wait before closing the menu that was opened on hover.&#xA;Specified in milliseconds. Requires the `openOnHover` prop.                                                            |
| className    | `string \| ((state: ContextMenu.SubmenuTrigger.State) => string \| undefined)`                           | -       | CSS class applied to the element, or a function that&#xA;returns a class based on the component's state.                                                                                      |
| style        | `React.CSSProperties \| ((state: ContextMenu.SubmenuTrigger.State) => React.CSSProperties \| undefined)` | -       | Style applied to the element, or a function that&#xA;returns a style object based on the component's state.                                                                                   |
| render       | `ReactElement \| ((props: HTMLProps, state: ContextMenu.SubmenuTrigger.State) => ReactElement)`          | -       | Allows you to replace the component's HTML element&#xA;with a different tag, or compose it with another component. Accepts a `ReactElement` or a function that returns the element to render. |

**SubmenuTrigger Data Attributes:**

| Attribute        | Type | Description                                      |
| :--------------- | :--- | :----------------------------------------------- |
| data-popup-open  | -    | Present when the corresponding submenu is open.  |
| data-highlighted | -    | Present when the submenu trigger is highlighted. |
| data-disabled    | -    | Present when the submenu trigger is disabled.    |

### SubmenuTrigger.Props [#submenutriggerprops]

Re-export of [SubmenuTrigger](#submenutrigger) props.

### SubmenuTrigger.State [#submenutriggerstate]

```typescript
type ContextMenuSubmenuTriggerState = {
  /** Whether the component should ignore user interaction. */
  disabled: boolean;
  /** Whether the item is highlighted. */
  highlighted: boolean;
  /** Whether the menu is currently open. */
  open: boolean;
};
```

### RadioGroup [#radiogroup]

Groups related radio items.
Renders a `<div>` element.

**RadioGroup Props:**

| Prop          | Type                                                                                                 | Default | Description                                                                                                                                                                                   |
| :------------ | :--------------------------------------------------------------------------------------------------- | :------ | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| defaultValue  | `any`                                                                                                | -       | The uncontrolled value of the radio item that should be initially selected. To render a controlled radio group, use the `value` prop instead.                                                 |
| value         | `any`                                                                                                | -       | The controlled value of the radio item that should be currently selected. To render an uncontrolled radio group, use the `defaultValue` prop instead.                                         |
| onValueChange | `((value: any, eventDetails: ContextMenu.RadioGroup.ChangeEventDetails) => void)`                    | -       | Function called when the selected value changes.                                                                                                                                              |
| disabled      | `boolean`                                                                                            | `false` | Whether the component should ignore user interaction.                                                                                                                                         |
| children      | `React.ReactNode`                                                                                    | -       | The content of the component.                                                                                                                                                                 |
| className     | `string \| ((state: ContextMenu.RadioGroup.State) => string \| undefined)`                           | -       | CSS class applied to the element, or a function that&#xA;returns a class based on the component's state.                                                                                      |
| style         | `React.CSSProperties \| ((state: ContextMenu.RadioGroup.State) => React.CSSProperties \| undefined)` | -       | Style applied to the element, or a function that&#xA;returns a style object based on the component's state.                                                                                   |
| render        | `ReactElement \| ((props: HTMLProps, state: ContextMenu.RadioGroup.State) => ReactElement)`          | -       | Allows you to replace the component's HTML element&#xA;with a different tag, or compose it with another component. Accepts a `ReactElement` or a function that returns the element to render. |

### RadioGroup.Props [#radiogroupprops]

Re-export of [RadioGroup](#radiogroup) props.

### RadioGroup.State [#radiogroupstate]

```typescript
type ContextMenuRadioGroupState = {
  /** Whether the component is disabled. */
  disabled: boolean;
};
```

### RadioGroup.ChangeEventReason [#radiogroupchangeeventreason]

```typescript
type ContextMenuRadioGroupChangeEventReason =
  | 'trigger-hover'
  | 'trigger-focus'
  | 'trigger-press'
  | 'outside-press'
  | 'focus-out'
  | 'list-navigation'
  | 'escape-key'
  | 'item-press'
  | 'close-press'
  | 'sibling-open'
  | 'cancel-open'
  | 'imperative-action'
  | 'none';
```

### RadioGroup.ChangeEventDetails [#radiogroupchangeeventdetails]

```typescript
type ContextMenuRadioGroupChangeEventDetails = (
  | { reason: 'trigger-hover'; event: MouseEvent }
  | { reason: 'trigger-focus'; event: FocusEvent }
  | { reason: 'trigger-press'; event: MouseEvent | PointerEvent | TouchEvent | KeyboardEvent }
  | { reason: 'outside-press'; event: MouseEvent | PointerEvent | TouchEvent }
  | { reason: 'focus-out'; event: FocusEvent | KeyboardEvent }
  | { reason: 'list-navigation'; event: KeyboardEvent }
  | { reason: 'escape-key'; event: KeyboardEvent }
  | { reason: 'item-press'; event: MouseEvent | PointerEvent | KeyboardEvent }
  | { reason: 'close-press'; event: MouseEvent | PointerEvent | KeyboardEvent }
  | { reason: 'sibling-open'; event: Event }
  | { reason: 'cancel-open'; event: MouseEvent }
  | { reason: 'imperative-action'; event: Event }
  | { reason: 'none'; event: Event }
) & {
  /** Cancels Base UI from handling the event. */
  cancel: () => void;
  /** Allows the event to propagate in cases where Base UI will stop the propagation. */
  allowPropagation: () => void;
  /** Indicates whether the event has been canceled. */
  isCanceled: boolean;
  /** Indicates whether the event is allowed to propagate. */
  isPropagationAllowed: boolean;
  /** The element that triggered the event, if applicable. */
  trigger: Element | undefined;
  preventUnmountOnClose: preventUnmountOnClose;
};
```

### RadioItem [#radioitem]

A menu item that works like a radio button in a given group.
Renders a `<div>` element.

**RadioItem Props:**

| Prop         | Type                                                                                                | Default | Description                                                                                                                                                                                   |
| :----------- | :-------------------------------------------------------------------------------------------------- | :------ | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| label        | `string`                                                                                            | -       | Overrides the text label to use when the item is matched during keyboard text navigation.                                                                                                     |
| value\*      | `any`                                                                                               | -       | Value of the radio item.&#xA;This is the value that will be set in the ContextMenu.RadioGroup when the item is selected.                                                                      |
| onClick      | `((event: BaseUIEvent<React.MouseEvent<HTMLDivElement, MouseEvent>>) => void)`                      | -       | The click handler for the menu item.                                                                                                                                                          |
| closeOnClick | `boolean`                                                                                           | `false` | Whether to close the menu when the item is clicked.                                                                                                                                           |
| nativeButton | `boolean`                                                                                           | `false` | Whether the component renders a native `<button>` element when replacing it&#xA;via the `render` prop.&#xA;Set to `true` if the rendered element is a native button.                          |
| disabled     | `boolean`                                                                                           | `false` | Whether the component should ignore user interaction.                                                                                                                                         |
| className    | `string \| ((state: ContextMenu.RadioItem.State) => string \| undefined)`                           | -       | CSS class applied to the element, or a function that&#xA;returns a class based on the component's state.                                                                                      |
| style        | `React.CSSProperties \| ((state: ContextMenu.RadioItem.State) => React.CSSProperties \| undefined)` | -       | Style applied to the element, or a function that&#xA;returns a style object based on the component's state.                                                                                   |
| render       | `ReactElement \| ((props: HTMLProps, state: ContextMenu.RadioItem.State) => ReactElement)`          | -       | Allows you to replace the component's HTML element&#xA;with a different tag, or compose it with another component. Accepts a `ReactElement` or a function that returns the element to render. |

**RadioItem Data Attributes:**

| Attribute        | Type | Description                                       |
| :--------------- | :--- | :------------------------------------------------ |
| data-checked     | -    | Present when the menu radio item is selected.     |
| data-unchecked   | -    | Present when the menu radio item is not selected. |
| data-highlighted | -    | Present when the menu radio item is highlighted.  |
| data-disabled    | -    | Present when the menu radio item is disabled.     |

### RadioItem.Props [#radioitemprops]

Re-export of [RadioItem](#radioitem) props.

### RadioItem.State [#radioitemstate]

```typescript
type ContextMenuRadioItemState = {
  /** Whether the radio item should ignore user interaction. */
  disabled: boolean;
  /** Whether the radio item is currently highlighted. */
  highlighted: boolean;
  /** Whether the radio item is currently selected. */
  checked: boolean;
};
```

### RadioItemIndicator [#radioitemindicator]

Indicates whether the radio item is selected.
Renders a `<span>` element.

**RadioItemIndicator Props:**

| Prop        | Type                                                                                                         | Default | Description                                                                                                                                                                                   |
| :---------- | :----------------------------------------------------------------------------------------------------------- | :------ | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| className   | `string \| ((state: ContextMenu.RadioItemIndicator.State) => string \| undefined)`                           | -       | CSS class applied to the element, or a function that&#xA;returns a class based on the component's state.                                                                                      |
| style       | `React.CSSProperties \| ((state: ContextMenu.RadioItemIndicator.State) => React.CSSProperties \| undefined)` | -       | Style applied to the element, or a function that&#xA;returns a style object based on the component's state.                                                                                   |
| keepMounted | `boolean`                                                                                                    | `false` | Whether to keep the HTML element in the DOM when the radio item is inactive.                                                                                                                  |
| render      | `ReactElement \| ((props: HTMLProps, state: ContextMenu.RadioItemIndicator.State) => ReactElement)`          | -       | Allows you to replace the component's HTML element&#xA;with a different tag, or compose it with another component. Accepts a `ReactElement` or a function that returns the element to render. |

**RadioItemIndicator Data Attributes:**

| Attribute           | Type | Description                                           |
| :------------------ | :--- | :---------------------------------------------------- |
| data-checked        | -    | Present when the menu radio item is selected.         |
| data-unchecked      | -    | Present when the menu radio item is not selected.     |
| data-disabled       | -    | Present when the menu radio item is disabled.         |
| data-starting-style | -    | Present when the radio indicator begins animating in. |
| data-ending-style   | -    | Present when the radio indicator is animating out.    |

### RadioItemIndicator.Props [#radioitemindicatorprops]

Re-export of [RadioItemIndicator](#radioitemindicator) props.

### RadioItemIndicator.State [#radioitemindicatorstate]

```typescript
type ContextMenuRadioItemIndicatorState = {
  /** Whether the radio item is currently selected. */
  checked: boolean;
  /** Whether the component should ignore user interaction. */
  disabled: boolean;
  /** Whether the item is highlighted. */
  highlighted: boolean;
  /** The transition status of the component. */
  transitionStatus: TransitionStatus;
};
```

### CheckboxItem [#checkboxitem]

A menu item that toggles a setting on or off.
Renders a `<div>` element.

**CheckboxItem Props:**

| Prop            | Type                                                                                                   | Default | Description                                                                                                                                                                                   |
| :-------------- | :----------------------------------------------------------------------------------------------------- | :------ | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| label           | `string`                                                                                               | -       | Overrides the text label to use when the item is matched during keyboard text navigation.                                                                                                     |
| defaultChecked  | `boolean`                                                                                              | `false` | Whether the checkbox item is initially ticked. To render a controlled checkbox item, use the `checked` prop instead.                                                                          |
| checked         | `boolean`                                                                                              | -       | Whether the checkbox item is currently ticked. To render an uncontrolled checkbox item, use the `defaultChecked` prop instead.                                                                |
| onCheckedChange | `((checked: boolean, eventDetails: ContextMenu.CheckboxItem.ChangeEventDetails) => void)`              | -       | Event handler called when the checkbox item is ticked or unticked.                                                                                                                            |
| onClick         | `((event: BaseUIEvent<React.MouseEvent<HTMLDivElement, MouseEvent>>) => void)`                         | -       | The click handler for the menu item.                                                                                                                                                          |
| closeOnClick    | `boolean`                                                                                              | `false` | Whether to close the menu when the item is clicked.                                                                                                                                           |
| nativeButton    | `boolean`                                                                                              | `false` | Whether the component renders a native `<button>` element when replacing it&#xA;via the `render` prop.&#xA;Set to `true` if the rendered element is a native button.                          |
| disabled        | `boolean`                                                                                              | `false` | Whether the component should ignore user interaction.                                                                                                                                         |
| className       | `string \| ((state: ContextMenu.CheckboxItem.State) => string \| undefined)`                           | -       | CSS class applied to the element, or a function that&#xA;returns a class based on the component's state.                                                                                      |
| style           | `React.CSSProperties \| ((state: ContextMenu.CheckboxItem.State) => React.CSSProperties \| undefined)` | -       | Style applied to the element, or a function that&#xA;returns a style object based on the component's state.                                                                                   |
| render          | `ReactElement \| ((props: HTMLProps, state: ContextMenu.CheckboxItem.State) => ReactElement)`          | -       | Allows you to replace the component's HTML element&#xA;with a different tag, or compose it with another component. Accepts a `ReactElement` or a function that returns the element to render. |

**CheckboxItem Data Attributes:**

| Attribute        | Type | Description                                         |
| :--------------- | :--- | :-------------------------------------------------- |
| data-checked     | -    | Present when the menu checkbox item is checked.     |
| data-unchecked   | -    | Present when the menu checkbox item is not checked. |
| data-highlighted | -    | Present when the menu checkbox item is highlighted. |
| data-disabled    | -    | Present when the menu checkbox item is disabled.    |

### CheckboxItem.Props [#checkboxitemprops]

Re-export of [CheckboxItem](#checkboxitem) props.

### CheckboxItem.State [#checkboxitemstate]

```typescript
type ContextMenuCheckboxItemState = {
  /** Whether the checkbox item should ignore user interaction. */
  disabled: boolean;
  /** Whether the checkbox item is currently highlighted. */
  highlighted: boolean;
  /** Whether the checkbox item is currently ticked. */
  checked: boolean;
};
```

### CheckboxItem.ChangeEventReason [#checkboxitemchangeeventreason]

```typescript
type ContextMenuCheckboxItemChangeEventReason =
  | 'trigger-hover'
  | 'trigger-focus'
  | 'trigger-press'
  | 'outside-press'
  | 'focus-out'
  | 'list-navigation'
  | 'escape-key'
  | 'item-press'
  | 'close-press'
  | 'sibling-open'
  | 'cancel-open'
  | 'imperative-action'
  | 'none';
```

### CheckboxItem.ChangeEventDetails [#checkboxitemchangeeventdetails]

```typescript
type ContextMenuCheckboxItemChangeEventDetails = (
  | { reason: 'trigger-hover'; event: MouseEvent }
  | { reason: 'trigger-focus'; event: FocusEvent }
  | { reason: 'trigger-press'; event: MouseEvent | PointerEvent | TouchEvent | KeyboardEvent }
  | { reason: 'outside-press'; event: MouseEvent | PointerEvent | TouchEvent }
  | { reason: 'focus-out'; event: FocusEvent | KeyboardEvent }
  | { reason: 'list-navigation'; event: KeyboardEvent }
  | { reason: 'escape-key'; event: KeyboardEvent }
  | { reason: 'item-press'; event: MouseEvent | PointerEvent | KeyboardEvent }
  | { reason: 'close-press'; event: MouseEvent | PointerEvent | KeyboardEvent }
  | { reason: 'sibling-open'; event: Event }
  | { reason: 'cancel-open'; event: MouseEvent }
  | { reason: 'imperative-action'; event: Event }
  | { reason: 'none'; event: Event }
) & {
  /** Cancels Base UI from handling the event. */
  cancel: () => void;
  /** Allows the event to propagate in cases where Base UI will stop the propagation. */
  allowPropagation: () => void;
  /** Indicates whether the event has been canceled. */
  isCanceled: boolean;
  /** Indicates whether the event is allowed to propagate. */
  isPropagationAllowed: boolean;
  /** The element that triggered the event, if applicable. */
  trigger: Element | undefined;
  preventUnmountOnClose: preventUnmountOnClose;
};
```

### CheckboxItemIndicator [#checkboxitemindicator]

Indicates whether the checkbox item is ticked.
Renders a `<span>` element.

**CheckboxItemIndicator Props:**

| Prop        | Type                                                                                                            | Default | Description                                                                                                                                                                                   |
| :---------- | :-------------------------------------------------------------------------------------------------------------- | :------ | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| className   | `string \| ((state: ContextMenu.CheckboxItemIndicator.State) => string \| undefined)`                           | -       | CSS class applied to the element, or a function that&#xA;returns a class based on the component's state.                                                                                      |
| style       | `React.CSSProperties \| ((state: ContextMenu.CheckboxItemIndicator.State) => React.CSSProperties \| undefined)` | -       | Style applied to the element, or a function that&#xA;returns a style object based on the component's state.                                                                                   |
| keepMounted | `boolean`                                                                                                       | `false` | Whether to keep the HTML element in the DOM when the checkbox item is not checked.                                                                                                            |
| render      | `ReactElement \| ((props: HTMLProps, state: ContextMenu.CheckboxItemIndicator.State) => ReactElement)`          | -       | Allows you to replace the component's HTML element&#xA;with a different tag, or compose it with another component. Accepts a `ReactElement` or a function that returns the element to render. |

**CheckboxItemIndicator Data Attributes:**

| Attribute           | Type | Description                                         |
| :------------------ | :--- | :-------------------------------------------------- |
| data-checked        | -    | Present when the menu checkbox item is checked.     |
| data-unchecked      | -    | Present when the menu checkbox item is not checked. |
| data-disabled       | -    | Present when the menu checkbox item is disabled.    |
| data-starting-style | -    | Present when the indicator begins animating in.     |
| data-ending-style   | -    | Present when the indicator is animating out.        |

### CheckboxItemIndicator.Props [#checkboxitemindicatorprops]

Re-export of [CheckboxItemIndicator](#checkboxitemindicator) props.

### CheckboxItemIndicator.State [#checkboxitemindicatorstate]

```typescript
type ContextMenuCheckboxItemIndicatorState = {
  /** Whether the checkbox item is currently ticked. */
  checked: boolean;
  /** Whether the component should ignore user interaction. */
  disabled: boolean;
  /** Whether the item is highlighted. */
  highlighted: boolean;
  /** The transition status of the component. */
  transitionStatus: TransitionStatus;
};
```

### LinkItem [#linkitem]

A link in the menu that can be used to navigate to a different page or section.
Renders an `<a>` element.

**LinkItem Props:**

| Prop         | Type                                                                                                                                                                      | Default | Description                                                                                                                                                                                   |
| :----------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :------ | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| label        | `string`                                                                                                                                                                  | -       | Overrides the text label to use when the item is matched during keyboard text navigation.                                                                                                     |
| closeOnClick | `boolean`                                                                                                                                                                 | `false` | Whether to close the menu when the item is clicked.                                                                                                                                           |
| className    | `string \| ((state: ContextMenu.LinkItem.State) => string \| undefined)`                                                                                                  | -       | CSS class applied to the element, or a function that&#xA;returns a class based on the component's state.                                                                                      |
| style        | `React.CSSProperties \| ((state: ContextMenu.LinkItem.State) => React.CSSProperties \| undefined)`                                                                        | -       | Style applied to the element, or a function that&#xA;returns a style object based on the component's state.                                                                                   |
| render       | `ReactElement \| ((props: React.DetailedHTMLProps<React.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, state: ContextMenu.LinkItem.State) => ReactElement)` | -       | Allows you to replace the component's HTML element&#xA;with a different tag, or compose it with another component. Accepts a `ReactElement` or a function that returns the element to render. |

**LinkItem Data Attributes:**

| Attribute        | Type | Description                           |
| :--------------- | :--- | :------------------------------------ |
| data-highlighted | -    | Present when the link is highlighted. |

### LinkItem.Props [#linkitemprops]

Re-export of [LinkItem](#linkitem) props.

### LinkItem.State [#linkitemstate]

```typescript
type ContextMenuLinkItemState = {
  /** Whether the item is highlighted. */
  highlighted: boolean;
};
```

## External Types [#external-types]

### Orientation [#orientation]

```typescript
type Orientation = 'horizontal' | 'vertical';
```

### Side [#side]

```typescript
type Side = 'top' | 'bottom' | 'left' | 'right' | 'inline-end' | 'inline-start';
```

### OffsetFunction [#offsetfunction]

```typescript
type OffsetFunction = (data: {
  side: 'top' | 'bottom' | 'left' | 'right' | 'inline-end' | 'inline-start';
  align: 'start' | 'center' | 'end';
  anchor: { width: number; height: number };
  positioner: { width: number; height: number };
}) => number;
```

### Align [#align]

```typescript
type Align = 'start' | 'center' | 'end';
```

### InteractionType [#interactiontype]

```typescript
type InteractionType = 'mouse' | 'touch' | 'pen' | 'keyboard' | '';
```

### preventUnmountOnClose [#preventunmountonclose]

```typescript
type preventUnmountOnClose = () => void;
```

## Export Groups [#export-groups]

* `ContextMenu.Root`: `ContextMenu.Root`, `ContextMenu.Root.State`, `ContextMenu.Root.Props`, `ContextMenu.Root.Actions`, `ContextMenu.Root.ChangeEventReason`, `ContextMenu.Root.ChangeEventDetails`
* `ContextMenu.Trigger`: `ContextMenu.Trigger`, `ContextMenu.Trigger.State`, `ContextMenu.Trigger.Props`
* `ContextMenu.Backdrop`: `ContextMenu.Backdrop`, `ContextMenu.Backdrop.State`, `ContextMenu.Backdrop.Props`
* `ContextMenu.Portal`: `ContextMenu.Portal`, `ContextMenu.Portal.State`, `ContextMenu.Portal.Props`
* `ContextMenu.Positioner`: `ContextMenu.Positioner`, `ContextMenu.Positioner.Props`, `ContextMenu.Positioner.State`
* `ContextMenu.Popup`: `ContextMenu.Popup`, `ContextMenu.Popup.Props`, `ContextMenu.Popup.State`
* `ContextMenu.Arrow`: `ContextMenu.Arrow`, `ContextMenu.Arrow.State`, `ContextMenu.Arrow.Props`
* `ContextMenu.Group`: `ContextMenu.Group`, `ContextMenu.Group.Props`, `ContextMenu.Group.State`
* `ContextMenu.GroupLabel`: `ContextMenu.GroupLabel`, `ContextMenu.GroupLabel.Props`, `ContextMenu.GroupLabel.State`
* `ContextMenu.Item`: `ContextMenu.Item`, `ContextMenu.Item.State`, `ContextMenu.Item.Props`
* `ContextMenu.CheckboxItem`: `ContextMenu.CheckboxItem`, `ContextMenu.CheckboxItem.State`, `ContextMenu.CheckboxItem.Props`, `ContextMenu.CheckboxItem.ChangeEventReason`, `ContextMenu.CheckboxItem.ChangeEventDetails`
* `ContextMenu.CheckboxItemIndicator`: `ContextMenu.CheckboxItemIndicator`, `ContextMenu.CheckboxItemIndicator.Props`, `ContextMenu.CheckboxItemIndicator.State`
* `ContextMenu.LinkItem`: `ContextMenu.LinkItem`, `ContextMenu.LinkItem.State`, `ContextMenu.LinkItem.Props`
* `ContextMenu.RadioGroup`: `ContextMenu.RadioGroup`, `ContextMenu.RadioGroup.Props`, `ContextMenu.RadioGroup.State`, `ContextMenu.RadioGroup.ChangeEventReason`, `ContextMenu.RadioGroup.ChangeEventDetails`
* `ContextMenu.RadioItem`: `ContextMenu.RadioItem`, `ContextMenu.RadioItem.State`, `ContextMenu.RadioItem.Props`
* `ContextMenu.RadioItemIndicator`: `ContextMenu.RadioItemIndicator`, `ContextMenu.RadioItemIndicator.Props`, `ContextMenu.RadioItemIndicator.State`
* `ContextMenu.SubmenuRoot`: `ContextMenu.SubmenuRoot`, `ContextMenu.SubmenuRoot.Props`, `ContextMenu.SubmenuRoot.State`, `ContextMenu.SubmenuRoot.ChangeEventReason`, `ContextMenu.SubmenuRoot.ChangeEventDetails`
* `ContextMenu.SubmenuTrigger`: `ContextMenu.SubmenuTrigger`, `ContextMenu.SubmenuTrigger.Props`, `ContextMenu.SubmenuTrigger.State`
* `ContextMenu.Separator`: `ContextMenu.Separator`, `ContextMenu.Separator.Props`, `ContextMenu.Separator.State`
* `Default`: `ContextMenuBackdropProps`, `ContextMenuBackdropState`, `ContextMenuPortalProps`, `ContextMenuPortalState`, `ContextMenuPopupProps`, `ContextMenuPopupState`, `ContextMenuArrowProps`, `ContextMenuArrowState`, `ContextMenuGroupProps`, `ContextMenuGroupState`, `ContextMenuGroupLabelProps`, `ContextMenuGroupLabelState`, `ContextMenuItemProps`, `ContextMenuItemState`, `ContextMenuLinkItemProps`, `ContextMenuLinkItemState`, `ContextMenuCheckboxItemProps`, `ContextMenuCheckboxItemState`, `ContextMenuCheckboxItemIndicatorProps`, `ContextMenuCheckboxItemIndicatorState`, `ContextMenuRadioGroupProps`, `ContextMenuRadioGroupState`, `ContextMenuRadioItemProps`, `ContextMenuRadioItemState`, `ContextMenuRadioItemIndicatorProps`, `ContextMenuRadioItemIndicatorState`, `ContextMenuSubmenuRootProps`, `ContextMenuSubmenuRootState`, `ContextMenuSubmenuTriggerProps`, `ContextMenuSubmenuTriggerState`, `ContextMenuRootState`, `ContextMenuRootProps`, `ContextMenuRootActions`, `ContextMenuRootChangeEventReason`, `ContextMenuRootChangeEventDetails`, `ContextMenuTriggerState`, `ContextMenuTriggerProps`, `ContextMenuPositionerState`, `ContextMenuPositionerProps`

## Canonical Types [#canonical-types]

Maps `Canonical`: `Alias` — Use Canonical when its namespace is already imported; otherwise use Alias.

* `ContextMenu.Root.State`: `ContextMenuRootState`
* `ContextMenu.Root.Props`: `ContextMenuRootProps`
* `ContextMenu.Root.Actions`: `ContextMenuRootActions`
* `ContextMenu.Root.ChangeEventReason`: `ContextMenuRootChangeEventReason`
* `ContextMenu.Root.ChangeEventDetails`: `ContextMenuRootChangeEventDetails`
* `ContextMenu.Trigger.State`: `ContextMenuTriggerState`
* `ContextMenu.Trigger.Props`: `ContextMenuTriggerProps`
* `ContextMenu.Backdrop.State`: `ContextMenuBackdropState`
* `ContextMenu.Backdrop.Props`: `ContextMenuBackdropProps`
* `ContextMenu.Portal.State`: `ContextMenuPortalState`
* `ContextMenu.Portal.Props`: `ContextMenuPortalProps`
* `ContextMenu.Positioner.Props`: `ContextMenuPositionerProps`
* `ContextMenu.Positioner.State`: `ContextMenuPositionerState`
* `ContextMenu.Popup.Props`: `ContextMenuPopupProps`
* `ContextMenu.Popup.State`: `ContextMenuPopupState`
* `ContextMenu.Arrow.State`: `ContextMenuArrowState`
* `ContextMenu.Arrow.Props`: `ContextMenuArrowProps`
* `ContextMenu.Group.Props`: `ContextMenuGroupProps`
* `ContextMenu.Group.State`: `ContextMenuGroupState`
* `ContextMenu.GroupLabel.Props`: `ContextMenuGroupLabelProps`
* `ContextMenu.GroupLabel.State`: `ContextMenuGroupLabelState`
* `ContextMenu.Item.State`: `ContextMenuItemState`
* `ContextMenu.Item.Props`: `ContextMenuItemProps`
* `ContextMenu.CheckboxItem.State`: `ContextMenuCheckboxItemState`
* `ContextMenu.CheckboxItem.Props`: `ContextMenuCheckboxItemProps`
* `ContextMenu.CheckboxItemIndicator.Props`: `ContextMenuCheckboxItemIndicatorProps`
* `ContextMenu.CheckboxItemIndicator.State`: `ContextMenuCheckboxItemIndicatorState`
* `ContextMenu.LinkItem.State`: `ContextMenuLinkItemState`
* `ContextMenu.LinkItem.Props`: `ContextMenuLinkItemProps`
* `ContextMenu.RadioGroup.Props`: `ContextMenuRadioGroupProps`
* `ContextMenu.RadioGroup.State`: `ContextMenuRadioGroupState`
* `ContextMenu.RadioItem.State`: `ContextMenuRadioItemState`
* `ContextMenu.RadioItem.Props`: `ContextMenuRadioItemProps`
* `ContextMenu.RadioItemIndicator.Props`: `ContextMenuRadioItemIndicatorProps`
* `ContextMenu.RadioItemIndicator.State`: `ContextMenuRadioItemIndicatorState`
* `ContextMenu.SubmenuRoot.Props`: `ContextMenuSubmenuRootProps`
* `ContextMenu.SubmenuRoot.State`: `ContextMenuSubmenuRootState`
* `ContextMenu.SubmenuTrigger.Props`: `ContextMenuSubmenuTriggerProps`
* `ContextMenu.SubmenuTrigger.State`: `ContextMenuSubmenuTriggerState`
