@ariakit/react-core 0.0.1 → 0.1.1

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

@@ -0,0 +1,86 @@
+import * as Core from "@ariakit/core/menu/menu-store";
+import type { BivariantCallback, PickRequired } from "@ariakit/core/utils/types";
+import type { CompositeStoreFunctions, CompositeStoreOptions, CompositeStoreState } from "../composite/composite-store.js";
+import type { HovercardStoreFunctions, HovercardStoreOptions, HovercardStoreState } from "../hovercard/hovercard-store.js";
+import type { Store } from "../utils/store.js";
+type Values = Core.MenuStoreValues;
+export declare function useMenuStoreOptions<T extends Values = Values>(props: MenuStoreProps<T>): {
+    values: T | undefined;
+    timeout: number;
+    placement: (("left" | "right" | "bottom" | "top") | "left-start" | "right-start" | "bottom-start" | "top-start" | "left-end" | "right-end" | "bottom-end" | "top-end") | undefined;
+    getAnchorRect: ((anchor: HTMLElement | null) => {
+        x?: number | undefined;
+        y?: number | undefined;
+        width?: number | undefined;
+        height?: number | undefined;
+    } | null) | undefined;
+    renderCallback: ((props: import("@ariakit/core/popover/popover-store").PopoverStoreRenderCallbackProps) => void | (() => void)) | undefined;
+    setOpen?: ((open: boolean) => void) | undefined;
+    defaultOpen?: boolean | undefined;
+    open?: boolean | undefined;
+    animated?: number | boolean | undefined;
+    setItems?: BivariantCallback<(items: ({
+        id: string;
+        element?: HTMLElement | null | undefined;
+    } & {
+        rowId?: string | undefined;
+        disabled?: boolean | undefined;
+        children?: string | undefined;
+    })[]) => void> | undefined;
+    defaultItems?: ({
+        id: string;
+        element?: HTMLElement | null | undefined;
+    } & {
+        rowId?: string | undefined;
+        disabled?: boolean | undefined;
+        children?: string | undefined;
+    })[] | undefined;
+    items?: ({
+        id: string;
+        element?: HTMLElement | null | undefined;
+    } & {
+        rowId?: string | undefined;
+        disabled?: boolean | undefined;
+        children?: string | undefined;
+    })[] | undefined;
+};
+export declare function useMenuStoreProps<T extends Omit<MenuStore, "hideAll">>(store: T, props: MenuStoreProps): T & {
+    hideAll: () => void;
+};
+/**
+ * Creates a menu store.
+ * @see https://ariakit.org/components/menu
+ * @example
+ * ```jsx
+ * const menu = useMenuStore({ placement: "top" });
+ * <MenuButton store={menu}>Edit</MenuButton>
+ * <Menu store={menu}>
+ *   <MenuItem>Undo</MenuItem>
+ *   <MenuItem>Redo</MenuItem>
+ * </Menu>
+ * ```
+ */
+export declare function useMenuStore<T extends Values = Values>(props: PickRequired<MenuStoreProps<T>, "values" | "defaultValues">): MenuStore<T>;
+export declare function useMenuStore(props?: MenuStoreProps): MenuStore;
+export type MenuStoreValues = Core.MenuStoreValues;
+export interface MenuStoreState<T extends Values = Values> extends Core.MenuStoreState<T>, CompositeStoreState, HovercardStoreState {
+}
+export interface MenuStoreFunctions<T extends Values = Values> extends Core.MenuStoreFunctions<T>, CompositeStoreFunctions, HovercardStoreFunctions {
+    /**
+     * Hides the menu and all its parent menus.
+     */
+    hideAll: () => void;
+}
+export interface MenuStoreOptions<T extends Values = Values> extends Core.MenuStoreOptions<T>, CompositeStoreOptions, HovercardStoreOptions {
+    /**
+     * A callback that gets called when the `values` state changes.
+     * @param values The new values.
+     * @example
+     * const [values, setValues] = useState({});
+     * const menu = useMenuStore({ values, setValues });
+     */
+    setValues?: BivariantCallback<(values: MenuStoreState<T>["values"]) => void>;
+}
+export type MenuStoreProps<T extends Values = Values> = MenuStoreOptions<T> & Core.MenuStoreProps<T>;
+export type MenuStore<T extends Values = Values> = MenuStoreFunctions<T> & Store<Core.MenuStore<T>>;
+export {};

package/esm/menu/menu-store.js

@@ -0,0 +1,73 @@
+import {
+  useHovercardStoreOptions,
+  useHovercardStoreProps
+} from "../__chunks/47TE2UD5.js";
+import {
+  MenuBarContext,
+  MenuContext
+} from "../__chunks/HVBRRKV4.js";
+import {
+  useCompositeStoreOptions,
+  useCompositeStoreProps
+} from "../__chunks/2EP53RLR.js";
+import "../__chunks/56XURSTF.js";
+import "../__chunks/RSJJ72ZD.js";
+import "../__chunks/OGTE6FGV.js";
+import "../__chunks/OXIHLN45.js";
+import {
+  useStore,
+  useStoreProps,
+  useStoreState
+} from "../__chunks/6DAEYZ43.js";
+import "../__chunks/B7MIN7YT.js";
+import "../__chunks/SXC6BPOF.js";
+
+// src/menu/menu-store.ts
+import { useContext, useMemo } from "react";
+import * as Core from "@ariakit/core/menu/menu-store";
+function useMenuStoreOptions(props) {
+  const state = props.store?.getState?.();
+  const parentMenu = useContext(MenuContext);
+  const parentMenuBar = useContext(MenuBarContext);
+  const placementProp = props.placement;
+  const placement = useStoreState(
+    parentMenu || parentMenuBar,
+    (state2) => placementProp || (state2.orientation === "vertical" ? "right-start" : "bottom-start")
+  );
+  const parentIsMenuBar = !!parentMenuBar && !parentMenu;
+  const timeout = parentIsMenuBar ? 0 : 150;
+  return {
+    ...useCompositeStoreOptions(props),
+    ...useHovercardStoreOptions(props),
+    // TODO: Pass parent prop and remove these default values
+    values: props.values ?? state?.values ?? props.defaultValues,
+    timeout: props.timeout ?? state?.timeout ?? timeout,
+    placement
+  };
+}
+function useMenuStoreProps(store, props) {
+  const parentMenu = useContext(MenuContext);
+  store = useCompositeStoreProps(store, props);
+  store = useHovercardStoreProps(store, props);
+  useStoreProps(store, props, "values", "setValues");
+  return useMemo(
+    () => ({
+      ...store,
+      hideAll: () => {
+        store.hide();
+        parentMenu?.hideAll();
+      }
+    }),
+    [store]
+  );
+}
+function useMenuStore(props = {}) {
+  const options = useMenuStoreOptions(props);
+  const store = useStore(() => Core.createMenuStore({ ...props, ...options }));
+  return useMenuStoreProps(store, props);
+}
+export {
+  useMenuStore,
+  useMenuStoreOptions,
+  useMenuStoreProps
+};

package/esm/menu/menu.d.ts

@@ -0,0 +1,35 @@
+import type { HovercardOptions } from "../hovercard/hovercard.js";
+import type { As, Props } from "../utils/types.js";
+import type { MenuListOptions } from "./menu-list.js";
+/**
+ * Returns props to create a `Menu` component.
+ * @see https://ariakit.org/components/menu
+ * @example
+ * ```jsx
+ * const store = useMenuStore();
+ * const props = useMenu({ store });
+ * <MenuButton store={store}>Edit</MenuButton>
+ * <Role {...props}>
+ *   <MenuItem>Undo</MenuItem>
+ *   <MenuItem>Redo</MenuItem>
+ * </Role>
+ * ```
+ */
+export declare const useMenu: import("../utils/types.js").Hook<MenuOptions<"div">>;
+/**
+ * Renders a dropdown menu element.
+ * @see https://ariakit.org/components/menu
+ * @example
+ * ```jsx
+ * const menu = useMenuStore();
+ * <MenuButton store={menu}>Edit</MenuButton>
+ * <Menu store={menu}>
+ *   <MenuItem>Undo</MenuItem>
+ *   <MenuItem>Redo</MenuItem>
+ * </Menu>
+ * ```
+ */
+export declare const Menu: import("../utils/types.js").Component<MenuOptions<"div">>;
+export interface MenuOptions<T extends As = "div"> extends MenuListOptions<T>, Omit<HovercardOptions<T>, "store"> {
+}
+export type MenuProps<T extends As = "div"> = Props<MenuOptions<T>>;

package/esm/menu/menu.js

@@ -0,0 +1,182 @@
+import {
+  useHovercard
+} from "../__chunks/Z3UAG7AM.js";
+import "../__chunks/X7FKJQME.js";
+import {
+  useMenuList
+} from "../__chunks/WOX4XCVH.js";
+import {
+  MenuBarContext,
+  MenuContext
+} from "../__chunks/HVBRRKV4.js";
+import "../__chunks/JUUV3EHC.js";
+import "../__chunks/NO5K4U2Q.js";
+import "../__chunks/4U6AOLE4.js";
+import "../__chunks/HLAXMBLL.js";
+import "../__chunks/WO2RXMKK.js";
+import "../__chunks/PU22SOKH.js";
+import "../__chunks/547F7FFZ.js";
+import "../__chunks/NV7HSBKK.js";
+import "../__chunks/2SVAPVVI.js";
+import "../__chunks/HVXLVRRR.js";
+import "../__chunks/7JNF6I52.js";
+import "../__chunks/LFCJQX2O.js";
+import "../__chunks/ZVCQYVEV.js";
+import "../__chunks/EJZ6BVXG.js";
+import "../__chunks/6OMX4H3W.js";
+import "../__chunks/COQHFAEN.js";
+import "../__chunks/LNHZLQEK.js";
+import "../__chunks/6OCAIYRY.js";
+import "../__chunks/6GS36SYX.js";
+import "../__chunks/FXC76SFN.js";
+import "../__chunks/STKLF26R.js";
+import "../__chunks/5TGAWEHD.js";
+import "../__chunks/Z3X3QN6P.js";
+import "../__chunks/3OSYJZM5.js";
+import "../__chunks/NDTB3OGK.js";
+import "../__chunks/LDDPB3PY.js";
+import "../__chunks/FFRIGW5T.js";
+import "../__chunks/SDULECC7.js";
+import {
+  createComponent,
+  createElement,
+  createHook
+} from "../__chunks/JE5NWDDX.js";
+import "../__chunks/6DAEYZ43.js";
+import {
+  useBooleanEvent,
+  useEvent,
+  useForkRef
+} from "../__chunks/B7MIN7YT.js";
+import "../__chunks/SXC6BPOF.js";
+
+// src/menu/menu.ts
+import { createRef, useContext, useEffect, useRef, useState } from "react";
+import { hasFocusWithin } from "@ariakit/core/utils/focus";
+var useMenu = createHook(
+  ({
+    store,
+    hideOnEscape = true,
+    autoFocusOnShow = true,
+    hideOnHoverOutside,
+    ...props
+  }) => {
+    const ref = useRef(null);
+    const parentMenu = useContext(MenuContext);
+    const parentMenuBar = useContext(MenuBarContext);
+    const hasParentMenu = !!parentMenu;
+    const parentIsMenuBar = !!parentMenuBar && !hasParentMenu;
+    const onKeyDownProp = props.onKeyDown;
+    const hideOnEscapeProp = useBooleanEvent(hideOnEscape);
+    const onKeyDown = useEvent((event) => {
+      onKeyDownProp?.(event);
+      if (event.defaultPrevented)
+        return;
+      if (event.key === "Escape") {
+        if (!hideOnEscapeProp(event))
+          return;
+        if (!hasParentMenu) {
+          event.stopPropagation();
+        }
+        return store.hide();
+      }
+    });
+    props = {
+      ...props,
+      ref: useForkRef(ref, props.ref),
+      onKeyDown
+    };
+    const { "aria-labelledby": ariaLabelledBy, ...menuListProps } = useMenuList(
+      {
+        store,
+        ...props
+      }
+    );
+    props = menuListProps;
+    const [initialFocusRef, setInitialFocusRef] = useState();
+    const autoFocusOnShowState = store.useState("autoFocusOnShow");
+    const initialFocus = store.useState("initialFocus");
+    const baseElement = store.useState("baseElement");
+    const items = store.useState("items");
+    useEffect(() => {
+      let cleaning = false;
+      setInitialFocusRef((prevInitialFocusRef) => {
+        if (cleaning)
+          return;
+        if (!autoFocusOnShowState)
+          return;
+        if (prevInitialFocusRef?.current?.isConnected)
+          return prevInitialFocusRef;
+        const ref2 = createRef();
+        switch (initialFocus) {
+          case "first":
+            ref2.current = items.find((item) => !item.disabled && item.element)?.element || null;
+            break;
+          case "last":
+            ref2.current = [...items].reverse().find((item) => !item.disabled && item.element)?.element || null;
+            break;
+          default:
+            return ref2;
+        }
+        if (!ref2.current)
+          return;
+        return ref2;
+      });
+      return () => {
+        cleaning = true;
+      };
+    }, [store, autoFocusOnShowState, initialFocus, items, baseElement]);
+    const mayAutoFocusOnShow = !!autoFocusOnShow;
+    const canAutoFocusOnShow = !!initialFocusRef || !!props.initialFocus || !!props.modal;
+    props = useHovercard({
+      store,
+      initialFocus: initialFocusRef,
+      autoFocusOnShow: mayAutoFocusOnShow ? canAutoFocusOnShow && autoFocusOnShow : autoFocusOnShowState || !!props.modal,
+      ...props,
+      hideOnHoverOutside: (event) => {
+        if (typeof hideOnHoverOutside === "function") {
+          return hideOnHoverOutside(event);
+        }
+        if (hideOnHoverOutside != null)
+          return hideOnHoverOutside;
+        if (hasParentMenu) {
+          parentMenu.setActiveId(null);
+          return true;
+        }
+        if (!parentIsMenuBar)
+          return false;
+        const { disclosureElement } = store.getState();
+        const disclosure = disclosureElement;
+        if (!disclosure)
+          return true;
+        if (hasFocusWithin(disclosure))
+          return false;
+        return true;
+      },
+      // If it's a submenu, it shouldn't behave like a modal dialog, nor display
+      // a backdrop.
+      modal: hasParentMenu ? false : props.modal,
+      backdrop: hasParentMenu ? false : props.backdrop,
+      // If it's a submenu, hide on esc will be handled differently. That is,
+      // event.stopPropagation() won't be called, so the parent menus will also
+      // be closed.
+      hideOnEscape: hasParentMenu ? false : hideOnEscape
+    });
+    props = {
+      "aria-labelledby": ariaLabelledBy,
+      ...props
+    };
+    return props;
+  }
+);
+var Menu = createComponent((props) => {
+  const htmlProps = useMenu(props);
+  return createElement("div", htmlProps);
+});
+if (process.env.NODE_ENV !== "production") {
+  Menu.displayName = "Menu";
+}
+export {
+  Menu,
+  useMenu
+};

package/esm/menu/utils.d.ts

@@ -0,0 +1,2 @@
+import type { MenuStoreState } from "./menu-store.js";
+export declare function hasExpandedMenuButton(items?: MenuStoreState["items"], currentElement?: Element): boolean;

package/esm/menu/utils.js

@@ -0,0 +1,6 @@
+import {
+  hasExpandedMenuButton
+} from "../__chunks/SJEKLK5Q.js";
+export {
+  hasExpandedMenuButton
+};

package/esm/popover/popover-anchor.d.ts

@@ -0,0 +1,33 @@
+import type { As, Options, Props } from "../utils/types.js";
+import type { PopoverStore } from "./popover-store.js";
+/**
+ * Returns props to create a `PopoverAnchor` component.
+ * @see https://ariakit.org/components/popover
+ * @example
+ * ```jsx
+ * const store = usePopoverStore();
+ * const props = usePopoverAnchor({ store });
+ * <Role {...props}>Anchor</Role>
+ * <Popover store={store}>Popover</Popover>
+ * ```
+ */
+export declare const usePopoverAnchor: import("../utils/types.js").Hook<PopoverAnchorOptions<"div">>;
+/**
+ * Renders an element that will serve as the popover's anchor. The popover will
+ * be positioned relative to this element.
+ * @see https://ariakit.org/components/popover
+ * @example
+ * ```jsx
+ * const popover = usePopoverStore();
+ * <PopoverAnchor store={popover}>Anchor</PopoverAnchor>
+ * <Popover store={popover}>Popover</Popover>
+ * ```
+ */
+export declare const PopoverAnchor: import("../utils/types.js").Component<PopoverAnchorOptions<"div">>;
+export interface PopoverAnchorOptions<T extends As = "div"> extends Options<T> {
+    /**
+     * Object returned by the `usePopoverStore` hook.
+     */
+    store: PopoverStore;
+}
+export type PopoverAnchorProps<T extends As = "div"> = Props<PopoverAnchorOptions<T>>;

package/esm/popover/popover-anchor.js

@@ -0,0 +1,11 @@
+import {
+  PopoverAnchor,
+  usePopoverAnchor
+} from "../__chunks/RNWB46DZ.js";
+import "../__chunks/JE5NWDDX.js";
+import "../__chunks/B7MIN7YT.js";
+import "../__chunks/SXC6BPOF.js";
+export {
+  PopoverAnchor,
+  usePopoverAnchor
+};

package/esm/popover/popover-arrow-path.d.ts

@@ -0,0 +1 @@
+export declare const POPOVER_ARROW_PATH = "M23,27.8c1.1,1.2,3.4,2.2,5,2.2h2H0h2c1.7,0,3.9-1,5-2.2l6.6-7.2c0.7-0.8,2-0.8,2.7,0L23,27.8L23,27.8z";

package/esm/popover/popover-arrow-path.js

@@ -0,0 +1,6 @@
+import {
+  POPOVER_ARROW_PATH
+} from "../__chunks/GM7XQV7F.js";
+export {
+  POPOVER_ARROW_PATH
+};

package/esm/popover/popover-arrow.d.ts

@@ -0,0 +1,42 @@
+import type { As, Options, Props } from "../utils/types.js";
+import type { PopoverStore } from "./popover-store.js";
+/**
+ * Returns props to create a `PopoverArrow` component.
+ * @see https://ariakit.org/components/popover
+ * @example
+ * ```jsx
+ * const store = usePopoverStore();
+ * const props = usePopoverArrow({ store });
+ * <Popover store={store}>
+ *   <Role {...props} />
+ *   Popover
+ * </Popover>
+ * ```
+ */
+export declare const usePopoverArrow: import("../utils/types.js").Hook<PopoverArrowOptions<"div">>;
+/**
+ * Renders an arrow inside a `Popover` component.
+ * @see https://ariakit.org/components/popover
+ * @example
+ * ```jsx
+ * const popover = usePopoverStore();
+ * <Popover store={popover}>
+ *   <PopoverArrow />
+ *   Popover
+ * </Popover>
+ * ```
+ */
+export declare const PopoverArrow: import("../utils/types.js").Component<PopoverArrowOptions<"div">>;
+export interface PopoverArrowOptions<T extends As = "div"> extends Options<T> {
+    /**
+     * Object returned by the `usePopoverStore` hook. If not provided, the parent
+     * `Popover` component's context will be used.
+     */
+    store?: PopoverStore;
+    /**
+     * The size of the arrow.
+     * @default 30
+     */
+    size?: number;
+}
+export type PopoverArrowProps<T extends As = "div"> = Props<PopoverArrowOptions<T>>;

package/esm/popover/popover-arrow.js

@@ -0,0 +1,13 @@
+import {
+  PopoverArrow,
+  usePopoverArrow
+} from "../__chunks/Q7WBN353.js";
+import "../__chunks/GM7XQV7F.js";
+import "../__chunks/6GS36SYX.js";
+import "../__chunks/JE5NWDDX.js";
+import "../__chunks/B7MIN7YT.js";
+import "../__chunks/SXC6BPOF.js";
+export {
+  PopoverArrow,
+  usePopoverArrow
+};

package/esm/popover/popover-context.d.ts

@@ -0,0 +1,2 @@
+import type { PopoverStore } from "./popover-store.js";
+export declare const PopoverContext: import("react").Context<PopoverStore | undefined>;

package/esm/popover/popover-context.js

@@ -0,0 +1,6 @@
+import {
+  PopoverContext
+} from "../__chunks/6GS36SYX.js";
+export {
+  PopoverContext
+};

package/esm/popover/popover-description.d.ts

@@ -0,0 +1,38 @@
+import type { DialogDescriptionOptions } from "../dialog/dialog-description.js";
+import type { As, Props } from "../utils/types.js";
+import type { PopoverStore } from "./popover-store.js";
+/**
+ * Returns props to create a `PopoverDescription` component. This hook must be
+ * used in a component that's wrapped with `Popover` so the `aria-describedby`
+ * prop is properly set on the popover element.
+ * @see https://ariakit.org/components/popover
+ * @example
+ * ```jsx
+ * // This component must be wrapped with Popover
+ * const props = usePopoverDescription();
+ * <Role {...props}>Description</Role>
+ * ```
+ */
+export declare const usePopoverDescription: import("../utils/types.js").Hook<PopoverDescriptionOptions<"p">>;
+/**
+ * Renders a description in a popover. This component must be wrapped with
+ * `Popover` so the `aria-describedby` prop is properly set on the popover
+ * element.
+ * @see https://ariakit.org/components/popover
+ * @example
+ * ```jsx
+ * const popover = usePopoverStore();
+ * <Popover store={popover}>
+ *   <PopoverDescription>Description</PopoverDescription>
+ * </Popover>
+ * ```
+ */
+export declare const PopoverDescription: import("../utils/types.js").Component<PopoverDescriptionOptions<"p">>;
+export interface PopoverDescriptionOptions<T extends As = "p"> extends DialogDescriptionOptions<T> {
+    /**
+     * Object returned by the `usePopoverStore` hook. If not provided, the parent
+     * `Popover` component's context will be used.
+     */
+    store?: PopoverStore;
+}
+export type PopoverDescriptionProps<T extends As = "p"> = Props<PopoverDescriptionOptions<T>>;

package/esm/popover/popover-description.js

@@ -0,0 +1,13 @@
+import {
+  PopoverDescription,
+  usePopoverDescription
+} from "../__chunks/HMJVMCGK.js";
+import "../__chunks/DGTYZREX.js";
+import "../__chunks/LNHZLQEK.js";
+import "../__chunks/JE5NWDDX.js";
+import "../__chunks/B7MIN7YT.js";
+import "../__chunks/SXC6BPOF.js";
+export {
+  PopoverDescription,
+  usePopoverDescription
+};

package/esm/popover/popover-disclosure-arrow.d.ts

@@ -0,0 +1,44 @@
+import type { As, Options, Props } from "../utils/types.js";
+import type { PopoverStore, PopoverStoreState } from "./popover-store.js";
+/**
+ * Returns props to create a `PopoverDisclosureArrow` component.
+ * @see https://ariakit.org/components/popover
+ * @example
+ * ```jsx
+ * const store = usePopoverStore();
+ * const props = usePopoverDisclosureArrow({ store });
+ * <PopoverDisclosure store={store}>
+ *   Disclosure
+ *   <Role {...props} />
+ * </PopoverDisclosure>
+ * ```
+ */
+export declare const usePopoverDisclosureArrow: import("../utils/types.js").Hook<PopoverDisclosureArrowOptions<"span">>;
+/**
+ * Renders an arrow pointing to the popover position. It's usually rendered
+ * inside the `PopoverDisclosure` component.
+ * @see https://ariakit.org/components/popover
+ * @example
+ * ```jsx
+ * const popover = usePopoverStore();
+ * <PopoverDisclosure store={popover}>
+ *   Disclosure
+ *   <PopoverDisclosureArrow />
+ * </PopoverDisclosure>
+ * <Popover store={popover}>Popover</Popover>
+ * ```
+ */
+export declare const PopoverDisclosureArrow: import("../utils/types.js").Component<PopoverDisclosureArrowOptions<"span">>;
+export interface PopoverDisclosureArrowOptions<T extends As = "span"> extends Options<T> {
+    /**
+     * Object returned by the `usePopoverStore` hook. If not provided, the parent
+     * `PopoverDisclosure` component's context will be used.
+     */
+    store?: PopoverStore;
+    /**
+     * Placement to which the arrow should point. If not provided, the parent
+     * `PopoverDisclosure` component's context will be used.
+     */
+    placement?: PopoverStoreState["placement"];
+}
+export type PopoverDisclosureArrowProps<T extends As = "span"> = Props<PopoverDisclosureArrowOptions<T>>;

package/esm/popover/popover-disclosure-arrow.js

@@ -0,0 +1,10 @@
+import {
+  PopoverDisclosureArrow,
+  usePopoverDisclosureArrow
+} from "../__chunks/KHFKAEA6.js";
+import "../__chunks/6GS36SYX.js";
+import "../__chunks/JE5NWDDX.js";
+export {
+  PopoverDisclosureArrow,
+  usePopoverDisclosureArrow
+};

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

@@ -0,0 +1,29 @@
+import type { DialogDisclosureOptions } from "../dialog/dialog-disclosure.js";
+import type { As, Props } from "../utils/types.js";
+import type { PopoverAnchorOptions } from "./popover-anchor.js";
+/**
+ * Returns props to create a `PopoverDisclosure` component.
+ * @see https://ariakit.org/components/popover
+ * @example
+ * ```jsx
+ * const store = usePopoverStore();
+ * const props = usePopoverDisclosure({ store });
+ * <Role {...props}>Disclosure</Role>
+ * <Popover store={store}>Popover</Popover>
+ * ```
+ */
+export declare const usePopoverDisclosure: import("../utils/types.js").Hook<PopoverDisclosureOptions<"button">>;
+/**
+ * Renders a button that controls the visibility of the popover when clicked.
+ * @see https://ariakit.org/components/popover
+ * @example
+ * ```jsx
+ * const popover = usePopoverStore();
+ * <PopoverDisclosure store={popover}>Disclosure</PopoverDisclosure>
+ * <Popover store={popover}>Popover</Popover>
+ * ```
+ */
+export declare const PopoverDisclosure: import("../utils/types.js").Component<PopoverDisclosureOptions<"button">>;
+export interface PopoverDisclosureOptions<T extends As = "button"> extends PopoverAnchorOptions<T>, Omit<DialogDisclosureOptions<T>, "store"> {
+}
+export type PopoverDisclosureProps<T extends As = "button"> = Props<PopoverDisclosureOptions<T>>;

package/esm/popover/popover-disclosure.js

@@ -0,0 +1,18 @@
+import {
+  PopoverDisclosure,
+  usePopoverDisclosure
+} from "../__chunks/JKSMOXA4.js";
+import "../__chunks/NRA7DRSD.js";
+import "../__chunks/57UTLR6J.js";
+import "../__chunks/I4MLEPTM.js";
+import "../__chunks/6GS36SYX.js";
+import "../__chunks/RNWB46DZ.js";
+import "../__chunks/SAVDGYCC.js";
+import "../__chunks/5TGAWEHD.js";
+import "../__chunks/JE5NWDDX.js";
+import "../__chunks/B7MIN7YT.js";
+import "../__chunks/SXC6BPOF.js";
+export {
+  PopoverDisclosure,
+  usePopoverDisclosure
+};