@ariakit/react-components 0.1.0

package/dist/toolbar/toolbar-provider.js

@@ -0,0 +1,30 @@
+"use client";
+import { ToolbarContextProvider } from "./toolbar-context.js";
+import { useToolbarStore } from "./toolbar-store.js";
+import { jsx } from "react/jsx-runtime";
+//#region src/toolbar/toolbar-provider.tsx
+/**
+* Provides a toolbar store to [Toolbar](https://ariakit.com/components/toolbar)
+* components.
+* @see https://ariakit.com/components/toolbar
+* @example
+* ```jsx
+* <ToolbarProvider>
+*   <Toolbar>
+*     <ToolbarItem />
+*     <ToolbarItem />
+*     <ToolbarItem />
+*   </Toolbar>
+* </ToolbarProvider>
+* ```
+*/
+function ToolbarProvider(props = {}) {
+	return /* @__PURE__ */ jsx(ToolbarContextProvider, {
+		value: useToolbarStore(props),
+		children: props.children
+	});
+}
+//#endregion
+export { ToolbarProvider };
+
+//# sourceMappingURL=toolbar-provider.js.map

package/dist/toolbar/toolbar-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolbar-provider.js","names":[],"sources":["../../src/toolbar/toolbar-provider.tsx"],"sourcesContent":["import type { ReactNode } from \"react\";\nimport { ToolbarContextProvider } from \"./toolbar-context.tsx\";\nimport type { ToolbarStoreProps } from \"./toolbar-store.ts\";\nimport { useToolbarStore } from \"./toolbar-store.ts\";\n\n/**\n * Provides a toolbar store to [Toolbar](https://ariakit.com/components/toolbar)\n * components.\n * @see https://ariakit.com/components/toolbar\n * @example\n * ```jsx\n * <ToolbarProvider>\n *   <Toolbar>\n *     <ToolbarItem />\n *     <ToolbarItem />\n *     <ToolbarItem />\n *   </Toolbar>\n * </ToolbarProvider>\n * ```\n */\nexport function ToolbarProvider(props: ToolbarProviderProps = {}) {\n  const store = useToolbarStore(props);\n  return (\n    <ToolbarContextProvider value={store}>\n      {props.children}\n    </ToolbarContextProvider>\n  );\n}\n\nexport interface ToolbarProviderProps extends ToolbarStoreProps {\n  children?: ReactNode;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;SAuBI,gBAAA,QAAC,CAAA,GAAA;QAFW,oBAAgB,wBAEO;yBAC1B,KAAA;EACe,UAAA,MAAA;CAE5B,CAAA"}

package/dist/toolbar/toolbar-separator.d.ts

@@ -0,0 +1,51 @@
+import { CompositeSeparatorOptions } from "../composite/composite-separator.js";
+import { t as ToolbarStore } from "../toolbar-store-Cs-9cGHx.js";
+import { Props } from "@ariakit/react-utils";
+import { ElementType } from "react";
+
+//#region src/toolbar/toolbar-separator.d.ts
+declare const TagName = "hr";
+type TagName = typeof TagName;
+/**
+ * Returns props to create a `ToolbarSeparator` component.
+ * @see https://ariakit.com/components/toolbar
+ * @example
+ * ```jsx
+ * const store = useToolbarStore();
+ * const props = useToolbarSeparator({ store });
+ * <Toolbar store={store}>
+ *   <ToolbarItem>Item 1</ToolbarItem>
+ *   <Role {...props} />
+ *   <ToolbarItem>Item 2</ToolbarItem>
+ * </Toolbar>
+ * ```
+ */
+declare const useToolbarSeparator: import("@ariakit/react-utils").Hook<"hr", ToolbarSeparatorOptions<"hr">>;
+/**
+ * Renders a divider between
+ * [`ToolbarItem`](https://ariakit.com/reference/toolbar-item) elements.
+ * @see https://ariakit.com/components/toolbar
+ * @example
+ * ```jsx {3}
+ * <Toolbar>
+ *   <ToolbarItem>Item 1</ToolbarItem>
+ *   <ToolbarSeparator />
+ *   <ToolbarItem>Item 2</ToolbarItem>
+ * </Toolbar>
+ * ```
+ */
+declare const ToolbarSeparator: (props: ToolbarSeparatorProps) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+interface ToolbarSeparatorOptions<T extends ElementType = TagName> extends CompositeSeparatorOptions<T> {
+  /**
+   * Object returned by the
+   * [`useToolbarStore`](https://ariakit.com/reference/use-toolbar-store) hook.
+   * If not provided, the closest
+   * [`Toolbar`](https://ariakit.com/reference/toolbar) component's context will
+   * be used.
+   */
+  store?: ToolbarStore;
+}
+type ToolbarSeparatorProps<T extends ElementType = TagName> = Props<T, ToolbarSeparatorOptions<T>>;
+//#endregion
+export { ToolbarSeparator, ToolbarSeparatorOptions, ToolbarSeparatorProps, useToolbarSeparator };
+//# sourceMappingURL=toolbar-separator.d.ts.map

package/dist/toolbar/toolbar-separator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolbar-separator.d.ts","names":["Props","ElementType","CompositeSeparatorOptions","ToolbarStore","TagName","useToolbarSeparator","ToolbarSeparatorOptions","Hook","ToolbarSeparator","ToolbarSeparatorProps","props","ReactElement","JSXElementConstructor","T","store"],"sources":["../../src/toolbar/toolbar-separator.d.ts"],"mappings":";;;;;;cAIcI,OAAAA;AAAAA,KACTA,OAAAA,UAAiBA,OAAO;AAF0B;;;;AAClC;AAAA;;;;AACQ;AAe7B;;;;AAjBuD,cAiBlCC,mBAAAA,iCAAoDE,IAAAA,OAAWD,uBAAuB;AAc3G;;;;;;;;;AAAyJ;AACzJ;;;AADA,cAAqBE,gBAAAA,GAAmBE,KAAAA,EAAOD,qBAAqB,qBAAqBE,YAAAA,+BAA2CC,qBAAAA;AAAAA,UACnHN,uBAAAA,WAAkCL,WAAAA,GAAcG,OAAAA,UAAiBF,yBAAAA,CAA0BW,CAAAA;EAAAA;;;;;;;EAQxGC,KAAAA,GAAQX,YAAAA;AAAAA;AAAAA,KAEAM,qBAAAA,WAAgCR,WAAAA,GAAcG,OAAAA,IAAWJ,KAAAA,CAAMa,CAAAA,EAAGP,uBAAAA,CAAwBO,CAAAA"}

package/dist/toolbar/toolbar-separator.js

@@ -0,0 +1,49 @@
+"use client";
+import { useCompositeSeparator } from "../composite/composite-separator.js";
+import { useToolbarContext } from "./toolbar-context.js";
+import { createElement, createHook, forwardRef } from "@ariakit/react-utils";
+//#region src/toolbar/toolbar-separator.tsx
+const TagName = "hr";
+/**
+* Returns props to create a `ToolbarSeparator` component.
+* @see https://ariakit.com/components/toolbar
+* @example
+* ```jsx
+* const store = useToolbarStore();
+* const props = useToolbarSeparator({ store });
+* <Toolbar store={store}>
+*   <ToolbarItem>Item 1</ToolbarItem>
+*   <Role {...props} />
+*   <ToolbarItem>Item 2</ToolbarItem>
+* </Toolbar>
+* ```
+*/
+const useToolbarSeparator = createHook(function useToolbarSeparator({ store, ...props }) {
+	const context = useToolbarContext();
+	store = store || context;
+	props = useCompositeSeparator({
+		store,
+		...props
+	});
+	return props;
+});
+/**
+* Renders a divider between
+* [`ToolbarItem`](https://ariakit.com/reference/toolbar-item) elements.
+* @see https://ariakit.com/components/toolbar
+* @example
+* ```jsx {3}
+* <Toolbar>
+*   <ToolbarItem>Item 1</ToolbarItem>
+*   <ToolbarSeparator />
+*   <ToolbarItem>Item 2</ToolbarItem>
+* </Toolbar>
+* ```
+*/
+const ToolbarSeparator = forwardRef(function ToolbarSeparator(props) {
+	return createElement(TagName, useToolbarSeparator(props));
+});
+//#endregion
+export { ToolbarSeparator, useToolbarSeparator };
+
+//# sourceMappingURL=toolbar-separator.js.map

package/dist/toolbar/toolbar-separator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolbar-separator.js","names":[],"sources":["../../src/toolbar/toolbar-separator.tsx"],"sourcesContent":["import { createElement, createHook, forwardRef } from \"@ariakit/react-utils\";\nimport type { Props } from \"@ariakit/react-utils\";\nimport type { ElementType } from \"react\";\nimport type { CompositeSeparatorOptions } from \"../composite/composite-separator.tsx\";\nimport { useCompositeSeparator } from \"../composite/composite-separator.tsx\";\nimport { useToolbarContext } from \"./toolbar-context.tsx\";\nimport type { ToolbarStore } from \"./toolbar-store.ts\";\n\nconst TagName = \"hr\" satisfies ElementType;\ntype TagName = typeof TagName;\n\n/**\n * Returns props to create a `ToolbarSeparator` component.\n * @see https://ariakit.com/components/toolbar\n * @example\n * ```jsx\n * const store = useToolbarStore();\n * const props = useToolbarSeparator({ store });\n * <Toolbar store={store}>\n *   <ToolbarItem>Item 1</ToolbarItem>\n *   <Role {...props} />\n *   <ToolbarItem>Item 2</ToolbarItem>\n * </Toolbar>\n * ```\n */\nexport const useToolbarSeparator = createHook<TagName, ToolbarSeparatorOptions>(\n  function useToolbarSeparator({ store, ...props }) {\n    const context = useToolbarContext();\n    store = store || context;\n    props = useCompositeSeparator({ store, ...props });\n    return props;\n  },\n);\n\n/**\n * Renders a divider between\n * [`ToolbarItem`](https://ariakit.com/reference/toolbar-item) elements.\n * @see https://ariakit.com/components/toolbar\n * @example\n * ```jsx {3}\n * <Toolbar>\n *   <ToolbarItem>Item 1</ToolbarItem>\n *   <ToolbarSeparator />\n *   <ToolbarItem>Item 2</ToolbarItem>\n * </Toolbar>\n * ```\n */\nexport const ToolbarSeparator = forwardRef(function ToolbarSeparator(\n  props: ToolbarSeparatorProps,\n) {\n  const htmlProps = useToolbarSeparator(props);\n  return createElement(TagName, htmlProps);\n});\n\nexport interface ToolbarSeparatorOptions<\n  T extends ElementType = TagName,\n> extends CompositeSeparatorOptions<T> {\n  /**\n   * Object returned by the\n   * [`useToolbarStore`](https://ariakit.com/reference/use-toolbar-store) hook.\n   * If not provided, the closest\n   * [`Toolbar`](https://ariakit.com/reference/toolbar) component's context will\n   * be used.\n   */\n  store?: ToolbarStore;\n}\n\nexport type ToolbarSeparatorProps<T extends ElementType = TagName> = Props<\n  T,\n  ToolbarSeparatorOptions<T>\n>;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;MA2BI,sBAAgB,WAAkB,SAAA,oBAAA,EAAA,OAAA,GAAA,SAAA;CAClC,MAAA,UAAQ,kBAAS;CACjB,QAAQ,SAAA;SAAwB,sBAAA;EAAO;EAAU,GAAA;CACjD,CAAA;CAEJ,OAAA;;;;;;;;;;;;;;;MAmBE,mBAAqB,WADH,SAAA,iBACqB,OAAA;CACxC,OAAA,cAAA,SAAA,oBAAA,KAAA,CAAA"}

package/dist/toolbar/toolbar-store.d.ts

@@ -0,0 +1,2 @@
+import { a as ToolbarStoreState, i as ToolbarStoreProps, n as ToolbarStoreFunctions, o as useToolbarStore, r as ToolbarStoreOptions, s as useToolbarStoreProps, t as ToolbarStore } from "../toolbar-store-Cs-9cGHx.js";
+export { ToolbarStore, ToolbarStoreFunctions, ToolbarStoreOptions, ToolbarStoreProps, ToolbarStoreState, useToolbarStore, useToolbarStoreProps };

package/dist/toolbar/toolbar-store.js

@@ -0,0 +1,31 @@
+"use client";
+import { useCompositeStoreProps } from "../composite/composite-store.js";
+import { useStore } from "@ariakit/react-store";
+import * as Core from "@ariakit/components/toolbar/toolbar-store";
+//#region src/toolbar/toolbar-store.ts
+function useToolbarStoreProps(store, update, props) {
+	return useCompositeStoreProps(store, update, props);
+}
+/**
+* Creates a toolbar store to control the state of
+* [Toolbar](https://ariakit.com/components/toolbar) components.
+* @see https://ariakit.com/components/toolbar
+* @example
+* ```jsx
+* const toolbar = useToolbarStore();
+*
+* <Toolbar store={toolbar}>
+*   <ToolbarItem>Item 1</ToolbarItem>
+*   <ToolbarItem>Item 2</ToolbarItem>
+*   <ToolbarItem>Item 3</ToolbarItem>
+* </Toolbar>
+* ```
+*/
+function useToolbarStore(props = {}) {
+	const [store, update] = useStore(Core.createToolbarStore, props);
+	return useToolbarStoreProps(store, update, props);
+}
+//#endregion
+export { useToolbarStore, useToolbarStoreProps };
+
+//# sourceMappingURL=toolbar-store.js.map

package/dist/toolbar/toolbar-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolbar-store.js","names":[],"sources":["../../src/toolbar/toolbar-store.ts"],"sourcesContent":["import * as Core from \"@ariakit/components/toolbar/toolbar-store\";\nimport { useStore } from \"@ariakit/react-store\";\nimport type { Store } from \"@ariakit/react-store\";\nimport type {\n  CompositeStoreFunctions,\n  CompositeStoreOptions,\n  CompositeStoreState,\n} from \"../composite/composite-store.ts\";\nimport { useCompositeStoreProps } from \"../composite/composite-store.ts\";\n\nexport function useToolbarStoreProps<T extends Core.ToolbarStore>(\n  store: T,\n  update: () => void,\n  props: ToolbarStoreProps,\n) {\n  return useCompositeStoreProps(store, update, props);\n}\n\n/**\n * Creates a toolbar store to control the state of\n * [Toolbar](https://ariakit.com/components/toolbar) components.\n * @see https://ariakit.com/components/toolbar\n * @example\n * ```jsx\n * const toolbar = useToolbarStore();\n *\n * <Toolbar store={toolbar}>\n *   <ToolbarItem>Item 1</ToolbarItem>\n *   <ToolbarItem>Item 2</ToolbarItem>\n *   <ToolbarItem>Item 3</ToolbarItem>\n * </Toolbar>\n * ```\n */\nexport function useToolbarStore(props: ToolbarStoreProps = {}): ToolbarStore {\n  const [store, update] = useStore(Core.createToolbarStore, props);\n  return useToolbarStoreProps(store, update, props);\n}\n\nexport interface ToolbarStoreState\n  extends Core.ToolbarStoreState, CompositeStoreState {}\n\nexport interface ToolbarStoreFunctions\n  extends Core.ToolbarStoreFunctions, CompositeStoreFunctions {}\n\nexport interface ToolbarStoreOptions\n  extends Core.ToolbarStoreOptions, CompositeStoreOptions {}\n\nexport interface ToolbarStoreProps\n  extends ToolbarStoreOptions, Core.ToolbarStoreProps {}\n\nexport interface ToolbarStore\n  extends ToolbarStoreFunctions, Store<Core.ToolbarStore> {}\n"],"mappings":";;;;;SAeS,qBAAA,OAAuB,QAAO,OAAa;CACpD,OAAA,uBAAA,OAAA,QAAA,KAAA;;;;;;;;;;;;;;;;;SAkBS,gBAAiB,QAAA,CAAS,GAAA;CACjC,MAAA,CAAO,OAAA,UAAA,SAAqB,KAAO,oBAAa,KAAA;CAClD,OAAA,qBAAA,OAAA,QAAA,KAAA"}

package/dist/toolbar/toolbar.d.ts

@@ -0,0 +1,50 @@
+import { n as CompositeOptions } from "../composite-DLvyFHMq.js";
+import { i as ToolbarStoreProps, t as ToolbarStore } from "../toolbar-store-Cs-9cGHx.js";
+import { Props } from "@ariakit/react-utils";
+import { ElementType } from "react";
+
+//#region src/toolbar/toolbar.d.ts
+declare const TagName = "div";
+type TagName = typeof TagName;
+/**
+ * Returns props to create a `Toolbar` component.
+ * @see https://ariakit.com/components/toolbar
+ * @example
+ * ```jsx
+ * const store = useToolbarStore();
+ * const props = useToolbar({ store });
+ * <Role {...props}>
+ *   <ToolbarItem>Item 1</ToolbarItem>
+ *   <ToolbarItem>Item 2</ToolbarItem>
+ * </Role>
+ * ```
+ */
+declare const useToolbar: import("@ariakit/react-utils").Hook<"div", ToolbarOptions<"div">>;
+/**
+ * Renders a toolbar element that groups interactive elements together.
+ * @see https://ariakit.com/components/toolbar
+ * @example
+ * ```jsx
+ * <Toolbar>
+ *   <ToolbarItem>Item 1</ToolbarItem>
+ *   <ToolbarItem>Item 2</ToolbarItem>
+ * </Toolbar>
+ * ```
+ */
+declare const Toolbar: (props: ToolbarProps) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+interface ToolbarOptions<T extends ElementType = TagName> extends CompositeOptions<T>, Pick<ToolbarStoreProps, "focusLoop" | "orientation" | "rtl" | "virtualFocus"> {
+  /**
+   * Object returned by the
+   * [`useToolbarStore`](https://ariakit.com/reference/use-toolbar-store) hook.
+   * If not provided, the closest
+   * [`ToolbarProvider`](https://ariakit.com/reference/toolbar-provider)
+   * component context will be used. If the component is not wrapped in a
+   * [`ToolbarProvider`](https://ariakit.com/reference/toolbar-provider)
+   * component, an internal store will be used.
+   */
+  store?: ToolbarStore;
+}
+type ToolbarProps<T extends ElementType = TagName> = Props<T, ToolbarOptions<T>>;
+//#endregion
+export { Toolbar, ToolbarOptions, ToolbarProps, useToolbar };
+//# sourceMappingURL=toolbar.d.ts.map

package/dist/toolbar/toolbar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolbar.d.ts","names":["Props","ElementType","CompositeOptions","ToolbarStore","ToolbarStoreProps","TagName","useToolbar","ToolbarOptions","Hook","Toolbar","ToolbarProps","props","ReactElement","JSXElementConstructor","T","Pick","store"],"sources":["../../src/toolbar/toolbar.d.ts"],"mappings":";;;;;;cAIcK,OAAAA;AAAAA,KACTA,OAAAA,UAAiBA,OAAO;AAF6C;;;;AACrD;AAAA;;;;AACQ;AAc7B;;;AAhB0E,cAgBrDC,UAAAA,iCAA2CE,IAAAA,QAAYD,cAAc;AAAA;AAY1F;;;;;;;;;AAAuI;AAZ7C,cAYrEE,OAAAA,GAAUE,KAAAA,EAAOD,YAAY,qBAAqBE,YAAAA,+BAA2CC,qBAAAA;AAAAA,UACjGN,cAAAA,WAAyBN,WAAAA,GAAcI,OAAAA,UAAiBH,gBAAAA,CAAiBY,CAAAA,GAAIC,IAAAA,CAAKX,iBAAAA;EAApEU;;;;;;;;;EAU3BE,KAAAA,GAAQb,YAAAA;AAAAA;AAAAA,KAEAO,YAAAA,WAAuBT,WAAAA,GAAcI,OAAAA,IAAWL,KAAAA,CAAMc,CAAAA,EAAGP,cAAAA,CAAeO,CAAAA"}

package/dist/toolbar/toolbar.js

@@ -0,0 +1,66 @@
+"use client";
+import { useComposite } from "../composite/composite.js";
+import { ToolbarScopedContextProvider, useToolbarProviderContext } from "./toolbar-context.js";
+import { useToolbarStore } from "./toolbar-store.js";
+import { createElement, createHook, forwardRef, useWrapElement } from "@ariakit/react-utils";
+import { jsx } from "react/jsx-runtime";
+import { useStoreState } from "@ariakit/react-store";
+//#region src/toolbar/toolbar.tsx
+const TagName = "div";
+/**
+* Returns props to create a `Toolbar` component.
+* @see https://ariakit.com/components/toolbar
+* @example
+* ```jsx
+* const store = useToolbarStore();
+* const props = useToolbar({ store });
+* <Role {...props}>
+*   <ToolbarItem>Item 1</ToolbarItem>
+*   <ToolbarItem>Item 2</ToolbarItem>
+* </Role>
+* ```
+*/
+const useToolbar = createHook(function useToolbar({ store: storeProp, orientation: orientationProp, virtualFocus, focusLoop, rtl, ...props }) {
+	const context = useToolbarProviderContext();
+	storeProp = storeProp || context;
+	const store = useToolbarStore({
+		store: storeProp,
+		orientation: orientationProp,
+		virtualFocus,
+		focusLoop,
+		rtl
+	});
+	const orientation = useStoreState(store, (state) => state.orientation === "both" ? void 0 : state.orientation);
+	props = useWrapElement(props, (element) => /* @__PURE__ */ jsx(ToolbarScopedContextProvider, {
+		value: store,
+		children: element
+	}), [store]);
+	props = {
+		role: "toolbar",
+		"aria-orientation": orientation,
+		...props
+	};
+	props = useComposite({
+		store,
+		...props
+	});
+	return props;
+});
+/**
+* Renders a toolbar element that groups interactive elements together.
+* @see https://ariakit.com/components/toolbar
+* @example
+* ```jsx
+* <Toolbar>
+*   <ToolbarItem>Item 1</ToolbarItem>
+*   <ToolbarItem>Item 2</ToolbarItem>
+* </Toolbar>
+* ```
+*/
+const Toolbar = forwardRef(function Toolbar(props) {
+	return createElement(TagName, useToolbar(props));
+});
+//#endregion
+export { Toolbar, useToolbar };
+
+//# sourceMappingURL=toolbar.js.map

package/dist/toolbar/toolbar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolbar.js","names":[],"sources":["../../src/toolbar/toolbar.tsx"],"sourcesContent":["import { useStoreState } from \"@ariakit/react-store\";\nimport {\n  useWrapElement,\n  createElement,\n  createHook,\n  forwardRef,\n} from \"@ariakit/react-utils\";\nimport type { Props } from \"@ariakit/react-utils\";\nimport type { ElementType } from \"react\";\nimport type { CompositeOptions } from \"../composite/composite.tsx\";\nimport { useComposite } from \"../composite/composite.tsx\";\nimport {\n  ToolbarScopedContextProvider,\n  useToolbarProviderContext,\n} from \"./toolbar-context.tsx\";\nimport type { ToolbarStore, ToolbarStoreProps } from \"./toolbar-store.ts\";\nimport { useToolbarStore } from \"./toolbar-store.ts\";\n\nconst TagName = \"div\" satisfies ElementType;\ntype TagName = typeof TagName;\n\n/**\n * Returns props to create a `Toolbar` component.\n * @see https://ariakit.com/components/toolbar\n * @example\n * ```jsx\n * const store = useToolbarStore();\n * const props = useToolbar({ store });\n * <Role {...props}>\n *   <ToolbarItem>Item 1</ToolbarItem>\n *   <ToolbarItem>Item 2</ToolbarItem>\n * </Role>\n * ```\n */\nexport const useToolbar = createHook<TagName, ToolbarOptions>(\n  function useToolbar({\n    store: storeProp,\n    orientation: orientationProp,\n    virtualFocus,\n    focusLoop,\n    rtl,\n    ...props\n  }) {\n    const context = useToolbarProviderContext();\n    storeProp = storeProp || context;\n\n    const store = useToolbarStore({\n      store: storeProp,\n      orientation: orientationProp,\n      virtualFocus,\n      focusLoop,\n      rtl,\n    });\n\n    const orientation = useStoreState(store, (state) =>\n      state.orientation === \"both\" ? undefined : state.orientation,\n    );\n\n    props = useWrapElement(\n      props,\n      (element) => (\n        <ToolbarScopedContextProvider value={store}>\n          {element}\n        </ToolbarScopedContextProvider>\n      ),\n      [store],\n    );\n\n    props = {\n      role: \"toolbar\",\n      \"aria-orientation\": orientation,\n      ...props,\n    };\n\n    props = useComposite({ store, ...props });\n\n    return props;\n  },\n);\n\n/**\n * Renders a toolbar element that groups interactive elements together.\n * @see https://ariakit.com/components/toolbar\n * @example\n * ```jsx\n * <Toolbar>\n *   <ToolbarItem>Item 1</ToolbarItem>\n *   <ToolbarItem>Item 2</ToolbarItem>\n * </Toolbar>\n * ```\n */\nexport const Toolbar = forwardRef(function Toolbar(props: ToolbarProps) {\n  const htmlProps = useToolbar(props);\n  return createElement(TagName, htmlProps);\n});\n\nexport interface ToolbarOptions<T extends ElementType = TagName>\n  extends\n    CompositeOptions<T>,\n    Pick<\n      ToolbarStoreProps,\n      \"focusLoop\" | \"orientation\" | \"rtl\" | \"virtualFocus\"\n    > {\n  /**\n   * Object returned by the\n   * [`useToolbarStore`](https://ariakit.com/reference/use-toolbar-store) hook.\n   * If not provided, the closest\n   * [`ToolbarProvider`](https://ariakit.com/reference/toolbar-provider)\n   * component context will be used. If the component is not wrapped in a\n   * [`ToolbarProvider`](https://ariakit.com/reference/toolbar-provider)\n   * component, an internal store will be used.\n   */\n  store?: ToolbarStore;\n}\n\nexport type ToolbarProps<T extends ElementType = TagName> = Props<\n  T,\n  ToolbarOptions<T>\n>;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;MA2CI,aAAgB,WAAA,SAAA,WAA0B,EAAA,OAAA,WAAA,aAAA,iBAAA,cAAA,WAAA,KAAA,GAAA,SAAA;CAC1C,MAAA,UAAY,0BAAa;CAEzB,YAAM,aAAQ;OACZ,QAAO,gBAAA;EACP,OAAA;EACA,aAAA;EACA;EACA;EACD;CAED,CAAA;CAIA,MAAA,cAAQ,cAEL,QAAA,UACC,MAAA,gBAAC,SAAA,KAAA,IAAA,MAAD,WAAA;SAAqC,eAAA,QAAA,YAAA,oBAAA,8BAAA;;EAEP,UAGlC;CAEA,CAAA,GAAA,CAAA,KAAQ,CAAA;SACA;EACN,MAAA;EACA,oBAAG;EACL,GAAA;CAEA;SAAuB,aAAA;EAAO;EAAU,GAAA;CAExC,CAAA;CAEJ,OAAA;;;;;;;;;;;;;MAeE,UAAO,WAAc,SADH,QAAW,OACU;CACxC,OAAA,cAAA,SAAA,WAAA,KAAA,CAAA"}

package/dist/toolbar-store-Cs-9cGHx.d.ts

@@ -0,0 +1,30 @@
+import { i as CompositeStoreOptions, n as CompositeStoreFunctions, o as CompositeStoreState } from "./composite-store-DyJc-XRA.js";
+import { Store } from "@ariakit/react-store";
+import * as Core from "@ariakit/components/toolbar/toolbar-store";
+
+//#region src/toolbar/toolbar-store.d.ts
+declare function useToolbarStoreProps<T extends Core.ToolbarStore>(store: T, update: () => void, props: ToolbarStoreProps): T;
+/**
+ * Creates a toolbar store to control the state of
+ * [Toolbar](https://ariakit.com/components/toolbar) components.
+ * @see https://ariakit.com/components/toolbar
+ * @example
+ * ```jsx
+ * const toolbar = useToolbarStore();
+ *
+ * <Toolbar store={toolbar}>
+ *   <ToolbarItem>Item 1</ToolbarItem>
+ *   <ToolbarItem>Item 2</ToolbarItem>
+ *   <ToolbarItem>Item 3</ToolbarItem>
+ * </Toolbar>
+ * ```
+ */
+declare function useToolbarStore(props?: ToolbarStoreProps): ToolbarStore;
+interface ToolbarStoreState extends Core.ToolbarStoreState, CompositeStoreState {}
+interface ToolbarStoreFunctions extends Core.ToolbarStoreFunctions, CompositeStoreFunctions {}
+interface ToolbarStoreOptions extends Core.ToolbarStoreOptions, CompositeStoreOptions {}
+interface ToolbarStoreProps extends ToolbarStoreOptions, Core.ToolbarStoreProps {}
+interface ToolbarStore extends ToolbarStoreFunctions, Store<Core.ToolbarStore> {}
+//#endregion
+export { ToolbarStoreState as a, ToolbarStoreProps as i, ToolbarStoreFunctions as n, useToolbarStore as o, ToolbarStoreOptions as r, useToolbarStoreProps as s, ToolbarStore as t };
+//# sourceMappingURL=toolbar-store-Cs-9cGHx.d.ts.map

package/dist/toolbar-store-Cs-9cGHx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolbar-store-Cs-9cGHx.d.ts","names":["Core","Store","CompositeStoreFunctions","CompositeStoreOptions","CompositeStoreState","useToolbarStoreProps","T","ToolbarStore","ToolbarStoreProps","store","update","props","useToolbarStore","ToolbarStoreState","ToolbarStoreFunctions","ToolbarStoreOptions"],"sources":["../src/toolbar/toolbar-store.d.ts"],"mappings":";;;;;iBAGwBK,oBAAAA,WAA+BL,IAAAA,CAAKO,YAAAA,CAAAA,CAAcE,KAAAA,EAAOH,CAAAA,EAAGI,MAAAA,cAAoBC,KAAAA,EAAOH,iBAAAA,GAAoBF,CAAAA;;AAAnI;;;;;;;;;;;;;;iBAgBwBM,eAAAA,CAAgBD,KAAAA,GAAQH,iBAAAA,GAAoBD,YAAY;AAAA,UAC/DM,iBAAAA,SAA0Bb,IAAAA,CAAKa,iBAAAA,EAAmBT,mBAAmB;AAAA,UAErEU,qBAAAA,SAA8Bd,IAAAA,CAAKc,qBAAAA,EAAuBZ,uBAAuB;AAAA,UAEjFa,mBAAAA,SAA4Bf,IAAAA,CAAKe,mBAAAA,EAAqBZ,qBAAqB;AAAA,UAE3EK,iBAAAA,SAA0BO,mBAAAA,EAAqBf,IAAAA,CAAKQ,iBAAiB;AAAA,UAErED,YAAAA,SAAqBO,qBAAAA,EAAuBb,KAAAA,CAAMD,IAAAA,CAAKO,YAAAA"}

package/dist/tooltip/tooltip-anchor.d.ts

@@ -0,0 +1,53 @@
+import { HovercardAnchorOptions } from "../hovercard/hovercard-anchor.js";
+import { TooltipStore } from "./tooltip-store.js";
+import { Props } from "@ariakit/react-utils";
+import { ElementType } from "react";
+
+//#region src/tooltip/tooltip-anchor.d.ts
+declare const TagName = "div";
+type TagName = typeof TagName;
+/**
+ * Returns props to create a `TooltipAnchor` component.
+ * @see https://ariakit.com/components/tooltip
+ * @example
+ * ```jsx
+ * const store = useToolTipStore();
+ * const props = useTooltipAnchor({ store });
+ * <Role {...props}>Anchor</Role>
+ * <Tooltip store={store}>Tooltip</Tooltip>
+ * ```
+ */
+declare const useTooltipAnchor: import("@ariakit/react-utils").Hook<"div", TooltipAnchorOptions<"div">>;
+/**
+ * Renders a reference element for a
+ * [`Tooltip`](https://ariakit.com/reference/tooltip), which is triggered by
+ * focusing or hovering over the anchor.
+ *
+ * The tooltip is strictly for visual purposes. It's your responsibility to
+ * ensure the anchor element has an accessible name. See [Tooltip anchors must
+ * have accessible
+ * names](https://ariakit.com/components/tooltip#tooltip-anchors-must-have-accessible-names)
+ * @see https://ariakit.com/components/tooltip
+ * @example
+ * ```jsx {2}
+ * <TooltipProvider>
+ *   <TooltipAnchor>Anchor</TooltipAnchor>
+ *   <Tooltip>Tooltip</Tooltip>
+ * </TooltipProvider>
+ * ```
+ */
+declare const TooltipAnchor: (props: TooltipAnchorProps) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+interface TooltipAnchorOptions<T extends ElementType = TagName> extends HovercardAnchorOptions<T> {
+  /**
+   * Object returned by the
+   * [`useTooltipStore`](https://ariakit.com/reference/use-tooltip-store) hook.
+   * If not provided, the closest
+   * [`TooltipProvider`](https://ariakit.com/reference/tooltip-provider)
+   * component's context will be used.
+   */
+  store?: TooltipStore;
+}
+type TooltipAnchorProps<T extends ElementType = TagName> = Props<T, TooltipAnchorOptions<T>>;
+//#endregion
+export { TooltipAnchor, TooltipAnchorOptions, TooltipAnchorProps, useTooltipAnchor };
+//# sourceMappingURL=tooltip-anchor.d.ts.map

package/dist/tooltip/tooltip-anchor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tooltip-anchor.d.ts","names":["Props","ElementType","HovercardAnchorOptions","TooltipStore","TagName","useTooltipAnchor","TooltipAnchorOptions","Hook","TooltipAnchor","TooltipAnchorProps","props","ReactElement","JSXElementConstructor","T","store"],"sources":["../../src/tooltip/tooltip-anchor.d.ts"],"mappings":";;;;;;cAIcI,OAAAA;AAAAA,KACTA,OAAAA,UAAiBA,OAAO;AAF0B;;;;AAClC;AAAA;;;;AACQ;AAY7B;AAduD,cAclCC,gBAAAA,iCAAiDE,IAAAA,QAAYD,oBAAoB;;;AAAA;AAmBtG;;;;;;;;;AAAmJ;AACnJ;;;;;cADqBE,aAAAA,GAAgBE,KAAAA,EAAOD,kBAAkB,qBAAqBE,YAAAA,+BAA2CC,qBAAAA;AAAAA,UAC7GN,oBAAAA,WAA+BL,WAAAA,GAAcG,OAAAA,UAAiBF,sBAAAA,CAAuBW,CAAAA;EAAvBX;;;;;;;EAQ3EY,KAAAA,GAAQX,YAAAA;AAAAA;AAAAA,KAEAM,kBAAAA,WAA6BR,WAAAA,GAAcG,OAAAA,IAAWJ,KAAAA,CAAMa,CAAAA,EAAGP,oBAAAA,CAAqBO,CAAAA"}

package/dist/tooltip/tooltip-anchor.js

@@ -0,0 +1,121 @@
+"use client";
+import { useHovercardAnchor } from "../hovercard/hovercard-anchor.js";
+import { useTooltipProviderContext } from "./tooltip-context.js";
+import { createElement, createHook, forwardRef, useEvent } from "@ariakit/react-utils";
+import { chain, invariant, isFalsyBooleanCallback } from "@ariakit/utils";
+import { useEffect, useRef } from "react";
+import { useStoreState } from "@ariakit/react-store";
+import { createStore, sync } from "@ariakit/store";
+//#region src/tooltip/tooltip-anchor.tsx
+const TagName = "div";
+const globalStore = createStore({ activeStore: null });
+function createRemoveStoreCallback(store) {
+	return () => {
+		const { activeStore } = globalStore.getState();
+		if (activeStore !== store) return;
+		globalStore.setState("activeStore", null);
+	};
+}
+/**
+* Returns props to create a `TooltipAnchor` component.
+* @see https://ariakit.com/components/tooltip
+* @example
+* ```jsx
+* const store = useToolTipStore();
+* const props = useTooltipAnchor({ store });
+* <Role {...props}>Anchor</Role>
+* <Tooltip store={store}>Tooltip</Tooltip>
+* ```
+*/
+const useTooltipAnchor = createHook(function useTooltipAnchor({ store, showOnHover = true, ...props }) {
+	const context = useTooltipProviderContext();
+	store = store || context;
+	invariant(store, "TooltipAnchor must receive a `store` prop or be wrapped in a TooltipProvider component.");
+	const canShowOnHoverRef = useRef(false);
+	useEffect(() => {
+		return sync(store, ["mounted"], (state) => {
+			if (state.mounted) return;
+			canShowOnHoverRef.current = false;
+		});
+	}, [store]);
+	useEffect(() => {
+		if (!store) return;
+		return chain(createRemoveStoreCallback(store), sync(store, ["mounted", "skipTimeout"], (state) => {
+			if (!store) return;
+			if (state.mounted) {
+				const { activeStore } = globalStore.getState();
+				if (activeStore !== store) activeStore?.hide();
+				return globalStore.setState("activeStore", store);
+			}
+			const id = setTimeout(createRemoveStoreCallback(store), state.skipTimeout);
+			return () => clearTimeout(id);
+		}));
+	}, [store]);
+	const onMouseEnterProp = props.onMouseEnter;
+	const onMouseEnter = useEvent((event) => {
+		onMouseEnterProp?.(event);
+		canShowOnHoverRef.current = true;
+	});
+	const onFocusVisibleProp = props.onFocusVisible;
+	const onFocusVisible = useEvent((event) => {
+		onFocusVisibleProp?.(event);
+		if (event.defaultPrevented) return;
+		store?.setAnchorElement(event.currentTarget);
+		store?.show();
+	});
+	const onBlurProp = props.onBlur;
+	const onBlur = useEvent((event) => {
+		onBlurProp?.(event);
+		if (event.defaultPrevented) return;
+		const { activeStore } = globalStore.getState();
+		canShowOnHoverRef.current = false;
+		if (activeStore === store) globalStore.setState("activeStore", null);
+	});
+	const type = useStoreState(store, "type");
+	const contentId = useStoreState(store, (state) => state.contentElement?.id);
+	props = {
+		"aria-labelledby": type === "label" && props["aria-label"] == null ? contentId : void 0,
+		...props,
+		onMouseEnter,
+		onFocusVisible,
+		onBlur
+	};
+	props = useHovercardAnchor({
+		store,
+		showOnHover(event) {
+			if (!canShowOnHoverRef.current) return false;
+			if (isFalsyBooleanCallback(showOnHover, event)) return false;
+			const { activeStore } = globalStore.getState();
+			if (!activeStore) return true;
+			store?.show();
+			return false;
+		},
+		...props
+	});
+	return props;
+});
+/**
+* Renders a reference element for a
+* [`Tooltip`](https://ariakit.com/reference/tooltip), which is triggered by
+* focusing or hovering over the anchor.
+*
+* The tooltip is strictly for visual purposes. It's your responsibility to
+* ensure the anchor element has an accessible name. See [Tooltip anchors must
+* have accessible
+* names](https://ariakit.com/components/tooltip#tooltip-anchors-must-have-accessible-names)
+* @see https://ariakit.com/components/tooltip
+* @example
+* ```jsx {2}
+* <TooltipProvider>
+*   <TooltipAnchor>Anchor</TooltipAnchor>
+*   <Tooltip>Tooltip</Tooltip>
+* </TooltipProvider>
+* ```
+*/
+const TooltipAnchor = forwardRef(function TooltipAnchor(props) {
+	return createElement(TagName, useTooltipAnchor(props));
+});
+//#endregion
+export { TooltipAnchor, useTooltipAnchor };
+
+//# sourceMappingURL=tooltip-anchor.js.map

package/dist/tooltip/tooltip-anchor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tooltip-anchor.js","names":[],"sources":["../../src/tooltip/tooltip-anchor.tsx"],"sourcesContent":["import { useStoreState } from \"@ariakit/react-store\";\nimport {\n  useEvent,\n  createElement,\n  createHook,\n  forwardRef,\n} from \"@ariakit/react-utils\";\nimport type { Props } from \"@ariakit/react-utils\";\nimport { createStore, sync } from \"@ariakit/store\";\nimport { chain, invariant, isFalsyBooleanCallback } from \"@ariakit/utils\";\nimport type { ElementType, FocusEvent, MouseEvent } from \"react\";\nimport { useEffect, useRef } from \"react\";\nimport type { HovercardAnchorOptions } from \"../hovercard/hovercard-anchor.tsx\";\nimport { useHovercardAnchor } from \"../hovercard/hovercard-anchor.tsx\";\nimport { useTooltipProviderContext } from \"./tooltip-context.tsx\";\nimport type { TooltipStore } from \"./tooltip-store.ts\";\n\nconst TagName = \"div\" satisfies ElementType;\ntype TagName = typeof TagName;\ntype HTMLType = HTMLElementTagNameMap[TagName];\n\n// Create a global store to keep track of the active tooltip store so we can\n// show other tooltips without a delay when there's already an active tooltip.\nconst globalStore = createStore<{ activeStore: TooltipStore | null }>({\n  activeStore: null,\n});\n\nfunction createRemoveStoreCallback(store: TooltipStore) {\n  return () => {\n    const { activeStore } = globalStore.getState();\n    if (activeStore !== store) return;\n    globalStore.setState(\"activeStore\", null);\n  };\n}\n\n/**\n * Returns props to create a `TooltipAnchor` component.\n * @see https://ariakit.com/components/tooltip\n * @example\n * ```jsx\n * const store = useToolTipStore();\n * const props = useTooltipAnchor({ store });\n * <Role {...props}>Anchor</Role>\n * <Tooltip store={store}>Tooltip</Tooltip>\n * ```\n */\nexport const useTooltipAnchor = createHook<TagName, TooltipAnchorOptions>(\n  function useTooltipAnchor({ store, showOnHover = true, ...props }) {\n    const context = useTooltipProviderContext();\n    store = store || context;\n\n    invariant(\n      store,\n      process.env.NODE_ENV !== \"production\" &&\n        \"TooltipAnchor must receive a `store` prop or be wrapped in a TooltipProvider component.\",\n    );\n\n    // Imagine the scenario: the user hovers over an anchor, which shows a\n    // tooltip, then presses escape to close the tooltip. We don't want to show\n    // the tooltip again while the anchor is still hovered. So we keep this flag\n    // that's set to true on mouse enter.\n    const canShowOnHoverRef = useRef(false);\n\n    useEffect(() => {\n      return sync(store, [\"mounted\"], (state) => {\n        if (state.mounted) return;\n        canShowOnHoverRef.current = false;\n      });\n    }, [store]);\n\n    useEffect(() => {\n      if (!store) return;\n      return chain(\n        // Immediately remove the current store from the global store when\n        // the component unmounts. This is useful, for example, to avoid\n        // showing tooltips immediately on serial tests.\n        createRemoveStoreCallback(store),\n        sync(store, [\"mounted\", \"skipTimeout\"], (state) => {\n          if (!store) return;\n          // If the current tooltip is open, we should immediately hide the\n          // active one and set the current one as the active tooltip.\n          if (state.mounted) {\n            const { activeStore } = globalStore.getState();\n            if (activeStore !== store) {\n              activeStore?.hide();\n            }\n            return globalStore.setState(\"activeStore\", store);\n          }\n          // Otherwise, if the current tooltip is closed, we should set a\n          // timeout to hide the active tooltip in the global store. This is so\n          // we can show other tooltips without a delay when there's already an\n          // active tooltip (see the showOnHover method below).\n          const id = setTimeout(\n            createRemoveStoreCallback(store),\n            state.skipTimeout,\n          );\n          return () => clearTimeout(id);\n        }),\n      );\n    }, [store]);\n\n    const onMouseEnterProp = props.onMouseEnter;\n\n    const onMouseEnter = useEvent((event: MouseEvent<HTMLType>) => {\n      onMouseEnterProp?.(event);\n      canShowOnHoverRef.current = true;\n    });\n\n    const onFocusVisibleProp = props.onFocusVisible;\n\n    const onFocusVisible = useEvent((event: FocusEvent<HTMLType>) => {\n      onFocusVisibleProp?.(event);\n      if (event.defaultPrevented) return;\n      store?.setAnchorElement(event.currentTarget);\n      store?.show();\n    });\n\n    const onBlurProp = props.onBlur;\n\n    const onBlur = useEvent((event: FocusEvent<HTMLType>) => {\n      onBlurProp?.(event);\n      if (event.defaultPrevented) return;\n      const { activeStore } = globalStore.getState();\n      // Sets canShowOnHover to false so moving the mouse over the anchor after\n      // it loses focus (for example, clicking on a menu button) doesn't show\n      // the tooltip until the mouse leaves and re-enters the anchor.\n      canShowOnHoverRef.current = false;\n      // If the current tooltip is the active tooltip and the anchor loses focus\n      // (for example, if the anchor is a menu button, clicking on the menu\n      // button will automatically focus on the menu), we don't want to show\n      // subsequent tooltips without a delay. So we set the active tooltip to\n      // null.\n      if (activeStore === store) {\n        globalStore.setState(\"activeStore\", null);\n      }\n    });\n\n    const type = useStoreState(store, \"type\");\n    const contentId = useStoreState(store, (state) => state.contentElement?.id);\n\n    props = {\n      \"aria-labelledby\":\n        type === \"label\" && props[\"aria-label\"] == null ? contentId : undefined,\n      ...props,\n      onMouseEnter,\n      onFocusVisible,\n      onBlur,\n    };\n\n    props = useHovercardAnchor<TagName>({\n      store,\n      showOnHover(event) {\n        if (!canShowOnHoverRef.current) return false;\n        if (isFalsyBooleanCallback(showOnHover, event)) return false;\n        const { activeStore } = globalStore.getState();\n        if (!activeStore) return true;\n        // Show the tooltip immediately if there's an active tooltip instead of\n        // waiting for the showTimeout delay.\n        store?.show();\n        return false;\n      },\n      ...props,\n    });\n\n    return props;\n  },\n);\n\n/**\n * Renders a reference element for a\n * [`Tooltip`](https://ariakit.com/reference/tooltip), which is triggered by\n * focusing or hovering over the anchor.\n *\n * The tooltip is strictly for visual purposes. It's your responsibility to\n * ensure the anchor element has an accessible name. See [Tooltip anchors must\n * have accessible\n * names](https://ariakit.com/components/tooltip#tooltip-anchors-must-have-accessible-names)\n * @see https://ariakit.com/components/tooltip\n * @example\n * ```jsx {2}\n * <TooltipProvider>\n *   <TooltipAnchor>Anchor</TooltipAnchor>\n *   <Tooltip>Tooltip</Tooltip>\n * </TooltipProvider>\n * ```\n */\nexport const TooltipAnchor = forwardRef(function TooltipAnchor(\n  props: TooltipAnchorProps,\n) {\n  const htmlProps = useTooltipAnchor(props);\n  return createElement(TagName, htmlProps);\n});\n\nexport interface TooltipAnchorOptions<\n  T extends ElementType = TagName,\n> extends HovercardAnchorOptions<T> {\n  /**\n   * Object returned by the\n   * [`useTooltipStore`](https://ariakit.com/reference/use-tooltip-store) hook.\n   * If not provided, the closest\n   * [`TooltipProvider`](https://ariakit.com/reference/tooltip-provider)\n   * component's context will be used.\n   */\n  store?: TooltipStore;\n}\n\nexport type TooltipAnchorProps<T extends ElementType = TagName> = Props<\n  T,\n  TooltipAnchorOptions<T>\n>;\n"],"mappings":";;;;;;;;;AAuBA,MAAM,UAAA;AAIN,MAAA,cAAS,YAAA,EAAA,aAA+C,KAAA,CAAA;SACtD,0BAAa,OAAA;cACH;EACR,MAAI,EAAA,gBAAgB,YAAO,SAAA;EAC3B,IAAA,gBAAY,OAAS;EACvB,YAAA,SAAA,eAAA,IAAA;CACF;;;;;;;;;;;;;MAeI,mBAAgB,WAAA,SAA0B,iBAAA,EAAA,OAAA,cAAA,MAAA,GAAA,SAAA;CAC1C,MAAA,UAAQ,0BAAS;CAEjB,QAAA,SAGI;CAOJ,UAAM,OAAA,yFAAgC;CAEtC,MAAA,oBAAgB,OAAA,KAAA;iBACF;SACN,KAAM,OAAA,CAAS,SAAA,IAAA,UAAA;GACnB,IAAA,MAAA,SAAkB;GACnB,kBAAA,UAAA;EACH,CAAA;CAEA,GAAA,CAAA,KAAA,CAAA;iBACc;EACZ,IAAA,CAAA,OAAO;SAME,MAAO,0BAAA,KAAA,GAAA,KAAA,OAAA,CAAA,WAAA,aAAA,IAAA,UAAA;GAGZ,IAAI,CAAA,OAAM;OACR,MAAQ,SAAA;IACR,MAAI,EAAA,gBAAgB,YAClB,SAAkB;IAEpB,IAAA,gBAAmB,OAAA,aAAS,KAAe;IAC7C,OAAA,YAAA,SAAA,eAAA,KAAA;GAKA;GAIA,MAAA,KAAA,WAAa,0BAAe,KAAA,GAAA,MAAA,WAAA;GAC7B,aACH,aAAA,EAAA;EACF,CAAA,CAAG;CAEH,GAAA,CAAA,KAAM,CAAA;CAEN,MAAM,mBAAe,MAAU;OAC7B,eAAmB,UAAK,UAAA;EACxB,mBAAkB,KAAA;EACnB,kBAAA,UAAA;CAED,CAAA;CAEA,MAAM,qBAAiB,MAAU;OAC/B,iBAAqB,UAAK,UAAA;EAC1B,qBAAU,KAAA;EACV,IAAA,MAAO,kBAAiB;EACxB,OAAO,iBAAK,MAAA,aAAA;EACb,OAAA,KAAA;CAED,CAAA;CAEA,MAAM,aAAS,MAAU;OACvB,SAAa,UAAK,UAAA;EAClB,aAAU,KAAA;EACV,IAAA,MAAQ,kBAAgB;EAIxB,MAAA,EAAA,gBAAkB,YAAU,SAAA;EAM5B,kBAAI,UACF;EAEH,IAAA,gBAAA,OAAA,YAAA,SAAA,eAAA,IAAA;CAED,CAAA;CACA,MAAM,OAAA,cAAY,OAAc,MAAQ;CAExC,MAAA,YAAQ,cAAA,QAAA,UAAA,MAAA,gBAAA,EAAA;SACN;EAEA,mBAAG,SAAA,WAAA,MAAA,iBAAA,OAAA,YAAA,KAAA;EACH,GAAA;EACA;EACA;EACF;CAEA;SACE,mBAAA;EACA;cACO,OAAA;GACL,IAAI,CAAA,kBAAA,SAAuB,OAAA;GAC3B,IAAA,uBAAwB,aAAY,KAAS,GAAA,OAAA;GAC7C,MAAK,EAAA,gBAAa,YAAO,SAAA;GAGzB,IAAA,CAAA,aAAY,OAAA;GACZ,OAAO,KAAA;GACT,OAAA;EACA;EACD,GAAA;CAED,CAAA;CAEJ,OAAA;;;;;;;;;;;;;;;;;;;;MAwBE,gBAAqB,WADH,SAAA,cACqB,OAAA;CACxC,OAAA,cAAA,SAAA,iBAAA,KAAA,CAAA"}

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

@@ -0,0 +1,54 @@
+import { PopoverArrowOptions } from "../popover/popover-arrow.js";
+import { TooltipStore } from "./tooltip-store.js";
+import { Props } from "@ariakit/react-utils";
+import { ElementType } from "react";
+
+//#region src/tooltip/tooltip-arrow.d.ts
+declare const TagName = "div";
+type TagName = typeof TagName;
+/**
+ * Returns props to create a `TooltipArrow` component.
+ * @see https://ariakit.com/components/tooltip
+ * @example
+ * ```jsx
+ * const store = useToolTipStore();
+ * const props = useTooltipArrow({ store });
+ * <TooltipAnchor store={store}>Anchor</TooltipAnchor>
+ * <Tooltip store={store}>
+ *   <Role {...props} />
+ *   Tooltip
+ * </Tooltip>
+ * ```
+ */
+declare const useTooltipArrow: import("@ariakit/react-utils").Hook<"div", TooltipArrowOptions<"div">>;
+/**
+ * Renders an arrow inside a [`Tooltip`](https://ariakit.com/reference/tooltip)
+ * pointing to the anchor element.
+ * @see https://ariakit.com/components/tooltip
+ * @example
+ * ```jsx {4}
+ * <TooltipProvider>
+ *   <TooltipAnchor>Anchor</TooltipAnchor>
+ *   <Tooltip>
+ *     <TooltipArrow />
+ *     Tooltip
+ *   </Tooltip>
+ * </TooltipProvider>
+ * ```
+ */
+declare const TooltipArrow: (props: TooltipArrowProps) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+interface TooltipArrowOptions<T extends ElementType = TagName> extends PopoverArrowOptions<T> {
+  /**
+   * Object returned by the
+   * [`useTooltipStore`](https://ariakit.com/reference/use-tooltip-store) hook.
+   * If not provided, the closest
+   * [`Tooltip`](https://ariakit.com/reference/tooltip) or
+   * [`TooltipProvider`](https://ariakit.com/reference/tooltip-provider)
+   * components' context will be used.
+   */
+  store?: TooltipStore;
+}
+type TooltipArrowProps<T extends ElementType = TagName> = Props<T, TooltipArrowOptions<T>>;
+//#endregion
+export { TooltipArrow, TooltipArrowOptions, TooltipArrowProps, useTooltipArrow };
+//# sourceMappingURL=tooltip-arrow.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tooltip-arrow.d.ts","names":["Props","ElementType","PopoverArrowOptions","TooltipStore","TagName","useTooltipArrow","TooltipArrowOptions","Hook","TooltipArrow","TooltipArrowProps","props","ReactElement","JSXElementConstructor","T","store"],"sources":["../../src/tooltip/tooltip-arrow.d.ts"],"mappings":";;;;;;cAIcI,OAAAA;AAAAA,KACTA,OAAAA,UAAiBA,OAAO;AAF0B;;;;AAClC;AAAA;;;;AACQ;AAe7B;;;;AAjBuD,cAiBlCC,eAAAA,iCAAgDE,IAAAA,QAAYD,mBAAmB;AAgBpG;;;;;;;;;AAAiJ;AACjJ;;;;;AADA,cAAqBE,YAAAA,GAAeE,KAAAA,EAAOD,iBAAiB,qBAAqBE,YAAAA,+BAA2CC,qBAAAA;AAAAA,UAC3GN,mBAAAA,WAA8BL,WAAAA,GAAcG,OAAAA,UAAiBF,mBAAAA,CAAoBW,CAAAA;EAApBX;;;;;;;;EAS1EY,KAAAA,GAAQX,YAAAA;AAAAA;AAAAA,KAEAM,iBAAAA,WAA4BR,WAAAA,GAAcG,OAAAA,IAAWJ,KAAAA,CAAMa,CAAAA,EAAGP,mBAAAA,CAAoBO,CAAAA"}