@stridge/noctis 1.0.0-beta.0

package/dist/components/menu/menu.d.ts

@@ -0,0 +1,355 @@
+import { IconGlyph } from "../../icons/glyphs.js";
+import { MenuItemPropsArgs, MenuPartProps, checkboxItemProps, contentProps, groupLabelProps, groupProps, itemProps, linkItemProps, radioGroupProps, radioItemProps, separatorProps, shortcutProps, submenuTriggerProps, triggerProps } from "./menu.props.js";
+import { menu_d_exports } from "../../primitives/menu.js";
+import { ReactElement, ReactNode } from "react";
+
+//#region src/components/menu/menu.d.ts
+/**
+ * Owns the open state and shares it with the trigger and content. Wraps Base UI's Menu. Modal by
+ * default — outside content is inert and page scroll is locked while open; set `modal={false}` for a
+ * lighter popup that leaves the page interactive.
+ */
+declare function MenuRoot(props: Menu.Root.Props): ReactElement;
+/**
+ * The control that opens the menu. Style it yourself, or compose a `Button` through `render` — e.g.
+ * `<Menu.Trigger render={<Button iconOnly aria-label="More" startIcon={ChevronDownIcon} />} />`.
+ */
+declare function MenuTrigger(props: Menu.Trigger.Props): ReactElement;
+/**
+ * The floating menu surface — portaled, elevated, and animated — holding the items, groups, and
+ * separators. A root menu opens below the trigger, aligned to its start; inside a `SubmenuRoot` it
+ * opens on the inline-end side instead, flipping to inline-start at the viewport edge. Caps at the
+ * available viewport height and scrolls its list, keeping the keyboard highlight in view.
+ */
+declare function MenuContent({
+  side,
+  align,
+  sideOffset,
+  alignOffset,
+  collisionPadding,
+  className,
+  style,
+  children,
+  ...props
+}: Menu.Content.Props): ReactElement;
+/** A labelled section of related items. Put a `GroupLabel` inside to name it for screen readers. */
+declare function MenuGroup({
+  className,
+  ...props
+}: Menu.Group.Props): ReactElement;
+/** The group's muted, non-interactive heading — announced as the group's accessible name. */
+declare function MenuGroupLabel({
+  className,
+  ...props
+}: Menu.GroupLabel.Props): ReactElement;
+/**
+ * A menu action. Optional leading `icon`; `inset` reserves the icon column on icon-less rows so
+ * labels align with iconed siblings; `tone="danger"` marks a destructive action — red label and a
+ * danger-tinted highlight. Trailing content (a `Menu.Shortcut`, secondary text) flows after the label.
+ */
+declare function MenuItem({
+  icon,
+  inset,
+  tone,
+  className,
+  children,
+  ...props
+}: Menu.Item.Props): ReactElement;
+/**
+ * A navigable menu row that renders an `<a>` — the canonical "Open in new tab" / "Copy link address"
+ * action. Same row recipe as `Item` (leading `icon`, `inset` alignment, `tone="danger"`); pass anchor
+ * props (`href`, `target`, `rel`) through. Navigating is a terminal action, so it closes the menu on
+ * click by default (set `closeOnClick={false}` to keep it open).
+ */
+declare function MenuLinkItem({
+  icon,
+  inset,
+  tone,
+  closeOnClick,
+  className,
+  children,
+  ...props
+}: Menu.LinkItem.Props): ReactElement;
+/**
+ * A menu item that toggles a setting. The leading slot is a check that animates in while ticked,
+ * holding the same column as item icons; toggling does not close the menu (`closeOnClick` stays
+ * Base UI's `false`).
+ */
+declare function MenuCheckboxItem({
+  className,
+  children,
+  ...props
+}: Menu.CheckboxItem.Props): ReactElement;
+/** Groups `RadioItem`s around one selected `value` (controlled or via `defaultValue`). */
+declare function MenuRadioGroup({
+  className,
+  ...props
+}: Menu.RadioGroup.Props): ReactElement;
+/**
+ * One choice in a `RadioGroup`. The leading slot is a dot that marks the selected item, holding the
+ * same column as item icons; selecting does not close the menu (`closeOnClick` stays Base UI's
+ * `false`).
+ */
+declare function MenuRadioItem({
+  className,
+  children,
+  ...props
+}: Menu.RadioItem.Props): ReactElement;
+/** Owns a nested submenu's open state. Renders no element — wrap a `SubmenuTrigger` and a `Content`. */
+declare function MenuSubmenuRoot(props: Menu.SubmenuRoot.Props): ReactElement;
+/**
+ * An item-shaped row that opens a nested submenu — on hover (after a short intent delay, with a
+ * grace period on leave so diagonal pointer travel into the submenu doesn't snap it shut), on click,
+ * and from the keyboard (Right arrow / Enter; Left arrow in RTL). The trailing chevron mirrors under
+ * RTL, and the row stays lit while its submenu is open.
+ */
+declare function MenuSubmenuTrigger({
+  icon,
+  inset,
+  openOnHover,
+  delay,
+  closeDelay,
+  className,
+  children,
+  ...props
+}: Menu.SubmenuTrigger.Props): ReactElement;
+/**
+ * A trailing, muted keyboard-shortcut hint composing the `Kbd` primitive — pass `keys` in `Kbd`
+ * syntax (`"Mod+K"`, `"G D"`) or custom children. Decorative: hidden from assistive tech so the
+ * item's action name stays clean (and typeahead never matches the shortcut); when the binding is
+ * live, set `aria-keyshortcuts` on the item to expose it.
+ */
+declare function MenuShortcut({
+  keys,
+  className,
+  children
+}: Menu.Shortcut.Props): ReactElement;
+/** A hairline between groups of menu items. */
+declare function MenuSeparator({
+  className,
+  ...props
+}: Menu.Separator.Props): ReactElement;
+/**
+ * A dropdown menu: a `Trigger` opens a floating list of actions. Built on Base UI's Menu for keyboard
+ * navigation (arrows, Home/End, typeahead), focus management, and `Escape`/outside-click dismissal,
+ * and decoupled from any particular trigger — pass your own (commonly a `Button` via `render`).
+ *
+ * Compose from parts: `Menu.Root` owns the open state, `Menu.Trigger` opens it, and `Menu.Content`
+ * holds the rows — `Item`s, `CheckboxItem`s, `RadioGroup`/`RadioItem`s, `Group`s with a `GroupLabel`,
+ * and `Separator`s. Nest a `SubmenuRoot` (wrapping a `SubmenuTrigger` and its own `Content`) for
+ * submenus, and give items a trailing `Shortcut` for keyboard hints. Noctis menus are flush against
+ * their anchor — there is no arrow/caret part (Base UI offers one; this system doesn't use it).
+ *
+ * Styling is precompiled in `menu.css`, keyed off each part's prefixed `data-slot`. Each part also
+ * carries the D12 `props()` escape hatch via `Object.assign` (e.g. `Menu.Item.props({ tone })`),
+ * returning a spreadable `{ "data-slot": "noctis-menu-<part>", ...dataAttrs }` bag for a foreign
+ * element a `<Menu.*>` can't wrap.
+ *
+ * The runtime compound is a plain object (kept tree-shakeable); per-part prop and state types are
+ * exposed through the matching `Menu` namespace — e.g. `Menu.Item.Props`.
+ */
+declare const Menu: {
+  Root: typeof MenuRoot;
+  Trigger: typeof MenuTrigger & {
+    props: typeof triggerProps;
+  };
+  Content: typeof MenuContent & {
+    props: typeof contentProps;
+  };
+  Group: typeof MenuGroup & {
+    props: typeof groupProps;
+  };
+  GroupLabel: typeof MenuGroupLabel & {
+    props: typeof groupLabelProps;
+  };
+  Item: typeof MenuItem & {
+    props: typeof itemProps;
+  };
+  LinkItem: typeof MenuLinkItem & {
+    props: typeof linkItemProps;
+  };
+  CheckboxItem: typeof MenuCheckboxItem & {
+    props: typeof checkboxItemProps;
+  };
+  RadioGroup: typeof MenuRadioGroup & {
+    props: typeof radioGroupProps;
+  };
+  RadioItem: typeof MenuRadioItem & {
+    props: typeof radioItemProps;
+  };
+  SubmenuRoot: typeof MenuSubmenuRoot;
+  SubmenuTrigger: typeof MenuSubmenuTrigger & {
+    props: typeof submenuTriggerProps;
+  };
+  Shortcut: typeof MenuShortcut & {
+    props: typeof shortcutProps;
+  };
+  Separator: typeof MenuSeparator & {
+    props: typeof separatorProps;
+  };
+};
+/**
+ * Per-part prop and state types, mirroring Base UI's `Component.Part.Props` convention. Types-only —
+ * it emits no runtime code and merges with the `Menu` object above, so `Menu.Item` is the component
+ * value while `Menu.Item.Props` is its prop type.
+ */
+declare namespace Menu {
+  /** The spreadable data-attribute prop bag every `Menu.*.props()` returns (D12). */
+  type PartProps = MenuPartProps;
+  namespace Root {
+    type Props = menu_d_exports.Menu.Root.Props;
+    type State = menu_d_exports.Menu.Root.State;
+  }
+  namespace Trigger {
+    type Props = menu_d_exports.Menu.Trigger.Props;
+    type State = menu_d_exports.Menu.Trigger.State;
+  }
+  namespace Content {
+    type Props = menu_d_exports.Menu.Popup.Props & {
+      /**
+       * Which side of the anchor to open on. Inside a `SubmenuRoot` the default becomes
+       * `"inline-end"` — beside the trigger row, flipping to `"inline-start"` at the
+       * viewport edge.
+       * @default "bottom"
+       */
+      side?: menu_d_exports.Menu.Positioner.Props["side"];
+      /**
+       * Alignment along that side.
+       * @default "start"
+       */
+      align?: menu_d_exports.Menu.Positioner.Props["align"];
+      /**
+       * Gap from the anchor, in px. Inside a `SubmenuRoot` it defaults to `0`, flush with
+       * the parent menu.
+       * @default 6
+       */
+      sideOffset?: number;
+      /**
+       * Shift along the alignment axis, in px. Inside a `SubmenuRoot` it defaults to `-4`,
+       * lining the submenu's first row up with its trigger.
+       * @default 0
+       */
+      alignOffset?: number;
+      /**
+       * Minimum space kept from the viewport edge when avoiding collisions, in px.
+       * @default 8
+       */
+      collisionPadding?: menu_d_exports.Menu.Positioner.Props["collisionPadding"];
+    };
+  }
+  namespace Group {
+    type Props = menu_d_exports.Menu.Group.Props;
+    type State = menu_d_exports.Menu.Group.State;
+  }
+  namespace GroupLabel {
+    type Props = menu_d_exports.Menu.GroupLabel.Props;
+    type State = menu_d_exports.Menu.GroupLabel.State;
+  }
+  namespace Item {
+    type Props = menu_d_exports.Menu.Item.Props & {
+      /** Optional leading glyph. */icon?: IconGlyph;
+      /**
+       * Reserve the leading icon column on a row without a glyph, so its label aligns with
+       * iconed siblings.
+       * @default false
+       */
+      inset?: boolean;
+      /**
+       * Visual intent. `danger` marks a destructive action — red label and a danger-tinted
+       * highlight.
+       * @default "default"
+       */
+      tone?: "default" | "danger";
+    };
+    type State = menu_d_exports.Menu.Item.State;
+    /** Argument to the `Menu.Item.props(...)` escape-hatch helper. */
+    type PropsArgs = MenuItemPropsArgs;
+  }
+  namespace LinkItem {
+    type Props = menu_d_exports.Menu.LinkItem.Props & {
+      /** Optional leading glyph. */icon?: IconGlyph;
+      /**
+       * Reserve the leading icon column on a row without a glyph, so its label aligns with
+       * iconed siblings.
+       * @default false
+       */
+      inset?: boolean;
+      /**
+       * Visual intent. `danger` marks a destructive link — red label and a danger-tinted
+       * highlight.
+       * @default "default"
+       */
+      tone?: "default" | "danger";
+      /**
+       * Close the menu when the link is clicked. Navigating is a terminal action, so this
+       * defaults to `true` (unlike Base UI's `false`).
+       * @default true
+       */
+      closeOnClick?: boolean;
+    };
+    type State = menu_d_exports.Menu.LinkItem.State;
+    /** Argument to the `Menu.LinkItem.props(...)` escape-hatch helper. */
+    type PropsArgs = MenuItemPropsArgs;
+  }
+  namespace CheckboxItem {
+    type Props = menu_d_exports.Menu.CheckboxItem.Props;
+    type State = menu_d_exports.Menu.CheckboxItem.State;
+  }
+  namespace RadioGroup {
+    type Props = menu_d_exports.Menu.RadioGroup.Props;
+    type State = menu_d_exports.Menu.RadioGroup.State;
+  }
+  namespace RadioItem {
+    type Props = menu_d_exports.Menu.RadioItem.Props;
+    type State = menu_d_exports.Menu.RadioItem.State;
+  }
+  namespace SubmenuRoot {
+    type Props = menu_d_exports.Menu.SubmenuRoot.Props;
+    type State = menu_d_exports.Menu.SubmenuRoot.State;
+  }
+  namespace SubmenuTrigger {
+    type Props = Omit<menu_d_exports.Menu.SubmenuTrigger.Props, "openOnHover" | "delay" | "closeDelay"> & {
+      /** Optional leading glyph. */icon?: IconGlyph;
+      /**
+       * Reserve the leading icon column on a row without a glyph, so its label aligns with
+       * iconed siblings.
+       * @default false
+       */
+      inset?: boolean;
+      /**
+       * Also open the submenu when the trigger is hovered.
+       * @default true
+       */
+      openOnHover?: boolean;
+      /**
+       * How long to wait before opening on hover, in ms.
+       * @default 100
+       */
+      delay?: number;
+      /**
+       * Grace period before a hover-opened submenu closes after the pointer leaves, in ms —
+       * long enough for diagonal travel into the submenu.
+       * @default 150
+       */
+      closeDelay?: number;
+    };
+    type State = menu_d_exports.Menu.SubmenuTrigger.State;
+  }
+  namespace Shortcut {
+    type Props = {
+      /**
+       * The keybinding, in `Kbd` syntax — `+` joins keys pressed together, whitespace
+       * separates sequence chords (`"Mod+K"`, `"G D"`).
+       */
+      keys?: string; /** Custom hint content, rendered when `keys` is not set. */
+      children?: ReactNode; /** Classes merged onto the hint. */
+      className?: string;
+    };
+  }
+  namespace Separator {
+    type Props = menu_d_exports.Menu.Separator.Props;
+    type State = menu_d_exports.Menu.Separator.State;
+  }
+}
+//#endregion
+export { Menu };

package/dist/components/menu/menu.js

@@ -0,0 +1,263 @@
+"use client";
+import { Icon } from "../../icons/icon.js";
+import { CheckIcon, ChevronRightIcon } from "../../icons/glyphs.js";
+import { Surface } from "../surface/surface.js";
+import { menu_exports } from "../../primitives/menu.js";
+import { Kbd } from "../kbd/kbd.js";
+import { MENU_SLOTS } from "./menu.slots.js";
+import { checkboxItemProps, contentProps, groupLabelProps, groupProps, itemProps, linkItemProps, radioGroupProps, radioItemProps, separatorProps, shortcutProps, submenuTriggerProps, triggerProps } from "./menu.props.js";
+import { createContext, useContext } from "react";
+import clsx$1 from "clsx";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/components/menu/menu.tsx
+/**
+* Marks the subtree of a `Menu.SubmenuRoot`, so a nested `Content` switches to submenu positioning
+* defaults (`side="inline-end"`, flush and row-aligned to its trigger) without the caller wiring it.
+*/
+const SubmenuLevelContext = createContext(false);
+/**
+* Owns the open state and shares it with the trigger and content. Wraps Base UI's Menu. Modal by
+* default — outside content is inert and page scroll is locked while open; set `modal={false}` for a
+* lighter popup that leaves the page interactive.
+*/
+function MenuRoot(props) {
+	return /* @__PURE__ */ jsx(menu_exports.Menu.Root, { ...props });
+}
+/**
+* The control that opens the menu. Style it yourself, or compose a `Button` through `render` — e.g.
+* `<Menu.Trigger render={<Button iconOnly aria-label="More" startIcon={ChevronDownIcon} />} />`.
+*/
+function MenuTrigger(props) {
+	return /* @__PURE__ */ jsx(menu_exports.Menu.Trigger, {
+		"data-slot": MENU_SLOTS.trigger,
+		...props
+	});
+}
+/**
+* The floating menu surface — portaled, elevated, and animated — holding the items, groups, and
+* separators. A root menu opens below the trigger, aligned to its start; inside a `SubmenuRoot` it
+* opens on the inline-end side instead, flipping to inline-start at the viewport edge. Caps at the
+* available viewport height and scrolls its list, keeping the keyboard highlight in view.
+*/
+function MenuContent({ side, align = "start", sideOffset, alignOffset, collisionPadding = 8, className, style, children, ...props }) {
+	const inSubmenu = useContext(SubmenuLevelContext);
+	return /* @__PURE__ */ jsx(menu_exports.Menu.Portal, { children: /* @__PURE__ */ jsx(menu_exports.Menu.Positioner, {
+		side: side ?? (inSubmenu ? "inline-end" : "bottom"),
+		align,
+		sideOffset: sideOffset ?? (inSubmenu ? 0 : 6),
+		alignOffset: alignOffset ?? (inSubmenu ? -4 : 0),
+		collisionPadding,
+		"data-slot": MENU_SLOTS.positioner,
+		children: /* @__PURE__ */ jsx(menu_exports.Menu.Popup, {
+			"data-slot": MENU_SLOTS.content,
+			render: /* @__PURE__ */ jsx(Surface, {
+				elevation: "menu",
+				bordered: true,
+				shadow: "popover"
+			}),
+			style: {
+				transformOrigin: "var(--transform-origin)",
+				maxHeight: "var(--available-height)",
+				...style
+			},
+			className: clsx$1(className),
+			...props,
+			children: /* @__PURE__ */ jsx("div", {
+				"data-slot": MENU_SLOTS.viewport,
+				"data-custom-scrollbar": true,
+				children
+			})
+		})
+	}) });
+}
+/** A labelled section of related items. Put a `GroupLabel` inside to name it for screen readers. */
+function MenuGroup({ className, ...props }) {
+	return /* @__PURE__ */ jsx(menu_exports.Menu.Group, {
+		"data-slot": MENU_SLOTS.group,
+		className: clsx$1(className),
+		...props
+	});
+}
+/** The group's muted, non-interactive heading — announced as the group's accessible name. */
+function MenuGroupLabel({ className, ...props }) {
+	return /* @__PURE__ */ jsx(menu_exports.Menu.GroupLabel, {
+		"data-slot": MENU_SLOTS.groupLabel,
+		className: clsx$1(className),
+		...props
+	});
+}
+/**
+* A menu action. Optional leading `icon`; `inset` reserves the icon column on icon-less rows so
+* labels align with iconed siblings; `tone="danger"` marks a destructive action — red label and a
+* danger-tinted highlight. Trailing content (a `Menu.Shortcut`, secondary text) flows after the label.
+*/
+function MenuItem({ icon, inset = false, tone = "default", className, children, ...props }) {
+	return /* @__PURE__ */ jsxs(menu_exports.Menu.Item, {
+		"data-slot": MENU_SLOTS.item,
+		"data-variant": tone,
+		className: clsx$1(className),
+		...props,
+		children: [icon ? /* @__PURE__ */ jsx(Icon, {
+			icon,
+			size: "sm"
+		}) : inset ? /* @__PURE__ */ jsx("span", { "data-slot": MENU_SLOTS.insetSpacer }) : null, children]
+	});
+}
+/**
+* A navigable menu row that renders an `<a>` — the canonical "Open in new tab" / "Copy link address"
+* action. Same row recipe as `Item` (leading `icon`, `inset` alignment, `tone="danger"`); pass anchor
+* props (`href`, `target`, `rel`) through. Navigating is a terminal action, so it closes the menu on
+* click by default (set `closeOnClick={false}` to keep it open).
+*/
+function MenuLinkItem({ icon, inset = false, tone = "default", closeOnClick = true, className, children, ...props }) {
+	return /* @__PURE__ */ jsxs(menu_exports.Menu.LinkItem, {
+		"data-slot": MENU_SLOTS.linkItem,
+		"data-variant": tone,
+		closeOnClick,
+		className: clsx$1(className),
+		...props,
+		children: [icon ? /* @__PURE__ */ jsx(Icon, {
+			icon,
+			size: "sm"
+		}) : inset ? /* @__PURE__ */ jsx("span", { "data-slot": MENU_SLOTS.insetSpacer }) : null, children]
+	});
+}
+/**
+* A menu item that toggles a setting. The leading slot is a check that animates in while ticked,
+* holding the same column as item icons; toggling does not close the menu (`closeOnClick` stays
+* Base UI's `false`).
+*/
+function MenuCheckboxItem({ className, children, ...props }) {
+	return /* @__PURE__ */ jsxs(menu_exports.Menu.CheckboxItem, {
+		"data-slot": MENU_SLOTS.checkboxItem,
+		className: clsx$1(className),
+		...props,
+		children: [/* @__PURE__ */ jsx(menu_exports.Menu.CheckboxItemIndicator, {
+			keepMounted: true,
+			"data-slot": MENU_SLOTS.itemIndicator,
+			children: /* @__PURE__ */ jsx(Icon, {
+				icon: CheckIcon,
+				size: "sm"
+			})
+		}), children]
+	});
+}
+/** Groups `RadioItem`s around one selected `value` (controlled or via `defaultValue`). */
+function MenuRadioGroup({ className, ...props }) {
+	return /* @__PURE__ */ jsx(menu_exports.Menu.RadioGroup, {
+		"data-slot": MENU_SLOTS.radioGroup,
+		className: clsx$1(className),
+		...props
+	});
+}
+/**
+* One choice in a `RadioGroup`. The leading slot is a dot that marks the selected item, holding the
+* same column as item icons; selecting does not close the menu (`closeOnClick` stays Base UI's
+* `false`).
+*/
+function MenuRadioItem({ className, children, ...props }) {
+	return /* @__PURE__ */ jsxs(menu_exports.Menu.RadioItem, {
+		"data-slot": MENU_SLOTS.radioItem,
+		className: clsx$1(className),
+		...props,
+		children: [/* @__PURE__ */ jsx(menu_exports.Menu.RadioItemIndicator, {
+			keepMounted: true,
+			"data-slot": MENU_SLOTS.itemIndicator,
+			children: /* @__PURE__ */ jsx("span", { "data-slot": MENU_SLOTS.radioDot })
+		}), children]
+	});
+}
+/** Owns a nested submenu's open state. Renders no element — wrap a `SubmenuTrigger` and a `Content`. */
+function MenuSubmenuRoot(props) {
+	return /* @__PURE__ */ jsx(SubmenuLevelContext.Provider, {
+		value: true,
+		children: /* @__PURE__ */ jsx(menu_exports.Menu.SubmenuRoot, { ...props })
+	});
+}
+/**
+* An item-shaped row that opens a nested submenu — on hover (after a short intent delay, with a
+* grace period on leave so diagonal pointer travel into the submenu doesn't snap it shut), on click,
+* and from the keyboard (Right arrow / Enter; Left arrow in RTL). The trailing chevron mirrors under
+* RTL, and the row stays lit while its submenu is open.
+*/
+function MenuSubmenuTrigger({ icon, inset = false, openOnHover = true, delay = 100, closeDelay = 150, className, children, ...props }) {
+	return /* @__PURE__ */ jsxs(menu_exports.Menu.SubmenuTrigger, {
+		"data-slot": MENU_SLOTS.submenuTrigger,
+		openOnHover,
+		delay,
+		closeDelay,
+		className: clsx$1(className),
+		...props,
+		children: [
+			icon ? /* @__PURE__ */ jsx(Icon, {
+				icon,
+				size: "sm"
+			}) : inset ? /* @__PURE__ */ jsx("span", { "data-slot": MENU_SLOTS.insetSpacer }) : null,
+			children,
+			/* @__PURE__ */ jsx(Icon, {
+				icon: ChevronRightIcon,
+				size: "sm",
+				directional: true
+			})
+		]
+	});
+}
+/**
+* A trailing, muted keyboard-shortcut hint composing the `Kbd` primitive — pass `keys` in `Kbd`
+* syntax (`"Mod+K"`, `"G D"`) or custom children. Decorative: hidden from assistive tech so the
+* item's action name stays clean (and typeahead never matches the shortcut); when the binding is
+* live, set `aria-keyshortcuts` on the item to expose it.
+*/
+function MenuShortcut({ keys, className, children }) {
+	return /* @__PURE__ */ jsx("span", {
+		"data-slot": MENU_SLOTS.shortcut,
+		"aria-hidden": true,
+		className: clsx$1(className),
+		children: keys ? /* @__PURE__ */ jsx(Kbd, { keys }) : children
+	});
+}
+/** A hairline between groups of menu items. */
+function MenuSeparator({ className, ...props }) {
+	return /* @__PURE__ */ jsx(menu_exports.Menu.Separator, {
+		"data-slot": MENU_SLOTS.separator,
+		className: clsx$1(className),
+		...props
+	});
+}
+/**
+* A dropdown menu: a `Trigger` opens a floating list of actions. Built on Base UI's Menu for keyboard
+* navigation (arrows, Home/End, typeahead), focus management, and `Escape`/outside-click dismissal,
+* and decoupled from any particular trigger — pass your own (commonly a `Button` via `render`).
+*
+* Compose from parts: `Menu.Root` owns the open state, `Menu.Trigger` opens it, and `Menu.Content`
+* holds the rows — `Item`s, `CheckboxItem`s, `RadioGroup`/`RadioItem`s, `Group`s with a `GroupLabel`,
+* and `Separator`s. Nest a `SubmenuRoot` (wrapping a `SubmenuTrigger` and its own `Content`) for
+* submenus, and give items a trailing `Shortcut` for keyboard hints. Noctis menus are flush against
+* their anchor — there is no arrow/caret part (Base UI offers one; this system doesn't use it).
+*
+* Styling is precompiled in `menu.css`, keyed off each part's prefixed `data-slot`. Each part also
+* carries the D12 `props()` escape hatch via `Object.assign` (e.g. `Menu.Item.props({ tone })`),
+* returning a spreadable `{ "data-slot": "noctis-menu-<part>", ...dataAttrs }` bag for a foreign
+* element a `<Menu.*>` can't wrap.
+*
+* The runtime compound is a plain object (kept tree-shakeable); per-part prop and state types are
+* exposed through the matching `Menu` namespace — e.g. `Menu.Item.Props`.
+*/
+const Menu = {
+	Root: MenuRoot,
+	Trigger: Object.assign(MenuTrigger, { props: triggerProps }),
+	Content: Object.assign(MenuContent, { props: contentProps }),
+	Group: Object.assign(MenuGroup, { props: groupProps }),
+	GroupLabel: Object.assign(MenuGroupLabel, { props: groupLabelProps }),
+	Item: Object.assign(MenuItem, { props: itemProps }),
+	LinkItem: Object.assign(MenuLinkItem, { props: linkItemProps }),
+	CheckboxItem: Object.assign(MenuCheckboxItem, { props: checkboxItemProps }),
+	RadioGroup: Object.assign(MenuRadioGroup, { props: radioGroupProps }),
+	RadioItem: Object.assign(MenuRadioItem, { props: radioItemProps }),
+	SubmenuRoot: MenuSubmenuRoot,
+	SubmenuTrigger: Object.assign(MenuSubmenuTrigger, { props: submenuTriggerProps }),
+	Shortcut: Object.assign(MenuShortcut, { props: shortcutProps }),
+	Separator: Object.assign(MenuSeparator, { props: separatorProps })
+};
+//#endregion
+export { Menu };