@ariakit/react-core 0.0.1 → 0.1.1

package/cjs/menu/menu-arrow.cjs

@@ -0,0 +1,28 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _OVCUW432cjs = require('../__chunks/OVCUW432.cjs');
+require('../__chunks/4K6QJIPX.cjs');
+require('../__chunks/W5PBA4D6.cjs');
+
+
+
+
+var _UYIFJ7U3cjs = require('../__chunks/UYIFJ7U3.cjs');
+require('../__chunks/5QY4WCTR.cjs');
+require('../__chunks/2X5K3J7Y.cjs');
+
+// src/menu/menu-arrow.ts
+var useMenuArrow = _UYIFJ7U3cjs.createHook.call(void 0, (props) => {
+  return _OVCUW432cjs.usePopoverArrow.call(void 0, props);
+});
+var MenuArrow = _UYIFJ7U3cjs.createComponent.call(void 0, (props) => {
+  const htmlProps = useMenuArrow(props);
+  return _UYIFJ7U3cjs.createElement.call(void 0, "div", htmlProps);
+});
+if (process.env.NODE_ENV !== "production") {
+  MenuArrow.displayName = "MenuArrow";
+}
+
+
+
+exports.MenuArrow = MenuArrow; exports.useMenuArrow = useMenuArrow;

package/cjs/menu/menu-arrow.d.ts

@@ -0,0 +1,38 @@
+import type { PopoverArrowOptions } from "../popover/popover-arrow.js";
+import type { As, Props } from "../utils/types.js";
+import type { MenuStore } from "./menu-store.js";
+/**
+ * Returns props to create a `MenuArrow` component.
+ * @see https://ariakit.org/components/menu
+ * @example
+ * ```jsx
+ * const store = useMenuStore();
+ * const props = useMenuArrow({ store });
+ * <MenuButton store={store}>Menu</MenuButton>
+ * <Menu store={store}>
+ *   <Role {...props} />
+ * </Menu>
+ * ```
+ */
+export declare const useMenuArrow: import("../utils/types.js").Hook<MenuArrowOptions<"div">>;
+/**
+ * Renders an arrow inside the menu element.
+ * @see https://ariakit.org/components/menu
+ * @example
+ * ```jsx
+ * const menu = useMenuStore();
+ * <MenuButton store={menu}>Menu</MenuButton>
+ * <Menu store={menu}>
+ *   <MenuArrow />
+ * </Menu>
+ * ```
+ */
+export declare const MenuArrow: import("../utils/types.js").Component<MenuArrowOptions<"div">>;
+export interface MenuArrowOptions<T extends As = "div"> extends PopoverArrowOptions<T> {
+    /**
+     * Object returned by the `useMenuStore` hook. If not provided, the parent
+     * `Menu` component's context will be used.
+     */
+    store?: MenuStore;
+}
+export type MenuArrowProps<T extends As = "div"> = Props<MenuArrowOptions<T>>;

package/cjs/menu/menu-bar-store.cjs

@@ -0,0 +1,31 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } }
+
+
+var _RG6JXX7Tcjs = require('../__chunks/RG6JXX7T.cjs');
+require('../__chunks/5LMWS5O4.cjs');
+
+
+var _F6IOE5QTcjs = require('../__chunks/F6IOE5QT.cjs');
+require('../__chunks/5QY4WCTR.cjs');
+require('../__chunks/2X5K3J7Y.cjs');
+
+// src/menu/menu-bar-store.ts
+var _menubarstore = require('@ariakit/core/menu/menu-bar-store'); var Core = _interopRequireWildcard(_menubarstore);
+function useMenuBarStoreOptions(props) {
+  return _RG6JXX7Tcjs.useCompositeStoreOptions.call(void 0, props);
+}
+function useMenuBarStoreProps(store, props) {
+  return _RG6JXX7Tcjs.useCompositeStoreProps.call(void 0, store, props);
+}
+function useMenuBarStore(props = {}) {
+  const options = useMenuBarStoreOptions(props);
+  const store = _F6IOE5QTcjs.useStore.call(void 0, 
+    () => Core.createMenuBarStore({ ...props, ...options })
+  );
+  return useMenuBarStoreProps(store, props);
+}
+
+
+
+
+exports.useMenuBarStore = useMenuBarStore; exports.useMenuBarStoreOptions = useMenuBarStoreOptions; exports.useMenuBarStoreProps = useMenuBarStoreProps;

package/cjs/menu/menu-bar-store.d.ts

@@ -0,0 +1,30 @@
+import * as Core from "@ariakit/core/menu/menu-bar-store";
+import type { CompositeStoreFunctions, CompositeStoreOptions, CompositeStoreState } from "../composite/composite-store.js";
+import type { Store } from "../utils/store.js";
+export declare function useMenuBarStoreOptions(props: MenuBarStoreProps): Partial<import("../collection/collection-store.js").CollectionStoreOptions<{
+    id: string;
+    element?: HTMLElement | null | undefined;
+} & {
+    rowId?: string | undefined;
+    disabled?: boolean | undefined;
+    children?: string | undefined;
+}>>;
+export declare function useMenuBarStoreProps<T extends MenuBarStore>(store: T, props: MenuBarStoreProps): T;
+/**
+ * Creates a menu bar store.
+ * @see https://ariakit.org/components/menu
+ * @example
+ * ```jsx
+ * const menu = useMenuBarStore();
+ * <MenuBar store={menu} />
+ * ```
+ */
+export declare function useMenuBarStore(props?: MenuBarStoreProps): MenuBarStore;
+export interface MenuBarStoreState extends Core.MenuBarStoreState, CompositeStoreState {
+}
+export interface MenuBarStoreFunctions extends Core.MenuBarStoreFunctions, CompositeStoreFunctions {
+}
+export interface MenuBarStoreOptions extends Core.MenuBarStoreOptions, CompositeStoreOptions {
+}
+export type MenuBarStoreProps = MenuBarStoreOptions & Core.MenuBarStoreProps;
+export type MenuBarStore = MenuBarStoreFunctions & Store<Core.MenuBarStore>;

package/cjs/menu/menu-bar.cjs

@@ -0,0 +1,53 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _MPFAD3UKcjs = require('../__chunks/MPFAD3UK.cjs');
+
+
+var _GV5LATA3cjs = require('../__chunks/GV5LATA3.cjs');
+require('../__chunks/6622YWGR.cjs');
+require('../__chunks/44UMDBZE.cjs');
+require('../__chunks/NVMBKFRB.cjs');
+
+
+
+
+var _UYIFJ7U3cjs = require('../__chunks/UYIFJ7U3.cjs');
+
+
+var _5QY4WCTRcjs = require('../__chunks/5QY4WCTR.cjs');
+require('../__chunks/2X5K3J7Y.cjs');
+
+// src/menu/menu-bar.tsx
+var _jsxruntime = require('react/jsx-runtime');
+var useMenuBar = _UYIFJ7U3cjs.createHook.call(void 0, 
+  ({ store, composite = true, ...props }) => {
+    const orientation = store.useState(
+      (state) => !composite || state.orientation === "both" ? void 0 : state.orientation
+    );
+    props = _5QY4WCTRcjs.useWrapElement.call(void 0, 
+      props,
+      (element) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _MPFAD3UKcjs.MenuBarContext.Provider, { value: store, children: element }),
+      [store]
+    );
+    if (composite) {
+      props = {
+        role: "menubar",
+        "aria-orientation": orientation,
+        ...props
+      };
+    }
+    props = _GV5LATA3cjs.useComposite.call(void 0, { store, composite, ...props });
+    return props;
+  }
+);
+var MenuBar = _UYIFJ7U3cjs.createComponent.call(void 0, (props) => {
+  const htmlProps = useMenuBar(props);
+  return _UYIFJ7U3cjs.createElement.call(void 0, "div", htmlProps);
+});
+if (process.env.NODE_ENV !== "production") {
+  MenuBar.displayName = "MenuBar";
+}
+
+
+
+exports.MenuBar = MenuBar; exports.useMenuBar = useMenuBar;

package/cjs/menu/menu-bar.d.ts

@@ -0,0 +1,61 @@
+import type { CompositeOptions } from "../composite/composite.js";
+import type { As, Props } from "../utils/types.js";
+import type { MenuBarStore } from "./menu-bar-store.js";
+/**
+ * Returns props to create a `MenuBar` component.
+ * @see https://ariakit.org/components/menu
+ * @example
+ * ```jsx
+ * const store = useMenuBarStore();
+ * const menuBarProps = useMenuBar({ store });
+ * const fileProps = useMenuItem({ store });
+ * const fileMenu = useMenuStore();
+ * <Role {...menuBarProps}>
+ *   <MenuButton {...fileProps} store={fileMenu}>
+ *     File
+ *   </MenuButton>
+ *   <Menu store={fileMenu}>
+ *     <MenuItem>New File</MenuItem>
+ *     <MenuItem>New Window</MenuItem>
+ *   </Menu>
+ * </Role>
+ * ```
+ */
+export declare const useMenuBar: import("../utils/types.js").Hook<MenuBarOptions<"div">>;
+/**
+ * Renders a menu bar that may contain a group of menu items that control other
+ * submenus.
+ * @see https://ariakit.org/components/menu
+ * @example
+ * ```jsx
+ * const store = useMenuBarStore();
+ * const fileProps = useMenuItem({ store });
+ * const editProps = useMenuItem({ store });
+ * const fileMenu = useMenuStore();
+ * const editMenu = useMenuStore();
+ * <MenuBar store={store}>
+ *   <MenuButton {...fileProps} store={fileMenu}>
+ *     File
+ *   </MenuButton>
+ *   <Menu store={fileMenu}>
+ *     <MenuItem>New File</MenuItem>
+ *     <MenuItem>New Window</MenuItem>
+ *   </Menu>
+ *   <MenuButton {...editProps} store={editMenu}>
+ *     Edit
+ *   </MenuButton>
+ *   <Menu store={editMenu}>
+ *     <MenuItem>Undo</MenuItem>
+ *     <MenuItem>Redo</MenuItem>
+ *   </Menu>
+ * </MenuBar>
+ * ```
+ */
+export declare const MenuBar: import("../utils/types.js").Component<MenuBarOptions<"div">>;
+export interface MenuBarOptions<T extends As = "div"> extends CompositeOptions<T> {
+    /**
+     * Object returned by the `useMenuBarStore` hook.
+     */
+    store: MenuBarStore;
+}
+export type MenuBarProps<T extends As = "div"> = Props<MenuBarOptions<T>>;

package/cjs/menu/menu-button-arrow.cjs

@@ -0,0 +1,30 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _QTUC5TMJcjs = require('../__chunks/QTUC5TMJ.cjs');
+require('../__chunks/W5PBA4D6.cjs');
+
+
+
+
+var _UYIFJ7U3cjs = require('../__chunks/UYIFJ7U3.cjs');
+
+// src/menu/menu-button-arrow.ts
+var useMenuButtonArrow = _UYIFJ7U3cjs.createHook.call(void 0, 
+  ({ store, ...props }) => {
+    props = _QTUC5TMJcjs.usePopoverDisclosureArrow.call(void 0, { store, ...props });
+    return props;
+  }
+);
+var MenuButtonArrow = _UYIFJ7U3cjs.createComponent.call(void 0, 
+  (props) => {
+    const htmlProps = useMenuButtonArrow(props);
+    return _UYIFJ7U3cjs.createElement.call(void 0, "span", htmlProps);
+  }
+);
+if (process.env.NODE_ENV !== "production") {
+  MenuButtonArrow.displayName = "MenuButtonArrow";
+}
+
+
+
+exports.MenuButtonArrow = MenuButtonArrow; exports.useMenuButtonArrow = useMenuButtonArrow;

package/cjs/menu/menu-button-arrow.d.ts

@@ -0,0 +1,47 @@
+import type { PopoverDisclosureArrowOptions } from "../popover/popover-disclosure-arrow.js";
+import type { As, Props } from "../utils/types.js";
+import type { MenuStore } from "./menu-store.js";
+/**
+ * Returns props to create a `MenuButtonArrow` component.
+ * @see https://ariakit.org/components/menu
+ * @example
+ * ```jsx
+ * const store = useMenuStore();
+ * const props = useMenuButtonArrow({ store });
+ * <MenuButton store={store}>
+ *   Edit
+ *   <Role {...props} />
+ * </MenuButton>
+ * <Menu store={store}>
+ *   <MenuItem>Undo</MenuItem>
+ *   <MenuItem>Redo</MenuItem>
+ * </Menu>
+ * ```
+ */
+export declare const useMenuButtonArrow: import("../utils/types.js").Hook<MenuButtonArrowOptions<"span">>;
+/**
+ * Renders an arrow pointing to the menu position, usually inside a
+ * `MenuButton`.
+ * @see https://ariakit.org/components/menu
+ * @example
+ * ```jsx
+ * const menu = useMenuStore();
+ * <MenuButton store={menu}>
+ *   Edit
+ *   <MenuButtonArrow />
+ * </MenuButton>
+ * <Menu store={menu}>
+ *   <MenuItem>Undo</MenuItem>
+ *   <MenuItem>Redo</MenuItem>
+ * </Menu>
+ * ```
+ */
+export declare const MenuButtonArrow: import("../utils/types.js").Component<MenuButtonArrowOptions<"span">>;
+export interface MenuButtonArrowOptions<T extends As = "span"> extends PopoverDisclosureArrowOptions<T> {
+    /**
+     * Object returned by the `useMenuStore` hook. If not provided, the parent
+     * `MenuButton` component's context will be used.
+     */
+    store?: MenuStore;
+}
+export type MenuButtonArrowProps<T extends As = "span"> = Props<MenuButtonArrowOptions<T>>;

package/cjs/menu/menu-button.cjs

@@ -0,0 +1,177 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _OSVJV44Dcjs = require('../__chunks/OSVJV44D.cjs');
+
+
+
+var _MPFAD3UKcjs = require('../__chunks/MPFAD3UK.cjs');
+
+
+var _F2O4M6DRcjs = require('../__chunks/F2O4M6DR.cjs');
+
+
+var _LICOAFSXcjs = require('../__chunks/LICOAFSX.cjs');
+require('../__chunks/22VQR3WC.cjs');
+require('../__chunks/VSKE43XZ.cjs');
+require('../__chunks/GTWUFHVO.cjs');
+
+
+var _W2ODSL37cjs = require('../__chunks/W2ODSL37.cjs');
+require('../__chunks/W5PBA4D6.cjs');
+require('../__chunks/BJTWNJAP.cjs');
+require('../__chunks/EWCMH6G3.cjs');
+require('../__chunks/6622YWGR.cjs');
+require('../__chunks/44UMDBZE.cjs');
+require('../__chunks/NVMBKFRB.cjs');
+
+
+
+
+var _UYIFJ7U3cjs = require('../__chunks/UYIFJ7U3.cjs');
+
+
+var _F6IOE5QTcjs = require('../__chunks/F6IOE5QT.cjs');
+
+
+
+
+var _5QY4WCTRcjs = require('../__chunks/5QY4WCTR.cjs');
+require('../__chunks/2X5K3J7Y.cjs');
+
+// src/menu/menu-button.ts
+var _react = require('react');
+var _dom = require('@ariakit/core/utils/dom');
+function getInitialFocus(event, dir) {
+  const keyMap = {
+    ArrowDown: dir === "bottom" || dir === "top" ? "first" : false,
+    ArrowUp: dir === "bottom" || dir === "top" ? "last" : false,
+    ArrowRight: dir === "right" ? "first" : false,
+    ArrowLeft: dir === "left" ? "first" : false
+  };
+  return keyMap[event.key];
+}
+var useMenuButton = _UYIFJ7U3cjs.createHook.call(void 0, 
+  ({ store, focusable, accessibleWhenDisabled, showOnHover, ...props }) => {
+    const ref = _react.useRef.call(void 0, null);
+    const parentMenu = _react.useContext.call(void 0, _MPFAD3UKcjs.MenuContext);
+    const parentMenuBar = _react.useContext.call(void 0, _MPFAD3UKcjs.MenuBarContext);
+    const hasParentMenu = !!parentMenu;
+    const parentIsMenuBar = !!parentMenuBar && !hasParentMenu;
+    const disabled = props.disabled || props["aria-disabled"] === true || props["aria-disabled"] === "true";
+    _react.useEffect.call(void 0, () => {
+      store.setDisclosureElement(ref.current);
+    });
+    const onFocusProp = props.onFocus;
+    const onFocus = _5QY4WCTRcjs.useEvent.call(void 0, (event) => {
+      _optionalChain([onFocusProp, 'optionalCall', _ => _(event)]);
+      if (disabled)
+        return;
+      if (event.defaultPrevented)
+        return;
+      store.setAutoFocusOnShow(false);
+      store.setActiveId(null);
+      if (!parentMenuBar)
+        return;
+      if (!parentIsMenuBar)
+        return;
+      const { items } = parentMenuBar.getState();
+      if (_F2O4M6DRcjs.hasExpandedMenuButton.call(void 0, items, event.currentTarget)) {
+        store.show();
+      }
+    });
+    const dir = store.useState(
+      (state) => state.placement.split("-")[0]
+    );
+    const onKeyDownProp = props.onKeyDown;
+    const onKeyDown = _5QY4WCTRcjs.useEvent.call(void 0, (event) => {
+      _optionalChain([onKeyDownProp, 'optionalCall', _2 => _2(event)]);
+      if (disabled)
+        return;
+      if (event.defaultPrevented)
+        return;
+      const initialFocus = getInitialFocus(event, dir);
+      if (initialFocus) {
+        event.preventDefault();
+        store.show();
+        store.setAutoFocusOnShow(true);
+        store.setInitialFocus(initialFocus);
+      }
+    });
+    const onClickProp = props.onClick;
+    const onClick = _5QY4WCTRcjs.useEvent.call(void 0, (event) => {
+      _optionalChain([onClickProp, 'optionalCall', _3 => _3(event)]);
+      if (event.defaultPrevented)
+        return;
+      const isKeyboardClick = !event.detail;
+      const { open } = store.getState();
+      if (!open || isKeyboardClick) {
+        if (!hasParentMenu || isKeyboardClick) {
+          store.setAutoFocusOnShow(true);
+        }
+        store.setInitialFocus(isKeyboardClick ? "first" : "container");
+      }
+      if (hasParentMenu) {
+        store.show();
+      }
+    });
+    if (hasParentMenu) {
+      props = { as: "div", ...props };
+    }
+    const id = _5QY4WCTRcjs.useId.call(void 0, props.id);
+    const parentContentElement = _F6IOE5QTcjs.useStoreState.call(void 0, parentMenu, "contentElement");
+    const role = hasParentMenu || parentIsMenuBar ? _dom.getPopupItemRole.call(void 0, parentContentElement, "menuitem") : void 0;
+    const contentElement = store.useState("contentElement");
+    props = {
+      id,
+      role,
+      "aria-haspopup": _dom.getPopupRole.call(void 0, contentElement, "menu"),
+      ...props,
+      ref: _5QY4WCTRcjs.useForkRef.call(void 0, ref, props.ref),
+      onFocus,
+      onKeyDown,
+      onClick
+    };
+    props = _OSVJV44Dcjs.useHovercardAnchor.call(void 0, {
+      store,
+      focusable,
+      accessibleWhenDisabled,
+      ...props,
+      showOnHover: (event) => {
+        if (typeof showOnHover === "function")
+          return showOnHover(event);
+        if (showOnHover != null)
+          return showOnHover;
+        if (hasParentMenu)
+          return true;
+        if (!parentMenuBar)
+          return false;
+        const { items } = parentMenuBar.getState();
+        return parentIsMenuBar && _F2O4M6DRcjs.hasExpandedMenuButton.call(void 0, items);
+      }
+    });
+    props = _LICOAFSXcjs.usePopoverDisclosure.call(void 0, {
+      store,
+      toggleOnClick: !hasParentMenu,
+      focusable,
+      accessibleWhenDisabled,
+      ...props
+    });
+    props = _W2ODSL37cjs.useCompositeTypeahead.call(void 0, {
+      store,
+      typeahead: parentIsMenuBar,
+      ...props
+    });
+    return props;
+  }
+);
+var MenuButton = _UYIFJ7U3cjs.createComponent.call(void 0, (props) => {
+  const htmlProps = useMenuButton(props);
+  return _UYIFJ7U3cjs.createElement.call(void 0, "button", htmlProps);
+});
+if (process.env.NODE_ENV !== "production") {
+  MenuButton.displayName = "MenuButton";
+}
+
+
+
+exports.MenuButton = MenuButton; exports.useMenuButton = useMenuButton;

package/cjs/menu/menu-button.d.ts

@@ -0,0 +1,50 @@
+import type { CompositeTypeaheadOptions } from "../composite/composite-typeahead.js";
+import type { HovercardAnchorOptions } from "../hovercard/hovercard-anchor.js";
+import type { PopoverDisclosureOptions } from "../popover/popover-disclosure.js";
+import type { As, Props } from "../utils/types.js";
+import type { MenuStore } from "./menu-store.js";
+/**
+ * Returns props to create a `MenuButton` component.
+ * @see https://ariakit.org/components/menu
+ * @example
+ * ```jsx
+ * const store = useMenuStore();
+ * const props = useMenuButton({ store });
+ * <Role {...props}>Edit</Role>
+ * <Menu store={store}>
+ *   <MenuItem>Undo</MenuItem>
+ *   <MenuItem>Redo</MenuItem>
+ * </Menu>
+ * ```
+ */
+export declare const useMenuButton: import("../utils/types.js").Hook<MenuButtonOptions<"button" | "div">>;
+/**
+ * Renders a menu button that triggers a dropdown menu. Usually, this is
+ * rendered as a native `button` element, but if it's a submenu button rendered
+ * as a menu item inside another menu, it'll be rendered as a `div`.
+ * @see https://ariakit.org/components/menu
+ * @example
+ * ```jsx
+ * const menu = useMenuStore();
+ * <MenuButton store={menu}>Edit</MenuButton>
+ * <Menu store={menu}>
+ *   <MenuItem>Undo</MenuItem>
+ *   <MenuItem>Redo</MenuItem>
+ * </Menu>
+ * ```
+ */
+export declare const MenuButton: import("../utils/types.js").Component<MenuButtonOptions<"button" | "div">>;
+export interface MenuButtonOptions<T extends As = "button" | "div"> extends HovercardAnchorOptions<T>, PopoverDisclosureOptions<T>, CompositeTypeaheadOptions<T> {
+    /**
+     * Object returned by the `useMenuStore` hook.
+     */
+    store: MenuStore;
+    /**
+     * Determines whether pressing a character key while focusing on the
+     * `MenuButton` should move focus to the `MenuItem` starting with that
+     * character. By default, it's `true` for menu buttons in a `MenuBar`, but
+     * `false` for other menu buttons.
+     */
+    typeahead?: boolean;
+}
+export type MenuButtonProps<T extends As = "button" | "div"> = Props<MenuButtonOptions<T>>;

package/cjs/menu/menu-context.cjs

@@ -0,0 +1,10 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+var _MPFAD3UKcjs = require('../__chunks/MPFAD3UK.cjs');
+
+
+
+
+exports.MenuBarContext = _MPFAD3UKcjs.MenuBarContext; exports.MenuContext = _MPFAD3UKcjs.MenuContext; exports.MenuItemCheckedContext = _MPFAD3UKcjs.MenuItemCheckedContext;

package/cjs/menu/menu-context.d.ts

@@ -0,0 +1,5 @@
+import type { MenuBarStore } from "./menu-bar-store.js";
+import type { MenuStore } from "./menu-store.js";
+export declare const MenuBarContext: import("react").Context<MenuBarStore | undefined>;
+export declare const MenuContext: import("react").Context<MenuStore | undefined>;
+export declare const MenuItemCheckedContext: import("react").Context<boolean | undefined>;

package/cjs/menu/menu-description.cjs

@@ -0,0 +1,34 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _R6BI5EIUcjs = require('../__chunks/R6BI5EIU.cjs');
+require('../__chunks/S6SU42H5.cjs');
+require('../__chunks/GD6HHJCV.cjs');
+require('../__chunks/N2VCZZLP.cjs');
+
+
+
+
+var _UYIFJ7U3cjs = require('../__chunks/UYIFJ7U3.cjs');
+require('../__chunks/5QY4WCTR.cjs');
+require('../__chunks/2X5K3J7Y.cjs');
+
+// src/menu/menu-description.ts
+var useMenuDescription = _UYIFJ7U3cjs.createHook.call(void 0, 
+  (props) => {
+    props = _R6BI5EIUcjs.useHovercardDescription.call(void 0, props);
+    return props;
+  }
+);
+var MenuDescription = _UYIFJ7U3cjs.createComponent.call(void 0, 
+  (props) => {
+    const htmlProps = useMenuDescription(props);
+    return _UYIFJ7U3cjs.createElement.call(void 0, "p", htmlProps);
+  }
+);
+if (process.env.NODE_ENV !== "production") {
+  MenuDescription.displayName = "MenuDescription";
+}
+
+
+
+exports.MenuDescription = MenuDescription; exports.useMenuDescription = useMenuDescription;

package/cjs/menu/menu-description.d.ts

@@ -0,0 +1,37 @@
+import type { HovercardDescriptionOptions } from "../hovercard/hovercard-description.js";
+import type { As, Props } from "../utils/types.js";
+import type { MenuStore } from "./menu-store.js";
+/**
+ * Returns props to create a `MenuDescription` component. This hook must be used
+ * in a component that's wrapped with `Menu` so the `aria-describedby` prop is
+ * properly set on the menu element.
+ * @see https://ariakit.org/components/menu
+ * @example
+ * ```jsx
+ * // This component must be wrapped with Menu
+ * const props = useMenuDescription();
+ * <Role {...props}>Description</Role>
+ * ```
+ */
+export declare const useMenuDescription: import("../utils/types.js").Hook<MenuDescriptionOptions<"p">>;
+/**
+ * Renders a description in a menu. This component must be wrapped with `Menu`
+ * so the `aria-describedby` prop is properly set on the menu element.
+ * @see https://ariakit.org/components/menu
+ * @example
+ * ```jsx
+ * const menu = useMenuStore();
+ * <Menu store={menu}>
+ *   <MenuDescription>Description</MenuDescription>
+ * </Menu>
+ * ```
+ */
+export declare const MenuDescription: import("../utils/types.js").Component<MenuDescriptionOptions<"p">>;
+export interface MenuDescriptionOptions<T extends As = "p"> extends HovercardDescriptionOptions<T> {
+    /**
+     * Object returned by the `useMenuStore` hook. If not provided, the parent
+     * `Menu` component's context will be used.
+     */
+    store?: MenuStore;
+}
+export type MenuDescriptionProps<T extends As = "p"> = Props<MenuDescriptionOptions<T>>;

package/cjs/menu/menu-dismiss.cjs

@@ -0,0 +1,33 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _M4ATEGE4cjs = require('../__chunks/M4ATEGE4.cjs');
+require('../__chunks/GWL7P7EG.cjs');
+require('../__chunks/743OAGBP.cjs');
+require('../__chunks/GTWUFHVO.cjs');
+require('../__chunks/N2VCZZLP.cjs');
+require('../__chunks/EWCMH6G3.cjs');
+require('../__chunks/44UMDBZE.cjs');
+
+
+
+
+var _UYIFJ7U3cjs = require('../__chunks/UYIFJ7U3.cjs');
+require('../__chunks/5QY4WCTR.cjs');
+require('../__chunks/2X5K3J7Y.cjs');
+
+// src/menu/menu-dismiss.ts
+var useMenuDismiss = _UYIFJ7U3cjs.createHook.call(void 0, (props) => {
+  props = _M4ATEGE4cjs.useHovercardDismiss.call(void 0, props);
+  return props;
+});
+var MenuDismiss = _UYIFJ7U3cjs.createComponent.call(void 0, (props) => {
+  const htmlProps = useMenuDismiss(props);
+  return _UYIFJ7U3cjs.createElement.call(void 0, "button", htmlProps);
+});
+if (process.env.NODE_ENV !== "production") {
+  MenuDismiss.displayName = "MenuDismiss";
+}
+
+
+
+exports.MenuDismiss = MenuDismiss; exports.useMenuDismiss = useMenuDismiss;