@ariakit/react-core 0.3.12 → 0.3.14

package/esm/composite/composite-overflow.js

@@ -1,10 +1,10 @@
 "use client";
 import {
   usePopover
-} from "../__chunks/A6XC27R5.js";
-import "../__chunks/PGAEII2Q.js";
+} from "../__chunks/IRX7SFUJ.js";
+import "../__chunks/NERBASET.js";
 import "../__chunks/LWHPHW7Q.js";
-import "../__chunks/CLF4PQ7T.js";
+import "../__chunks/TQYOGOE2.js";
 import "../__chunks/BULCTPRV.js";
 import "../__chunks/6BJGLK2C.js";
 import "../__chunks/CS347UVZ.js";
@@ -12,11 +12,11 @@ import "../__chunks/IUB2BTEK.js";
 import "../__chunks/XHJGS6Z5.js";
 import "../__chunks/TL67WVI6.js";
 import "../__chunks/MKDDWKFK.js";
+import "../__chunks/72E5EPFF.js";
 import "../__chunks/OOBDFMJL.js";
+import "../__chunks/X6WIMZJE.js";
 import "../__chunks/677M2CI3.js";
 import "../__chunks/6GXEOXGT.js";
-import "../__chunks/72E5EPFF.js";
-import "../__chunks/X6WIMZJE.js";
 import "../__chunks/HPP6CWMY.js";
 import "../__chunks/UYRJLDVS.js";
 import "../__chunks/JPXNJYSO.js";

package/esm/composite/composite-provider.d.ts

@@ -2,7 +2,8 @@ import type { ReactElement, ReactNode } from "react";
 import type { PickRequired } from "@ariakit/core/utils/types";
 import type { CompositeStoreItem, CompositeStoreProps } from "./composite-store.js";
 /**
- * Provides a composite store to CompositeItem components.
+ * Provides a composite store to
+ * [`CompositeItem`](https://ariakit.org/reference/composite-item) components.
  * @see https://ariakit.org/components/composite
  * @example
  * ```jsx

package/esm/composite/composite-renderer.d.ts

@@ -294,7 +294,7 @@ export interface CompositeRendererOptions<T extends Item = any> extends Omit<Col
     /**
      * Object returned by the
      * [`useCompositeStore`](https://ariakit.org/reference/use-composite-store)
-     * hook. If not provided, the parent
+     * hook. If not provided, the closest
      * [Composite](https://ariakit.org/components/composite) component's context
      * will be used.
      *

package/esm/composite/composite-row.d.ts

@@ -20,32 +20,39 @@ import type { CompositeStore } from "./composite-store.js";
  */
 export declare const useCompositeRow: import("../utils/types.js").Hook<CompositeRowOptions<"div">>;
 /**
- * Renders a composite row. Wrapping `CompositeItem` elements within
- * `CompositeRow` will create a two-dimensional composite widget, such as a
- * grid.
+ * Renders a row element for composite items that allows two-dimensional arrow
+ * key navigation.
+ * [`CompositeItem`](https://ariakit.org/reference/composite-item) elements
+ * wrapped within this component will automatically receive a
+ * [`rowId`](https://ariakit.org/reference/composite-item#rowid) prop.
  * @see https://ariakit.org/components/composite
  * @example
- * ```jsx
- * const composite = useCompositeStore();
- * <Composite store={composite}>
- *   <CompositeRow>
- *     <CompositeItem>Item 1.1</CompositeItem>
- *     <CompositeItem>Item 1.2</CompositeItem>
- *     <CompositeItem>Item 1.3</CompositeItem>
- *   </CompositeRow>
- *   <CompositeRow>
- *     <CompositeItem>Item 2.1</CompositeItem>
- *     <CompositeItem>Item 2.2</CompositeItem>
- *     <CompositeItem>Item 2.3</CompositeItem>
- *   </CompositeRow>
- * </Composite>
+ * ```jsx {3-12}
+ * <CompositeProvider>
+ *   <Composite>
+ *     <CompositeRow>
+ *       <CompositeItem>Item 1.1</CompositeItem>
+ *       <CompositeItem>Item 1.2</CompositeItem>
+ *       <CompositeItem>Item 1.3</CompositeItem>
+ *     </CompositeRow>
+ *     <CompositeRow>
+ *       <CompositeItem>Item 2.1</CompositeItem>
+ *       <CompositeItem>Item 2.2</CompositeItem>
+ *       <CompositeItem>Item 2.3</CompositeItem>
+ *     </CompositeRow>
+ *   </Composite>
+ * </CompositeProvider>
  * ```
  */
 export declare const CompositeRow: import("../utils/types.js").Component<CompositeRowOptions<"div">>;
 export interface CompositeRowOptions<T extends As = "div"> extends Options<T> {
     /**
-     * Object returned by the `useCompositeStore` hook. If not provided, the
-     * parent `Composite` component's context will be used.
+     * Object returned by the
+     * [`useCompositeStore`](https://ariakit.org/reference/use-composite-store)
+     * hook. If not provided, the closest
+     * [`Composite`](https://ariakit.org/reference/composite) or
+     * [`CompositeProvider`](https://ariakit.org/reference/composite-provider)
+     * components' context will be used.
      */
     store?: CompositeStore;
 }

package/esm/composite/composite-separator.d.ts

@@ -17,24 +17,37 @@ import type { CompositeStore } from "./composite-store.js";
  */
 export declare const useCompositeSeparator: import("../utils/types.js").Hook<CompositeSeparatorOptions<"hr">>;
 /**
- * Renders a separator for composite items.
+ * Renders a divider between
+ * [`CompositeItem`](https://ariakit.org/reference/composite-item) elements.
  * @see https://ariakit.org/components/composite
  * @example
- * ```jsx
- * const composite = useCompositeStore();
- * <Composite store={composite}>
- *   <CompositeItem>Item 1</CompositeItem>
- *   <CompositeSeparator />
- *   <CompositeItem>Item 2</CompositeItem>
- * </Composite>
+ * ```jsx {4}
+ * <CompositeProvider>
+ *   <Composite>
+ *     <CompositeItem>Item 1</CompositeItem>
+ *     <CompositeSeparator />
+ *     <CompositeItem>Item 2</CompositeItem>
+ *   </Composite>
+ * </CompositeProvider>
  * ```
  */
 export declare const CompositeSeparator: import("../utils/types.js").Component<CompositeSeparatorOptions<"hr">>;
 export interface CompositeSeparatorOptions<T extends As = "hr"> extends SeparatorOptions<T> {
     /**
-     * Object returned by the `useCompositeStore` hook. If not provided, the
-     * parent `Composite` component's context will be used.
+     * Object returned by the
+     * [`useCompositeStore`](https://ariakit.org/reference/use-composite-store)
+     * hook. If not provided, the closest
+     * [`Composite`](https://ariakit.org/reference/composite) or
+     * [`CompositeProvider`](https://ariakit.org/reference/composite-provider)
+     * components' context will be used.
      */
     store?: CompositeStore;
+    /**
+     * The orientation of the separator. By default, this is the opposite of the
+     * [`orientation`](https://ariakit.org/reference/composite-provider#orientation)
+     * state of the composite widget. Which means it doesn't need to be explicitly
+     * set in most cases.
+     */
+    orientation?: SeparatorOptions<T>["orientation"];
 }
 export type CompositeSeparatorProps<T extends As = "hr"> = Props<CompositeSeparatorOptions<T>>;

package/esm/composite/composite-store.d.ts

@@ -4,11 +4,13 @@ import type { CollectionStoreFunctions, CollectionStoreOptions, CollectionStoreS
 import type { Store } from "../utils/store.js";
 export declare function useCompositeStoreProps<T extends Core.CompositeStore>(store: T, update: () => void, props: CompositeStoreProps): T;
 /**
- * Creates a composite store.
+ * Creates a composite store to control the state of
+ * [Composite](https://ariakit.org/components/composite) components.
  * @see https://ariakit.org/components/composite
  * @example
  * ```jsx
  * const composite = useCompositeStore();
+ *
  * <Composite store={composite}>
  *   <CompositeItem>Item</CompositeItem>
  *   <CompositeItem>Item</CompositeItem>

package/esm/composite/composite-typeahead.d.ts

@@ -17,25 +17,37 @@ export declare const useCompositeTypeahead: import("../utils/types.js").Hook<Com
 /**
  * Renders a component that adds typeahead functionality to composite
  * components.
+ *
+ * When the
+ * [`typeahead`](https://ariakit.org/reference/composite-typeahead#typeahead)
+ * prop is enabled, which it is by default, hitting printable character keys
+ * will move focus to the next composite item that begins with the input
+ * characters.
  * @see https://ariakit.org/components/composite
  * @example
  * ```jsx
- * const composite = useCompositeStore();
- * <Composite store={composite} render={<CompositeTypeahead />}>
- *   <CompositeItem>Item 1</CompositeItem>
- *   <CompositeItem>Item 2</CompositeItem>
- * </Composite>
+ * <CompositeProvider>
+ *   <Composite render={<CompositeTypeahead />}>
+ *     <CompositeItem>Item 1</CompositeItem>
+ *     <CompositeItem>Item 2</CompositeItem>
+ *   </Composite>
+ * </CompositeProvider>
  * ```
  */
 export declare const CompositeTypeahead: import("../utils/types.js").Component<CompositeTypeaheadOptions<"div">>;
 export interface CompositeTypeaheadOptions<T extends As = "div"> extends Options<T> {
     /**
-     * Object returned by the `useCompositeStore` hook. If not provided, the
-     * parent `Composite` component's context will be used.
+     * Object returned by the
+     * [`useCompositeStore`](https://ariakit.org/reference/use-composite-store)
+     * hook. If not provided, the closest
+     * [`Composite`](https://ariakit.org/reference/composite) or
+     * [`CompositeProvider`](https://ariakit.org/reference/composite-provider)
+     * components' context will be used.
      */
     store?: CompositeStore;
     /**
-     * Determines whether the typeahead behavior is enabled.
+     * When enabled, pressing printable character keys will move focus to the next
+     * composite item that starts with the entered characters.
      * @default true
      */
     typeahead?: boolean;

package/esm/composite/composite.d.ts

@@ -32,27 +32,82 @@ export declare const useComposite: import("../utils/types.js").Hook<CompositeOpt
 export declare const Composite: import("../utils/types.js").Component<CompositeOptions<"div">>;
 export interface CompositeOptions<T extends As = "div"> extends FocusableOptions<T> {
     /**
-     * Object returned by the `useCompositeStore` hook.
+     * Object returned by the
+     * [`useCompositeStore`](https://ariakit.org/reference/use-composite-store)
+     * hook. If not provided, the closest
+     * [`CompositeProvider`](https://ariakit.org/reference/composite-provider)
+     * component's context will be used.
      */
     store?: CompositeStore;
     /**
-     * Whether the component should behave as a composite widget. This prop should
-     * be set to `false` when combining different composite widgets where only one
-     * should behave as such.
+     * Determines if the component should act as a composite widget. This prop
+     * needs to be set to `false` when merging various composite widgets where
+     * only one should function in that manner.
+     *
+     * If disabled, this component will stop managing focus and keyboard
+     * navigation for its items and itself. Additionally, composite ARIA
+     * attributes won't be applied. These responsibilities should be taken over by
+     * another composite component.
+     *
+     * **Note**: In most cases, this prop doesn't need to be set manually. For
+     * example, when composing [Menu with
+     * Combobox](https://ariakit.org/examples/menu-combobox) or [Select with
+     * Combobox](https://ariakit.org/examples/select-combobox), this prop will be
+     * set to `false` automatically on the
+     * [`Menu`](https://ariakit.org/reference/menu) and
+     * [`SelectPopover`](https://ariakit.org/reference/select-popover) components
+     * so the [`Combobox`](https://ariakit.org/reference/combobox) component can
+     * take over the composite widget responsibilities.
+     *
+     * Live examples:
+     * - [Menu with Combobox](https://ariakit.org/examples/menu-combobox)
+     * - [Select with Combobox](https://ariakit.org/examples/select-combobox)
      * @default true
      */
     composite?: boolean;
     /**
-     * Whether the active composite item should receive focus when `store.move` is
-     * called.
+     * Determines whether the composite widget should move focus to an item when
+     * arrow keys are pressed, given that the composite element is focused and
+     * there's no active item.
+     *
+     * **Note**: To entirely disable focus moving within a composite widget, you
+     * can use the
+     * [`focusOnMove`](https://ariakit.org/reference/composite#focusonmove) prop
+     * instead. If you want to control the behavior _only when arrow keys are
+     * pressed_, where
+     * [`focusOnMove`](https://ariakit.org/reference/composite#focusonmove) may
+     * not be applicable, this prop must be set on composite items as well.
      * @default true
+     * @example
+     * ```jsx
+     * <Composite moveOnKeyPress={false}>
+     *   <CompositeItem moveOnKeyPress={false} />
+     *   <CompositeItem moveOnKeyPress={false} />
+     * </Composite>
+     * ```
      */
-    focusOnMove?: boolean;
+    moveOnKeyPress?: BooleanOrCallback<ReactKeyboardEvent<HTMLElement>>;
     /**
-     * Whether the composite widget should move focus to an item when pressing
-     * arrow keys.
+     * Determines if the active composite item should receive focus (or virtual
+     * focus if the
+     * [`virtualFocus`](https://ariakit.org/reference/composite-provider#virtualfocus)
+     * option is enabled) when moving through items. This typically happens when
+     * navigating through items with arrow keys, but it can also happen when
+     * calling the
+     * [`move`](https://ariakit.org/reference/use-composite-store#move) method
+     * directly.
+     *
+     * Unlike the
+     * [`composite`](https://ariakit.org/reference/composite#composite-1) prop,
+     * this option doesn't disable the entire composite widget behavior. It only
+     * stops this component from managing focus when navigating through items.
+     *
+     * **Note**: If you want to control the behavior only _when arrow keys are
+     * pressed_, use the
+     * [`moveOnKeyPress`](https://ariakit.org/reference/composite#moveonkeypress)
+     * prop instead.
      * @default true
      */
-    moveOnKeyPress?: BooleanOrCallback<ReactKeyboardEvent<HTMLElement>>;
+    focusOnMove?: boolean;
 }
 export type CompositeProps<T extends As = "div"> = Props<CompositeOptions<T>>;

package/esm/dialog/dialog-disclosure.d.ts

@@ -14,7 +14,8 @@ import type { DialogStore } from "./dialog-store.js";
  */
 export declare const useDialogDisclosure: import("../utils/types.js").Hook<DialogDisclosureOptions<"button">>;
 /**
- * Renders a button that shows/hides a dialog.
+ * Renders a button that toggles the visibility of a
+ * [`Dialog`](https://ariakit.org/reference/dialog) component when clicked.
  * @see https://ariakit.org/components/dialog
  * @example
  * ```jsx {2}

package/esm/dialog/dialog-dismiss.d.ts

@@ -15,7 +15,8 @@ import type { DialogStore } from "./dialog-store.js";
  */
 export declare const useDialogDismiss: import("../utils/types.js").Hook<DialogDismissOptions<"button">>;
 /**
- * Renders a button that hides a dialog.
+ * Renders a button that hides a
+ * [`Dialog`](https://ariakit.org/reference/dialog) when clicked.
  * @see https://ariakit.org/components/dialog
  * @example
  * ```jsx {4}

package/esm/dialog/dialog-provider.d.ts

@@ -1,7 +1,8 @@
 import type { ReactNode } from "react";
 import type { DialogStoreProps } from "./dialog-store.js";
 /**
- * Provides a dialog store to Dialog components.
+ * Provides a dialog store to [Dialog](https://ariakit.org/components/dialog)
+ * components.
  * @see https://ariakit.org/components/dialog
  * @example
  * ```jsx

package/esm/dialog/dialog-store.d.ts

@@ -3,11 +3,13 @@ import type { DisclosureStoreFunctions, DisclosureStoreOptions, DisclosureStoreS
 import type { Store } from "../utils/store.js";
 export declare function useDialogStoreProps<T extends Core.DialogStore>(store: T, update: () => void, props: DialogStoreProps): T;
 /**
- * Creates a dialog store.
+ * Creates a dialog store to control the state of
+ * [Dialog](https://ariakit.org/components/dialog) components.
  * @see https://ariakit.org/components/dialog
  * @example
  * ```jsx
  * const dialog = useDialogStore();
+ *
  * <button onClick={dialog.toggle}>Open dialog</button>
  * <Dialog store={dialog}>Content</Dialog>
  * ```

package/esm/dialog/dialog.d.ts

@@ -18,7 +18,14 @@ import type { DialogStore } from "./dialog-store.js";
 export declare const useDialog: import("../utils/types.js").Hook<DialogOptions<"div">>;
 export declare function createDialogComponent<T extends DialogOptions>(Component: Component<T>, useProviderContext?: () => DialogStore | undefined): Component<T>;
 /**
- * Renders a dialog element.
+ * Renders a dialog similar to the native `dialog` element that's rendered in a
+ * [`portal`](https://ariakit.org/reference/dialog#portal) by default.
+ *
+ * The dialog can be either
+ * [`modal`](https://ariakit.org/reference/dialog#modal) or non-modal. The
+ * visibility state can be controlled with the
+ * [`open`](https://ariakit.org/reference/dialog#open) and
+ * [`onClose`](https://ariakit.org/reference/dialog#onclose) props.
  * @see https://ariakit.org/components/dialog
  * @example
  * ```jsx {4-6}
@@ -60,7 +67,7 @@ export interface DialogOptions<T extends As = "div"> extends FocusableOptions<T>
      * This is an event handler prop triggered when the dialog's `close` event is
      * dispatched. The `close` event is similar to the native dialog
      * [`close`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLDialogElement/close_event)
-     * event. The only difference is that this event can be cancelled with
+     * event. The only difference is that this event can be canceled with
      * `event.preventDefault()`, which will prevent the dialog from hiding.
      *
      * It's important to note that this event only fires when the dialog store's
@@ -87,14 +94,14 @@ export interface DialogOptions<T extends As = "div"> extends FocusableOptions<T>
      * - The [`portal`](https://ariakit.org/reference/dialog#portal) and
      *   [`preventBodyScroll`](https://ariakit.org/reference/dialog#preventbodyscroll)
      *   props are set to `true`. They can still be manually set to `false`.
-     * - A visually hidden dismiss button will be rendered if the
-     *   [`DialogDismiss`](https://ariakit.org/reference/dialog-dismiss) component
-     *   hasn't been used. This allows screen reader users to close the dialog.
-     * - When the dialog is open, element tree outside it will be disabled.
      * - When using the [`Heading`](https://ariakit.org/reference/heading) or
      *   [`DialogHeading`](https://ariakit.org/reference/dialog-heading)
      *   components within the dialog, their level will be reset so they start
      *   with `h1`.
+     * - A visually hidden dismiss button will be rendered if the
+     *   [`DialogDismiss`](https://ariakit.org/reference/dialog-dismiss) component
+     *   hasn't been used. This allows screen reader users to close the dialog.
+     * - When the dialog is open, element tree outside it will be inert.
      *
      * Live examples:
      * - [Combobox with tabs](https://ariakit.org/examples/combobox-tabs)
@@ -111,8 +118,10 @@ export interface DialogOptions<T extends As = "div"> extends FocusableOptions<T>
      * dialogs, this is `true` by default. Besides a `boolean`, this prop can also
      * be a React component or JSX element that will be rendered as the backdrop.
      *
-     * **If a custom component is used, it must accept ref and spread all props to
-     * its underlying DOM element**, the same way a native element would.
+     * **Note**: If a custom component is used, it must [accept ref and spread all
+     * props to its underlying DOM
+     * element](https://ariakit.org/guide/composition#custom-components-must-be-open-for-extension),
+     * the same way a native element would.
      *
      * Live examples:
      * - [Animated Dialog](https://ariakit.org/examples/dialog-animated)
@@ -139,14 +148,27 @@ export interface DialogOptions<T extends As = "div"> extends FocusableOptions<T>
      */
     backdropProps?: ComponentPropsWithRef<"div">;
     /**
-     * Determines whether the dialog will be hidden when the user presses the
-     * Escape key.
+     * Determines if the dialog will hide when the user presses the Escape key.
+     *
+     * This prop can be either a boolean or a function that accepts an event as an
+     * argument and returns a boolean. The event object represents the keydown
+     * event that initiated the hide action, which could be either a native
+     * keyboard event or a React synthetic event.
+     *
+     * **Note**: When placing Ariakit dialogs inside third-party dialogs, using
+     * `event.stopPropagation()` within this function will stop the event from
+     * reaching the third-party dialog, closing only the Ariakit dialog.
      * @default true
      */
     hideOnEscape?: BooleanOrCallback<KeyboardEvent | ReactKeyboardEvent>;
     /**
-     * Determines whether the dialog will be hidden when the user clicks or focus
-     * on an element outside of the dialog.
+     * Determines if the dialog should hide when the user clicks or focuses on an
+     * element outside the dialog.
+     *
+     * This prop can be either a boolean or a function that takes an event as an
+     * argument and returns a boolean. The event object represents the event that
+     * triggered the action, which could be a native event or a React synthetic
+     * event of various types.
      *
      * Live examples:
      * - [Selection Popover](https://ariakit.org/examples/popover-selection)
@@ -154,11 +176,17 @@ export interface DialogOptions<T extends As = "div"> extends FocusableOptions<T>
      */
     hideOnInteractOutside?: BooleanOrCallback<Event | SyntheticEvent>;
     /**
-     * When a dialog is open, the elements outside of it will be disabled so they
-     * can't be interacted with if the dialog is modal. For non-modal dialogs,
-     * interacting with elements outside of the dialog will close it. With this
-     * function, you can return a collection of elements that will be considered
-     * part of the dialog and therefore will be excluded from this behavior.
+     * When a dialog is open, the elements outside of it are disabled to prevent
+     * interaction if the dialog is
+     * [`modal`](https://ariakit.org/reference/dialog#modal). For non-modal
+     * dialogs, interacting with elements outside the dialog prompts it to close.
+     *
+     * This function allows you to return an iterable collection of elements that
+     * will be considered as part of the dialog, thus excluding them from this
+     * behavior.
+     *
+     * **Note**: The elements returned by this function must exist in the DOM when
+     * the dialog opens.
      *
      * Live examples:
      * - [Dialog with
@@ -167,14 +195,17 @@ export interface DialogOptions<T extends As = "div"> extends FocusableOptions<T>
     getPersistentElements?: () => Iterable<Element>;
     /**
      * Determines whether the body scrolling will be prevented when the dialog is
-     * shown.
+     * shown. This is automatically set to `true` when the dialog is
+     * [`modal`](https://ariakit.org/reference/dialog#modal). You can disable this
+     * prop if you want to implement your own logic.
      */
     preventBodyScroll?: boolean;
     /**
      * Determines whether an element inside the dialog will receive focus when the
      * dialog is shown. By default, this is usually the first tabbable element in
-     * the dialog or the dialog itself. The `initialFocus` prop can be used to set
-     * a different element to receive focus.
+     * the dialog or the dialog itself. The
+     * [`initialFocus`](https://ariakit.org/reference/dialog#initialfocus) prop
+     * can be used to set a different element to receive focus.
      *
      * Live examples:
      * - [Warning on Dialog

package/esm/dialog/dialog.js

@@ -3,9 +3,9 @@ import {
   Dialog,
   createDialogComponent,
   useDialog
-} from "../__chunks/PGAEII2Q.js";
+} from "../__chunks/NERBASET.js";
 import "../__chunks/LWHPHW7Q.js";
-import "../__chunks/CLF4PQ7T.js";
+import "../__chunks/TQYOGOE2.js";
 import "../__chunks/BULCTPRV.js";
 import "../__chunks/6BJGLK2C.js";
 import "../__chunks/CS347UVZ.js";
@@ -13,11 +13,11 @@ import "../__chunks/IUB2BTEK.js";
 import "../__chunks/XHJGS6Z5.js";
 import "../__chunks/TL67WVI6.js";
 import "../__chunks/MKDDWKFK.js";
+import "../__chunks/72E5EPFF.js";
 import "../__chunks/OOBDFMJL.js";
+import "../__chunks/X6WIMZJE.js";
 import "../__chunks/677M2CI3.js";
 import "../__chunks/6GXEOXGT.js";
-import "../__chunks/72E5EPFF.js";
-import "../__chunks/X6WIMZJE.js";
 import "../__chunks/HPP6CWMY.js";
 import "../__chunks/UYRJLDVS.js";
 import "../__chunks/JPXNJYSO.js";

package/esm/dialog/utils/disable-tree.js

@@ -2,12 +2,12 @@
 import {
   disableTree,
   disableTreeOutside
-} from "../../__chunks/CLF4PQ7T.js";
+} from "../../__chunks/TQYOGOE2.js";
 import "../../__chunks/BULCTPRV.js";
 import "../../__chunks/MKDDWKFK.js";
-import "../../__chunks/677M2CI3.js";
 import "../../__chunks/72E5EPFF.js";
 import "../../__chunks/X6WIMZJE.js";
+import "../../__chunks/677M2CI3.js";
 import "../../__chunks/4R3V3JGP.js";
 export {
   disableTree,

package/esm/dialog/utils/use-hide-on-interact-outside.js

@@ -4,8 +4,8 @@ import {
 } from "../../__chunks/XHJGS6Z5.js";
 import "../../__chunks/TL67WVI6.js";
 import "../../__chunks/MKDDWKFK.js";
-import "../../__chunks/OOBDFMJL.js";
 import "../../__chunks/72E5EPFF.js";
+import "../../__chunks/OOBDFMJL.js";
 import "../../__chunks/X6WIMZJE.js";
 import "../../__chunks/6O5OEQGF.js";
 import "../../__chunks/XM66DUTO.js";

package/esm/disclosure/disclosure-content.d.ts

@@ -14,10 +14,11 @@ export declare function isHidden(mounted: boolean, hidden?: boolean | null, alwa
  */
 export declare const useDisclosureContent: import("../utils/types.js").Hook<DisclosureContentOptions<"div">>;
 /**
- * Renders an element that can be shown or hidden.
+ * Renders an element that can be shown or hidden by a
+ * [`Disclosure`](https://ariakit.org/components/disclosure) component.
  * @see https://ariakit.org/components/disclosure
  * @example
- * ```jsx
+ * ```jsx {3}
  * <DisclosureProvider>
  *   <Disclosure>Disclosure</Disclosure>
  *   <DisclosureContent>Content</DisclosureContent>
@@ -36,9 +37,9 @@ export interface DisclosureContentOptions<T extends As = "div"> extends Options<
     store?: DisclosureStore;
     /**
      * Determines whether the content element should remain visible even when the
-     * `open` state is `false`. If this prop is set to `true`, the `hidden` prop
-     * and the `display: none` style will not be applied, unless explicitly set
-     * otherwise.
+     * [`open`](https://ariakit.org/reference/disclosure-provider#open) state is
+     * `false`. If this prop is set to `true`, the `hidden` prop and the `display:
+     * none` style will not be applied, unless explicitly set otherwise.
      *
      * This prop is particularly useful when using third-party animation libraries
      * such as Framer Motion or React Spring, where the element needs to be

package/esm/disclosure/disclosure-provider.d.ts

@@ -1,7 +1,8 @@
 import type { ReactNode } from "react";
 import type { DisclosureStoreProps } from "./disclosure-store.js";
 /**
- * Provides a disclosure store to Disclosure components.
+ * Provides a disclosure store to
+ * [Disclosure](https://ariakit.org/components/disclosure) components.
  * @see https://ariakit.org/components/disclosure
  * @example
  * ```jsx

package/esm/disclosure/disclosure-store.d.ts

@@ -2,11 +2,13 @@ import * as Core from "@ariakit/core/disclosure/disclosure-store";
 import type { Store } from "../utils/store.js";
 export declare function useDisclosureStoreProps<T extends Core.DisclosureStore>(store: T, update: () => void, props: DisclosureStoreProps): T;
 /**
- * Creates a disclosure store.
+ * Creates a disclosure store to control the state of
+ * [Disclosure](https://ariakit.org/components/disclosure) components.
  * @see https://ariakit.org/components/disclosure
  * @example
  * ```jsx
  * const disclosure = useDisclosureStore();
+ *
  * <Disclosure store={disclosure}>Disclosure</Disclosure>
  * <DisclosureContent store={disclosure}>Content</DisclosureContent>
  * ```
@@ -18,8 +20,9 @@ export interface DisclosureStoreFunctions extends Core.DisclosureStoreFunctions
 }
 export interface DisclosureStoreOptions extends Core.DisclosureStoreOptions {
     /**
-     * A callback that gets called when the `open` state changes.
-     * @param open The new open value.
+     * A callback that gets called when the
+     * [`open`](https://ariakit.org/reference/disclosure-provider#open) state
+     * changes.
      * @example
      * const [open, setOpen] = useState(false);
      * const disclosure = useDisclosureStore({ open, setOpen });
@@ -27,7 +30,6 @@ export interface DisclosureStoreOptions extends Core.DisclosureStoreOptions {
     setOpen?: (open: DisclosureStoreState["open"]) => void;
     /**
      * A callback that gets called when the `mounted` state changes.
-     * @param mounted The new mounted value.
      * @example
      * const [mounted, setMounted] = useState(false);
      * const disclosure = useDisclosureStore({ setMounted });

package/esm/disclosure/disclosure.d.ts

@@ -16,11 +16,12 @@ import type { DisclosureStore } from "./disclosure-store.js";
  */
 export declare const useDisclosure: import("../utils/types.js").Hook<DisclosureOptions<"button">>;
 /**
- * Renders an element that controls the visibility of a disclosure content
+ * Renders an element that controls the visibility of a
+ * [`DisclosureContent`](https://ariakit.org/reference/disclosure-content)
  * element.
  * @see https://ariakit.org/components/disclosure
  * @example
- * ```jsx
+ * ```jsx {2}
  * <DisclosureProvider>
  *   <Disclosure>Disclosure</Disclosure>
  *   <DisclosureContent>Content</DisclosureContent>