@ariakit/react-components 0.1.0

package/dist/hovercard-store-gIeoQEn_.d.ts

@@ -0,0 +1,30 @@
+import { t as DisclosureStore } from "./disclosure-store-BsaBaRKv.js";
+import { a as PopoverStoreState, n as PopoverStoreFunctions, r as PopoverStoreOptions } from "./popover-store-Bc-l5VVO.js";
+import { Store } from "@ariakit/react-store";
+import * as Core from "@ariakit/components/hovercard/hovercard-store";
+
+//#region src/hovercard/hovercard-store.d.ts
+declare function useHovercardStoreProps<T extends Core.HovercardStore>(store: T, update: () => void, props: HovercardStoreProps): T & {
+  disclosure: DisclosureStore | null | undefined;
+};
+/**
+ * Creates a hovercard store to control the state of
+ * [Hovercard](https://ariakit.com/reference/hovercard) components.
+ * @see https://ariakit.com/components/hovercard
+ * @example
+ * ```jsx
+ * const hovercard = useHovercardStore({ placement: "top" });
+ *
+ * <HovercardAnchor store={hovercard}>@username</HovercardAnchor>
+ * <Hovercard store={hovercard}>Details</Hovercard>
+ * ```
+ */
+declare function useHovercardStore(props?: HovercardStoreProps): HovercardStore;
+interface HovercardStoreState extends Core.HovercardStoreState, PopoverStoreState {}
+interface HovercardStoreFunctions extends Omit<Core.HovercardStoreFunctions, "disclosure">, PopoverStoreFunctions {}
+interface HovercardStoreOptions extends Omit<Core.HovercardStoreOptions, "disclosure">, PopoverStoreOptions {}
+interface HovercardStoreProps extends HovercardStoreOptions, Omit<Core.HovercardStoreProps, "disclosure"> {}
+interface HovercardStore extends HovercardStoreFunctions, Omit<Store<Core.HovercardStore>, "disclosure"> {}
+//#endregion
+export { HovercardStoreState as a, HovercardStoreProps as i, HovercardStoreFunctions as n, useHovercardStore as o, HovercardStoreOptions as r, useHovercardStoreProps as s, HovercardStore as t };
+//# sourceMappingURL=hovercard-store-gIeoQEn_.d.ts.map

package/dist/hovercard-store-gIeoQEn_.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hovercard-store-gIeoQEn_.d.ts","names":["Core","Store","PopoverStoreFunctions","PopoverStoreOptions","PopoverStoreState","useHovercardStoreProps","T","HovercardStore","HovercardStoreProps","_$___disclosure_disclosure_store_ts0","DisclosureStore","store","update","props","disclosure","useHovercardStore","HovercardStoreState","HovercardStoreFunctions","Omit","HovercardStoreOptions"],"sources":["../src/hovercard/hovercard-store.d.ts"],"mappings":";;;;;;iBAGwBK,sBAAAA,WAAiCL,IAAAA,CAAKO,cAAAA,CAAAA,CAAgBI,KAAAA,EAAOL,CAAAA,EAAGM,MAAAA,cAAoBC,KAAAA,EAAOL,mBAAAA,GAAsBF,CAAAA;EACrIQ,UAAAA,EADsIL,eAAAA;AAAAA;AAA1I;;;;;;;;;;;;AAAA,iBAewBM,iBAAAA,CAAkBF,KAAAA,GAAQL,mBAAAA,GAAsBD,cAAc;AAAA,UACrES,mBAAAA,SAA4BhB,IAAAA,CAAKgB,mBAAAA,EAAqBZ,iBAAiB;AAAA,UAEvEa,uBAAAA,SAAgCC,IAAAA,CAAKlB,IAAAA,CAAKiB,uBAAAA,iBAAwCf,qBAAAA;AAAAA,UAElFiB,qBAAAA,SAA8BD,IAAAA,CAAKlB,IAAAA,CAAKmB,qBAAAA,iBAAsChB,mBAAAA;AAAAA,UAE9EK,mBAAAA,SAA4BW,qBAAAA,EAAuBD,IAAAA,CAAKlB,IAAAA,CAAKQ,mBAAAA;AAAAA,UAE7DD,cAAAA,SAAuBU,uBAAAA,EAAyBC,IAAAA,CAAKjB,KAAAA,CAAMD,IAAAA,CAAKO,cAAAA"}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+//#region src/index.d.ts
+declare const _default: {};
+//#endregion
+export { _default as default };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":["_default","default"],"sources":["../src/index.d.ts"],"mappings":";cAAcA,QAAAA"}

package/dist/index.js

@@ -0,0 +1,7 @@
+"use client";
+//#region src/index.ts
+var src_default = {};
+//#endregion
+export { src_default as default };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["export default {};\n"],"mappings":""}

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

@@ -0,0 +1,52 @@
+import { PopoverArrowOptions } from "../popover/popover-arrow.js";
+import { t as MenuStore } from "../menu-store-0CKKmNek.js";
+import { Props } from "@ariakit/react-utils";
+import { ElementType } from "react";
+
+//#region src/menu/menu-arrow.d.ts
+declare const TagName = "div";
+type TagName = typeof TagName;
+/**
+ * Returns props to create a `MenuArrow` component.
+ * @see https://ariakit.com/components/menu
+ * @example
+ * ```jsx
+ * const store = useMenuStore();
+ * const props = useMenuArrow({ store });
+ * <MenuButton store={store}>Menu</MenuButton>
+ * <Menu store={store}>
+ *   <Role {...props} />
+ * </Menu>
+ * ```
+ */
+declare const useMenuArrow: import("@ariakit/react-utils").Hook<"div", MenuArrowOptions<"div">>;
+/**
+ * Renders an arrow element inside a
+ * [`Menu`](https://ariakit.com/reference/menu) component that points to its
+ * [`MenuButton`](https://ariakit.com/reference/menu-button).
+ * @see https://ariakit.com/components/menu
+ * @example
+ * ```jsx {4}
+ * <MenuProvider>
+ *   <MenuButton>Menu</MenuButton>
+ *   <Menu>
+ *     <MenuArrow />
+ *   </Menu>
+ * </MenuProvider>
+ * ```
+ */
+declare const MenuArrow: (props: MenuArrowProps) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+interface MenuArrowOptions<T extends ElementType = TagName> extends PopoverArrowOptions<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 MenuArrowProps<T extends ElementType = TagName> = Props<T, MenuArrowOptions<T>>;
+//#endregion
+export { MenuArrow, MenuArrowOptions, MenuArrowProps, useMenuArrow };
+//# sourceMappingURL=menu-arrow.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"menu-arrow.d.ts","names":["Props","ElementType","PopoverArrowOptions","MenuStore","TagName","useMenuArrow","MenuArrowOptions","Hook","MenuArrow","MenuArrowProps","props","ReactElement","JSXElementConstructor","T","store"],"sources":["../../src/menu/menu-arrow.d.ts"],"mappings":";;;;;;cAIcI,OAAAA;AAAAA,KACTA,OAAAA,UAAiBA,OAAO;AAFoB;;;;AAC5B;AAAA;;;;AACQ;AAc7B;;;AAhBiD,cAgB5BC,YAAAA,iCAA6CE,IAAAA,QAAYD,gBAAgB;AAAA;AAgB9F;;;;;;;;;AAA2I;AAC3I;;;;AAjB8F,cAgBzEE,SAAAA,GAAYE,KAAAA,EAAOD,cAAc,qBAAqBE,YAAAA,+BAA2CC,qBAAAA;AAAAA,UACrGN,gBAAAA,WAA2BL,WAAAA,GAAcG,OAAAA,UAAiBF,mBAAAA,CAAoBW,CAAAA;EAQnFV;;;;;;;EAARW,KAAAA,GAAQX,SAAAA;AAAAA;AAAAA,KAEAM,cAAAA,WAAyBR,WAAAA,GAAcG,OAAAA,IAAWJ,KAAAA,CAAMa,CAAAA,EAAGP,gBAAAA,CAAiBO,CAAAA"}

package/dist/menu/menu-arrow.js

@@ -0,0 +1,49 @@
+"use client";
+import { usePopoverArrow } from "../popover/popover-arrow.js";
+import { useMenuContext } from "./menu-context.js";
+import { createElement, createHook, forwardRef } from "@ariakit/react-utils";
+//#region src/menu/menu-arrow.tsx
+const TagName = "div";
+/**
+* Returns props to create a `MenuArrow` component.
+* @see https://ariakit.com/components/menu
+* @example
+* ```jsx
+* const store = useMenuStore();
+* const props = useMenuArrow({ store });
+* <MenuButton store={store}>Menu</MenuButton>
+* <Menu store={store}>
+*   <Role {...props} />
+* </Menu>
+* ```
+*/
+const useMenuArrow = createHook(function useMenuArrow({ store, ...props }) {
+	const context = useMenuContext();
+	store = store || context;
+	return usePopoverArrow({
+		store,
+		...props
+	});
+});
+/**
+* Renders an arrow element inside a
+* [`Menu`](https://ariakit.com/reference/menu) component that points to its
+* [`MenuButton`](https://ariakit.com/reference/menu-button).
+* @see https://ariakit.com/components/menu
+* @example
+* ```jsx {4}
+* <MenuProvider>
+*   <MenuButton>Menu</MenuButton>
+*   <Menu>
+*     <MenuArrow />
+*   </Menu>
+* </MenuProvider>
+* ```
+*/
+const MenuArrow = forwardRef(function MenuArrow(props) {
+	return createElement(TagName, useMenuArrow(props));
+});
+//#endregion
+export { MenuArrow, useMenuArrow };
+
+//# sourceMappingURL=menu-arrow.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"menu-arrow.js","names":[],"sources":["../../src/menu/menu-arrow.tsx"],"sourcesContent":["import { createElement, createHook, forwardRef } from \"@ariakit/react-utils\";\nimport type { Props } from \"@ariakit/react-utils\";\nimport type { ElementType } from \"react\";\nimport type { PopoverArrowOptions } from \"../popover/popover-arrow.tsx\";\nimport { usePopoverArrow } from \"../popover/popover-arrow.tsx\";\nimport { useMenuContext } from \"./menu-context.tsx\";\nimport type { MenuStore } from \"./menu-store.ts\";\n\nconst TagName = \"div\" satisfies ElementType;\ntype TagName = typeof TagName;\n\n/**\n * Returns props to create a `MenuArrow` component.\n * @see https://ariakit.com/components/menu\n * @example\n * ```jsx\n * const store = useMenuStore();\n * const props = useMenuArrow({ store });\n * <MenuButton store={store}>Menu</MenuButton>\n * <Menu store={store}>\n *   <Role {...props} />\n * </Menu>\n * ```\n */\nexport const useMenuArrow = createHook<TagName, MenuArrowOptions>(\n  function useMenuArrow({ store, ...props }) {\n    const context = useMenuContext();\n    store = store || context;\n    return usePopoverArrow({ store, ...props });\n  },\n);\n\n/**\n * Renders an arrow element inside a\n * [`Menu`](https://ariakit.com/reference/menu) component that points to its\n * [`MenuButton`](https://ariakit.com/reference/menu-button).\n * @see https://ariakit.com/components/menu\n * @example\n * ```jsx {4}\n * <MenuProvider>\n *   <MenuButton>Menu</MenuButton>\n *   <Menu>\n *     <MenuArrow />\n *   </Menu>\n * </MenuProvider>\n * ```\n */\nexport const MenuArrow = forwardRef(function MenuArrow(props: MenuArrowProps) {\n  const htmlProps = useMenuArrow(props);\n  return createElement(TagName, htmlProps);\n});\n\nexport interface MenuArrowOptions<\n  T extends ElementType = TagName,\n> extends PopoverArrowOptions<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 MenuArrowProps<T extends ElementType = TagName> = Props<\n  T,\n  MenuArrowOptions<T>\n>;\n"],"mappings":";;;;;;;;;;;;;;;;;;;MA0BI,eAAgB,WAAe,SAAA,aAAA,EAAA,OAAA,GAAA,SAAA;CAC/B,MAAA,UAAQ,eAAS;CACjB,QAAO,SAAA;QAAkB,gBAAA;EAAO;EAAU,GAAA;CAE9C,CAAA;;;;;;;;;;;;;;;;;MAmBE,YAAO,WAAc,SADH,UAAa,OACQ;CACxC,OAAA,cAAA,SAAA,aAAA,KAAA,CAAA"}

package/dist/menu/menu-bar-provider.d.ts

@@ -0,0 +1,35 @@
+import { MenubarProviderProps } from "../menubar/menubar-provider.js";
+
+//#region src/menu/menu-bar-provider.d.ts
+/**
+ * Provides a menubar store to MenuBar components.
+ * @deprecated
+ * Use [`MenubarProvider`](https://ariakit.com/reference/menubar-provider)
+ * instead.
+ * @example
+ * ```jsx
+ * <MenuBarProvider>
+ *   <MenuBar>
+ *     <MenuProvider>
+ *       <MenuItem render={<MenuButton />}>File</MenuItem>
+ *       <Menu>
+ *         <MenuItem>New File</MenuItem>
+ *         <MenuItem>New Window</MenuItem>
+ *       </Menu>
+ *     </MenuProvider>
+ *     <MenuProvider>
+ *       <MenuItem render={<MenuButton />}>Edit</MenuItem>
+ *       <Menu>
+ *         <MenuItem>Undo</MenuItem>
+ *         <MenuItem>Redo</MenuItem>
+ *       </Menu>
+ *     </MenuProvider>
+ *   </MenuBar>
+ * </MenuBarProvider>
+ * ```
+ */
+declare function MenuBarProvider(props?: MenuBarProviderProps): import("react/jsx-runtime").JSX.Element;
+interface MenuBarProviderProps extends MenubarProviderProps {}
+//#endregion
+export { MenuBarProvider, MenuBarProviderProps };
+//# sourceMappingURL=menu-bar-provider.d.ts.map

package/dist/menu/menu-bar-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu-bar-provider.d.ts","names":["MenubarProviderProps","MenuBarProvider","MenuBarProviderProps","props","JSX","Element"],"sources":["../../src/menu/menu-bar-provider.d.ts"],"mappings":";;;;;AA4BA;;;;;;;;;AAA8G;AAC9G;;;;AAAkE;;;;;;;;;;;iBAD1CC,eAAAA,CAAgBE,KAAAA,GAAQD,oBAAoB,+BAA+BE,GAAAA,CAAIC,OAAAA;AAAAA,UACtFH,oBAAAA,SAA6BF,oBAAoB"}

package/dist/menu/menu-bar-provider.js

@@ -0,0 +1,42 @@
+"use client";
+import { MenubarProvider } from "../menubar/menubar-provider.js";
+import { useEffect } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/menu/menu-bar-provider.tsx
+/**
+* Provides a menubar store to MenuBar components.
+* @deprecated
+* Use [`MenubarProvider`](https://ariakit.com/reference/menubar-provider)
+* instead.
+* @example
+* ```jsx
+* <MenuBarProvider>
+*   <MenuBar>
+*     <MenuProvider>
+*       <MenuItem render={<MenuButton />}>File</MenuItem>
+*       <Menu>
+*         <MenuItem>New File</MenuItem>
+*         <MenuItem>New Window</MenuItem>
+*       </Menu>
+*     </MenuProvider>
+*     <MenuProvider>
+*       <MenuItem render={<MenuButton />}>Edit</MenuItem>
+*       <Menu>
+*         <MenuItem>Undo</MenuItem>
+*         <MenuItem>Redo</MenuItem>
+*       </Menu>
+*     </MenuProvider>
+*   </MenuBar>
+* </MenuBarProvider>
+* ```
+*/
+function MenuBarProvider(props = {}) {
+	useEffect(() => {
+		console.warn("MenuBarProvider is deprecated. Use MenubarProvider instead.", "See https://ariakit.com/reference/menubar-provider");
+	}, []);
+	return /* @__PURE__ */ jsx(MenubarProvider, { ...props });
+}
+//#endregion
+export { MenuBarProvider };
+
+//# sourceMappingURL=menu-bar-provider.js.map

package/dist/menu/menu-bar-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu-bar-provider.js","names":[],"sources":["../../src/menu/menu-bar-provider.tsx"],"sourcesContent":["import { useEffect } from \"react\";\nimport type { MenubarProviderProps } from \"../menubar/menubar-provider.tsx\";\nimport { MenubarProvider } from \"../menubar/menubar-provider.tsx\";\n\n/**\n * Provides a menubar store to MenuBar components.\n * @deprecated\n * Use [`MenubarProvider`](https://ariakit.com/reference/menubar-provider)\n * instead.\n * @example\n * ```jsx\n * <MenuBarProvider>\n *   <MenuBar>\n *     <MenuProvider>\n *       <MenuItem render={<MenuButton />}>File</MenuItem>\n *       <Menu>\n *         <MenuItem>New File</MenuItem>\n *         <MenuItem>New Window</MenuItem>\n *       </Menu>\n *     </MenuProvider>\n *     <MenuProvider>\n *       <MenuItem render={<MenuButton />}>Edit</MenuItem>\n *       <Menu>\n *         <MenuItem>Undo</MenuItem>\n *         <MenuItem>Redo</MenuItem>\n *       </Menu>\n *     </MenuProvider>\n *   </MenuBar>\n * </MenuBarProvider>\n * ```\n */\nexport function MenuBarProvider(props: MenuBarProviderProps = {}) {\n  useEffect(() => {\n    if (process.env.NODE_ENV !== \"production\") {\n      console.warn(\n        \"MenuBarProvider is deprecated. Use MenubarProvider instead.\",\n        \"See https://ariakit.com/reference/menubar-provider\",\n      );\n    }\n  }, []);\n  return <MenubarProvider {...props} />;\n}\n\nexport interface MenuBarProviderProps extends MenubarProviderProps {}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAgCE,gBAAgB,QAAA,CAAA,GAAA;iBAGV;EAIN,QAAK,KAAA,+DAAA,oDAAA;CACL,GAAA,CAAA,CAAA;CACF,OAAA,oBAAA,iBAAA,EAAA,GAAA,MAAA,CAAA"}

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

@@ -0,0 +1,25 @@
+import { a as MenubarStoreState, i as MenubarStoreProps, n as MenubarStoreFunctions, r as MenubarStoreOptions, t as MenubarStore } from "../menubar-store-3h0eNIbS.js";
+import * as Core from "@ariakit/components/menu/menu-bar-store";
+
+//#region src/menu/menu-bar-store.d.ts
+declare function useMenuBarStoreProps<T extends Core.MenuBarStore>(store: T, update: () => void, props: MenuBarStoreProps): T;
+/**
+ * Creates a menu bar store.
+ * @deprecated
+ * Use [`useMenubarStore`](https://ariakit.com/reference/use-menubar-store)
+ * instead.
+ * @example
+ * ```jsx
+ * const menu = useMenuBarStore();
+ * <MenuBar store={menu} />
+ * ```
+ */
+declare function useMenuBarStore(props?: MenuBarStoreProps): MenuBarStore;
+interface MenuBarStoreState extends MenubarStoreState {}
+interface MenuBarStoreFunctions extends MenubarStoreFunctions {}
+interface MenuBarStoreOptions extends MenubarStoreOptions {}
+interface MenuBarStoreProps extends MenubarStoreProps {}
+interface MenuBarStore extends MenubarStore {}
+//#endregion
+export { MenuBarStore, MenuBarStoreFunctions, MenuBarStoreOptions, MenuBarStoreProps, MenuBarStoreState, useMenuBarStore, useMenuBarStoreProps };
+//# sourceMappingURL=menu-bar-store.d.ts.map

package/dist/menu/menu-bar-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu-bar-store.d.ts","names":["Core","MenubarStore","MenubarStoreFunctions","MenubarStoreOptions","MenubarStoreProps","MenubarStoreState","useMenuBarStoreProps","T","MenuBarStore","MenuBarStoreProps","store","update","props","useMenuBarStore","MenuBarStoreState","MenuBarStoreFunctions","MenuBarStoreOptions"],"sources":["../../src/menu/menu-bar-store.d.ts"],"mappings":";;;;iBAEwBM,oBAAAA,WAA+BN,IAAAA,CAAKQ,YAAAA,CAAAA,CAAcE,KAAAA,EAAOH,CAAAA,EAAGI,MAAAA,cAAoBC,KAAAA,EAAOH,iBAAAA,GAAoBF,CAAAA;;AAAnI;;;;;;;;;;iBAYwBM,eAAAA,CAAgBD,KAAAA,GAAQH,iBAAAA,GAAoBD,YAAY;AAAA,UAC/DM,iBAAAA,SAA0BT,iBAAiB;AAAA,UAE3CU,qBAAAA,SAA8Bb,qBAAqB;AAAA,UAEnDc,mBAAAA,SAA4Bb,mBAAmB;AAAA,UAE/CM,iBAAAA,SAA0BL,iBAAiB;AAAA,UAE3CI,YAAAA,SAAqBP,YAAY"}

package/dist/menu/menu-bar-store.js

@@ -0,0 +1,28 @@
+"use client";
+import { useMenubarStore, useMenubarStoreProps } from "../menubar/menubar-store.js";
+import { useEffect } from "react";
+//#region src/menu/menu-bar-store.ts
+function useMenuBarStoreProps(store, update, props) {
+	return useMenubarStoreProps(store, update, props);
+}
+/**
+* Creates a menu bar store.
+* @deprecated
+* Use [`useMenubarStore`](https://ariakit.com/reference/use-menubar-store)
+* instead.
+* @example
+* ```jsx
+* const menu = useMenuBarStore();
+* <MenuBar store={menu} />
+* ```
+*/
+function useMenuBarStore(props = {}) {
+	useEffect(() => {
+		console.warn("useMenuBarStore is deprecated. Use useMenubarStore instead.", "See https://ariakit.com/reference/use-menubar-store");
+	}, []);
+	return useMenubarStore(props);
+}
+//#endregion
+export { useMenuBarStore, useMenuBarStoreProps };
+
+//# sourceMappingURL=menu-bar-store.js.map

package/dist/menu/menu-bar-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu-bar-store.js","names":[],"sources":["../../src/menu/menu-bar-store.ts"],"sourcesContent":["import type * as Core from \"@ariakit/components/menu/menu-bar-store\";\nimport { useEffect } from \"react\";\nimport type {\n  MenubarStore,\n  MenubarStoreFunctions,\n  MenubarStoreOptions,\n  MenubarStoreProps,\n  MenubarStoreState,\n} from \"../menubar/menubar-store.ts\";\nimport {\n  useMenubarStore,\n  useMenubarStoreProps,\n} from \"../menubar/menubar-store.ts\";\n\nexport function useMenuBarStoreProps<T extends Core.MenuBarStore>(\n  store: T,\n  update: () => void,\n  props: MenuBarStoreProps,\n) {\n  return useMenubarStoreProps(store, update, props);\n}\n\n/**\n * Creates a menu bar store.\n * @deprecated\n * Use [`useMenubarStore`](https://ariakit.com/reference/use-menubar-store)\n * instead.\n * @example\n * ```jsx\n * const menu = useMenuBarStore();\n * <MenuBar store={menu} />\n * ```\n */\nexport function useMenuBarStore(props: MenuBarStoreProps = {}): MenuBarStore {\n  useEffect(() => {\n    if (process.env.NODE_ENV !== \"production\") {\n      console.warn(\n        \"useMenuBarStore is deprecated. Use useMenubarStore instead.\",\n        \"See https://ariakit.com/reference/use-menubar-store\",\n      );\n    }\n  }, []);\n  return useMenubarStore(props);\n}\n\nexport interface MenuBarStoreState extends MenubarStoreState {}\n\nexport interface MenuBarStoreFunctions extends MenubarStoreFunctions {}\n\nexport interface MenuBarStoreOptions extends MenubarStoreOptions {}\n\nexport interface MenuBarStoreProps extends MenubarStoreProps {}\n\nexport interface MenuBarStore extends MenubarStore {}\n"],"mappings":";;;;SAmBS,qBAAqB,OAAO,QAAQ,OAAK;CAClD,OAAA,qBAAA,OAAA,QAAA,KAAA;;;;;;;;;;;;;SAcE,gBAAgB,QAAA,CAAA,GAAA;iBAGV;EAIN,QAAK,KAAA,+DAAA,qDAAA;CACL,GAAA,CAAA,CAAA;CACF,OAAA,gBAAA,KAAA"}

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

@@ -0,0 +1,61 @@
+import { MenubarOptions } from "../menubar/menubar.js";
+import { Props } from "@ariakit/react-utils";
+import { ElementType } from "react";
+
+//#region src/menu/menu-bar.d.ts
+declare const TagName = "div";
+type TagName = typeof TagName;
+/**
+ * Returns props to create a `MenuBar` component.
+ * @deprecated Use `useMenubar` instead.
+ * @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>
+ * ```
+ */
+declare const useMenuBar: import("@ariakit/react-utils").Hook<"div", MenuBarOptions<"div">>;
+/**
+ * Renders a menu bar that may contain a group of menu items that control other
+ * submenus.
+ * @deprecated
+ * Use [`Menubar`](https://ariakit.com/reference/menubar) instead.
+ * @example
+ * ```jsx
+ * <MenuBarProvider>
+ *   <MenuBar>
+ *     <MenuProvider>
+ *       <MenuItem render={<MenuButton />}>File</MenuItem>
+ *       <Menu>
+ *         <MenuItem>New File</MenuItem>
+ *         <MenuItem>New Window</MenuItem>
+ *       </Menu>
+ *     </MenuProvider>
+ *     <MenuProvider>
+ *       <MenuItem render={<MenuButton />}>Edit</MenuItem>
+ *       <Menu>
+ *         <MenuItem>Undo</MenuItem>
+ *         <MenuItem>Redo</MenuItem>
+ *       </Menu>
+ *     </MenuProvider>
+ *   </MenuBar>
+ * </MenuBarProvider>
+ * ```
+ */
+declare const MenuBar: (props: MenuBarProps) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+interface MenuBarOptions<T extends ElementType = TagName> extends MenubarOptions<T> {}
+type MenuBarProps<T extends ElementType = TagName> = Props<T, MenuBarOptions<T>>;
+//#endregion
+export { MenuBar, MenuBarOptions, MenuBarProps, useMenuBar };
+//# sourceMappingURL=menu-bar.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"menu-bar.d.ts","names":["Props","ElementType","MenubarOptions","TagName","useMenuBar","MenuBarOptions","Hook","MenuBar","MenuBarProps","props","ReactElement","JSXElementConstructor","T"],"sources":["../../src/menu/menu-bar.d.ts"],"mappings":";;;;;cAGcG,OAAAA;AAAAA,KACTA,OAAAA,UAAiBA,OAAO;AAFgC;;;;AACxC;AAAA;;;;AACQ;AAqB7B;;;;AAA0F;AA4B1F;;;;;AAnD6D,cAuBxCC,UAAAA,iCAA2CE,IAAAA,QAAYD,cAAc;;;;AA4B6C;AACvI;;;;;;;;;;;;;;;AAAyF;AAEzF;;;;;;;cAHqBE,OAAAA,GAAUE,KAAAA,EAAOD,YAAY,qBAAqBE,YAAAA,+BAA2CC,qBAAAA;AAAAA,UACjGN,cAAAA,WAAyBJ,WAAAA,GAAcE,OAAAA,UAAiBD,cAAAA,CAAeU,CAAAA;AAAAA,KAE5EJ,YAAAA,WAAuBP,WAAAA,GAAcE,OAAAA,IAAWH,KAAAA,CAAMY,CAAAA,EAAGP,cAAAA,CAAeO,CAAAA"}

package/dist/menu/menu-bar.js

@@ -0,0 +1,66 @@
+"use client";
+import { useMenubar } from "../menubar/menubar.js";
+import { createElement, createHook, forwardRef } from "@ariakit/react-utils";
+import { useEffect } from "react";
+//#region src/menu/menu-bar.tsx
+const TagName = "div";
+/**
+* Returns props to create a `MenuBar` component.
+* @deprecated Use `useMenubar` instead.
+* @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>
+* ```
+*/
+const useMenuBar = createHook(function useMenuBar(props) {
+	useEffect(() => {
+		console.warn("MenuBar is deprecated. Use Menubar instead.", "See https://ariakit.com/reference/menubar");
+	}, []);
+	return useMenubar(props);
+});
+/**
+* Renders a menu bar that may contain a group of menu items that control other
+* submenus.
+* @deprecated
+* Use [`Menubar`](https://ariakit.com/reference/menubar) instead.
+* @example
+* ```jsx
+* <MenuBarProvider>
+*   <MenuBar>
+*     <MenuProvider>
+*       <MenuItem render={<MenuButton />}>File</MenuItem>
+*       <Menu>
+*         <MenuItem>New File</MenuItem>
+*         <MenuItem>New Window</MenuItem>
+*       </Menu>
+*     </MenuProvider>
+*     <MenuProvider>
+*       <MenuItem render={<MenuButton />}>Edit</MenuItem>
+*       <Menu>
+*         <MenuItem>Undo</MenuItem>
+*         <MenuItem>Redo</MenuItem>
+*       </Menu>
+*     </MenuProvider>
+*   </MenuBar>
+* </MenuBarProvider>
+* ```
+*/
+const MenuBar = forwardRef(function MenuBar(props) {
+	return createElement(TagName, useMenuBar(props));
+});
+//#endregion
+export { MenuBar, useMenuBar };
+
+//# sourceMappingURL=menu-bar.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"menu-bar.js","names":[],"sources":["../../src/menu/menu-bar.tsx"],"sourcesContent":["import { createElement, createHook, forwardRef } from \"@ariakit/react-utils\";\nimport type { Props } from \"@ariakit/react-utils\";\nimport type { ElementType } from \"react\";\nimport { useEffect } from \"react\";\nimport type { MenubarOptions } from \"../menubar/menubar.tsx\";\nimport { useMenubar } from \"../menubar/menubar.tsx\";\n\nconst TagName = \"div\" satisfies ElementType;\ntype TagName = typeof TagName;\n\n/**\n * Returns props to create a `MenuBar` component.\n * @deprecated Use `useMenubar` instead.\n * @example\n * ```jsx\n * const store = useMenuBarStore();\n * const menuBarProps = useMenuBar({ store });\n * const fileProps = useMenuItem({ store });\n * const fileMenu = useMenuStore();\n * <Role {...menuBarProps}>\n *   <MenuButton {...fileProps} store={fileMenu}>\n *     File\n *   </MenuButton>\n *   <Menu store={fileMenu}>\n *     <MenuItem>New File</MenuItem>\n *     <MenuItem>New Window</MenuItem>\n *   </Menu>\n * </Role>\n * ```\n */\nexport const useMenuBar = createHook<TagName, MenuBarOptions>(\n  function useMenuBar(props) {\n    useEffect(() => {\n      if (process.env.NODE_ENV !== \"production\") {\n        console.warn(\n          \"MenuBar is deprecated. Use Menubar instead.\",\n          \"See https://ariakit.com/reference/menubar\",\n        );\n      }\n    }, []);\n    return useMenubar(props);\n  },\n);\n\n/**\n * Renders a menu bar that may contain a group of menu items that control other\n * submenus.\n * @deprecated\n * Use [`Menubar`](https://ariakit.com/reference/menubar) instead.\n * @example\n * ```jsx\n * <MenuBarProvider>\n *   <MenuBar>\n *     <MenuProvider>\n *       <MenuItem render={<MenuButton />}>File</MenuItem>\n *       <Menu>\n *         <MenuItem>New File</MenuItem>\n *         <MenuItem>New Window</MenuItem>\n *       </Menu>\n *     </MenuProvider>\n *     <MenuProvider>\n *       <MenuItem render={<MenuButton />}>Edit</MenuItem>\n *       <Menu>\n *         <MenuItem>Undo</MenuItem>\n *         <MenuItem>Redo</MenuItem>\n *       </Menu>\n *     </MenuProvider>\n *   </MenuBar>\n * </MenuBarProvider>\n * ```\n */\nexport const MenuBar = forwardRef(function MenuBar(props: MenuBarProps) {\n  const htmlProps = useMenuBar(props);\n  return createElement(TagName, htmlProps);\n});\n\nexport interface MenuBarOptions<\n  T extends ElementType = TagName,\n> extends MenubarOptions<T> {}\n\nexport type MenuBarProps<T extends ElementType = TagName> = Props<\n  T,\n  MenuBarOptions<T>\n>;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;MAgCI,aAAgB,WAAA,SAAA,WAAA,OAAA;iBAGV;EAIN,QAAK,KAAA,+CAAA,2CAAA;CACL,GAAA,CAAA,CAAA;CAEJ,OAAA,WAAA,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE,UAAO,WAAc,SADH,QAAW,OACU;CACxC,OAAA,cAAA,SAAA,WAAA,KAAA,CAAA"}

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

@@ -0,0 +1,65 @@
+import { t as MenuStore } from "../menu-store-0CKKmNek.js";
+import { PopoverDisclosureArrowOptions } from "../popover/popover-disclosure-arrow.js";
+import { Props } from "@ariakit/react-utils";
+import { ElementType } from "react";
+
+//#region src/menu/menu-button-arrow.d.ts
+declare const TagName = "span";
+type TagName = typeof TagName;
+/**
+ * Returns props to create a `MenuButtonArrow` component.
+ * @see https://ariakit.com/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>
+ * ```
+ */
+declare const useMenuButtonArrow: import("@ariakit/react-utils").Hook<"span", MenuButtonArrowOptions<"span">>;
+/**
+ * Displays an arrow within a
+ * [`MenuButton`](https://ariakit.com/reference/menu-button), pointing to the
+ * [`Menu`](https://ariakit.com/reference/menu) position. It's typically based
+ * on the [`placement`](https://ariakit.com/reference/menu-provider#placement)
+ * state from the menu store, but this can be overridden with the
+ * [`placement`](https://ariakit.com/reference/menu-button-arrow#placement)
+ * prop.
+ * @see https://ariakit.com/components/menu
+ * @example
+ * ```jsx {4}
+ * <MenuProvider placement="bottom-start">
+ *   <MenuButton>
+ *     Edit
+ *     <MenuButtonArrow />
+ *   </MenuButton>
+ *   <Menu>
+ *     <MenuItem>Undo</MenuItem>
+ *     <MenuItem>Redo</MenuItem>
+ *   </Menu>
+ * </MenuProvider>
+ * ```
+ */
+declare const MenuButtonArrow: (props: MenuButtonArrowProps) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+interface MenuButtonArrowOptions<T extends ElementType = TagName> extends PopoverDisclosureArrowOptions<T> {
+  /**
+   * Object returned by the
+   * [`useMenuStore`](https://ariakit.com/reference/use-menu-store) hook. If not
+   * provided, the closest
+   * [`MenuButton`](https://ariakit.com/reference/menu-button) or
+   * [`MenuProvider`](https://ariakit.com/reference/menu-provider) components'
+   * context will be used.
+   */
+  store?: MenuStore;
+}
+type MenuButtonArrowProps<T extends ElementType = TagName> = Props<T, MenuButtonArrowOptions<T>>;
+//#endregion
+export { MenuButtonArrow, MenuButtonArrowOptions, MenuButtonArrowProps, useMenuButtonArrow };
+//# sourceMappingURL=menu-button-arrow.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"menu-button-arrow.d.ts","names":["Props","ElementType","PopoverDisclosureArrowOptions","MenuStore","TagName","useMenuButtonArrow","MenuButtonArrowOptions","Hook","MenuButtonArrow","MenuButtonArrowProps","props","ReactElement","JSXElementConstructor","T","store"],"sources":["../../src/menu/menu-button-arrow.d.ts"],"mappings":";;;;;;cAIcI,OAAAA;AAAAA,KACTA,OAAAA,UAAiBA,OAAO;AAFoB;;;;AAC5B;AAAA;;;;AACQ;AAkB7B;;;;AAA2G;AAwB3G;;AA5CiD,cAoB5BC,kBAAAA,iCAAmDE,IAAAA,SAAaD,sBAAsB;;;;;;;AAwB4C;AACvJ;;;;;;;;;;;;;;;;cADqBE,eAAAA,GAAkBE,KAAAA,EAAOD,oBAAoB,qBAAqBE,YAAAA,+BAA2CC,qBAAAA;AAAAA,UACjHN,sBAAAA,WAAiCL,WAAAA,GAAcG,OAAAA,UAAiBF,6BAAAA,CAA8BW,CAAAA;EAS1F;AAErB;;;;;;;EAFIC,KAAAA,GAAQX,SAAAA;AAAAA;AAAAA,KAEAM,oBAAAA,WAA+BR,WAAAA,GAAcG,OAAAA,IAAWJ,KAAAA,CAAMa,CAAAA,EAAGP,sBAAAA,CAAuBO,CAAAA"}

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

@@ -0,0 +1,62 @@
+"use client";
+import { useMenuContext } from "./menu-context.js";
+import { usePopoverDisclosureArrow } from "../popover/popover-disclosure-arrow.js";
+import { createElement, createHook, forwardRef } from "@ariakit/react-utils";
+//#region src/menu/menu-button-arrow.tsx
+const TagName = "span";
+/**
+* Returns props to create a `MenuButtonArrow` component.
+* @see https://ariakit.com/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>
+* ```
+*/
+const useMenuButtonArrow = createHook(function useMenuButtonArrow({ store, ...props }) {
+	const context = useMenuContext();
+	store = store || context;
+	props = usePopoverDisclosureArrow({
+		store,
+		...props
+	});
+	return props;
+});
+/**
+* Displays an arrow within a
+* [`MenuButton`](https://ariakit.com/reference/menu-button), pointing to the
+* [`Menu`](https://ariakit.com/reference/menu) position. It's typically based
+* on the [`placement`](https://ariakit.com/reference/menu-provider#placement)
+* state from the menu store, but this can be overridden with the
+* [`placement`](https://ariakit.com/reference/menu-button-arrow#placement)
+* prop.
+* @see https://ariakit.com/components/menu
+* @example
+* ```jsx {4}
+* <MenuProvider placement="bottom-start">
+*   <MenuButton>
+*     Edit
+*     <MenuButtonArrow />
+*   </MenuButton>
+*   <Menu>
+*     <MenuItem>Undo</MenuItem>
+*     <MenuItem>Redo</MenuItem>
+*   </Menu>
+* </MenuProvider>
+* ```
+*/
+const MenuButtonArrow = forwardRef(function MenuButtonArrow(props) {
+	return createElement(TagName, useMenuButtonArrow(props));
+});
+//#endregion
+export { MenuButtonArrow, useMenuButtonArrow };
+
+//# sourceMappingURL=menu-button-arrow.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"menu-button-arrow.js","names":[],"sources":["../../src/menu/menu-button-arrow.tsx"],"sourcesContent":["import { createElement, createHook, forwardRef } from \"@ariakit/react-utils\";\nimport type { Props } from \"@ariakit/react-utils\";\nimport type { ElementType } from \"react\";\nimport type { PopoverDisclosureArrowOptions } from \"../popover/popover-disclosure-arrow.tsx\";\nimport { usePopoverDisclosureArrow } from \"../popover/popover-disclosure-arrow.tsx\";\nimport { useMenuContext } from \"./menu-context.tsx\";\nimport type { MenuStore } from \"./menu-store.ts\";\n\nconst TagName = \"span\" satisfies ElementType;\ntype TagName = typeof TagName;\n\n/**\n * Returns props to create a `MenuButtonArrow` component.\n * @see https://ariakit.com/components/menu\n * @example\n * ```jsx\n * const store = useMenuStore();\n * const props = useMenuButtonArrow({ store });\n * <MenuButton store={store}>\n *   Edit\n *   <Role {...props} />\n * </MenuButton>\n * <Menu store={store}>\n *   <MenuItem>Undo</MenuItem>\n *   <MenuItem>Redo</MenuItem>\n * </Menu>\n * ```\n */\nexport const useMenuButtonArrow = createHook<TagName, MenuButtonArrowOptions>(\n  function useMenuButtonArrow({ store, ...props }) {\n    const context = useMenuContext();\n    store = store || context;\n    props = usePopoverDisclosureArrow({ store, ...props });\n    return props;\n  },\n);\n\n/**\n * Displays an arrow within a\n * [`MenuButton`](https://ariakit.com/reference/menu-button), pointing to the\n * [`Menu`](https://ariakit.com/reference/menu) position. It's typically based\n * on the [`placement`](https://ariakit.com/reference/menu-provider#placement)\n * state from the menu store, but this can be overridden with the\n * [`placement`](https://ariakit.com/reference/menu-button-arrow#placement)\n * prop.\n * @see https://ariakit.com/components/menu\n * @example\n * ```jsx {4}\n * <MenuProvider placement=\"bottom-start\">\n *   <MenuButton>\n *     Edit\n *     <MenuButtonArrow />\n *   </MenuButton>\n *   <Menu>\n *     <MenuItem>Undo</MenuItem>\n *     <MenuItem>Redo</MenuItem>\n *   </Menu>\n * </MenuProvider>\n * ```\n */\nexport const MenuButtonArrow = forwardRef(function MenuButtonArrow(\n  props: MenuButtonArrowProps,\n) {\n  const htmlProps = useMenuButtonArrow(props);\n  return createElement(TagName, htmlProps);\n});\n\nexport interface MenuButtonArrowOptions<\n  T extends ElementType = TagName,\n> extends PopoverDisclosureArrowOptions<T> {\n  /**\n   * Object returned by the\n   * [`useMenuStore`](https://ariakit.com/reference/use-menu-store) hook. If not\n   * provided, the closest\n   * [`MenuButton`](https://ariakit.com/reference/menu-button) or\n   * [`MenuProvider`](https://ariakit.com/reference/menu-provider) components'\n   * context will be used.\n   */\n  store?: MenuStore;\n}\n\nexport type MenuButtonArrowProps<T extends ElementType = TagName> = Props<\n  T,\n  MenuButtonArrowOptions<T>\n>;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;MA8BI,qBAAgB,WAAe,SAAA,mBAAA,EAAA,OAAA,GAAA,SAAA;CAC/B,MAAA,UAAQ,eAAS;CACjB,QAAQ,SAAA;SAA4B,0BAAA;EAAO;EAAU,GAAA;CACrD,CAAA;CAEJ,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;MA6BE,kBAAqB,WADH,SAAA,gBACqB,OAAA;CACxC,OAAA,cAAA,SAAA,mBAAA,KAAA,CAAA"}