@ariakit/react-components 0.1.0

package/dist/tag/tag.js

@@ -0,0 +1,114 @@
+"use client";
+import { useCompositeItem } from "../composite/composite-item.js";
+import { TagRemoveIdContext, TagValueContext, useTagContext } from "./tag-context.js";
+import { useTouchDevice } from "./utils.js";
+import { createElement, createHook, forwardRef, memo, useBooleanEvent, useEvent, useId, useWrapElement } from "@ariakit/react-utils";
+import { invariant, isApple } from "@ariakit/utils";
+import { useCallback, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/tag/tag.tsx
+const TagName = "div";
+/**
+* Returns props to create a `Tag` component.
+* @see https://ariakit.com/components/tag
+* @example
+* ```jsx
+* const props = useTag();
+* <Role.div {...props} />
+* ```
+*/
+const useTag = createHook(function useTag({ store, value, getItem: getItemProp, removeOnKeyPress = true, ...props }) {
+	const context = useTagContext();
+	store = store || context;
+	invariant(store, "Tag must be wrapped in a TagList component.");
+	const id = useId(props.id);
+	const touchDevice = useTouchDevice();
+	const getItem = useCallback((item) => {
+		const nextItem = {
+			...item,
+			value
+		};
+		if (getItemProp) return getItemProp(nextItem);
+		return nextItem;
+	}, [value, getItemProp]);
+	const onKeyDownProp = props.onKeyDown;
+	const removeOnKeyPressProp = useBooleanEvent(removeOnKeyPress);
+	const onKeyDown = useEvent((event) => {
+		onKeyDownProp?.(event);
+		if (event.defaultPrevented) return;
+		const { inputElement } = store.getState();
+		const isBackspace = event.key === "Backspace";
+		if ((isBackspace || event.key === "Delete") && removeOnKeyPressProp(event)) {
+			event.preventDefault();
+			store.removeValue(value);
+			const nextId = isBackspace ? store.previous() || store.next() : store.next();
+			store.move(nextId);
+		}
+		const isPrintableKey = !event.ctrlKey && !event.metaKey && event.key.length === 1;
+		const pc = !isApple();
+		const v = event.key === "v" || event.key === "V";
+		const isPaste = (pc ? event.ctrlKey : event.metaKey) && v;
+		if (isPrintableKey || isPaste) inputElement?.focus();
+	});
+	const [removeId, setRemoveId] = useState();
+	props = useWrapElement(props, (element) => /* @__PURE__ */ jsx(TagValueContext.Provider, {
+		value,
+		children: /* @__PURE__ */ jsx(TagRemoveIdContext.Provider, {
+			value: setRemoveId,
+			children: element
+		})
+	}), [value]);
+	props = {
+		role: !touchDevice ? "option" : "listitem",
+		children: value,
+		"aria-describedby": removeId,
+		...props,
+		id,
+		onKeyDown
+	};
+	props = useCompositeItem({
+		store,
+		...props,
+		getItem
+	});
+	return props;
+});
+/**
+* Renders a tag element inside a
+* [`TagList`](https://ariakit.com/reference/tag-list) wrapper.
+*
+* The user can remove the tag by pressing `Backspace` or `Delete` keys when the
+* tag is focused. The
+* [`removeOnKeyPress`](https://ariakit.com/reference/tag#removeonkeypress) prop
+* can be used to disable this behavior.
+*
+* When a printable key is pressed, the focus is automatically moved to the
+* input element.
+* @see https://ariakit.com/components/tag
+* @example
+* ```jsx {7-10}
+* <TagProvider>
+*   <TagListLabel>Invitees</TagListLabel>
+*   <TagList>
+*     <TagValues>
+*       {(values) =>
+*         values.map((value) => (
+*           <Tag key={value} value={value}>
+*             {value}
+*             <TagRemove />
+*           </Tag>
+*         ))
+*       }
+*     </TagValues>
+*     <TagInput />
+*   </TagList>
+* </TagProvider>
+* ```
+*/
+const Tag = memo(forwardRef(function Tag(props) {
+	return createElement(TagName, useTag(props));
+}));
+//#endregion
+export { Tag, useTag };
+
+//# sourceMappingURL=tag.js.map

package/dist/tag/tag.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tag.js","names":[],"sources":["../../src/tag/tag.tsx"],"sourcesContent":["import {\n  useBooleanEvent,\n  useEvent,\n  useId,\n  useWrapElement,\n  createElement,\n  createHook,\n  forwardRef,\n  memo,\n} from \"@ariakit/react-utils\";\nimport type { Props } from \"@ariakit/react-utils\";\nimport { invariant, isApple } from \"@ariakit/utils\";\nimport type { BooleanOrCallback } from \"@ariakit/utils\";\nimport type { ElementType, KeyboardEvent } from \"react\";\nimport { useCallback, useState } from \"react\";\nimport type { CompositeItemOptions } from \"../composite/composite-item.tsx\";\nimport { useCompositeItem } from \"../composite/composite-item.tsx\";\nimport {\n  TagRemoveIdContext,\n  TagValueContext,\n  useTagContext,\n} from \"./tag-context.tsx\";\nimport type { TagStore } from \"./tag-store.ts\";\nimport { useTouchDevice } from \"./utils.ts\";\n\nconst TagName = \"div\" satisfies ElementType;\ntype TagName = typeof TagName;\ntype HTMLType = HTMLElementTagNameMap[TagName];\n\n/**\n * Returns props to create a `Tag` component.\n * @see https://ariakit.com/components/tag\n * @example\n * ```jsx\n * const props = useTag();\n * <Role.div {...props} />\n * ```\n */\nexport const useTag = createHook<TagName, TagOptions>(function useTag({\n  store,\n  value,\n  getItem: getItemProp,\n  removeOnKeyPress = true,\n  ...props\n}) {\n  const context = useTagContext();\n  store = store || context;\n\n  invariant(\n    store,\n    process.env.NODE_ENV !== \"production\" &&\n      \"Tag must be wrapped in a TagList component.\",\n  );\n\n  const id = useId(props.id);\n  const touchDevice = useTouchDevice();\n\n  const getItem = useCallback<NonNullable<CompositeItemOptions[\"getItem\"]>>(\n    (item) => {\n      const nextItem = { ...item, value };\n      if (getItemProp) {\n        return getItemProp(nextItem);\n      }\n      return nextItem;\n    },\n    [value, getItemProp],\n  );\n\n  const onKeyDownProp = props.onKeyDown;\n  const removeOnKeyPressProp = useBooleanEvent(removeOnKeyPress);\n\n  const onKeyDown = useEvent((event: KeyboardEvent<HTMLType>) => {\n    onKeyDownProp?.(event);\n    if (event.defaultPrevented) return;\n    const { inputElement } = store.getState();\n\n    const isBackspace = event.key === \"Backspace\";\n    const isRemoveKey = isBackspace || event.key === \"Delete\";\n\n    if (isRemoveKey && removeOnKeyPressProp(event)) {\n      event.preventDefault();\n      store.removeValue(value);\n      const nextId = isBackspace\n        ? store.previous() || store.next()\n        : store.next();\n      store.move(nextId);\n    }\n\n    const isPrintableKey =\n      !event.ctrlKey && !event.metaKey && event.key.length === 1;\n\n    // If it's cmd/ctrl+v, focus on the input element so the value is pasted\n    // there.\n    const pc = !isApple();\n    const v = event.key === \"v\" || event.key === \"V\";\n    const mod = pc ? event.ctrlKey : event.metaKey;\n    const isPaste = mod && v;\n\n    if (isPrintableKey || isPaste) {\n      inputElement?.focus();\n    }\n  });\n\n  const [removeId, setRemoveId] = useState<string>();\n\n  props = useWrapElement(\n    props,\n    (element) => (\n      <TagValueContext.Provider value={value}>\n        <TagRemoveIdContext.Provider value={setRemoveId}>\n          {element}\n        </TagRemoveIdContext.Provider>\n      </TagValueContext.Provider>\n    ),\n    [value],\n  );\n\n  props = {\n    role: !touchDevice ? \"option\" : \"listitem\",\n    children: value,\n    \"aria-describedby\": removeId,\n    ...props,\n    id,\n    onKeyDown,\n  };\n\n  props = useCompositeItem<TagName>({\n    store,\n    ...props,\n    getItem,\n  });\n\n  return props;\n});\n\n/**\n * Renders a tag element inside a\n * [`TagList`](https://ariakit.com/reference/tag-list) wrapper.\n *\n * The user can remove the tag by pressing `Backspace` or `Delete` keys when the\n * tag is focused. The\n * [`removeOnKeyPress`](https://ariakit.com/reference/tag#removeonkeypress) prop\n * can be used to disable this behavior.\n *\n * When a printable key is pressed, the focus is automatically moved to the\n * input element.\n * @see https://ariakit.com/components/tag\n * @example\n * ```jsx {7-10}\n * <TagProvider>\n *   <TagListLabel>Invitees</TagListLabel>\n *   <TagList>\n *     <TagValues>\n *       {(values) =>\n *         values.map((value) => (\n *           <Tag key={value} value={value}>\n *             {value}\n *             <TagRemove />\n *           </Tag>\n *         ))\n *       }\n *     </TagValues>\n *     <TagInput />\n *   </TagList>\n * </TagProvider>\n * ```\n */\nexport const Tag = memo(\n  forwardRef(function Tag(props: TagProps) {\n    const htmlProps = useTag(props);\n    return createElement(TagName, htmlProps);\n  }),\n);\n\nexport interface TagOptions<\n  T extends ElementType = TagName,\n> extends CompositeItemOptions<T> {\n  /**\n   * Object returned by the\n   * [`useTagStore`](https://ariakit.com/reference/use-tag-store) hook. If not\n   * provided, the closest [`TagList`](https://ariakit.com/reference/tag-list)\n   * component's context will be used.\n   */\n  store?: TagStore;\n  /**\n   * The unique value of the tag. This is automatically rendered as the tag's\n   * content if no children are provided.\n   */\n  value: string;\n  /**\n   * Defines the behavior of the `Backspace` and `Delete` keys when the tag is\n   * focused. If `true`, the tag is removed. If it's a function, it's invoked\n   * with the key event and should return a boolean.\n   * @default true\n   */\n  removeOnKeyPress?: BooleanOrCallback<KeyboardEvent<HTMLType>>;\n}\n\nexport type TagProps<T extends ElementType = TagName> = Props<T, TagOptions<T>>;\n"],"mappings":";;;;;;;;;;;;;;;;;;;MA6CE,SAAM,WAAU,SAAc,OAAA,EAAA,OAAA,OAAA,SAAA,aAAA,mBAAA,MAAA,GAAA,SAAA;CAC9B,MAAA,UAAQ,cAAS;CAEjB,QAAA,SAGI;CAGJ,UAAM,OAAW,6CAAQ;CACzB,MAAM,KAAA,MAAA,MAAc,EAAA;CAEpB,MAAM,cAAU,eACb;OACC,UAAM,aAAW,SAAA;QAAK,WAAA;GAAM,GAAA;GAAM;EAClC;EAGA,IAAA,aAAO,OAAA,YAAA,QAAA;EACT,OACC;CAGH,GAAA,CAAA,OAAM,WAAgB,CAAA;CACtB,MAAM,gBAAA,MAAA;CAEN,MAAM,uBAAsB,gBAAmC,gBAAA;OAC7D,YAAgB,UAAK,UAAA;EACrB,gBAAU,KAAA;EACV,IAAA,MAAQ,kBAAiB;EAEzB,MAAM,EAAA,iBAAc,MAAM,SAAQ;EAGlC,MAFoB,cAAe,MAAM,QAAQ;OAG/C,eAAM,MAAe,QAAA,aAAA,qBAAA,KAAA,GAAA;GACrB,MAAM,eAAY;GAClB,MAAM,YAAS,KAAA;GAGf,MAAM,SAAK,cAAM,MAAA,SAAA,KAAA,MAAA,KAAA,IAAA,MAAA,KAAA;GACnB,MAAA,KAAA,MAAA;EAEA;EAKA,MAAM,iBAAc,CAAA,MAAA,WAAA,CAAA,MAAA,WAAA,MAAA,IAAA,WAAA;EACpB,MAAM,KAAI,CAAA,QAAM;EAEhB,MAAM,IAAA,MAAA,QADW,OAAM,MAAA,QAAgB;EAGvC,MAAI,WAAA,KAAkB,MAAA,UACpB,MAAA,YAAoB;EAEvB,IAAA,kBAAA,SAAA,cAAA,MAAA;CAED,CAAA;CAEA,MAAA,CAAA,UAAQ,eAEL,SAAA;SACkC,eAAA,QAAA,YAAA,oBAAA,gBAAA,UAAA;;YACK,oBAAA,mBAAA,UAAA;;GAEP,UAAA;EACL,CAAA;CAK9B,CAAA,GAAA,CAAA,KAAQ,CAAA;SACC;EACP,MAAA,CAAA,cAAU,WAAA;EACV,UAAA;EACA,oBAAG;EACH,GAAA;EACA;EACF;CAEA;SACE,iBAAA;EACA;EACA,GAAA;EACD;CAED,CAAA;CACD,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAqCG,MAAO,KAAA,WAAc,SADH,IAAO,OACc;CACxC,OACH,cAAA,SAAA,OAAA,KAAA,CAAA"}

package/dist/tag/utils.d.ts

@@ -0,0 +1,5 @@
+//#region src/tag/utils.d.ts
+declare function useTouchDevice(): boolean;
+//#endregion
+export { useTouchDevice };
+//# sourceMappingURL=utils.d.ts.map

package/dist/tag/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","names":["useTouchDevice"],"sources":["../../src/tag/utils.d.ts"],"mappings":";iBAAwBA,cAAAA,CAAAA"}

package/dist/tag/utils.js

@@ -0,0 +1,15 @@
+"use client";
+import { isTouchDevice } from "@ariakit/utils";
+import { useEffect, useState } from "react";
+//#region src/tag/utils.ts
+function useTouchDevice() {
+	const [touchDevice, setTouchDevice] = useState(false);
+	useEffect(() => {
+		setTouchDevice(isTouchDevice());
+	}, []);
+	return touchDevice;
+}
+//#endregion
+export { useTouchDevice };
+
+//# sourceMappingURL=utils.js.map

package/dist/tag/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":[],"sources":["../../src/tag/utils.ts"],"sourcesContent":["import { isTouchDevice } from \"@ariakit/utils\";\nimport { useEffect, useState } from \"react\";\n\nexport function useTouchDevice() {\n  const [touchDevice, setTouchDevice] = useState(false);\n\n  useEffect(() => {\n    setTouchDevice(isTouchDevice());\n  }, []);\n\n  return touchDevice;\n}\n"],"mappings":";;;;SAIS,iBAAa;CAEpB,MAAA,CAAA,aAAgB,kBAAA,SAAA,KAAA;iBACC;EACjB,eAAK,cAAA,CAAA;CAEL,GAAA,CAAA,CAAA;CACF,OAAA"}

package/dist/tag-store-xANOvuGo.d.ts

@@ -0,0 +1,49 @@
+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/tag/tag-store";
+
+//#region src/tag/tag-store.d.ts
+declare function useTagStoreProps<T extends Core.TagStore>(store: T, update: () => void, props: TagStoreProps): T;
+/**
+ * Creates a tag store to control the state of
+ * [Tag](https://ariakit.com/components/tag) components.
+ * @see https://ariakit.com/components/tag
+ * @example
+ * ```jsx
+ * const tag = useTagStore({ defaultValues: ["Apple", "Banana"]});
+ * const values = useStoreState(tag, "values");
+ *
+ * <TagList store={tag}>
+ *   {values.map((value) => (
+ *     <Tag key={value} value={value}>
+ *       {value}
+ *       <TagRemove />
+ *     </Tag>
+ *   ))}
+ *   <TagInput />
+ * </TagList>
+ * ```
+ */
+declare function useTagStore(props?: TagStoreProps): TagStore;
+interface TagStoreItem extends Core.TagStoreItem {}
+interface TagStoreState extends Core.TagStoreState, CompositeStoreState<TagStoreItem> {}
+interface TagStoreFunctions extends Core.TagStoreFunctions, CompositeStoreFunctions<TagStoreItem> {}
+interface TagStoreOptions extends Core.TagStoreOptions, CompositeStoreOptions<TagStoreItem> {
+  /**
+   * A callback that gets called when the
+   * [`value`](https://ariakit.com/reference/tag-provider#value) state
+   * changes.
+   */
+  setValue?: (value: TagStoreState["value"]) => void;
+  /**
+   * A callback that gets called when the
+   * [`values`](https://ariakit.com/reference/tag-provider#values) state
+   * changes.
+   */
+  setValues?: (values: TagStoreState["values"]) => void;
+}
+interface TagStoreProps extends TagStoreOptions, Core.TagStoreProps {}
+interface TagStore extends TagStoreFunctions, Store<Core.TagStore> {}
+//#endregion
+export { TagStoreProps as a, useTagStoreProps as c, TagStoreOptions as i, TagStoreFunctions as n, TagStoreState as o, TagStoreItem as r, useTagStore as s, TagStore as t };
+//# sourceMappingURL=tag-store-xANOvuGo.d.ts.map

package/dist/tag-store-xANOvuGo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tag-store-xANOvuGo.d.ts","names":["Core","Store","CompositeStoreFunctions","CompositeStoreOptions","CompositeStoreState","useTagStoreProps","T","TagStore","TagStoreProps","store","update","props","useTagStore","TagStoreItem","TagStoreState","TagStoreFunctions","TagStoreOptions","setValue","value","setValues","values"],"sources":["../src/tag/tag-store.d.ts"],"mappings":";;;;;iBAGwBK,gBAAAA,WAA2BL,IAAAA,CAAKO,QAAAA,CAAAA,CAAUE,KAAAA,EAAOH,CAAAA,EAAGI,MAAAA,cAAoBC,KAAAA,EAAOH,aAAAA,GAAgBF,CAAAA;;AAAvH;;;;;;;;;;;;;;;;;;;iBAqBwBM,WAAAA,CAAYD,KAAAA,GAAQH,aAAAA,GAAgBD,QAAQ;AAAA,UACnDM,YAAAA,SAAqBb,IAAAA,CAAKa,YAAY;AAAA,UAEtCC,aAAAA,SAAsBd,IAAAA,CAAKc,aAAAA,EAAeV,mBAAAA,CAAoBS,YAAAA;AAAAA,UAE9DE,iBAAAA,SAA0Bf,IAAAA,CAAKe,iBAAAA,EAAmBb,uBAAAA,CAAwBW,YAAAA;AAAAA,UAE1EG,eAAAA,SAAwBhB,IAAAA,CAAKgB,eAAAA,EAAiBb,qBAAAA,CAAsBU,YAAAA;EAPjB;AAAA;AACpE;;;EAYII,QAAAA,IAAYC,KAAAA,EAAOJ,aAAAA;EAZgC;AAEvD;;;;EAgBIK,SAAAA,IAAaC,MAAAA,EAAQN,aAAAA;AAAAA;AAAAA,UAERN,aAAAA,SAAsBQ,eAAAA,EAAiBhB,IAAAA,CAAKQ,aAAa;AAAA,UAEzDD,QAAAA,SAAiBQ,iBAAAA,EAAmBd,KAAAA,CAAMD,IAAAA,CAAKO,QAAAA"}

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

@@ -0,0 +1,41 @@
+import { CompositeContainerOptions } from "../composite/composite-container.js";
+import { ToolbarItemOptions } from "./toolbar-item.js";
+import { Props } from "@ariakit/react-utils";
+import { ElementType } from "react";
+
+//#region src/toolbar/toolbar-container.d.ts
+declare const TagName = "div";
+type TagName = typeof TagName;
+/**
+ * Returns props to create a `ToolbarContainer` component.
+ * @see https://ariakit.com/components/toolbar
+ * @example
+ * ```jsx
+ * const store = useToolbarStore();
+ * const props = useToolbarContainer({ store });
+ * <Toolbar store={store}>
+ *   <Role {...props}>
+ *     <input type="text" />
+ *   </Role>
+ * </Toolbar>
+ * ```
+ */
+declare const useToolbarContainer: import("@ariakit/react-utils").Hook<"div", ToolbarContainerOptions<"div">>;
+/**
+ * Renders a toolbar item that may contain interactive widgets inside.
+ * @see https://ariakit.com/components/toolbar
+ * @example
+ * ```jsx {2-4}
+ * <Toolbar>
+ *   <ToolbarContainer>
+ *     <input type="text" />
+ *   </ToolbarContainer>
+ * </Toolbar>
+ * ```
+ */
+declare const ToolbarContainer: (props: ToolbarContainerProps) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+interface ToolbarContainerOptions<T extends ElementType = TagName> extends ToolbarItemOptions<T>, Omit<CompositeContainerOptions<T>, "store"> {}
+type ToolbarContainerProps<T extends ElementType = TagName> = Props<T, ToolbarContainerOptions<T>>;
+//#endregion
+export { ToolbarContainer, ToolbarContainerOptions, ToolbarContainerProps, useToolbarContainer };
+//# sourceMappingURL=toolbar-container.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"toolbar-container.d.ts","names":["Props","ElementType","CompositeContainerOptions","ToolbarItemOptions","TagName","useToolbarContainer","ToolbarContainerOptions","Hook","ToolbarContainer","ToolbarContainerProps","props","ReactElement","JSXElementConstructor","T","Omit"],"sources":["../../src/toolbar/toolbar-container.d.ts"],"mappings":";;;;;;cAIcI,OAAAA;AAAAA,KACTA,OAAAA,UAAiBA,OAAO;AAFgC;;;;AACxC;AAAA;;;;AACQ;AAe7B;;;;AAjB6D,cAiBxCC,mBAAAA,iCAAoDE,IAAAA,QAAYD,uBAAuB;AAa5G;;;;;;;;;AAAyJ;AACzJ;;AADA,cAAqBE,gBAAAA,GAAmBE,KAAAA,EAAOD,qBAAqB,qBAAqBE,YAAAA,+BAA2CC,qBAAAA;AAAAA,UACnHN,uBAAAA,WAAkCL,WAAAA,GAAcG,OAAAA,UAAiBD,kBAAAA,CAAmBU,CAAAA,GAAIC,IAAAA,CAAKZ,yBAAAA,CAA0BW,CAAAA;AAAAA,KAE5HJ,qBAAAA,WAAgCR,WAAAA,GAAcG,OAAAA,IAAWJ,KAAAA,CAAMa,CAAAA,EAAGP,uBAAAA,CAAwBO,CAAAA"}

package/dist/toolbar/toolbar-container.js

@@ -0,0 +1,53 @@
+"use client";
+import { useCompositeContainer } from "../composite/composite-container.js";
+import { useToolbarContext } from "./toolbar-context.js";
+import { useToolbarItem } from "./toolbar-item.js";
+import { createElement, createHook, forwardRef, memo } from "@ariakit/react-utils";
+//#region src/toolbar/toolbar-container.tsx
+const TagName = "div";
+/**
+* Returns props to create a `ToolbarContainer` component.
+* @see https://ariakit.com/components/toolbar
+* @example
+* ```jsx
+* const store = useToolbarStore();
+* const props = useToolbarContainer({ store });
+* <Toolbar store={store}>
+*   <Role {...props}>
+*     <input type="text" />
+*   </Role>
+* </Toolbar>
+* ```
+*/
+const useToolbarContainer = createHook(function useToolbarContainer({ store, ...props }) {
+	const context = useToolbarContext();
+	store = store || context;
+	props = useCompositeContainer({
+		store,
+		...props
+	});
+	props = useToolbarItem({
+		store,
+		...props
+	});
+	return props;
+});
+/**
+* Renders a toolbar item that may contain interactive widgets inside.
+* @see https://ariakit.com/components/toolbar
+* @example
+* ```jsx {2-4}
+* <Toolbar>
+*   <ToolbarContainer>
+*     <input type="text" />
+*   </ToolbarContainer>
+* </Toolbar>
+* ```
+*/
+const ToolbarContainer = memo(forwardRef(function ToolbarContainer(props) {
+	return createElement(TagName, useToolbarContainer(props));
+}));
+//#endregion
+export { ToolbarContainer, useToolbarContainer };
+
+//# sourceMappingURL=toolbar-container.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"toolbar-container.js","names":[],"sources":["../../src/toolbar/toolbar-container.tsx"],"sourcesContent":["import {\n  createElement,\n  createHook,\n  forwardRef,\n  memo,\n} from \"@ariakit/react-utils\";\nimport type { Props } from \"@ariakit/react-utils\";\nimport type { ElementType } from \"react\";\nimport type { CompositeContainerOptions } from \"../composite/composite-container.tsx\";\nimport { useCompositeContainer } from \"../composite/composite-container.tsx\";\nimport { useToolbarContext } from \"./toolbar-context.tsx\";\nimport type { ToolbarItemOptions } from \"./toolbar-item.tsx\";\nimport { useToolbarItem } from \"./toolbar-item.tsx\";\n\nconst TagName = \"div\" satisfies ElementType;\ntype TagName = typeof TagName;\n\n/**\n * Returns props to create a `ToolbarContainer` component.\n * @see https://ariakit.com/components/toolbar\n * @example\n * ```jsx\n * const store = useToolbarStore();\n * const props = useToolbarContainer({ store });\n * <Toolbar store={store}>\n *   <Role {...props}>\n *     <input type=\"text\" />\n *   </Role>\n * </Toolbar>\n * ```\n */\nexport const useToolbarContainer = createHook<TagName, ToolbarContainerOptions>(\n  function useToolbarContainer({ store, ...props }) {\n    const context = useToolbarContext();\n    store = store || context;\n    props = useCompositeContainer({ store, ...props });\n    props = useToolbarItem<TagName>({ store, ...props });\n    return props;\n  },\n);\n\n/**\n * Renders a toolbar item that may contain interactive widgets inside.\n * @see https://ariakit.com/components/toolbar\n * @example\n * ```jsx {2-4}\n * <Toolbar>\n *   <ToolbarContainer>\n *     <input type=\"text\" />\n *   </ToolbarContainer>\n * </Toolbar>\n * ```\n */\nexport const ToolbarContainer = memo(\n  forwardRef(function ToolbarContainer(props: ToolbarContainerProps) {\n    const htmlProps = useToolbarContainer(props);\n    return createElement(TagName, htmlProps);\n  }),\n);\n\nexport interface ToolbarContainerOptions<T extends ElementType = TagName>\n  extends ToolbarItemOptions<T>, Omit<CompositeContainerOptions<T>, \"store\"> {}\n\nexport type ToolbarContainerProps<T extends ElementType = TagName> = Props<\n  T,\n  ToolbarContainerOptions<T>\n>;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;MAiCI,sBAAgB,WAAkB,SAAA,oBAAA,EAAA,OAAA,GAAA,SAAA;CAClC,MAAA,UAAQ,kBAAS;CACjB,QAAQ,SAAA;SAAwB,sBAAA;EAAO;EAAU,GAAA;CACjD,CAAA;SAAkC,eAAA;EAAO;EAAU,GAAA;CACnD,CAAA;CAEJ,OAAA;;;;;;;;;;;;;;MAiBI,mBAAqB,KAAA,WADH,SAAA,iBACqB,OAAA;CACxC,OACH,cAAA,SAAA,oBAAA,KAAA,CAAA"}

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

@@ -0,0 +1,24 @@
+import { t as ToolbarStore } from "../toolbar-store-Cs-9cGHx.js";
+
+//#region src/toolbar/toolbar-context.d.ts
+/**
+ * Returns the toolbar store from the nearest toolbar container.
+ * @example
+ * function ToolbarItem() {
+ *   const store = useToolbarContext();
+ *
+ *   if (!store) {
+ *     throw new Error("ToolbarItem must be wrapped in ToolbarProvider");
+ *   }
+ *
+ *   // Use the store...
+ * }
+ */
+declare const useToolbarContext: () => ToolbarStore | undefined;
+declare const useToolbarScopedContext: (onlyScoped?: boolean) => ToolbarStore | undefined;
+declare const useToolbarProviderContext: () => ToolbarStore | undefined;
+declare const ToolbarContextProvider: (props: import("react").ProviderProps<ToolbarStore | undefined>) => import("react/jsx-runtime").JSX.Element;
+declare const ToolbarScopedContextProvider: (props: import("react").ProviderProps<ToolbarStore | undefined>) => import("react/jsx-runtime").JSX.Element;
+//#endregion
+export { ToolbarContextProvider, ToolbarScopedContextProvider, useToolbarContext, useToolbarProviderContext, useToolbarScopedContext };
+//# sourceMappingURL=toolbar-context.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"toolbar-context.d.ts","names":["ToolbarStore","useToolbarContext","useToolbarScopedContext","onlyScoped","useToolbarProviderContext","ToolbarContextProvider","ProviderProps","props","JSX","Element","ToolbarScopedContextProvider"],"sources":["../../src/toolbar/toolbar-context.d.ts"],"mappings":";;;;;AAcA;;;;AAA0D;AAC1D;;;;AAAoF;AACpF;cAFqBC,iBAAAA,QAAyBD,YAAY;AAAA,cACrCE,uBAAAA,GAA0BC,UAAAA,eAAyBH,YAAY;AAAA,cAC/DI,yBAAAA,QAAiCJ,YAAY;AAAA,cAC7CK,sBAAAA,GAAyBE,KAAAA,kBAAuBD,aAAAA,CAAcN,YAAY,8CAA8CQ,GAAAA,CAAIC,OAAAA;AAAAA,cAC5HC,4BAAAA,GAA+BH,KAAAA,kBAAuBD,aAAAA,CAAcN,YAAY,8CAA8CQ,GAAAA,CAAIC,OAAAA"}

package/dist/toolbar/toolbar-context.js

@@ -0,0 +1,27 @@
+"use client";
+import { CompositeContextProvider, CompositeScopedContextProvider } from "../composite/composite-context.js";
+import { createStoreContext } from "@ariakit/react-utils";
+//#region src/toolbar/toolbar-context.tsx
+const ctx = createStoreContext([CompositeContextProvider], [CompositeScopedContextProvider]);
+/**
+* Returns the toolbar store from the nearest toolbar container.
+* @example
+* function ToolbarItem() {
+*   const store = useToolbarContext();
+*
+*   if (!store) {
+*     throw new Error("ToolbarItem must be wrapped in ToolbarProvider");
+*   }
+*
+*   // Use the store...
+* }
+*/
+const useToolbarContext = ctx.useContext;
+const useToolbarScopedContext = ctx.useScopedContext;
+const useToolbarProviderContext = ctx.useProviderContext;
+const ToolbarContextProvider = ctx.ContextProvider;
+const ToolbarScopedContextProvider = ctx.ScopedContextProvider;
+//#endregion
+export { ToolbarContextProvider, ToolbarScopedContextProvider, useToolbarContext, useToolbarProviderContext, useToolbarScopedContext };
+
+//# sourceMappingURL=toolbar-context.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"toolbar-context.js","names":[],"sources":["../../src/toolbar/toolbar-context.tsx"],"sourcesContent":["import { createStoreContext } from \"@ariakit/react-utils\";\nimport {\n  CompositeContextProvider,\n  CompositeScopedContextProvider,\n} from \"../composite/composite-context.tsx\";\nimport type { ToolbarStore } from \"./toolbar-store.ts\";\n\nconst ctx = createStoreContext<ToolbarStore>(\n  [CompositeContextProvider],\n  [CompositeScopedContextProvider],\n);\n\n/**\n * Returns the toolbar store from the nearest toolbar container.\n * @example\n * function ToolbarItem() {\n *   const store = useToolbarContext();\n *\n *   if (!store) {\n *     throw new Error(\"ToolbarItem must be wrapped in ToolbarProvider\");\n *   }\n *\n *   // Use the store...\n * }\n */\nexport const useToolbarContext = ctx.useContext;\n\nexport const useToolbarScopedContext = ctx.useScopedContext;\n\nexport const useToolbarProviderContext = ctx.useProviderContext;\n\nexport const ToolbarContextProvider = ctx.ContextProvider;\n\nexport const ToolbarScopedContextProvider = ctx.ScopedContextProvider;\n"],"mappings":";;;;;;;;;;;;;;;;;;AA2BA,MAAa,oBAAA,IAAA;AAEb,MAAa,0BAAA,IAA4B;AAEzC,MAAa,4BAAyB,IAAI;AAE1C,MAAa,yBAAA,IAAA"}

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

@@ -0,0 +1,39 @@
+import { ToolbarItemOptions } from "./toolbar-item.js";
+import { Props } from "@ariakit/react-utils";
+import { ElementType } from "react";
+
+//#region src/toolbar/toolbar-input.d.ts
+declare const TagName = "input";
+type TagName = typeof TagName;
+/**
+ * Returns props to create a `ToolbarInput` component.
+ * @see https://ariakit.com/components/toolbar
+ * @deprecated Use `useToolbarItem` instead.
+ * @example
+ * ```jsx
+ * const store = useToolbarStore();
+ * const props = useToolbarInput({ store });
+ * <Toolbar store={store}>
+ *   <Role {...props} />
+ * </Toolbar>
+ * ```
+ */
+declare const useToolbarInput: import("@ariakit/react-utils").Hook<"input", ToolbarInputOptions<"input">>;
+/**
+ * Renders a text input as a toolbar item, maintaining arrow key navigation on
+ * the toolbar.
+ * @see https://ariakit.com/components/toolbar
+ * @deprecated Use `<ToolbarItem render={<input />}>` instead.
+ * @example
+ * ```jsx {2}
+ * <Toolbar>
+ *   <ToolbarInput />
+ * </Toolbar>
+ * ```
+ */
+declare const ToolbarInput: (props: ToolbarInputProps) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+interface ToolbarInputOptions<T extends ElementType = TagName> extends ToolbarItemOptions<T> {}
+type ToolbarInputProps<T extends ElementType = TagName> = Props<T, ToolbarInputOptions<T>>;
+//#endregion
+export { ToolbarInput, ToolbarInputOptions, ToolbarInputProps, useToolbarInput };
+//# sourceMappingURL=toolbar-input.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"toolbar-input.d.ts","names":["Props","ElementType","ToolbarItemOptions","TagName","useToolbarInput","ToolbarInputOptions","Hook","ToolbarInput","ToolbarInputProps","props","ReactElement","JSXElementConstructor","T"],"sources":["../../src/toolbar/toolbar-input.d.ts"],"mappings":";;;;;cAGcG,OAAAA;AAAAA,KACTA,OAAAA,UAAiBA,OAAO;AAFgC;;;;AACxC;AAAA;;;;AACQ;AAc7B;;;AAhB6D,cAgBxCC,eAAAA,iCAAgDE,IAAAA,UAAcD,mBAAmB;AAAA;AAatG;;;;;;;;;AAAiJ;AACjJ;AAdsG,cAajFE,YAAAA,GAAeE,KAAAA,EAAOD,iBAAiB,qBAAqBE,YAAAA,+BAA2CC,qBAAAA;AAAAA,UAC3GN,mBAAAA,WAA8BJ,WAAAA,GAAcE,OAAAA,UAAiBD,kBAAAA,CAAmBU,CAAAA;AAAAA,KAErFJ,iBAAAA,WAA4BP,WAAAA,GAAcE,OAAAA,IAAWH,KAAAA,CAAMY,CAAAA,EAAGP,mBAAAA,CAAoBO,CAAAA"}

package/dist/toolbar/toolbar-input.js

@@ -0,0 +1,47 @@
+"use client";
+import { useToolbarContext } from "./toolbar-context.js";
+import { useToolbarItem } from "./toolbar-item.js";
+import { createElement, createHook, forwardRef, memo } from "@ariakit/react-utils";
+//#region src/toolbar/toolbar-input.tsx
+const TagName = "input";
+/**
+* Returns props to create a `ToolbarInput` component.
+* @see https://ariakit.com/components/toolbar
+* @deprecated Use `useToolbarItem` instead.
+* @example
+* ```jsx
+* const store = useToolbarStore();
+* const props = useToolbarInput({ store });
+* <Toolbar store={store}>
+*   <Role {...props} />
+* </Toolbar>
+* ```
+*/
+const useToolbarInput = createHook(function useToolbarInput({ store, ...props }) {
+	const context = useToolbarContext();
+	store = store || context;
+	props = useToolbarItem({
+		store,
+		...props
+	});
+	return props;
+});
+/**
+* Renders a text input as a toolbar item, maintaining arrow key navigation on
+* the toolbar.
+* @see https://ariakit.com/components/toolbar
+* @deprecated Use `<ToolbarItem render={<input />}>` instead.
+* @example
+* ```jsx {2}
+* <Toolbar>
+*   <ToolbarInput />
+* </Toolbar>
+* ```
+*/
+const ToolbarInput = memo(forwardRef(function ToolbarInput(props) {
+	return createElement(TagName, useToolbarInput(props));
+}));
+//#endregion
+export { ToolbarInput, useToolbarInput };
+
+//# sourceMappingURL=toolbar-input.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"toolbar-input.js","names":[],"sources":["../../src/toolbar/toolbar-input.tsx"],"sourcesContent":["import {\n  createElement,\n  createHook,\n  forwardRef,\n  memo,\n} from \"@ariakit/react-utils\";\nimport type { Props } from \"@ariakit/react-utils\";\nimport type { ElementType } from \"react\";\nimport { useToolbarContext } from \"./toolbar-context.tsx\";\nimport type { ToolbarItemOptions } from \"./toolbar-item.tsx\";\nimport { useToolbarItem } from \"./toolbar-item.tsx\";\n\nconst TagName = \"input\" satisfies ElementType;\ntype TagName = typeof TagName;\n\n/**\n * Returns props to create a `ToolbarInput` component.\n * @see https://ariakit.com/components/toolbar\n * @deprecated Use `useToolbarItem` instead.\n * @example\n * ```jsx\n * const store = useToolbarStore();\n * const props = useToolbarInput({ store });\n * <Toolbar store={store}>\n *   <Role {...props} />\n * </Toolbar>\n * ```\n */\nexport const useToolbarInput = createHook<TagName, ToolbarInputOptions>(\n  function useToolbarInput({ store, ...props }) {\n    const context = useToolbarContext();\n    store = store || context;\n    props = useToolbarItem<TagName>({ store, ...props });\n    return props;\n  },\n);\n\n/**\n * Renders a text input as a toolbar item, maintaining arrow key navigation on\n * the toolbar.\n * @see https://ariakit.com/components/toolbar\n * @deprecated Use `<ToolbarItem render={<input />}>` instead.\n * @example\n * ```jsx {2}\n * <Toolbar>\n *   <ToolbarInput />\n * </Toolbar>\n * ```\n */\nexport const ToolbarInput = memo(\n  forwardRef(function ToolbarInput(props: ToolbarInputProps) {\n    const htmlProps = useToolbarInput(props);\n    return createElement(TagName, htmlProps);\n  }),\n);\n\nexport interface ToolbarInputOptions<\n  T extends ElementType = TagName,\n> extends ToolbarItemOptions<T> {}\n\nexport type ToolbarInputProps<T extends ElementType = TagName> = Props<\n  T,\n  ToolbarInputOptions<T>\n>;\n"],"mappings":";;;;;;;;;;;;;;;;;;;MA8BI,kBAAgB,WAAkB,SAAA,gBAAA,EAAA,OAAA,GAAA,SAAA;CAClC,MAAA,UAAQ,kBAAS;CACjB,QAAQ,SAAA;SAA0B,eAAA;EAAO;EAAU,GAAA;CACnD,CAAA;CAEJ,OAAA;;;;;;;;;;;;;;MAiBI,eAAO,KAAc,WADH,SAAA,aACqB,OAAA;CACxC,OACH,cAAA,SAAA,gBAAA,KAAA,CAAA"}

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

@@ -0,0 +1,47 @@
+import { n as CompositeItemOptions } from "../composite-item-B4WTelVz.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-item.d.ts
+declare const TagName = "button";
+type TagName = typeof TagName;
+/**
+ * Returns props to create a `ToolbarItem` component.
+ * @see https://ariakit.com/components/toolbar
+ * @example
+ * ```jsx
+ * const store = useToolbarStore();
+ * const props = useToolbarItem({ store });
+ * <Toolbar store={store}>
+ *   <Role {...props}>Item</Role>
+ * </Toolbar>
+ * ```
+ */
+declare const useToolbarItem: import("@ariakit/react-utils").Hook<"button", ToolbarItemOptions<"button">>;
+/**
+ * Renders an interactive element inside a
+ * [`Toolbar`](https://ariakit.com/reference/toolbar).
+ * @see https://ariakit.com/components/toolbar
+ * @example
+ * ```jsx {2}
+ * <Toolbar>
+ *   <ToolbarItem>Item</ToolbarItem>
+ * </Toolbar>
+ * ```
+ */
+declare const ToolbarItem: (props: ToolbarItemProps) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+interface ToolbarItemOptions<T extends ElementType = TagName> extends CompositeItemOptions<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 ToolbarItemProps<T extends ElementType = TagName> = Props<T, ToolbarItemOptions<T>>;
+//#endregion
+export { ToolbarItem, ToolbarItemOptions, ToolbarItemProps, useToolbarItem };
+//# sourceMappingURL=toolbar-item.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"toolbar-item.d.ts","names":["Props","ElementType","CompositeItemOptions","ToolbarStore","TagName","useToolbarItem","ToolbarItemOptions","Hook","ToolbarItem","ToolbarItemProps","props","ReactElement","JSXElementConstructor","T","store"],"sources":["../../src/toolbar/toolbar-item.d.ts"],"mappings":";;;;;;cAIcI,OAAAA;AAAAA,KACTA,OAAAA,UAAiBA,OAAO;AAF0B;;;;AAClC;AAAA;;;;AACQ;AAa7B;;AAfuD,cAelCC,cAAAA,iCAA+CE,IAAAA,WAAeD,kBAAkB;;AAAA;AAYrG;;;;;;;;;cAAqBE,WAAAA,GAAcE,KAAAA,EAAOD,gBAAgB,qBAAqBE,YAAAA,+BAA2CC,qBAAAA;AAAAA,UACzGN,kBAAAA,WAA6BL,WAAAA,GAAcG,OAAAA,UAAiBF,oBAAAA,CAAqBW,CAAAA;EAA/D;;;;;;;EAQ/BC,KAAAA,GAAQX,YAAAA;AAAAA;AAAAA,KAEAM,gBAAAA,WAA2BR,WAAAA,GAAcG,OAAAA,IAAWJ,KAAAA,CAAMa,CAAAA,EAAGP,kBAAAA,CAAmBO,CAAAA"}

package/dist/toolbar/toolbar-item.js

@@ -0,0 +1,45 @@
+"use client";
+import { useCompositeItem } from "../composite/composite-item.js";
+import { useToolbarContext } from "./toolbar-context.js";
+import { createElement, createHook, forwardRef, memo } from "@ariakit/react-utils";
+//#region src/toolbar/toolbar-item.tsx
+const TagName = "button";
+/**
+* Returns props to create a `ToolbarItem` component.
+* @see https://ariakit.com/components/toolbar
+* @example
+* ```jsx
+* const store = useToolbarStore();
+* const props = useToolbarItem({ store });
+* <Toolbar store={store}>
+*   <Role {...props}>Item</Role>
+* </Toolbar>
+* ```
+*/
+const useToolbarItem = createHook(function useToolbarItem({ store, ...props }) {
+	const context = useToolbarContext();
+	store = store || context;
+	props = useCompositeItem({
+		store,
+		...props
+	});
+	return props;
+});
+/**
+* Renders an interactive element inside a
+* [`Toolbar`](https://ariakit.com/reference/toolbar).
+* @see https://ariakit.com/components/toolbar
+* @example
+* ```jsx {2}
+* <Toolbar>
+*   <ToolbarItem>Item</ToolbarItem>
+* </Toolbar>
+* ```
+*/
+const ToolbarItem = memo(forwardRef(function ToolbarItem(props) {
+	return createElement(TagName, useToolbarItem(props));
+}));
+//#endregion
+export { ToolbarItem, useToolbarItem };
+
+//# sourceMappingURL=toolbar-item.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"toolbar-item.js","names":[],"sources":["../../src/toolbar/toolbar-item.tsx"],"sourcesContent":["import {\n  createElement,\n  createHook,\n  forwardRef,\n  memo,\n} from \"@ariakit/react-utils\";\nimport type { Props } from \"@ariakit/react-utils\";\nimport type { ElementType } from \"react\";\nimport type { CompositeItemOptions } from \"../composite/composite-item.tsx\";\nimport { useCompositeItem } from \"../composite/composite-item.tsx\";\nimport { useToolbarContext } from \"./toolbar-context.tsx\";\nimport type { ToolbarStore } from \"./toolbar-store.ts\";\n\nconst TagName = \"button\" satisfies ElementType;\ntype TagName = typeof TagName;\n\n/**\n * Returns props to create a `ToolbarItem` component.\n * @see https://ariakit.com/components/toolbar\n * @example\n * ```jsx\n * const store = useToolbarStore();\n * const props = useToolbarItem({ store });\n * <Toolbar store={store}>\n *   <Role {...props}>Item</Role>\n * </Toolbar>\n * ```\n */\nexport const useToolbarItem = createHook<TagName, ToolbarItemOptions>(\n  function useToolbarItem({ store, ...props }) {\n    const context = useToolbarContext();\n    store = store || context;\n    props = useCompositeItem({ store, ...props });\n    return props;\n  },\n);\n\n/**\n * Renders an interactive element inside a\n * [`Toolbar`](https://ariakit.com/reference/toolbar).\n * @see https://ariakit.com/components/toolbar\n * @example\n * ```jsx {2}\n * <Toolbar>\n *   <ToolbarItem>Item</ToolbarItem>\n * </Toolbar>\n * ```\n */\nexport const ToolbarItem = memo(\n  forwardRef(function ToolbarItem(props: ToolbarItemProps) {\n    const htmlProps = useToolbarItem(props);\n    return createElement(TagName, htmlProps);\n  }),\n);\n\nexport interface ToolbarItemOptions<\n  T extends ElementType = TagName,\n> extends CompositeItemOptions<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 ToolbarItemProps<T extends ElementType = TagName> = Props<\n  T,\n  ToolbarItemOptions<T>\n>;\n"],"mappings":";;;;;;;;;;;;;;;;;;MA8BI,iBAAgB,WAAA,SAAkB,eAAA,EAAA,OAAA,GAAA,SAAA;CAClC,MAAA,UAAQ,kBAAS;CACjB,QAAQ,SAAA;SAAmB,iBAAA;EAAO;EAAU,GAAA;CAC5C,CAAA;CAEJ,OAAA;;;;;;;;;;;;;MAgBI,cAAO,KAAc,WADH,SAAA,YACqB,OAAA;CACxC,OACH,cAAA,SAAA,eAAA,KAAA,CAAA"}

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

@@ -0,0 +1,26 @@
+import { i as ToolbarStoreProps } from "../toolbar-store-Cs-9cGHx.js";
+import { ReactNode } from "react";
+
+//#region src/toolbar/toolbar-provider.d.ts
+/**
+ * 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>
+ * ```
+ */
+declare function ToolbarProvider(props?: ToolbarProviderProps): import("react/jsx-runtime").JSX.Element;
+interface ToolbarProviderProps extends ToolbarStoreProps {
+  children?: ReactNode;
+}
+//#endregion
+export { ToolbarProvider, ToolbarProviderProps };
+//# sourceMappingURL=toolbar-provider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"toolbar-provider.d.ts","names":["ReactNode","ToolbarStoreProps","ToolbarProvider","ToolbarProviderProps","props","JSX","Element","children"],"sources":["../../src/toolbar/toolbar-provider.d.ts"],"mappings":";;;;;;AAiBA;;;;;;;;;AAA8G;AAC9G;;;iBADwBE,eAAAA,CAAgBE,KAAAA,GAAQD,oBAAoB,+BAA+BE,GAAAA,CAAIC,OAAAA;AAAAA,UACtFH,oBAAAA,SAA6BF,iBAAiB;EAC3DM,QAAAA,GAAWP,SAAAA;AAAAA"}