@ariakit/react-components 0.1.0

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

@@ -0,0 +1,67 @@
+import { PopoverDisclosureOptions } from "../popover/popover-disclosure.js";
+import { n as CompositeTypeaheadOptions } from "../composite-typeahead-DDhpyKqm.js";
+import { HovercardAnchorOptions } from "../hovercard/hovercard-anchor.js";
+import { t as MenuStore } from "../menu-store-0CKKmNek.js";
+import { Props } from "@ariakit/react-utils";
+import { ElementType } from "react";
+
+//#region src/menu/menu-button.d.ts
+declare const TagName = "button";
+type TagName = typeof TagName | "div";
+/**
+ * Returns props to create a `MenuButton` component.
+ * @see https://ariakit.com/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>
+ * ```
+ */
+declare const useMenuButton: import("@ariakit/react-utils").Hook<TagName, MenuButtonOptions<TagName>>;
+/**
+ * Renders a menu button that toggles the visibility of a
+ * [`Menu`](https://ariakit.com/reference/menu) component when clicked or when
+ * using arrow keys.
+ * @see https://ariakit.com/components/menu
+ * @example
+ * ```jsx {2}
+ * <MenuProvider>
+ *   <MenuButton>Edit</MenuButton>
+ *   <Menu>
+ *     <MenuItem>Undo</MenuItem>
+ *     <MenuItem>Redo</MenuItem>
+ *   </Menu>
+ * </MenuProvider>
+ * ```
+ */
+declare const MenuButton: (props: MenuButtonProps) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+interface MenuButtonOptions<T extends ElementType = TagName> extends HovercardAnchorOptions<T>, PopoverDisclosureOptions<T>, CompositeTypeaheadOptions<T> {
+  /**
+   * Object returned by the
+   * [`useMenuStore`](https://ariakit.com/reference/use-menu-store) hook. If not
+   * provided, the closest
+   * [`MenuProvider`](https://ariakit.com/reference/menu-provider) component's
+   * context will be used.
+   */
+  store?: MenuStore;
+  /**
+   * Determines whether pressing a character key while focusing on the
+   * [`MenuButton`](https://ariakit.com/reference/menu-button) should move focus
+   * to the [`MenuItem`](https://ariakit.com/reference/menu-item) starting with
+   * that character.
+   *
+   * By default, it's `true` for menu buttons in a
+   * [`Menubar`](https://ariakit.com/reference/menubar), but `false` for other
+   * menu buttons.
+   */
+  typeahead?: boolean;
+}
+type MenuButtonProps<T extends ElementType = TagName> = Props<T, MenuButtonOptions<T>>;
+//#endregion
+export { MenuButton, MenuButtonOptions, MenuButtonProps, useMenuButton };
+//# sourceMappingURL=menu-button.d.ts.map

package/dist/menu/menu-button.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu-button.d.ts","names":["Props","ElementType","CompositeTypeaheadOptions","HovercardAnchorOptions","PopoverDisclosureOptions","MenuStore","TagName","useMenuButton","MenuButtonOptions","Hook","MenuButton","MenuButtonProps","props","ReactElement","JSXElementConstructor","T","store","typeahead"],"sources":["../../src/menu/menu-button.d.ts"],"mappings":";;;;;;;;cAMcM,OAAAA;AAAAA,KACTA,OAAAA,UAAiBA,OAAO;AAFoB;;;;AAC5B;AAAA;;;;AACQ;AAe7B;;;;AAjBiD,cAiB5BC,aAAAA,iCAA8CE,IAAAA,CAAKH,OAAAA,EAASE,iBAAAA,CAAkBF,OAAAA;;;;;;;;;AAAO;AAiB1G;;;;;;;cAAqBI,UAAAA,GAAaE,KAAAA,EAAOD,eAAe,qBAAqBE,YAAAA,+BAA2CC,qBAAAA;AAAAA,UACvGN,iBAAAA,WAA4BP,WAAAA,GAAcK,OAAAA,UAAiBH,sBAAAA,CAAuBY,CAAAA,GAAIX,wBAAAA,CAAyBW,CAAAA,GAAIb,yBAAAA,CAA0Ba,CAAAA;EADjB;AAC7I;;;;;;EAQIC,KAAAA,GAAQX,SAAAA;EARkJU;;;;;;;;;;EAmB1JE,SAAAA;AAAAA;AAAAA,KAEQN,eAAAA,WAA0BV,WAAAA,GAAcK,OAAAA,IAAWN,KAAAA,CAAMe,CAAAA,EAAGP,iBAAAA,CAAkBO,CAAAA"}

package/dist/menu/menu-button.js

@@ -0,0 +1,183 @@
+"use client";
+import { Role } from "../role/role.js";
+import { usePopoverDisclosure } from "../popover/popover-disclosure.js";
+import { useCompositeTypeahead } from "../composite/composite-typeahead.js";
+import { useHovercardAnchor } from "../hovercard/hovercard-anchor.js";
+import { MenuContextProvider, useMenuProviderContext } from "./menu-context.js";
+import { createElement, createHook, forwardRef, useEvent, useId, useMergeRefs, useWrapElement } from "@ariakit/react-utils";
+import { disabledFromElement, disabledFromProps, getPopupItemRole, getPopupRole, invariant } from "@ariakit/utils";
+import { useRef } from "react";
+import { jsx } from "react/jsx-runtime";
+import { useStoreState } from "@ariakit/react-store";
+//#region src/menu/menu-button.tsx
+const TagName = "button";
+function getInitialFocus(event, dir) {
+	return {
+		ArrowDown: dir === "bottom" || dir === "top" ? "first" : false,
+		ArrowUp: dir === "bottom" || dir === "top" ? "last" : false,
+		ArrowRight: dir === "right" ? "first" : false,
+		ArrowLeft: dir === "left" ? "first" : false
+	}[event.key];
+}
+function hasActiveItem(items, excludeElement) {
+	return !!items?.some((item) => {
+		if (!item.element) return false;
+		if (item.element === excludeElement) return false;
+		return item.element.getAttribute("aria-expanded") === "true";
+	});
+}
+/**
+* Returns props to create a `MenuButton` component.
+* @see https://ariakit.com/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>
+* ```
+*/
+const useMenuButton = createHook(function useMenuButton({ store, focusable, accessibleWhenDisabled, showOnHover, ...props }) {
+	const context = useMenuProviderContext();
+	store = store || context;
+	invariant(store, "MenuButton must receive a `store` prop or be wrapped in a MenuProvider component.");
+	const ref = useRef(null);
+	const parentMenu = store.parent;
+	const parentMenubar = store.menubar;
+	const hasParentMenu = !!parentMenu;
+	const parentIsMenubar = !!parentMenubar && !hasParentMenu;
+	const disabled = disabledFromProps(props);
+	const isDisabled = (element) => disabled || disabledFromElement(element);
+	const showMenu = () => {
+		const trigger = ref.current;
+		if (!trigger) return;
+		store?.setDisclosureElement(trigger);
+		store?.setAnchorElement(trigger);
+		store?.show();
+	};
+	const onFocusProp = props.onFocus;
+	const onFocus = useEvent((event) => {
+		onFocusProp?.(event);
+		if (isDisabled(event.currentTarget)) return;
+		if (event.defaultPrevented) return;
+		store?.setAutoFocusOnShow(false);
+		store?.setActiveId(null);
+		if (!parentMenubar) return;
+		if (!parentIsMenubar) return;
+		const { items } = parentMenubar.getState();
+		if (hasActiveItem(items, event.currentTarget)) showMenu();
+	});
+	const dir = useStoreState(store, (state) => state.placement.split("-")[0]);
+	const onKeyDownProp = props.onKeyDown;
+	const onKeyDown = useEvent((event) => {
+		onKeyDownProp?.(event);
+		if (isDisabled(event.currentTarget)) return;
+		if (event.defaultPrevented) return;
+		const initialFocus = getInitialFocus(event, dir);
+		if (initialFocus) {
+			event.preventDefault();
+			const { open } = store.getState();
+			if (open) {
+				const id = initialFocus === "last" ? store.last() : store.first();
+				store.move(id);
+				return;
+			}
+			showMenu();
+			store?.setAutoFocusOnShow(true);
+			store?.setInitialFocus(initialFocus);
+		}
+	});
+	const onClickProp = props.onClick;
+	const onClick = useEvent((event) => {
+		onClickProp?.(event);
+		if (event.defaultPrevented) return;
+		if (!store) 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) showMenu();
+	});
+	props = useWrapElement(props, (element) => /* @__PURE__ */ jsx(MenuContextProvider, {
+		value: store,
+		children: element
+	}), [store]);
+	if (hasParentMenu) props = {
+		...props,
+		render: /* @__PURE__ */ jsx(Role.div, { render: props.render })
+	};
+	const id = useId(props.id);
+	const parentContentElement = useStoreState(parentMenu?.combobox || parentMenu, "contentElement");
+	props = {
+		role: hasParentMenu || parentIsMenubar ? getPopupItemRole(parentContentElement, "menuitem") : void 0,
+		"aria-haspopup": getPopupRole(useStoreState(store, "contentElement"), !!store.combobox ? "dialog" : "menu"),
+		...props,
+		id,
+		ref: useMergeRefs(ref, props.ref),
+		onFocus,
+		onKeyDown,
+		onClick
+	};
+	props = useHovercardAnchor({
+		store,
+		focusable,
+		accessibleWhenDisabled,
+		...props,
+		showOnHover: (event) => {
+			const getShowOnHover = () => {
+				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 && hasActiveItem(items);
+			};
+			if (!getShowOnHover()) return false;
+			const parent = parentIsMenubar ? parentMenubar : parentMenu;
+			if (!parent) return true;
+			parent.setActiveId(event.currentTarget.id);
+			return true;
+		}
+	});
+	props = usePopoverDisclosure({
+		store,
+		toggleOnClick: !hasParentMenu,
+		focusable,
+		accessibleWhenDisabled,
+		...props
+	});
+	props = useCompositeTypeahead({
+		store,
+		typeahead: parentIsMenubar,
+		...props
+	});
+	return props;
+});
+/**
+* Renders a menu button that toggles the visibility of a
+* [`Menu`](https://ariakit.com/reference/menu) component when clicked or when
+* using arrow keys.
+* @see https://ariakit.com/components/menu
+* @example
+* ```jsx {2}
+* <MenuProvider>
+*   <MenuButton>Edit</MenuButton>
+*   <Menu>
+*     <MenuItem>Undo</MenuItem>
+*     <MenuItem>Redo</MenuItem>
+*   </Menu>
+* </MenuProvider>
+* ```
+*/
+const MenuButton = forwardRef(function MenuButton(props) {
+	return createElement(TagName, useMenuButton(props));
+});
+//#endregion
+export { MenuButton, useMenuButton };
+
+//# sourceMappingURL=menu-button.js.map

package/dist/menu/menu-button.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu-button.js","names":[],"sources":["../../src/menu/menu-button.tsx"],"sourcesContent":["import { useStoreState } from \"@ariakit/react-store\";\nimport {\n  useEvent,\n  useId,\n  useMergeRefs,\n  useWrapElement,\n  createElement,\n  createHook,\n  forwardRef,\n} from \"@ariakit/react-utils\";\nimport type { Props } from \"@ariakit/react-utils\";\nimport {\n  getPopupItemRole,\n  getPopupRole,\n  disabledFromElement,\n  disabledFromProps,\n  invariant,\n} from \"@ariakit/utils\";\nimport type { ElementType, FocusEvent, KeyboardEvent, MouseEvent } from \"react\";\nimport { useRef } from \"react\";\nimport type { CompositeTypeaheadOptions } from \"../composite/composite-typeahead.tsx\";\nimport { useCompositeTypeahead } from \"../composite/composite-typeahead.tsx\";\nimport type { HovercardAnchorOptions } from \"../hovercard/hovercard-anchor.tsx\";\nimport { useHovercardAnchor } from \"../hovercard/hovercard-anchor.tsx\";\nimport type { PopoverDisclosureOptions } from \"../popover/popover-disclosure.tsx\";\nimport { usePopoverDisclosure } from \"../popover/popover-disclosure.tsx\";\nimport { Role } from \"../role/role.tsx\";\nimport {\n  MenuContextProvider,\n  useMenuProviderContext,\n} from \"./menu-context.tsx\";\nimport type { MenuStore, MenuStoreState } from \"./menu-store.ts\";\n\nconst TagName = \"button\" satisfies ElementType;\ntype TagName = typeof TagName | \"div\";\ntype HTMLType = HTMLElementTagNameMap[TagName];\ntype BasePlacement = \"top\" | \"bottom\" | \"left\" | \"right\";\n\nfunction getInitialFocus(event: KeyboardEvent, dir: BasePlacement) {\n  const keyMap = {\n    ArrowDown: dir === \"bottom\" || dir === \"top\" ? \"first\" : false,\n    ArrowUp: dir === \"bottom\" || dir === \"top\" ? \"last\" : false,\n    ArrowRight: dir === \"right\" ? \"first\" : false,\n    ArrowLeft: dir === \"left\" ? \"first\" : false,\n  } as const;\n  return keyMap[event.key as keyof typeof keyMap];\n}\n\nfunction hasActiveItem(\n  items?: MenuStoreState[\"items\"],\n  excludeElement?: Element | null,\n) {\n  return !!items?.some((item) => {\n    if (!item.element) return false;\n    if (item.element === excludeElement) return false;\n    return item.element.getAttribute(\"aria-expanded\") === \"true\";\n  });\n}\n\n/**\n * Returns props to create a `MenuButton` component.\n * @see https://ariakit.com/components/menu\n * @example\n * ```jsx\n * const store = useMenuStore();\n * const props = useMenuButton({ store });\n * <Role {...props}>Edit</Role>\n * <Menu store={store}>\n *   <MenuItem>Undo</MenuItem>\n *   <MenuItem>Redo</MenuItem>\n * </Menu>\n * ```\n */\nexport const useMenuButton = createHook<TagName, MenuButtonOptions>(\n  function useMenuButton({\n    store,\n    focusable,\n    accessibleWhenDisabled,\n    showOnHover,\n    ...props\n  }) {\n    const context = useMenuProviderContext();\n    store = store || context;\n\n    invariant(\n      store,\n      process.env.NODE_ENV !== \"production\" &&\n        \"MenuButton must receive a `store` prop or be wrapped in a MenuProvider component.\",\n    );\n\n    const ref = useRef<HTMLElement>(null);\n    const parentMenu = store.parent;\n    const parentMenubar = store.menubar;\n    const hasParentMenu = !!parentMenu;\n    const parentIsMenubar = !!parentMenubar && !hasParentMenu;\n    const disabled = disabledFromProps(props);\n    const isDisabled = (element: Element) =>\n      disabled || disabledFromElement(element);\n\n    const showMenu = () => {\n      const trigger = ref.current;\n      if (!trigger) return;\n      store?.setDisclosureElement(trigger);\n      store?.setAnchorElement(trigger);\n      store?.show();\n    };\n\n    const onFocusProp = props.onFocus;\n\n    const onFocus = useEvent((event: FocusEvent<HTMLType>) => {\n      onFocusProp?.(event as any);\n      if (isDisabled(event.currentTarget)) return;\n      if (event.defaultPrevented) return;\n      // Reset the autoFocusOnShow state so we can focus the menu button while\n      // the menu is open and press arrow keys to move focus to the menu items.\n      store?.setAutoFocusOnShow(false);\n      // We need to unset the active menu item so no menu item appears active\n      // while the menu button is focused.\n      store?.setActiveId(null);\n      // When the menu button is focused, we'll only show its menu if it's in a\n      // menu bar\n      if (!parentMenubar) return;\n      if (!parentIsMenubar) return;\n      const { items } = parentMenubar.getState();\n      // and there's already another expanded menu button or the previously\n      // focused element is another menu item.\n      if (hasActiveItem(items, event.currentTarget)) {\n        showMenu();\n      }\n    });\n\n    const dir = useStoreState(\n      store,\n      (state) => state.placement.split(\"-\")[0] as BasePlacement,\n    );\n\n    const onKeyDownProp = props.onKeyDown;\n\n    const onKeyDown = useEvent((event: KeyboardEvent<HTMLType>) => {\n      onKeyDownProp?.(event as any);\n      if (isDisabled(event.currentTarget)) return;\n      if (event.defaultPrevented) return;\n      const initialFocus = getInitialFocus(event, dir);\n      if (initialFocus) {\n        event.preventDefault();\n        const { open } = store.getState();\n        if (open) {\n          const id = initialFocus === \"last\" ? store.last() : store.first();\n          store.move(id);\n          return;\n        }\n        showMenu();\n        store?.setAutoFocusOnShow(true);\n        store?.setInitialFocus(initialFocus);\n      }\n    });\n\n    const onClickProp = props.onClick;\n\n    const onClick = useEvent((event: MouseEvent<HTMLType>) => {\n      onClickProp?.(event as any);\n      if (event.defaultPrevented) return;\n      if (!store) return;\n      const isKeyboardClick = !event.detail;\n      const { open } = store.getState();\n      // When the menu button is clicked, if the menu is hidden or if it's a\n      // keyboard click (enter or space),\n      if (!open || isKeyboardClick) {\n        // we'll only automatically focus on the menu if it's not a submenu\n        // button, or if it's a keyboard click.\n        if (!hasParentMenu || isKeyboardClick) {\n          store.setAutoFocusOnShow(true);\n        }\n        store.setInitialFocus(isKeyboardClick ? \"first\" : \"container\");\n      }\n      // On submenu buttons, we can't hide the submenu by clicking on the menu\n      // button again.\n      if (hasParentMenu) {\n        showMenu();\n      }\n    });\n\n    props = useWrapElement(\n      props,\n      (element) => (\n        <MenuContextProvider value={store}>{element}</MenuContextProvider>\n      ),\n      [store],\n    );\n\n    if (hasParentMenu) {\n      // On Safari, VO+Space triggers a click twice on native button elements\n      // with role menuitem (https://bugs.webkit.org/show_bug.cgi?id=228318).\n      // So, if the menu button is rendered within a menu, we need to render it\n      // as another element.\n      props = {\n        ...props,\n        render: <Role.div render={props.render} />,\n      };\n    }\n\n    // We'll use this id to render the aria-labelledby attribute on the menu.\n    const id = useId(props.id);\n\n    const parentContentElement = useStoreState(\n      parentMenu?.combobox || parentMenu,\n      \"contentElement\",\n    );\n\n    // When the menu button is rendered inside another menu, we set the role\n    // attribute here so it doesn't get overridden by the button component with\n    // role=\"button\".\n    const role =\n      hasParentMenu || parentIsMenubar\n        ? getPopupItemRole(parentContentElement, \"menuitem\")\n        : undefined;\n\n    const contentElement = useStoreState(store, \"contentElement\");\n\n    // Use the combobox presence to pick the correct fallback so\n    // aria-haspopup stays stable before the content element mounts.\n    // See https://github.com/ariakit/ariakit/issues/4443\n    const hasCombobox = !!store.combobox;\n    const popupRole = getPopupRole(\n      contentElement,\n      hasCombobox ? \"dialog\" : \"menu\",\n    );\n\n    props = {\n      role,\n      \"aria-haspopup\": popupRole,\n      ...props,\n      id,\n      ref: useMergeRefs(ref, props.ref),\n      onFocus,\n      onKeyDown,\n      onClick,\n    };\n\n    props = useHovercardAnchor<TagName>({\n      store,\n      focusable,\n      accessibleWhenDisabled,\n      ...props,\n      showOnHover: (event) => {\n        const getShowOnHover = () => {\n          if (typeof showOnHover === \"function\") return showOnHover(event);\n          if (showOnHover != null) return showOnHover;\n          if (hasParentMenu) return true;\n          if (!parentMenubar) return false;\n          const { items } = parentMenubar.getState();\n          return parentIsMenubar && hasActiveItem(items);\n        };\n        const canShowOnHover = getShowOnHover();\n        if (!canShowOnHover) return false;\n        const parent = parentIsMenubar ? parentMenubar : parentMenu;\n        if (!parent) return true;\n        // When hovering over a menu button shows a menu and the menu button is\n        // part of another menu or menubar, it's not guaranteed that the button\n        // will get focused. That's why we make sure the active item is updated\n        // on the parent menu store. See \"moving between menus with arrow keys\n        // after hovering over subitems\" test.\n        parent.setActiveId(event.currentTarget.id);\n        return true;\n      },\n    });\n\n    props = usePopoverDisclosure<TagName>({\n      store,\n      toggleOnClick: !hasParentMenu,\n      focusable,\n      accessibleWhenDisabled,\n      ...props,\n    });\n\n    props = useCompositeTypeahead<TagName>({\n      store,\n      typeahead: parentIsMenubar,\n      ...props,\n    });\n\n    return props;\n  },\n);\n\n/**\n * Renders a menu button that toggles the visibility of a\n * [`Menu`](https://ariakit.com/reference/menu) component when clicked or when\n * using arrow keys.\n * @see https://ariakit.com/components/menu\n * @example\n * ```jsx {2}\n * <MenuProvider>\n *   <MenuButton>Edit</MenuButton>\n *   <Menu>\n *     <MenuItem>Undo</MenuItem>\n *     <MenuItem>Redo</MenuItem>\n *   </Menu>\n * </MenuProvider>\n * ```\n */\nexport const MenuButton = forwardRef(function MenuButton(\n  props: MenuButtonProps,\n) {\n  const htmlProps = useMenuButton(props);\n  return createElement(TagName, htmlProps);\n});\n\nexport interface MenuButtonOptions<T extends ElementType = TagName>\n  extends\n    HovercardAnchorOptions<T>,\n    PopoverDisclosureOptions<T>,\n    CompositeTypeaheadOptions<T> {\n  /**\n   * Object returned by the\n   * [`useMenuStore`](https://ariakit.com/reference/use-menu-store) hook. If not\n   * provided, the closest\n   * [`MenuProvider`](https://ariakit.com/reference/menu-provider) component's\n   * context will be used.\n   */\n  store?: MenuStore;\n  /**\n   * Determines whether pressing a character key while focusing on the\n   * [`MenuButton`](https://ariakit.com/reference/menu-button) should move focus\n   * to the [`MenuItem`](https://ariakit.com/reference/menu-item) starting with\n   * that character.\n   *\n   * By default, it's `true` for menu buttons in a\n   * [`Menubar`](https://ariakit.com/reference/menubar), but `false` for other\n   * menu buttons.\n   */\n  typeahead?: boolean;\n}\n\nexport type MenuButtonProps<T extends ElementType = TagName> = Props<\n  T,\n  MenuButtonOptions<T>\n>;\n"],"mappings":"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"}

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

@@ -0,0 +1,47 @@
+import { t as MenubarStore } from "../menubar-store-3h0eNIbS.js";
+import { t as MenuStore } from "../menu-store-0CKKmNek.js";
+
+//#region src/menu/menu-context.d.ts
+/**
+ * Returns the menu store from the nearest menu container.
+ * @example
+ * function Menu() {
+ *   const store = useMenuContext();
+ *
+ *   if (!store) {
+ *     throw new Error("Menu must be wrapped in MenuProvider");
+ *   }
+ *
+ *   // Use the store...
+ * }
+ */
+declare const useMenuContext: () => MenuStore<import("@ariakit/components/menu/menu-store").MenuStoreValues> | undefined;
+declare const useMenuScopedContext: (onlyScoped?: boolean) => MenuStore<import("@ariakit/components/menu/menu-store").MenuStoreValues> | undefined;
+declare const useMenuProviderContext: () => MenuStore<import("@ariakit/components/menu/menu-store").MenuStoreValues> | undefined;
+declare const MenuContextProvider: (props: import("react").ProviderProps<MenuStore<import("@ariakit/components/menu/menu-store").MenuStoreValues> | undefined>) => import("react/jsx-runtime").JSX.Element;
+declare const MenuScopedContextProvider: (props: import("react").ProviderProps<MenuStore<import("@ariakit/components/menu/menu-store").MenuStoreValues> | undefined>) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Returns the menuBar store from the nearest menuBar container.
+ * @deprecated
+ * Use [`useMenubarContext`](https://ariakit.com/reference/use-menubar-context)
+ * instead.
+ * @example
+ * function MenuBar() {
+ *   const store = useMenuBarContext();
+ *
+ *   if (!store) {
+ *     throw new Error("MenuBar must be wrapped in MenuBarProvider");
+ *   }
+ *
+ *   // Use the store...
+ * }
+ */
+declare const useMenuBarContext: () => MenubarStore | undefined;
+declare const useMenuBarScopedContext: (onlyScoped?: boolean) => MenubarStore | undefined;
+declare const useMenuBarProviderContext: () => MenubarStore | undefined;
+declare const MenuBarContextProvider: (props: import("react").ProviderProps<MenubarStore | undefined>) => import("react/jsx-runtime").JSX.Element;
+declare const MenuBarScopedContextProvider: (props: import("react").ProviderProps<MenubarStore | undefined>) => import("react/jsx-runtime").JSX.Element;
+declare const MenuItemCheckedContext: import("react").Context<boolean | undefined>;
+//#endregion
+export { MenuBarContextProvider, MenuBarScopedContextProvider, MenuContextProvider, MenuItemCheckedContext, MenuScopedContextProvider, useMenuBarContext, useMenuBarProviderContext, useMenuBarScopedContext, useMenuContext, useMenuProviderContext, useMenuScopedContext };
+//# sourceMappingURL=menu-context.d.ts.map

package/dist/menu/menu-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu-context.d.ts","names":["MenuStore","useMenuContext","MenuStoreValues","useMenuScopedContext","onlyScoped","useMenuProviderContext","MenuContextProvider","ProviderProps","props","JSX","Element","MenuScopedContextProvider","useMenuBarContext","_$___menubar_menubar_store_ts0","MenubarStore","useMenuBarScopedContext","useMenuBarProviderContext","MenuBarContextProvider","MenuBarScopedContextProvider","MenuItemCheckedContext","Context"],"sources":["../../src/menu/menu-context.d.ts"],"mappings":";;;;;;;AAcA;;;;AAAkH;AAClH;;;;;cADqBC,cAAAA,QAAsBD,SAAS,+CAA+CE,eAAe;AAAA,cAC7FC,oBAAAA,GAAuBC,UAAAA,eAAyBJ,SAAS,+CAA+CE,eAAAA;AAAAA,cACxGG,sBAAAA,QAA8BL,SAAS,+CAA+CE,eAAe;AAAA,cACrGI,mBAAAA,GAAsBE,KAAAA,kBAAuBD,aAAAA,CAAcP,SAAS,+CAA+CE,eAAAA,+CAA8DO,GAAAA,CAAIC,OAAAA;AAAAA,cACrLC,yBAAAA,GAA4BH,KAAAA,kBAAuBD,aAAAA,CAAcP,SAAS,+CAA+CE,eAAAA,+CAA8DO,GAAAA,CAAIC,OAAAA;;;;AAFtF;AAC1H;;;;;;;;;;;AAAiN;cAkB5LE,iBAAAA,QAAuFC,YAAZ;AAAA,cAC3EE,uBAAAA,GAA0BX,UAAAA,eAAuFS,YAAZ;AAAA,cACrGG,yBAAAA,QAA+FH,YAAZ;AAAA,cACnFI,sBAAAA,GAAyBT,KAAAA,kBAAuBD,aAAAA,CAAyHM,YAAzD,8CAA8CJ,GAAAA,CAAIC,OAAAA;AAAAA,cAClKQ,4BAAAA,GAA+BV,KAAAA,kBAAuBD,aAAAA,CAAyHM,YAAzD,8CAA8CJ,GAAAA,CAAIC,OAAAA;AAAAA,cACxKS,sBAAAA,kBAAwCC,OAAO"}

package/dist/menu/menu-context.js

@@ -0,0 +1,52 @@
+"use client";
+import { CompositeContextProvider, CompositeScopedContextProvider } from "../composite/composite-context.js";
+import { HovercardContextProvider, HovercardScopedContextProvider } from "../hovercard/hovercard-context.js";
+import { MenubarContextProvider, MenubarScopedContextProvider, useMenubarContext, useMenubarProviderContext, useMenubarScopedContext } from "../menubar/menubar-context.js";
+import { createStoreContext } from "@ariakit/react-utils";
+import { createContext } from "react";
+//#region src/menu/menu-context.tsx
+const menu = createStoreContext([CompositeContextProvider, HovercardContextProvider], [CompositeScopedContextProvider, HovercardScopedContextProvider]);
+/**
+* Returns the menu store from the nearest menu container.
+* @example
+* function Menu() {
+*   const store = useMenuContext();
+*
+*   if (!store) {
+*     throw new Error("Menu must be wrapped in MenuProvider");
+*   }
+*
+*   // Use the store...
+* }
+*/
+const useMenuContext = menu.useContext;
+const useMenuScopedContext = menu.useScopedContext;
+const useMenuProviderContext = menu.useProviderContext;
+const MenuContextProvider = menu.ContextProvider;
+const MenuScopedContextProvider = menu.ScopedContextProvider;
+/**
+* Returns the menuBar store from the nearest menuBar container.
+* @deprecated
+* Use [`useMenubarContext`](https://ariakit.com/reference/use-menubar-context)
+* instead.
+* @example
+* function MenuBar() {
+*   const store = useMenuBarContext();
+*
+*   if (!store) {
+*     throw new Error("MenuBar must be wrapped in MenuBarProvider");
+*   }
+*
+*   // Use the store...
+* }
+*/
+const useMenuBarContext = useMenubarContext;
+const useMenuBarScopedContext = useMenubarScopedContext;
+const useMenuBarProviderContext = useMenubarProviderContext;
+const MenuBarContextProvider = MenubarContextProvider;
+const MenuBarScopedContextProvider = MenubarScopedContextProvider;
+const MenuItemCheckedContext = createContext(void 0);
+//#endregion
+export { MenuBarContextProvider, MenuBarScopedContextProvider, MenuContextProvider, MenuItemCheckedContext, MenuScopedContextProvider, useMenuBarContext, useMenuBarProviderContext, useMenuBarScopedContext, useMenuContext, useMenuProviderContext, useMenuScopedContext };
+
+//# sourceMappingURL=menu-context.js.map

package/dist/menu/menu-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu-context.js","names":[],"sources":["../../src/menu/menu-context.tsx"],"sourcesContent":["import { createStoreContext } from \"@ariakit/react-utils\";\nimport { createContext } from \"react\";\nimport {\n  CompositeContextProvider,\n  CompositeScopedContextProvider,\n} from \"../composite/composite-context.tsx\";\nimport {\n  HovercardContextProvider,\n  HovercardScopedContextProvider,\n} from \"../hovercard/hovercard-context.tsx\";\nimport {\n  MenubarContextProvider,\n  MenubarScopedContextProvider,\n  useMenubarContext,\n  useMenubarProviderContext,\n  useMenubarScopedContext,\n} from \"../menubar/menubar-context.tsx\";\nimport type { MenuStore } from \"./menu-store.ts\";\n\nconst menu = createStoreContext<MenuStore>(\n  [CompositeContextProvider, HovercardContextProvider],\n  [CompositeScopedContextProvider, HovercardScopedContextProvider],\n);\n\n/**\n * Returns the menu store from the nearest menu container.\n * @example\n * function Menu() {\n *   const store = useMenuContext();\n *\n *   if (!store) {\n *     throw new Error(\"Menu must be wrapped in MenuProvider\");\n *   }\n *\n *   // Use the store...\n * }\n */\nexport const useMenuContext = menu.useContext;\n\nexport const useMenuScopedContext = menu.useScopedContext;\n\nexport const useMenuProviderContext = menu.useProviderContext;\n\nexport const MenuContextProvider = menu.ContextProvider;\n\nexport const MenuScopedContextProvider = menu.ScopedContextProvider;\n\n/**\n * Returns the menuBar store from the nearest menuBar container.\n * @deprecated\n * Use [`useMenubarContext`](https://ariakit.com/reference/use-menubar-context)\n * instead.\n * @example\n * function MenuBar() {\n *   const store = useMenuBarContext();\n *\n *   if (!store) {\n *     throw new Error(\"MenuBar must be wrapped in MenuBarProvider\");\n *   }\n *\n *   // Use the store...\n * }\n */\nexport const useMenuBarContext = useMenubarContext;\n\nexport const useMenuBarScopedContext = useMenubarScopedContext;\n\nexport const useMenuBarProviderContext = useMenubarProviderContext;\n\nexport const MenuBarContextProvider = MenubarContextProvider;\n\nexport const MenuBarScopedContextProvider = MenubarScopedContextProvider;\n\nexport const MenuItemCheckedContext = createContext<boolean | undefined>(\n  undefined,\n);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAuCA,MAAa,iBAAA,KAAA;AAEb,MAAa,uBAAA,KAAyB;AAEtC,MAAa,yBAAsB,KAAK;AAExC,MAAa,sBAAA,KAAA;;;;;;;;;;;;;;;;;;AAoBb,MAAa,oBAAA;AAEb,MAAa,0BAAA;AAEb,MAAa,4BAAyB;AAEtC,MAAa,yBAAA;AAEb,MAAa,+BAAyB"}

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

@@ -0,0 +1,50 @@
+import { HovercardDescriptionOptions } from "../hovercard/hovercard-description.js";
+import { t as MenuStore } from "../menu-store-0CKKmNek.js";
+import { Props } from "@ariakit/react-utils";
+import { ElementType } from "react";
+
+//#region src/menu/menu-description.d.ts
+declare const TagName = "p";
+type TagName = typeof TagName;
+/**
+ * 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.com/components/menu
+ * @example
+ * ```jsx
+ * // This component must be wrapped with Menu
+ * const props = useMenuDescription();
+ * <Role {...props}>Description</Role>
+ * ```
+ */
+declare const useMenuDescription: import("@ariakit/react-utils").Hook<"p", MenuDescriptionOptions<"p">>;
+/**
+ * Renders a description in a menu. This component must be wrapped with a
+ * [`Menu`](https://ariakit.com/reference/menu) component so the
+ * `aria-describedby` prop is properly set on the menu element.
+ * @see https://ariakit.com/components/menu
+ * @example
+ * ```jsx {3}
+ * <MenuProvider>
+ *   <Menu>
+ *     <MenuDescription>Description</MenuDescription>
+ *   </Menu>
+ * </MenuProvider>
+ * ```
+ */
+declare const MenuDescription: (props: MenuDescriptionProps) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+interface MenuDescriptionOptions<T extends ElementType = TagName> extends HovercardDescriptionOptions<T> {
+  /**
+   * Object returned by the
+   * [`useMenuStore`](https://ariakit.com/reference/use-menu-store) hook. If not
+   * provided, the closest [`Menu`](https://ariakit.com/reference/menu) or
+   * [`MenuProvider`](https://ariakit.com/reference/menu-provider) components'
+   * context will be used.
+   */
+  store?: MenuStore;
+}
+type MenuDescriptionProps<T extends ElementType = TagName> = Props<T, MenuDescriptionOptions<T>>;
+//#endregion
+export { MenuDescription, MenuDescriptionOptions, MenuDescriptionProps, useMenuDescription };
+//# sourceMappingURL=menu-description.d.ts.map

package/dist/menu/menu-description.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu-description.d.ts","names":["Props","ElementType","HovercardDescriptionOptions","MenuStore","TagName","useMenuDescription","MenuDescriptionOptions","Hook","MenuDescription","MenuDescriptionProps","props","ReactElement","JSXElementConstructor","T","store"],"sources":["../../src/menu/menu-description.d.ts"],"mappings":";;;;;;cAIcI,OAAAA;AAAAA,KACTA,OAAAA,UAAiBA,OAAO;AAFoB;;;;AAC5B;AAAA;;;;AACQ;AAa7B;;AAfiD,cAe5BC,kBAAAA,iCAAmDE,IAAAA,MAAUD,sBAAsB;;AAAA;AAexG;;;;;;;;;AAAuJ;AACvJ;;cADqBE,eAAAA,GAAkBE,KAAAA,EAAOD,oBAAoB,qBAAqBE,YAAAA,+BAA2CC,qBAAAA;AAAAA,UACjHN,sBAAAA,WAAiCL,WAAAA,GAAcG,OAAAA,UAAiBF,2BAAAA,CAA4BW,CAAAA;EAA7CT;;;;;;;EAQ5DU,KAAAA,GAAQX,SAAAA;AAAAA;AAAAA,KAEAM,oBAAAA,WAA+BR,WAAAA,GAAcG,OAAAA,IAAWJ,KAAAA,CAAMa,CAAAA,EAAGP,sBAAAA,CAAuBO,CAAAA"}

package/dist/menu/menu-description.js

@@ -0,0 +1,42 @@
+"use client";
+import { useHovercardDescription } from "../hovercard/hovercard-description.js";
+import { createElement, createHook, forwardRef } from "@ariakit/react-utils";
+//#region src/menu/menu-description.tsx
+const TagName = "p";
+/**
+* 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.com/components/menu
+* @example
+* ```jsx
+* // This component must be wrapped with Menu
+* const props = useMenuDescription();
+* <Role {...props}>Description</Role>
+* ```
+*/
+const useMenuDescription = createHook(function useMenuDescription(props) {
+	props = useHovercardDescription(props);
+	return props;
+});
+/**
+* Renders a description in a menu. This component must be wrapped with a
+* [`Menu`](https://ariakit.com/reference/menu) component so the
+* `aria-describedby` prop is properly set on the menu element.
+* @see https://ariakit.com/components/menu
+* @example
+* ```jsx {3}
+* <MenuProvider>
+*   <Menu>
+*     <MenuDescription>Description</MenuDescription>
+*   </Menu>
+* </MenuProvider>
+* ```
+*/
+const MenuDescription = forwardRef(function MenuDescription(props) {
+	return createElement(TagName, useMenuDescription(props));
+});
+//#endregion
+export { MenuDescription, useMenuDescription };
+
+//# sourceMappingURL=menu-description.js.map

package/dist/menu/menu-description.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu-description.js","names":[],"sources":["../../src/menu/menu-description.tsx"],"sourcesContent":["import { createElement, createHook, forwardRef } from \"@ariakit/react-utils\";\nimport type { Props } from \"@ariakit/react-utils\";\nimport type { ElementType } from \"react\";\nimport type { HovercardDescriptionOptions } from \"../hovercard/hovercard-description.tsx\";\nimport { useHovercardDescription } from \"../hovercard/hovercard-description.tsx\";\nimport type { MenuStore } from \"./menu-store.ts\";\n\nconst TagName = \"p\" satisfies ElementType;\ntype TagName = typeof TagName;\n\n/**\n * Returns props to create a `MenuDescription` component. This hook must be used\n * in a component that's wrapped with `Menu` so the `aria-describedby` prop is\n * properly set on the menu element.\n * @see https://ariakit.com/components/menu\n * @example\n * ```jsx\n * // This component must be wrapped with Menu\n * const props = useMenuDescription();\n * <Role {...props}>Description</Role>\n * ```\n */\nexport const useMenuDescription = createHook<TagName, MenuDescriptionOptions>(\n  function useMenuDescription(props) {\n    props = useHovercardDescription(props);\n    return props;\n  },\n);\n\n/**\n * Renders a description in a menu. This component must be wrapped with a\n * [`Menu`](https://ariakit.com/reference/menu) component so the\n * `aria-describedby` prop is properly set on the menu element.\n * @see https://ariakit.com/components/menu\n * @example\n * ```jsx {3}\n * <MenuProvider>\n *   <Menu>\n *     <MenuDescription>Description</MenuDescription>\n *   </Menu>\n * </MenuProvider>\n * ```\n */\nexport const MenuDescription = forwardRef(function MenuDescription(\n  props: MenuDescriptionProps,\n) {\n  const htmlProps = useMenuDescription(props);\n  return createElement(TagName, htmlProps);\n});\n\nexport interface MenuDescriptionOptions<\n  T extends ElementType = TagName,\n> extends HovercardDescriptionOptions<T> {\n  /**\n   * Object returned by the\n   * [`useMenuStore`](https://ariakit.com/reference/use-menu-store) hook. If not\n   * provided, the closest [`Menu`](https://ariakit.com/reference/menu) or\n   * [`MenuProvider`](https://ariakit.com/reference/menu-provider) components'\n   * context will be used.\n   */\n  store?: MenuStore;\n}\n\nexport type MenuDescriptionProps<T extends ElementType = TagName> = Props<\n  T,\n  MenuDescriptionOptions<T>\n>;\n"],"mappings":";;;;;;;;;;;;;;;;;MAwBI,qBAAQ,WAA6B,SAAA,mBAAA,OAAA;CACrC,QAAO,wBAAA,KAAA;CAEX,OAAA;;;;;;;;;;;;;;;;MAoBE,kBAAqB,WADH,SAAA,gBACqB,OAAA;CACxC,OAAA,cAAA,SAAA,mBAAA,KAAA,CAAA"}

package/dist/menu/menu-dismiss.d.ts

@@ -0,0 +1,49 @@
+import { HovercardDismissOptions } from "../hovercard/hovercard-dismiss.js";
+import { t as MenuStore } from "../menu-store-0CKKmNek.js";
+import { Props } from "@ariakit/react-utils";
+import { ElementType } from "react";
+
+//#region src/menu/menu-dismiss.d.ts
+declare const TagName = "button";
+type TagName = typeof TagName;
+/**
+ * Returns props to create a `MenuDismiss` component.
+ * @see https://ariakit.com/components/menu
+ * @example
+ * ```jsx
+ * const store = useMenuStore();
+ * const props = useMenuDismiss({ store });
+ * <Menu store={store}>
+ *   <Role {...props} />
+ * </Menu>
+ * ```
+ */
+declare const useMenuDismiss: import("@ariakit/react-utils").Hook<"button", MenuDismissOptions<"button">>;
+/**
+ * Renders a button that hides a [`Menu`](https://ariakit.com/reference/menu)
+ * when clicked.
+ * @see https://ariakit.com/components/menu
+ * @example
+ * ```jsx {3}
+ * <MenuProvider>
+ *   <Menu>
+ *     <MenuDismiss />
+ *   </Menu>
+ * </MenuProvider>
+ * ```
+ */
+declare const MenuDismiss: (props: MenuDismissProps) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+interface MenuDismissOptions<T extends ElementType = TagName> extends HovercardDismissOptions<T> {
+  /**
+   * Object returned by the
+   * [`useMenuStore`](https://ariakit.com/reference/use-menu-store) hook. If not
+   * provided, the closest [`Menu`](https://ariakit.com/reference/menu) or
+   * [`MenuProvider`](https://ariakit.com/reference/menu-provider) components'
+   * context will be used.
+   */
+  store?: MenuStore;
+}
+type MenuDismissProps<T extends ElementType = TagName> = Props<T, MenuDismissOptions<T>>;
+//#endregion
+export { MenuDismiss, MenuDismissOptions, MenuDismissProps, useMenuDismiss };
+//# sourceMappingURL=menu-dismiss.d.ts.map

package/dist/menu/menu-dismiss.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu-dismiss.d.ts","names":["Props","ElementType","HovercardDismissOptions","MenuStore","TagName","useMenuDismiss","MenuDismissOptions","Hook","MenuDismiss","MenuDismissProps","props","ReactElement","JSXElementConstructor","T","store"],"sources":["../../src/menu/menu-dismiss.d.ts"],"mappings":";;;;;;cAIcI,OAAAA;AAAAA,KACTA,OAAAA,UAAiBA,OAAO;AAFoB;;;;AAC5B;AAAA;;;;AACQ;AAa7B;;AAfiD,cAe5BC,cAAAA,iCAA+CE,IAAAA,WAAeD,kBAAkB;;AAAA;AAcrG;;;;;;;;;AAA+I;AAC/I;cADqBE,WAAAA,GAAcE,KAAAA,EAAOD,gBAAgB,qBAAqBE,YAAAA,+BAA2CC,qBAAAA;AAAAA,UACzGN,kBAAAA,WAA6BL,WAAAA,GAAcG,OAAAA,UAAiBF,uBAAAA,CAAwBW,CAAAA;EAAvDZ;;;;;;;EAQ1Ca,KAAAA,GAAQX,SAAAA;AAAAA;AAAAA,KAEAM,gBAAAA,WAA2BR,WAAAA,GAAcG,OAAAA,IAAWJ,KAAAA,CAAMa,CAAAA,EAAGP,kBAAAA,CAAmBO,CAAAA"}

package/dist/menu/menu-dismiss.js

@@ -0,0 +1,47 @@
+"use client";
+import { useHovercardDismiss } from "../hovercard/hovercard-dismiss.js";
+import { useMenuScopedContext } from "./menu-context.js";
+import { createElement, createHook, forwardRef } from "@ariakit/react-utils";
+//#region src/menu/menu-dismiss.tsx
+const TagName = "button";
+/**
+* Returns props to create a `MenuDismiss` component.
+* @see https://ariakit.com/components/menu
+* @example
+* ```jsx
+* const store = useMenuStore();
+* const props = useMenuDismiss({ store });
+* <Menu store={store}>
+*   <Role {...props} />
+* </Menu>
+* ```
+*/
+const useMenuDismiss = createHook(function useMenuDismiss({ store, ...props }) {
+	const context = useMenuScopedContext();
+	store = store || context;
+	props = useHovercardDismiss({
+		store,
+		...props
+	});
+	return props;
+});
+/**
+* Renders a button that hides a [`Menu`](https://ariakit.com/reference/menu)
+* when clicked.
+* @see https://ariakit.com/components/menu
+* @example
+* ```jsx {3}
+* <MenuProvider>
+*   <Menu>
+*     <MenuDismiss />
+*   </Menu>
+* </MenuProvider>
+* ```
+*/
+const MenuDismiss = forwardRef(function MenuDismiss(props) {
+	return createElement(TagName, useMenuDismiss(props));
+});
+//#endregion
+export { MenuDismiss, useMenuDismiss };
+
+//# sourceMappingURL=menu-dismiss.js.map

package/dist/menu/menu-dismiss.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu-dismiss.js","names":[],"sources":["../../src/menu/menu-dismiss.tsx"],"sourcesContent":["import { createElement, createHook, forwardRef } from \"@ariakit/react-utils\";\nimport type { Props } from \"@ariakit/react-utils\";\nimport type { ElementType } from \"react\";\nimport type { HovercardDismissOptions } from \"../hovercard/hovercard-dismiss.tsx\";\nimport { useHovercardDismiss } from \"../hovercard/hovercard-dismiss.tsx\";\nimport { useMenuScopedContext } from \"./menu-context.tsx\";\nimport type { MenuStore } from \"./menu-store.ts\";\n\nconst TagName = \"button\" satisfies ElementType;\ntype TagName = typeof TagName;\n\n/**\n * Returns props to create a `MenuDismiss` component.\n * @see https://ariakit.com/components/menu\n * @example\n * ```jsx\n * const store = useMenuStore();\n * const props = useMenuDismiss({ store });\n * <Menu store={store}>\n *   <Role {...props} />\n * </Menu>\n * ```\n */\nexport const useMenuDismiss = createHook<TagName, MenuDismissOptions>(\n  function useMenuDismiss({ store, ...props }) {\n    const context = useMenuScopedContext();\n    store = store || context;\n    props = useHovercardDismiss({ store, ...props });\n    return props;\n  },\n);\n\n/**\n * Renders a button that hides a [`Menu`](https://ariakit.com/reference/menu)\n * when clicked.\n * @see https://ariakit.com/components/menu\n * @example\n * ```jsx {3}\n * <MenuProvider>\n *   <Menu>\n *     <MenuDismiss />\n *   </Menu>\n * </MenuProvider>\n * ```\n */\nexport const MenuDismiss = forwardRef(function MenuDismiss(\n  props: MenuDismissProps,\n) {\n  const htmlProps = useMenuDismiss(props);\n  return createElement(TagName, htmlProps);\n});\n\nexport interface MenuDismissOptions<\n  T extends ElementType = TagName,\n> extends HovercardDismissOptions<T> {\n  /**\n   * Object returned by the\n   * [`useMenuStore`](https://ariakit.com/reference/use-menu-store) hook. If not\n   * provided, the closest [`Menu`](https://ariakit.com/reference/menu) or\n   * [`MenuProvider`](https://ariakit.com/reference/menu-provider) components'\n   * context will be used.\n   */\n  store?: MenuStore;\n}\n\nexport type MenuDismissProps<T extends ElementType = TagName> = Props<\n  T,\n  MenuDismissOptions<T>\n>;\n"],"mappings":";;;;;;;;;;;;;;;;;;MAyBI,iBAAgB,WAAA,SAAqB,eAAA,EAAA,OAAA,GAAA,SAAA;CACrC,MAAA,UAAQ,qBAAS;CACjB,QAAQ,SAAA;SAAsB,oBAAA;EAAO;EAAU,GAAA;CAC/C,CAAA;CAEJ,OAAA;;;;;;;;;;;;;;;MAmBE,cAAO,WADW,SAAA,YACqB,OAAA;CACxC,OAAA,cAAA,SAAA,eAAA,KAAA,CAAA"}