@ariakit/react-components 0.1.0

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

@@ -0,0 +1,24 @@
+import { t as RadioStore } from "../radio-store-DOZ_1RSk.js";
+
+//#region src/radio/radio-context.d.ts
+/**
+ * Returns the radio store from the nearest radio container.
+ * @example
+ * function Radio() {
+ *   const store = useRadioContext();
+ *
+ *   if (!store) {
+ *     throw new Error("Radio must be wrapped in RadioProvider");
+ *   }
+ *
+ *   // Use the store...
+ * }
+ */
+declare const useRadioContext: () => RadioStore | undefined;
+declare const useRadioScopedContext: (onlyScoped?: boolean) => RadioStore | undefined;
+declare const useRadioProviderContext: () => RadioStore | undefined;
+declare const RadioContextProvider: (props: import("react").ProviderProps<RadioStore | undefined>) => import("react/jsx-runtime").JSX.Element;
+declare const RadioScopedContextProvider: (props: import("react").ProviderProps<RadioStore | undefined>) => import("react/jsx-runtime").JSX.Element;
+//#endregion
+export { RadioContextProvider, RadioScopedContextProvider, useRadioContext, useRadioProviderContext, useRadioScopedContext };
+//# sourceMappingURL=radio-context.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"radio-context.d.ts","names":["RadioStore","useRadioContext","useRadioScopedContext","onlyScoped","useRadioProviderContext","RadioContextProvider","ProviderProps","props","JSX","Element","RadioScopedContextProvider"],"sources":["../../src/radio/radio-context.d.ts"],"mappings":";;;;;AAcA;;;;AAAsD;AACtD;;;;AAAgF;AAChF;cAFqBC,eAAAA,QAAuBD,UAAU;AAAA,cACjCE,qBAAAA,GAAwBC,UAAAA,eAAyBH,UAAU;AAAA,cAC3DI,uBAAAA,QAA+BJ,UAAU;AAAA,cACzCK,oBAAAA,GAAuBE,KAAAA,kBAAuBD,aAAAA,CAAcN,UAAU,8CAA8CQ,GAAAA,CAAIC,OAAAA;AAAAA,cACxHC,0BAAAA,GAA6BH,KAAAA,kBAAuBD,aAAAA,CAAcN,UAAU,8CAA8CQ,GAAAA,CAAIC,OAAAA"}

package/dist/radio/radio-context.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"radio-context.js","names":[],"sources":["../../src/radio/radio-context.tsx"],"sourcesContent":["import { createStoreContext } from \"@ariakit/react-utils\";\nimport {\n  CompositeContextProvider,\n  CompositeScopedContextProvider,\n} from \"../composite/composite-context.tsx\";\nimport type { RadioStore } from \"./radio-store.ts\";\n\nconst ctx = createStoreContext<RadioStore>(\n  [CompositeContextProvider],\n  [CompositeScopedContextProvider],\n);\n\n/**\n * Returns the radio store from the nearest radio container.\n * @example\n * function Radio() {\n *   const store = useRadioContext();\n *\n *   if (!store) {\n *     throw new Error(\"Radio must be wrapped in RadioProvider\");\n *   }\n *\n *   // Use the store...\n * }\n */\nexport const useRadioContext = ctx.useContext;\n\nexport const useRadioScopedContext = ctx.useScopedContext;\n\nexport const useRadioProviderContext = ctx.useProviderContext;\n\nexport const RadioContextProvider = ctx.ContextProvider;\n\nexport const RadioScopedContextProvider = ctx.ScopedContextProvider;\n"],"mappings":";;;;;;;;;;;;;;;;;;AA2BA,MAAa,kBAAA,IAAA;AAEb,MAAa,wBAAA,IAA0B;AAEvC,MAAa,0BAAuB,IAAI;AAExC,MAAa,uBAAA,IAAA"}

package/dist/radio/radio-group.d.ts

@@ -0,0 +1,51 @@
+import { n as CompositeOptions } from "../composite-DLvyFHMq.js";
+import { t as RadioStore } from "../radio-store-DOZ_1RSk.js";
+import { Props } from "@ariakit/react-utils";
+import { ElementType } from "react";
+
+//#region src/radio/radio-group.d.ts
+declare const TagName = "div";
+type TagName = typeof TagName;
+/**
+ * Returns props to create a `RadioGroup` component.
+ * @see https://ariakit.com/components/radio
+ * @example
+ * ```jsx
+ * const store = useRadioStore();
+ * const props = useRadioGroup({ store });
+ * <Role {...props}>
+ *   <Radio value="Apple" />
+ *   <Radio value="Orange" />
+ * </Role>
+ * ```
+ */
+declare const useRadioGroup: import("@ariakit/react-utils").Hook<"div", RadioGroupOptions<"div">>;
+/**
+ * Renders a [`radiogroup`](https://w3c.github.io/aria/#radiogroup) element that
+ * manages a group of [`Radio`](https://ariakit.com/reference/radio) elements.
+ * @see https://ariakit.com/components/radio
+ * @example
+ * ```jsx
+ * <RadioProvider>
+ *   <RadioGroup>
+ *     <Radio value="Apple" />
+ *     <Radio value="Orange" />
+ *   </RadioGroup>
+ * </RadioProvider>
+ * ```
+ */
+declare const RadioGroup: (props: RadioGroupProps) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+interface RadioGroupOptions<T extends ElementType = TagName> extends CompositeOptions<T> {
+  /**
+   * Object returned by the
+   * [`useRadioStore`](https://ariakit.com/reference/use-radio-store) hook. If
+   * not provided, the closest
+   * [`RadioProvider`](https://ariakit.com/reference/radio-provider) component's
+   * context will be used.
+   */
+  store?: RadioStore;
+}
+type RadioGroupProps<T extends ElementType = TagName> = Props<T, RadioGroupOptions<T>>;
+//#endregion
+export { RadioGroup, RadioGroupOptions, RadioGroupProps, useRadioGroup };
+//# sourceMappingURL=radio-group.d.ts.map

package/dist/radio/radio-group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"radio-group.d.ts","names":["Props","ElementType","CompositeOptions","RadioStore","TagName","useRadioGroup","RadioGroupOptions","Hook","RadioGroup","RadioGroupProps","props","ReactElement","JSXElementConstructor","T","store"],"sources":["../../src/radio/radio-group.d.ts"],"mappings":";;;;;;cAIcI,OAAAA;AAAAA,KACTA,OAAAA,UAAiBA,OAAO;AAFsB;;;;AAC9B;AAAA;;;;AACQ;AAc7B;;;AAhBmD,cAgB9BC,aAAAA,iCAA8CE,IAAAA,QAAYD,iBAAiB;AAAA;AAehG;;;;;;;;;AAA6I;AAC7I;;;AAhBgG,cAe3EE,UAAAA,GAAaE,KAAAA,EAAOD,eAAe,qBAAqBE,YAAAA,+BAA2CC,qBAAAA;AAAAA,UACvGN,iBAAAA,WAA4BL,WAAAA,GAAcG,OAAAA,UAAiBF,gBAAAA,CAAiBW,CAAAA;EAAAA;;;;;;;EAQzFC,KAAAA,GAAQX,UAAAA;AAAAA;AAAAA,KAEAM,eAAAA,WAA0BR,WAAAA,GAAcG,OAAAA,IAAWJ,KAAAA,CAAMa,CAAAA,EAAGP,iBAAAA,CAAkBO,CAAAA"}

package/dist/radio/radio-group.js

@@ -0,0 +1,60 @@
+"use client";
+import { useComposite } from "../composite/composite.js";
+import { RadioScopedContextProvider, useRadioProviderContext } from "./radio-context.js";
+import { createElement, createHook, forwardRef, useWrapElement } from "@ariakit/react-utils";
+import { invariant } from "@ariakit/utils";
+import { jsx } from "react/jsx-runtime";
+//#region src/radio/radio-group.tsx
+const TagName = "div";
+/**
+* Returns props to create a `RadioGroup` component.
+* @see https://ariakit.com/components/radio
+* @example
+* ```jsx
+* const store = useRadioStore();
+* const props = useRadioGroup({ store });
+* <Role {...props}>
+*   <Radio value="Apple" />
+*   <Radio value="Orange" />
+* </Role>
+* ```
+*/
+const useRadioGroup = createHook(function useRadioGroup({ store, ...props }) {
+	const context = useRadioProviderContext();
+	store = store || context;
+	invariant(store, "RadioGroup must receive a `store` prop or be wrapped in a RadioProvider component.");
+	props = useWrapElement(props, (element) => /* @__PURE__ */ jsx(RadioScopedContextProvider, {
+		value: store,
+		children: element
+	}), [store]);
+	props = {
+		role: "radiogroup",
+		...props
+	};
+	props = useComposite({
+		store,
+		...props
+	});
+	return props;
+});
+/**
+* Renders a [`radiogroup`](https://w3c.github.io/aria/#radiogroup) element that
+* manages a group of [`Radio`](https://ariakit.com/reference/radio) elements.
+* @see https://ariakit.com/components/radio
+* @example
+* ```jsx
+* <RadioProvider>
+*   <RadioGroup>
+*     <Radio value="Apple" />
+*     <Radio value="Orange" />
+*   </RadioGroup>
+* </RadioProvider>
+* ```
+*/
+const RadioGroup = forwardRef(function RadioGroup(props) {
+	return createElement(TagName, useRadioGroup(props));
+});
+//#endregion
+export { RadioGroup, useRadioGroup };
+
+//# sourceMappingURL=radio-group.js.map

package/dist/radio/radio-group.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"radio-group.js","names":[],"sources":["../../src/radio/radio-group.tsx"],"sourcesContent":["import {\n  useWrapElement,\n  createElement,\n  createHook,\n  forwardRef,\n} from \"@ariakit/react-utils\";\nimport type { Props } from \"@ariakit/react-utils\";\nimport { invariant } from \"@ariakit/utils\";\nimport type { ElementType } from \"react\";\nimport type { CompositeOptions } from \"../composite/composite.tsx\";\nimport { useComposite } from \"../composite/composite.tsx\";\nimport {\n  RadioScopedContextProvider,\n  useRadioProviderContext,\n} from \"./radio-context.tsx\";\nimport type { RadioStore } from \"./radio-store.ts\";\n\nconst TagName = \"div\" satisfies ElementType;\ntype TagName = typeof TagName;\n\n/**\n * Returns props to create a `RadioGroup` component.\n * @see https://ariakit.com/components/radio\n * @example\n * ```jsx\n * const store = useRadioStore();\n * const props = useRadioGroup({ store });\n * <Role {...props}>\n *   <Radio value=\"Apple\" />\n *   <Radio value=\"Orange\" />\n * </Role>\n * ```\n */\nexport const useRadioGroup = createHook<TagName, RadioGroupOptions>(\n  function useRadioGroup({ store, ...props }) {\n    const context = useRadioProviderContext();\n    store = store || context;\n\n    invariant(\n      store,\n      process.env.NODE_ENV !== \"production\" &&\n        \"RadioGroup must receive a `store` prop or be wrapped in a RadioProvider component.\",\n    );\n\n    props = useWrapElement(\n      props,\n      (element) => (\n        <RadioScopedContextProvider value={store}>\n          {element}\n        </RadioScopedContextProvider>\n      ),\n      [store],\n    );\n\n    props = {\n      role: \"radiogroup\",\n      ...props,\n    };\n\n    props = useComposite({ store, ...props });\n\n    return props;\n  },\n);\n\n/**\n * Renders a [`radiogroup`](https://w3c.github.io/aria/#radiogroup) element that\n * manages a group of [`Radio`](https://ariakit.com/reference/radio) elements.\n * @see https://ariakit.com/components/radio\n * @example\n * ```jsx\n * <RadioProvider>\n *   <RadioGroup>\n *     <Radio value=\"Apple\" />\n *     <Radio value=\"Orange\" />\n *   </RadioGroup>\n * </RadioProvider>\n * ```\n */\nexport const RadioGroup = forwardRef(function RadioGroup(\n  props: RadioGroupProps,\n) {\n  const htmlProps = useRadioGroup(props);\n  return createElement(TagName, htmlProps);\n});\n\nexport interface RadioGroupOptions<\n  T extends ElementType = TagName,\n> extends CompositeOptions<T> {\n  /**\n   * Object returned by the\n   * [`useRadioStore`](https://ariakit.com/reference/use-radio-store) hook. If\n   * not provided, the closest\n   * [`RadioProvider`](https://ariakit.com/reference/radio-provider) component's\n   * context will be used.\n   */\n  store?: RadioStore;\n}\n\nexport type RadioGroupProps<T extends ElementType = TagName> = Props<\n  T,\n  RadioGroupOptions<T>\n>;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;MAmCI,gBAAgB,WAAA,SAAwB,cAAA,EAAA,OAAA,GAAA,SAAA;CACxC,MAAA,UAAQ,wBAAS;CAEjB,QAAA,SAGI;CAGJ,UAAQ,OAAA,oFAGJ;SAAmC,eAAA,QAAA,YAAA,oBAAA,4BAAA;;EAEP,UAGhC;CAEA,CAAA,GAAA,CAAA,KAAQ,CAAA;SACA;EACN,MAAG;EACL,GAAA;CAEA;SAAuB,aAAA;EAAO;EAAU,GAAA;CAExC,CAAA;CAEJ,OAAA;;;;;;;;;;;;;;;;MAoBE,aAAO,WAAc,SADH,WACoB,OAAC;CACxC,OAAA,cAAA,SAAA,cAAA,KAAA,CAAA"}

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

@@ -0,0 +1,25 @@
+import { i as RadioStoreProps } from "../radio-store-DOZ_1RSk.js";
+import { ReactNode } from "react";
+
+//#region src/radio/radio-provider.d.ts
+/**
+ * Provides a radio store to [Radio](https://ariakit.com/components/radio)
+ * components.
+ * @see https://ariakit.com/components/radio
+ * @example
+ * ```jsx
+ * <RadioProvider defaultValue="Apple">
+ *   <RadioGroup>
+ *     <Radio value="Apple" />
+ *     <Radio value="Orange" />
+ *   </RadioGroup>
+ * </RadioProvider>
+ * ```
+ */
+declare function RadioProvider(props?: RadioProviderProps): import("react/jsx-runtime").JSX.Element;
+interface RadioProviderProps extends RadioStoreProps {
+  children?: ReactNode;
+}
+//#endregion
+export { RadioProvider, RadioProviderProps };
+//# sourceMappingURL=radio-provider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"radio-provider.d.ts","names":["ReactNode","RadioStoreProps","RadioProvider","RadioProviderProps","props","JSX","Element","children"],"sources":["../../src/radio/radio-provider.d.ts"],"mappings":";;;;;;AAgBA;;;;;;;;;AAA0G;AAC1G;;iBADwBE,aAAAA,CAAcE,KAAAA,GAAQD,kBAAkB,+BAA+BE,GAAAA,CAAIC,OAAAA;AAAAA,UAClFH,kBAAAA,SAA2BF,eAAe;EACvDM,QAAAA,GAAWP,SAAAA;AAAAA"}

package/dist/radio/radio-provider.js

@@ -0,0 +1,29 @@
+"use client";
+import { RadioContextProvider } from "./radio-context.js";
+import { useRadioStore } from "./radio-store.js";
+import { jsx } from "react/jsx-runtime";
+//#region src/radio/radio-provider.tsx
+/**
+* Provides a radio store to [Radio](https://ariakit.com/components/radio)
+* components.
+* @see https://ariakit.com/components/radio
+* @example
+* ```jsx
+* <RadioProvider defaultValue="Apple">
+*   <RadioGroup>
+*     <Radio value="Apple" />
+*     <Radio value="Orange" />
+*   </RadioGroup>
+* </RadioProvider>
+* ```
+*/
+function RadioProvider(props = {}) {
+	return /* @__PURE__ */ jsx(RadioContextProvider, {
+		value: useRadioStore(props),
+		children: props.children
+	});
+}
+//#endregion
+export { RadioProvider };
+
+//# sourceMappingURL=radio-provider.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"radio-provider.js","names":[],"sources":["../../src/radio/radio-provider.tsx"],"sourcesContent":["import type { ReactNode } from \"react\";\nimport { RadioContextProvider } from \"./radio-context.tsx\";\nimport type { RadioStoreProps } from \"./radio-store.ts\";\nimport { useRadioStore } from \"./radio-store.ts\";\n\n/**\n * Provides a radio store to [Radio](https://ariakit.com/components/radio)\n * components.\n * @see https://ariakit.com/components/radio\n * @example\n * ```jsx\n * <RadioProvider defaultValue=\"Apple\">\n *   <RadioGroup>\n *     <Radio value=\"Apple\" />\n *     <Radio value=\"Orange\" />\n *   </RadioGroup>\n * </RadioProvider>\n * ```\n */\nexport function RadioProvider(props: RadioProviderProps = {}) {\n  const store = useRadioStore(props);\n  return (\n    <RadioContextProvider value={store}>{props.children}</RadioContextProvider>\n  );\n}\n\nexport interface RadioProviderProps extends RadioStoreProps {\n  children?: ReactNode;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;SAsBI,cAAA,QAAC,CAAA,GAAA;QAFyB,oBAEO,sBAAA;uBAAU,KAAA;EAA+B,UAAA,MAAA;CAE9E,CAAA"}

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

@@ -0,0 +1,2 @@
+import { a as RadioStoreState, i as RadioStoreProps, n as RadioStoreFunctions, o as useRadioStore, r as RadioStoreOptions, s as useRadioStoreProps, t as RadioStore } from "../radio-store-DOZ_1RSk.js";
+export { RadioStore, RadioStoreFunctions, RadioStoreOptions, RadioStoreProps, RadioStoreState, useRadioStore, useRadioStoreProps };

package/dist/radio/radio-store.js

@@ -0,0 +1,33 @@
+"use client";
+import { useCompositeStoreOptions, useCompositeStoreProps } from "../composite/composite-store.js";
+import { useStore, useStoreProps } from "@ariakit/react-store";
+import * as Core from "@ariakit/components/radio/radio-store";
+//#region src/radio/radio-store.ts
+function useRadioStoreProps(store, update, props) {
+	store = useCompositeStoreProps(store, update, props);
+	useStoreProps(store, props, "value", "setValue");
+	return store;
+}
+/**
+* Creates a radio store to control the state of
+* [Radio](https://ariakit.com/components/radio) components.
+* @see https://ariakit.com/components/radio
+* @example
+* ```jsx
+* const radio = useRadioStore();
+*
+* <RadioGroup store={radio}>
+*   <Radio value="Apple" />
+*   <Radio value="Orange" />
+* </RadioGroup>
+* ```
+*/
+function useRadioStore(props = {}) {
+	props = useCompositeStoreOptions(props);
+	const [store, update] = useStore(Core.createRadioStore, props);
+	return useRadioStoreProps(store, update, props);
+}
+//#endregion
+export { useRadioStore, useRadioStoreProps };
+
+//# sourceMappingURL=radio-store.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"radio-store.js","names":[],"sources":["../../src/radio/radio-store.ts"],"sourcesContent":["import * as Core from \"@ariakit/components/radio/radio-store\";\nimport { useStore, useStoreProps } 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 {\n  useCompositeStoreOptions,\n  useCompositeStoreProps,\n} from \"../composite/composite-store.ts\";\n\nexport function useRadioStoreProps<T extends Core.RadioStore>(\n  store: T,\n  update: () => void,\n  props: RadioStoreProps,\n) {\n  store = useCompositeStoreProps(store, update, props);\n  useStoreProps(store, props, \"value\", \"setValue\");\n  return store;\n}\n\n/**\n * Creates a radio store to control the state of\n * [Radio](https://ariakit.com/components/radio) components.\n * @see https://ariakit.com/components/radio\n * @example\n * ```jsx\n * const radio = useRadioStore();\n *\n * <RadioGroup store={radio}>\n *   <Radio value=\"Apple\" />\n *   <Radio value=\"Orange\" />\n * </RadioGroup>\n * ```\n */\nexport function useRadioStore(props: RadioStoreProps = {}): RadioStore {\n  props = useCompositeStoreOptions(props);\n  const [store, update] = useStore(Core.createRadioStore, props);\n  return useRadioStoreProps(store, update, props);\n}\n\nexport interface RadioStoreState\n  extends Core.RadioStoreState, CompositeStoreState {}\n\nexport interface RadioStoreFunctions\n  extends Core.RadioStoreFunctions, CompositeStoreFunctions {}\n\nexport interface RadioStoreOptions\n  extends Core.RadioStoreOptions, CompositeStoreOptions {\n  /**\n   * Function that will be called when the\n   * [`value`](https://ariakit.com/reference/radio-provider#value) state\n   * changes.\n   */\n  setValue?: (value: RadioStoreState[\"value\"]) => void;\n}\n\nexport interface RadioStoreProps\n  extends RadioStoreOptions, Core.RadioStoreProps {}\n\nexport interface RadioStore\n  extends RadioStoreFunctions, Store<Core.RadioStore> {}\n"],"mappings":";;;;;SAkBU,mBAAA,OAAuB,QAAO,OAAQ;CAC9C,QAAA,uBAA4B,OAAS,QAAA,KAAU;CAC/C,cAAO,OAAA,OAAA,SAAA,UAAA;CACT,OAAA;;;;;;;;;;;;;;;;SAiBU,cAAA,QAAA,CAAA,GAAyB;CACjC,QAAO,yBAA0B,KAAK;CACtC,MAAA,CAAO,OAAA,UAAA,SAA0B,KAAA,kBAAa,KAAA;CAChD,OAAA,mBAAA,OAAA,QAAA,KAAA"}

package/dist/radio/radio.d.ts

@@ -0,0 +1,76 @@
+import { n as CompositeItemOptions } from "../composite-item-B4WTelVz.js";
+import { t as RadioStore } from "../radio-store-DOZ_1RSk.js";
+import { Props } from "@ariakit/react-utils";
+import { ChangeEvent, ElementType } from "react";
+import { BivariantCallback } from "@ariakit/utils";
+
+//#region src/radio/radio.d.ts
+declare const TagName = "input";
+type TagName = typeof TagName;
+type HTMLType = HTMLElementTagNameMap[TagName];
+/**
+ * Returns props to create a `Radio` component.
+ * @see https://ariakit.com/components/radio
+ * @example
+ * ```jsx
+ * const store = useRadioStore();
+ * const props = useRadio({ store, value: "Apple" });
+ * <RadioGroup store={store}>
+ *   <Role {...props} render={<input />} />
+ *   <Radio value="Orange" />
+ * </RadioGroup>
+ * ```
+ */
+declare const useRadio: import("@ariakit/react-utils").Hook<"input", RadioOptions<"input">>;
+/**
+ * Renders a radio button element that's typically wrapped in a
+ * [`RadioGroup`](https://ariakit.com/reference/radio-group) component.
+ * @see https://ariakit.com/components/radio
+ * @example
+ * ```jsx {3-4}
+ * <RadioProvider>
+ *   <RadioGroup>
+ *     <Radio value="Apple" />
+ *     <Radio value="Orange" />
+ *   </RadioGroup>
+ * </RadioProvider>
+ * ```
+ */
+declare const Radio: (props: RadioProps) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+interface RadioOptions<T extends ElementType = TagName> extends CompositeItemOptions<T> {
+  /**
+   * Object returned by the
+   * [`useRadioStore`](https://ariakit.com/reference/use-radio-store) hook. If
+   * not provided, the closest
+   * [`RadioGroup`](https://ariakit.com/reference/radio-group) or
+   * [`RadioProvider`](https://ariakit.com/reference/radio-provider) components'
+   * context will be used.
+   */
+  store?: RadioStore;
+  /**
+   * The value of the radio button.
+   *
+   * Live examples:
+   * - [FormRadio](https://ariakit.com/examples/form-radio)
+   * - [MenuItemRadio](https://ariakit.com/examples/menu-item-radio)
+   */
+  value: string | number;
+  /**
+   * The native `name` attribute.
+   */
+  name?: string;
+  /**
+   * Determines if the radio button is checked. Using this prop will make the
+   * radio button controlled and override the
+   * [`value`](https://ariakit.com/reference/radio-provider#value) state.
+   */
+  checked?: boolean;
+  /**
+   * Callback function that is called when the radio button state changes.
+   */
+  onChange?: BivariantCallback<(event: ChangeEvent<HTMLType>) => void>;
+}
+type RadioProps<T extends ElementType = TagName> = Props<T, RadioOptions<T>>;
+//#endregion
+export { Radio, RadioOptions, RadioProps, useRadio };
+//# sourceMappingURL=radio.d.ts.map

package/dist/radio/radio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"radio.d.ts","names":["Props","BivariantCallback","ChangeEvent","ElementType","CompositeItemOptions","RadioStore","TagName","HTMLType","HTMLElementTagNameMap","useRadio","RadioOptions","Hook","Radio","RadioProps","props","ReactElement","JSXElementConstructor","T","store","value","name","checked","onChange","event"],"sources":["../../src/radio/radio.d.ts"],"mappings":";;;;;;;cAKcM,OAAAA;AAAAA,KACTA,OAAAA,UAAiBA,OAAO;AAAA,KACxBC,QAAAA,GAAWC,qBAAAA,CAAsBF,OAAO;;;;AAFxB;AAAA;;;;AACQ;AAAA;;;;cAeRG,QAAAA,iCAAyCE,IAAAA,UAAcD,YAAY;AAAxF;;;;AAAwF;AAexF;;;;;;;;;AAfA,cAeqBE,KAAAA,GAAQE,KAAAA,EAAOD,UAAU,qBAAqBE,YAAAA,+BAA2CC,qBAAAA;AAAAA,UAC7FN,YAAAA,WAAuBP,WAAAA,GAAcG,OAAAA,UAAiBF,oBAAAA,CAAqBa,CAAAA;EAA/D;;;;;;;;EASzBC,KAAAA,GAAQb,UAAAA;EAT2DD;;;;;;;EAiBnEe,KAAAA;EARAD;;;EAYAE,IAAAA;EAMAC;;;;;EAAAA,OAAAA;EAI0D;AAAA;AAE9D;EAFIC,QAAAA,GAAWrB,iBAAAA,EAAmBsB,KAAAA,EAAOrB,WAAAA,CAAYK,QAAAA;AAAAA;AAAAA,KAEzCM,UAAAA,WAAqBV,WAAAA,GAAcG,OAAAA,IAAWN,KAAAA,CAAMiB,CAAAA,EAAGP,YAAAA,CAAaO,CAAAA"}

package/dist/radio/radio.js

@@ -0,0 +1,143 @@
+"use client";
+import { useCompositeItem } from "../composite/composite-item.js";
+import { useRadioContext } from "./radio-context.js";
+import { createElement, createHook, forwardRef, memo, useEvent, useForceUpdate, useId, useMergeRefs, useTagName } from "@ariakit/react-utils";
+import { disabledFromProps, removeUndefinedValues } from "@ariakit/utils";
+import { useEffect, useRef } from "react";
+import { useStoreState } from "@ariakit/react-store";
+//#region src/radio/radio.tsx
+const TagName = "input";
+function getIsChecked(value, storeValue) {
+	if (storeValue === void 0) return;
+	if (value != null && storeValue != null) return storeValue === value;
+	return !!storeValue;
+}
+function isNativeRadio(tagName, type) {
+	return tagName === "input" && (!type || type === "radio");
+}
+/**
+* Returns props to create a `Radio` component.
+* @see https://ariakit.com/components/radio
+* @example
+* ```jsx
+* const store = useRadioStore();
+* const props = useRadio({ store, value: "Apple" });
+* <RadioGroup store={store}>
+*   <Role {...props} render={<input />} />
+*   <Radio value="Orange" />
+* </RadioGroup>
+* ```
+*/
+const useRadio = createHook(function useRadio({ store, name: nameProp, value, checked, ...props }) {
+	const context = useRadioContext();
+	store = store || context;
+	const id = useId(props.id);
+	const ref = useRef(null);
+	const isChecked = useStoreState(store, (state) => checked ?? getIsChecked(value, state?.value));
+	const storeId = useStoreState(store, (state) => state?.id);
+	const name = nameProp ?? storeId;
+	useEffect(() => {
+		if (!id) return;
+		if (!isChecked) return;
+		if (store?.getState().activeId === id) return;
+		store?.setActiveId(id);
+	}, [
+		store,
+		isChecked,
+		id
+	]);
+	const onChangeProp = props.onChange;
+	const nativeRadio = isNativeRadio(useTagName(ref, TagName), props.type);
+	const disabled = disabledFromProps(props);
+	const [propertyUpdated, schedulePropertyUpdate] = useForceUpdate();
+	useEffect(() => {
+		const element = ref.current;
+		if (!element) return;
+		if (nativeRadio) return;
+		if (isChecked !== void 0) element.checked = isChecked;
+		if (name !== void 0) element.name = name;
+		if (value !== void 0) element.value = `${value}`;
+	}, [
+		propertyUpdated,
+		nativeRadio,
+		isChecked,
+		name,
+		value
+	]);
+	const onChange = useEvent((event) => {
+		if (disabled) {
+			event.preventDefault();
+			event.stopPropagation();
+			return;
+		}
+		if (store?.getState().value === value) return;
+		if (!nativeRadio) {
+			event.currentTarget.checked = true;
+			schedulePropertyUpdate();
+		}
+		onChangeProp?.(event);
+		if (event.defaultPrevented) return;
+		store?.setValue(value);
+	});
+	const onClickProp = props.onClick;
+	const onClick = useEvent((event) => {
+		onClickProp?.(event);
+		if (event.defaultPrevented) return;
+		if (nativeRadio) return;
+		onChange(event);
+	});
+	const onFocusProp = props.onFocus;
+	const onFocus = useEvent((event) => {
+		onFocusProp?.(event);
+		if (event.defaultPrevented) return;
+		if (!nativeRadio) return;
+		if (!store) return;
+		const { moves, activeId } = store.getState();
+		if (!moves) return;
+		if (id && activeId !== id) return;
+		onChange(event);
+	});
+	props = {
+		role: !nativeRadio ? "radio" : void 0,
+		type: nativeRadio ? "radio" : void 0,
+		"aria-checked": isChecked,
+		...props,
+		id,
+		ref: useMergeRefs(ref, props.ref),
+		onChange,
+		onClick,
+		onFocus
+	};
+	props = useCompositeItem({
+		store,
+		clickOnEnter: !nativeRadio,
+		...props
+	});
+	return removeUndefinedValues({
+		name: nativeRadio ? name : void 0,
+		value: nativeRadio ? value : void 0,
+		checked: isChecked,
+		...props
+	});
+});
+/**
+* Renders a radio button element that's typically wrapped in a
+* [`RadioGroup`](https://ariakit.com/reference/radio-group) component.
+* @see https://ariakit.com/components/radio
+* @example
+* ```jsx {3-4}
+* <RadioProvider>
+*   <RadioGroup>
+*     <Radio value="Apple" />
+*     <Radio value="Orange" />
+*   </RadioGroup>
+* </RadioProvider>
+* ```
+*/
+const Radio = memo(forwardRef(function Radio(props) {
+	return createElement(TagName, useRadio(props));
+}));
+//#endregion
+export { Radio, useRadio };
+
+//# sourceMappingURL=radio.js.map

package/dist/radio/radio.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"radio.js","names":[],"sources":["../../src/radio/radio.tsx"],"sourcesContent":["import { useStoreState } from \"@ariakit/react-store\";\nimport {\n  useEvent,\n  useForceUpdate,\n  useId,\n  useMergeRefs,\n  useTagName,\n  createElement,\n  createHook,\n  forwardRef,\n  memo,\n} from \"@ariakit/react-utils\";\nimport type { Props } from \"@ariakit/react-utils\";\nimport { disabledFromProps, removeUndefinedValues } from \"@ariakit/utils\";\nimport type { BivariantCallback } from \"@ariakit/utils\";\nimport type { ChangeEvent, ElementType, FocusEvent, MouseEvent } from \"react\";\nimport { useEffect, useRef } from \"react\";\nimport type { CompositeItemOptions } from \"../composite/composite-item.tsx\";\nimport { useCompositeItem } from \"../composite/composite-item.tsx\";\nimport { useRadioContext } from \"./radio-context.tsx\";\nimport type { RadioStore, RadioStoreState } from \"./radio-store.ts\";\n\nconst TagName = \"input\" satisfies ElementType;\ntype TagName = typeof TagName;\ntype HTMLType = HTMLElementTagNameMap[TagName];\n\nfunction getIsChecked(\n  value: RadioOptions[\"value\"],\n  storeValue?: RadioStoreState[\"value\"],\n) {\n  if (storeValue === undefined) return;\n  if (value != null && storeValue != null) {\n    return storeValue === value;\n  }\n  return !!storeValue;\n}\n\nfunction isNativeRadio(tagName?: string, type?: string) {\n  return tagName === \"input\" && (!type || type === \"radio\");\n}\n\n/**\n * Returns props to create a `Radio` component.\n * @see https://ariakit.com/components/radio\n * @example\n * ```jsx\n * const store = useRadioStore();\n * const props = useRadio({ store, value: \"Apple\" });\n * <RadioGroup store={store}>\n *   <Role {...props} render={<input />} />\n *   <Radio value=\"Orange\" />\n * </RadioGroup>\n * ```\n */\nexport const useRadio = createHook<TagName, RadioOptions>(function useRadio({\n  store,\n  name: nameProp,\n  value,\n  checked,\n  ...props\n}) {\n  const context = useRadioContext();\n  store = store || context;\n\n  const id = useId(props.id);\n\n  const ref = useRef<HTMLType>(null);\n  const isChecked = useStoreState(\n    store,\n    (state) => checked ?? getIsChecked(value, state?.value),\n  );\n\n  // Use the store's id as the default name to ensure radios in different\n  // groups have unique names. This prevents the browser from treating all\n  // radios as a single group. See https://github.com/ariakit/ariakit/issues/3833\n  const storeId = useStoreState(store, (state) => state?.id);\n  const name = nameProp ?? storeId;\n\n  // When the radio store has a default value, we need to update the active id\n  // to point to the checked element, otherwise it'll be the first item in the\n  // list. TODO: Maybe this could be done in the radio store directly?\n  useEffect(() => {\n    if (!id) return;\n    if (!isChecked) return;\n    const isActiveItem = store?.getState().activeId === id;\n    if (isActiveItem) return;\n    store?.setActiveId(id);\n  }, [store, isChecked, id]);\n\n  const onChangeProp = props.onChange;\n  const tagName = useTagName(ref, TagName);\n  const nativeRadio = isNativeRadio(tagName, props.type);\n  const disabled = disabledFromProps(props);\n  // When the checked property is programmatically set on the change event, we\n  // need to schedule the element's property update, so the controlled\n  // isChecked state can be taken into account.\n  const [propertyUpdated, schedulePropertyUpdate] = useForceUpdate();\n\n  useEffect(() => {\n    const element = ref.current;\n    if (!element) return;\n    if (nativeRadio) return;\n    if (isChecked !== undefined) {\n      element.checked = isChecked;\n    }\n    if (name !== undefined) {\n      element.name = name;\n    }\n    if (value !== undefined) {\n      element.value = `${value}`;\n    }\n  }, [propertyUpdated, nativeRadio, isChecked, name, value]);\n\n  const onChange = useEvent((event: ChangeEvent<HTMLType>) => {\n    if (disabled) {\n      event.preventDefault();\n      event.stopPropagation();\n      return;\n    }\n    // Do not call onChange if the value is the same as the current value. See\n    // https://github.com/ariakit/ariakit/issues/3771\n    if (store?.getState().value === value) return;\n    if (!nativeRadio) {\n      event.currentTarget.checked = true;\n      schedulePropertyUpdate();\n    }\n    onChangeProp?.(event);\n    if (event.defaultPrevented) return;\n    store?.setValue(value);\n  });\n\n  const onClickProp = props.onClick;\n\n  const onClick = useEvent((event: MouseEvent<HTMLType>) => {\n    onClickProp?.(event);\n    if (event.defaultPrevented) return;\n    if (nativeRadio) return;\n    // @ts-expect-error The onChange event expects a ChangeEvent, but here we\n    // need to pass a MouseEvent.\n    onChange(event);\n  });\n\n  const onFocusProp = props.onFocus;\n\n  const onFocus = useEvent((event: FocusEvent<HTMLType>) => {\n    onFocusProp?.(event);\n    if (event.defaultPrevented) return;\n    if (!nativeRadio) return;\n    if (!store) return;\n    const { moves, activeId } = store.getState();\n    if (!moves) return;\n    if (id && activeId !== id) return;\n    onChange(event);\n  });\n\n  props = {\n    role: !nativeRadio ? \"radio\" : undefined,\n    type: nativeRadio ? \"radio\" : undefined,\n    \"aria-checked\": isChecked,\n    ...props,\n    id,\n    ref: useMergeRefs(ref, props.ref),\n    onChange,\n    onClick,\n    onFocus,\n  };\n\n  props = useCompositeItem<TagName>({\n    store,\n    clickOnEnter: !nativeRadio,\n    ...props,\n  });\n\n  return removeUndefinedValues({\n    name: nativeRadio ? name : undefined,\n    value: nativeRadio ? value : undefined,\n    checked: isChecked,\n    ...props,\n  });\n});\n\n/**\n * Renders a radio button element that's typically wrapped in a\n * [`RadioGroup`](https://ariakit.com/reference/radio-group) component.\n * @see https://ariakit.com/components/radio\n * @example\n * ```jsx {3-4}\n * <RadioProvider>\n *   <RadioGroup>\n *     <Radio value=\"Apple\" />\n *     <Radio value=\"Orange\" />\n *   </RadioGroup>\n * </RadioProvider>\n * ```\n */\nexport const Radio = memo(\n  forwardRef(function Radio(props: RadioProps) {\n    const htmlProps = useRadio(props);\n    return createElement(TagName, htmlProps);\n  }),\n);\n\nexport interface RadioOptions<\n  T extends ElementType = TagName,\n> extends CompositeItemOptions<T> {\n  /**\n   * Object returned by the\n   * [`useRadioStore`](https://ariakit.com/reference/use-radio-store) hook. If\n   * not provided, the closest\n   * [`RadioGroup`](https://ariakit.com/reference/radio-group) or\n   * [`RadioProvider`](https://ariakit.com/reference/radio-provider) components'\n   * context will be used.\n   */\n  store?: RadioStore;\n  /**\n   * The value of the radio button.\n   *\n   * Live examples:\n   * - [FormRadio](https://ariakit.com/examples/form-radio)\n   * - [MenuItemRadio](https://ariakit.com/examples/menu-item-radio)\n   */\n  value: string | number;\n  /**\n   * The native `name` attribute.\n   */\n  name?: string;\n  /**\n   * Determines if the radio button is checked. Using this prop will make the\n   * radio button controlled and override the\n   * [`value`](https://ariakit.com/reference/radio-provider#value) state.\n   */\n  checked?: boolean;\n  /**\n   * Callback function that is called when the radio button state changes.\n   */\n  onChange?: BivariantCallback<(event: ChangeEvent<HTMLType>) => void>;\n}\n\nexport type RadioProps<T extends ElementType = TagName> = Props<\n  T,\n  RadioOptions<T>\n>;\n"],"mappings":";;;;;;;;AA0BA,MAAA,UAAS;SAIH,aAAe,OAAW,YAAA;CAC9B,IAAI,eAAS,KAAQ,GAAA;CAGrB,IAAA,SAAS,QAAA,cAAA,MAAA,OAAA,eAAA;CACX,OAAA,CAAA,CAAA;AAEA;SACS,cAAY,SAAY,MAAC;CAClC,OAAA,YAAA,YAAA,CAAA,QAAA,SAAA;;;;;;;;;;;;;;;MAsBE,WAAgB,WAAA,SAAgB,SAAA,EAAA,OAAA,MAAA,UAAA,OAAA,SAAA,GAAA,SAAA;CAChC,MAAA,UAAQ,gBAAS;CAEjB,QAAM,SAAW;CAEjB,MAAM,KAAA,MAAM,MAAqB,EAAA;CACjC,MAAM,MAAA,OAAY,IAAA;CAQlB,MAAM,YAAU,cAAc,QAAQ,UAAU,WAAS,aAAA,OAAA,OAAA,KAAA,CAAA;CACzD,MAAM,UAAO,cAAY,QAAA,UAAA,OAAA,EAAA;CAKzB,MAAA,OAAA,YAAgB;iBACL;EACT,IAAI,CAAC,IAAA;EAEL,IADqB,CAAA,WAAO;EAE5B,IAAA,OAAO,SAAY,EAAE,aAAA,IAAA;EACvB,OAAG,YAAA,EAAA;IAAC;EAAO;EAAW;EAAG;CAEzB,CAAA;CAEA,MAAM,eAAc,MAAA;CACpB,MAAM,cAAW,cAAA,WAAuB,KAAA,OAAA,GAAA,MAAA,IAAA;CAIxC,MAAM,WAAC,kBAAiB,KAAA;CAExB,MAAA,CAAA,iBAAgB,0BAAA,eAAA;iBACR;EACN,MAAK,UAAS,IAAA;EACd,IAAI,CAAA,SAAA;EACJ,IAAI,aAAA;EAGJ,IAAI,cAAS,KACX,GAAA,QAAQ,UAAO;EAEjB,IAAI,SAAA,KAAU,GAAA,QACZ,OAAQ;EAEZ,IAAG,UAAA,KAAA,GAAA,QAAA,QAAA,GAAA;IAAC;EAAiB;EAAa;EAAW;EAAM;EAAM;CAEzD,CAAA;OACM,WAAU,UAAA,UAAA;MACZ,UAAM;GACN,MAAM,eAAA;GACN,MAAA,gBAAA;GACF;EAGA;EACA,IAAI,OAAC,SAAa,EAAA,UAAA,OAAA;MAChB,CAAA,aAAM;GACN,MAAA,cAAA,UAAuB;GACzB,uBAAA;EACA;EACA,eAAU,KAAA;EACV,IAAA,MAAO,kBAAc;EACtB,OAAA,SAAA,KAAA;CAED,CAAA;CAEA,MAAM,cAAU,MAAU;OACxB,UAAc,UAAK,UAAA;EACnB,cAAU,KAAA;EACV,IAAI,MAAA,kBAAa;EAGjB,IAAA,aAAc;EACf,SAAA,KAAA;CAED,CAAA;CAEA,MAAM,cAAU,MAAU;OACxB,UAAc,UAAK,UAAA;EACnB,cAAU,KAAA;EACV,IAAI,MAAC,kBAAa;EAClB,IAAI,CAAC,aAAO;EACZ,IAAA,CAAA,OAAQ;EACR,MAAK,EAAA,OAAO,aAAA,MAAA,SAAA;EACZ,IAAI,CAAA,OAAM;EACV,IAAA,MAAS,aAAK,IAAA;EACf,SAAA,KAAA;CAED,CAAA;SACS;EACP,MAAM,CAAA,cAAc,UAAU,KAAA;EAC9B,MAAA,cAAgB,UAAA,KAAA;EAChB,gBAAG;EACH,GAAA;EACA;EACA,KAAA,aAAA,KAAA,MAAA,GAAA;EACA;EACA;EACF;CAEA;SACE,iBAAA;EACA;EACA,cAAG,CAAA;EACJ,GAAA;CAED,CAAA;QACQ,sBAAqB;EAC3B,MAAA,cAAO,OAAc,KAAQ;EAC7B,OAAA,cAAS,QAAA,KAAA;EACT,SAAG;EACJ,GAAA;CACF,CAAA;;;;;;;;;;;;;;;;MAmBG,QAAO,KAAA,WAAc,SADH,MACoB,OAAC;CACxC,OACH,cAAA,SAAA,SAAA,KAAA,CAAA"}

package/dist/radio-store-DOZ_1RSk.d.ts

@@ -0,0 +1,36 @@
+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/radio/radio-store";
+
+//#region src/radio/radio-store.d.ts
+declare function useRadioStoreProps<T extends Core.RadioStore>(store: T, update: () => void, props: RadioStoreProps): T;
+/**
+ * Creates a radio store to control the state of
+ * [Radio](https://ariakit.com/components/radio) components.
+ * @see https://ariakit.com/components/radio
+ * @example
+ * ```jsx
+ * const radio = useRadioStore();
+ *
+ * <RadioGroup store={radio}>
+ *   <Radio value="Apple" />
+ *   <Radio value="Orange" />
+ * </RadioGroup>
+ * ```
+ */
+declare function useRadioStore(props?: RadioStoreProps): RadioStore;
+interface RadioStoreState extends Core.RadioStoreState, CompositeStoreState {}
+interface RadioStoreFunctions extends Core.RadioStoreFunctions, CompositeStoreFunctions {}
+interface RadioStoreOptions extends Core.RadioStoreOptions, CompositeStoreOptions {
+  /**
+   * Function that will be called when the
+   * [`value`](https://ariakit.com/reference/radio-provider#value) state
+   * changes.
+   */
+  setValue?: (value: RadioStoreState["value"]) => void;
+}
+interface RadioStoreProps extends RadioStoreOptions, Core.RadioStoreProps {}
+interface RadioStore extends RadioStoreFunctions, Store<Core.RadioStore> {}
+//#endregion
+export { RadioStoreState as a, RadioStoreProps as i, RadioStoreFunctions as n, useRadioStore as o, RadioStoreOptions as r, useRadioStoreProps as s, RadioStore as t };
+//# sourceMappingURL=radio-store-DOZ_1RSk.d.ts.map

package/dist/radio-store-DOZ_1RSk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"radio-store-DOZ_1RSk.d.ts","names":["Core","Store","CompositeStoreFunctions","CompositeStoreOptions","CompositeStoreState","useRadioStoreProps","T","RadioStore","RadioStoreProps","store","update","props","useRadioStore","RadioStoreState","RadioStoreFunctions","RadioStoreOptions","setValue","value"],"sources":["../src/radio/radio-store.d.ts"],"mappings":";;;;;iBAGwBK,kBAAAA,WAA6BL,IAAAA,CAAKO,UAAAA,CAAAA,CAAYE,KAAAA,EAAOH,CAAAA,EAAGI,MAAAA,cAAoBC,KAAAA,EAAOH,eAAAA,GAAkBF,CAAAA;;AAA7H;;;;;;;;;;;;;iBAewBM,aAAAA,CAAcD,KAAAA,GAAQH,eAAAA,GAAkBD,UAAU;AAAA,UACzDM,eAAAA,SAAwBb,IAAAA,CAAKa,eAAAA,EAAiBT,mBAAmB;AAAA,UAEjEU,mBAAAA,SAA4Bd,IAAAA,CAAKc,mBAAAA,EAAqBZ,uBAAuB;AAAA,UAE7Ea,iBAAAA,SAA0Bf,IAAAA,CAAKe,iBAAAA,EAAmBZ,qBAAAA;EApB2D;AAe9H;;;;EAWIa,QAAAA,IAAYC,KAAAA,EAAOJ,eAAAA;AAAAA;AAAAA,UAENL,eAAAA,SAAwBO,iBAAAA,EAAmBf,IAAAA,CAAKQ,eAAe;AAAA,UAE/DD,UAAAA,SAAmBO,mBAAAA,EAAqBb,KAAAA,CAAMD,IAAAA,CAAKO,UAAAA"}

package/dist/role/role.d.ts

@@ -0,0 +1,34 @@
+import { Options, Props } from "@ariakit/react-utils";
+import { ElementType, FC } from "react";
+
+//#region src/role/role.d.ts
+declare const TagName = "div";
+type TagName = typeof TagName;
+declare const elements: readonly ["a", "button", "details", "dialog", "div", "form", "h1", "h2", "h3", "h4", "h5", "h6", "header", "img", "input", "label", "li", "nav", "ol", "p", "section", "select", "span", "summary", "textarea", "ul", "svg"];
+type RoleElements = { [K in (typeof elements)[number]]: FC<RoleProps<K>> };
+/**
+ * Returns props to create a `Role` component.
+ * @see https://ariakit.com/components/role
+ * @example
+ * ```jsx
+ * const props = useRole();
+ * <Role {...props} />
+ * ```
+ */
+declare const useRole: import("@ariakit/react-utils").Hook<"div", RoleOptions<"div">>;
+/**
+ * Renders an abstract element that supports the `render` prop and a
+ * `wrapElement` prop that can be used to wrap the underlying element with React
+ * Portal, Context or other component types.
+ * @see https://ariakit.com/components/role
+ * @example
+ * ```jsx
+ * <Role render={<div />} />
+ * ```
+ */
+declare const Role: FC<RoleProps> & RoleElements;
+interface RoleOptions<_T extends ElementType = TagName> extends Options {}
+type RoleProps<T extends ElementType = TagName> = Props<T, RoleOptions<T>>;
+//#endregion
+export { Role, RoleOptions, RoleProps, useRole };
+//# sourceMappingURL=role.d.ts.map

package/dist/role/role.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"role.d.ts","names":["Options","Props","ElementType","FC","TagName","elements","RoleElements","K","RoleProps","useRole","RoleOptions","Hook","Role","_T","T"],"sources":["../../src/role/role.d.ts"],"mappings":";;;;cAEcI,OAAAA;AAAAA,KACTA,OAAAA,UAAiBA,OAAO;AAAA,cACfC,QAAAA;AAAAA,KACTC,YAAAA,mBACaD,QAAAA,YAAoBF,EAAAA,CAAGK,SAAAA,CAAUD,CAAAA;AAJ9B;AAAA;;;;AACQ;AAAA;;;AADR,cAeAE,OAAAA,iCAAwCE,IAAAA,QAAYD,WAAW;AAbgK;AAAA;;;;;;;;;AAAA,cAwB/NE,IAAAA,EAAMT,EAAAA,CAAGK,SAAAA,IAAaF,YAAAA;AAAAA,UAC1BI,WAAAA,YAAuBR,WAAAA,GAAcE,OAAAA,UAAiBJ,OAAAA;AAAAA,KAE3DQ,SAAAA,WAAoBN,WAAAA,GAAcE,OAAAA,IAAWH,KAAAA,CAAMa,CAAAA,EAAGJ,WAAAA,CAAYI,CAAAA"}