@ariakit/react-components 0.1.0

package/dist/hovercard/hovercard-arrow.js

@@ -0,0 +1,51 @@
+"use client";
+import { useHovercardContext } from "./hovercard-context.js";
+import { usePopoverArrow } from "../popover/popover-arrow.js";
+import { createElement, createHook, forwardRef } from "@ariakit/react-utils";
+//#region src/hovercard/hovercard-arrow.tsx
+const TagName = "div";
+/**
+* Returns props to create a `HovercardArrow` component.
+* @see https://ariakit.com/components/hovercard
+* @example
+* ```jsx
+* const store = useHovercardStore();
+* const props = useHovercardArrow({ store });
+* <Hovercard store={store}>
+*   <Role {...props} />
+*   Details
+* </Hovercard>
+* ```
+*/
+const useHovercardArrow = createHook(function useHovercardArrow({ store, ...props }) {
+	const context = useHovercardContext();
+	store = store || context;
+	props = usePopoverArrow({
+		store,
+		...props
+	});
+	return props;
+});
+/**
+* Renders an arrow element inside a
+* [`Hovercard`](https://ariakit.com/reference/hovercard) component that points
+* to the anchor element.
+* @see https://ariakit.com/components/hovercard
+* @example
+* ```jsx {4}
+* <HovercardProvider>
+*   <HovercardAnchor>@username</HovercardAnchor>
+*   <Hovercard>
+*     <HovercardArrow />
+*     Details
+*   </Hovercard>
+* </HovercardProvider>
+* ```
+*/
+const HovercardArrow = forwardRef(function HovercardArrow(props) {
+	return createElement(TagName, useHovercardArrow(props));
+});
+//#endregion
+export { HovercardArrow, useHovercardArrow };
+
+//# sourceMappingURL=hovercard-arrow.js.map

package/dist/hovercard/hovercard-arrow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hovercard-arrow.js","names":[],"sources":["../../src/hovercard/hovercard-arrow.tsx"],"sourcesContent":["import { createElement, createHook, forwardRef } from \"@ariakit/react-utils\";\nimport type { Props } from \"@ariakit/react-utils\";\nimport type { ElementType } from \"react\";\nimport type { PopoverArrowOptions } from \"../popover/popover-arrow.tsx\";\nimport { usePopoverArrow } from \"../popover/popover-arrow.tsx\";\nimport { useHovercardContext } from \"./hovercard-context.tsx\";\nimport type { HovercardStore } from \"./hovercard-store.ts\";\n\nconst TagName = \"div\" satisfies ElementType;\ntype TagName = typeof TagName;\n\n/**\n * Returns props to create a `HovercardArrow` component.\n * @see https://ariakit.com/components/hovercard\n * @example\n * ```jsx\n * const store = useHovercardStore();\n * const props = useHovercardArrow({ store });\n * <Hovercard store={store}>\n *   <Role {...props} />\n *   Details\n * </Hovercard>\n * ```\n */\nexport const useHovercardArrow = createHook<TagName, HovercardArrowOptions>(\n  function useHovercardArrow({ store, ...props }) {\n    const context = useHovercardContext();\n    store = store || context;\n    props = usePopoverArrow({ store, ...props });\n    return props;\n  },\n);\n\n/**\n * Renders an arrow element inside a\n * [`Hovercard`](https://ariakit.com/reference/hovercard) component that points\n * to the anchor element.\n * @see https://ariakit.com/components/hovercard\n * @example\n * ```jsx {4}\n * <HovercardProvider>\n *   <HovercardAnchor>@username</HovercardAnchor>\n *   <Hovercard>\n *     <HovercardArrow />\n *     Details\n *   </Hovercard>\n * </HovercardProvider>\n * ```\n */\nexport const HovercardArrow = forwardRef(function HovercardArrow(\n  props: HovercardArrowProps,\n) {\n  const htmlProps = useHovercardArrow(props);\n  return createElement(TagName, htmlProps);\n});\n\nexport interface HovercardArrowOptions<\n  T extends ElementType = TagName,\n> extends PopoverArrowOptions<T> {\n  /**\n   * Object returned by the\n   * [`useHovercardStore`](https://ariakit.com/reference/use-hovercard-store)\n   * hook. If not provided, the closest\n   * [`Hovercard`](https://ariakit.com/reference/hovercard) or\n   * [`HovercardProvider`](https://ariakit.com/reference/hovercard-provider)\n   * components' context will be used.\n   */\n  store?: HovercardStore;\n}\n\nexport type HovercardArrowProps<T extends ElementType = TagName> = Props<\n  T,\n  HovercardArrowOptions<T>\n>;\n"],"mappings":";;;;;;;;;;;;;;;;;;;MA0BI,oBAAgB,WAAoB,SAAA,kBAAA,EAAA,OAAA,GAAA,SAAA;CACpC,MAAA,UAAQ,oBAAS;CACjB,QAAQ,SAAA;SAAkB,gBAAA;EAAO;EAAU,GAAA;CAC3C,CAAA;CAEJ,OAAA;;;;;;;;;;;;;;;;;;MAsBE,iBAAqB,WADH,SAAA,eACqB,OAAA;CACxC,OAAA,cAAA,SAAA,kBAAA,KAAA,CAAA"}

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

@@ -0,0 +1,24 @@
+import { t as HovercardStore } from "../hovercard-store-gIeoQEn_.js";
+
+//#region src/hovercard/hovercard-context.d.ts
+/**
+ * Returns the hovercard store from the nearest hovercard container.
+ * @example
+ * function Hovercard() {
+ *   const store = useHovercardContext();
+ *
+ *   if (!store) {
+ *     throw new Error("Hovercard must be wrapped in HovercardProvider");
+ *   }
+ *
+ *   // Use the store...
+ * }
+ */
+declare const useHovercardContext: () => HovercardStore | undefined;
+declare const useHovercardScopedContext: (onlyScoped?: boolean) => HovercardStore | undefined;
+declare const useHovercardProviderContext: () => HovercardStore | undefined;
+declare const HovercardContextProvider: (props: import("react").ProviderProps<HovercardStore | undefined>) => import("react/jsx-runtime").JSX.Element;
+declare const HovercardScopedContextProvider: (props: import("react").ProviderProps<HovercardStore | undefined>) => import("react/jsx-runtime").JSX.Element;
+//#endregion
+export { HovercardContextProvider, HovercardScopedContextProvider, useHovercardContext, useHovercardProviderContext, useHovercardScopedContext };
+//# sourceMappingURL=hovercard-context.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hovercard-context.d.ts","names":["HovercardStore","useHovercardContext","useHovercardScopedContext","onlyScoped","useHovercardProviderContext","HovercardContextProvider","ProviderProps","props","JSX","Element","HovercardScopedContextProvider"],"sources":["../../src/hovercard/hovercard-context.d.ts"],"mappings":";;;;;AAcA;;;;AAA8D;AAC9D;;;;AAAwF;AACxF;cAFqBC,mBAAAA,QAA2BD,cAAc;AAAA,cACzCE,yBAAAA,GAA4BC,UAAAA,eAAyBH,cAAc;AAAA,cACnEI,2BAAAA,QAAmCJ,cAAc;AAAA,cACjDK,wBAAAA,GAA2BE,KAAAA,kBAAuBD,aAAAA,CAAcN,cAAc,8CAA8CQ,GAAAA,CAAIC,OAAAA;AAAAA,cAChIC,8BAAAA,GAAiCH,KAAAA,kBAAuBD,aAAAA,CAAcN,cAAc,8CAA8CQ,GAAAA,CAAIC,OAAAA"}

package/dist/hovercard/hovercard-context.js

@@ -0,0 +1,27 @@
+"use client";
+import { PopoverContextProvider, PopoverScopedContextProvider } from "../popover/popover-context.js";
+import { createStoreContext } from "@ariakit/react-utils";
+//#region src/hovercard/hovercard-context.tsx
+const ctx = createStoreContext([PopoverContextProvider], [PopoverScopedContextProvider]);
+/**
+* Returns the hovercard store from the nearest hovercard container.
+* @example
+* function Hovercard() {
+*   const store = useHovercardContext();
+*
+*   if (!store) {
+*     throw new Error("Hovercard must be wrapped in HovercardProvider");
+*   }
+*
+*   // Use the store...
+* }
+*/
+const useHovercardContext = ctx.useContext;
+const useHovercardScopedContext = ctx.useScopedContext;
+const useHovercardProviderContext = ctx.useProviderContext;
+const HovercardContextProvider = ctx.ContextProvider;
+const HovercardScopedContextProvider = ctx.ScopedContextProvider;
+//#endregion
+export { HovercardContextProvider, HovercardScopedContextProvider, useHovercardContext, useHovercardProviderContext, useHovercardScopedContext };
+
+//# sourceMappingURL=hovercard-context.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hovercard-context.js","names":[],"sources":["../../src/hovercard/hovercard-context.tsx"],"sourcesContent":["import { createStoreContext } from \"@ariakit/react-utils\";\nimport {\n  PopoverContextProvider,\n  PopoverScopedContextProvider,\n} from \"../popover/popover-context.tsx\";\nimport type { HovercardStore } from \"./hovercard-store.ts\";\n\nconst ctx = createStoreContext<HovercardStore>(\n  [PopoverContextProvider],\n  [PopoverScopedContextProvider],\n);\n\n/**\n * Returns the hovercard store from the nearest hovercard container.\n * @example\n * function Hovercard() {\n *   const store = useHovercardContext();\n *\n *   if (!store) {\n *     throw new Error(\"Hovercard must be wrapped in HovercardProvider\");\n *   }\n *\n *   // Use the store...\n * }\n */\nexport const useHovercardContext = ctx.useContext;\n\nexport const useHovercardScopedContext = ctx.useScopedContext;\n\nexport const useHovercardProviderContext = ctx.useProviderContext;\n\nexport const HovercardContextProvider = ctx.ContextProvider;\n\nexport const HovercardScopedContextProvider = ctx.ScopedContextProvider;\n"],"mappings":";;;;;;;;;;;;;;;;;;AA2BA,MAAa,sBAAA,IAAA;AAEb,MAAa,4BAAA,IAA8B;AAE3C,MAAa,8BAA2B,IAAI;AAE5C,MAAa,2BAAA,IAAA"}

package/dist/hovercard/hovercard-description.d.ts

@@ -0,0 +1,51 @@
+import { t as HovercardStore } from "../hovercard-store-gIeoQEn_.js";
+import { n as PopoverDescriptionOptions } from "../popover-description-DU753dah.js";
+import { Props } from "@ariakit/react-utils";
+import { ElementType } from "react";
+
+//#region src/hovercard/hovercard-description.d.ts
+declare const TagName = "p";
+type TagName = typeof TagName;
+/**
+ * Returns props to create a `HovercardDescription` component. This hook must be
+ * used in a component that's wrapped with `Hovercard` so the `aria-describedby`
+ * prop is properly set on the hovercard element.
+ * @see https://ariakit.com/components/hovercard
+ * @example
+ * ```jsx
+ * // This component must be wrapped with Hovercard
+ * const props = useHovercardDescription();
+ * <Role {...props}>Description</Role>
+ * ```
+ */
+declare const useHovercardDescription: import("@ariakit/react-utils").Hook<"p", HovercardDescriptionOptions<"p">>;
+/**
+ * Renders a description in a hovercard. This component must be wrapped within
+ * [`Hovercard`](https://ariakit.com/reference/hovercard) so the
+ * `aria-describedby` prop is properly set on the content element.
+ * @see https://ariakit.com/components/hovercard
+ * @example
+ * ```jsx {3}
+ * <HovercardProvider>
+ *   <Hovercard>
+ *     <HovercardDescription>Description</HovercardDescription>
+ *   </Hovercard>
+ * </HovercardProvider>
+ * ```
+ */
+declare const HovercardDescription: (props: HovercardDescriptionProps) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+interface HovercardDescriptionOptions<T extends ElementType = TagName> extends PopoverDescriptionOptions<T> {
+  /**
+   * Object returned by the
+   * [`useHovercardStore`](https://ariakit.com/reference/use-hovercard-store)
+   * hook. If not provided, the closest
+   * [`Hovercard`](https://ariakit.com/reference/hovercard) or
+   * [`HovercardProvider`](https://ariakit.com/reference/hovercard-provider)
+   * components' context will be used.
+   */
+  store?: HovercardStore;
+}
+type HovercardDescriptionProps<T extends ElementType = TagName> = Props<T, HovercardDescriptionOptions<T>>;
+//#endregion
+export { HovercardDescription, HovercardDescriptionOptions, HovercardDescriptionProps, useHovercardDescription };
+//# sourceMappingURL=hovercard-description.d.ts.map

package/dist/hovercard/hovercard-description.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hovercard-description.d.ts","names":["Props","ElementType","PopoverDescriptionOptions","HovercardStore","TagName","useHovercardDescription","HovercardDescriptionOptions","Hook","HovercardDescription","HovercardDescriptionProps","props","ReactElement","JSXElementConstructor","T","store"],"sources":["../../src/hovercard/hovercard-description.d.ts"],"mappings":";;;;;;cAIcI,OAAAA;AAAAA,KACTA,OAAAA,UAAiBA,OAAO;AAF8B;;;;AACtC;AAAA;;;;AACQ;AAa7B;;AAf2D,cAetCC,uBAAAA,iCAAwDE,IAAAA,MAAUD,2BAA2B;;AAAA;AAelH;;;;;;;;;AAAiK;AACjK;;cADqBE,oBAAAA,GAAuBE,KAAAA,EAAOD,yBAAyB,qBAAqBE,YAAAA,+BAA2CC,qBAAAA;AAAAA,UAC3HN,2BAAAA,WAAsCL,WAAAA,GAAcG,OAAAA,UAAiBF,yBAAAA,CAA0BW,CAAAA;EAA3CT;;;;;;;;EASjEU,KAAAA,GAAQX,cAAAA;AAAAA;AAAAA,KAEAM,yBAAAA,WAAoCR,WAAAA,GAAcG,OAAAA,IAAWJ,KAAAA,CAAMa,CAAAA,EAAGP,2BAAAA,CAA4BO,CAAAA"}

package/dist/hovercard/hovercard-description.js

@@ -0,0 +1,42 @@
+"use client";
+import { usePopoverDescription } from "../popover/popover-description.js";
+import { createElement, createHook, forwardRef } from "@ariakit/react-utils";
+//#region src/hovercard/hovercard-description.tsx
+const TagName = "p";
+/**
+* Returns props to create a `HovercardDescription` component. This hook must be
+* used in a component that's wrapped with `Hovercard` so the `aria-describedby`
+* prop is properly set on the hovercard element.
+* @see https://ariakit.com/components/hovercard
+* @example
+* ```jsx
+* // This component must be wrapped with Hovercard
+* const props = useHovercardDescription();
+* <Role {...props}>Description</Role>
+* ```
+*/
+const useHovercardDescription = createHook(function useHovercardDescription(props) {
+	props = usePopoverDescription(props);
+	return props;
+});
+/**
+* Renders a description in a hovercard. This component must be wrapped within
+* [`Hovercard`](https://ariakit.com/reference/hovercard) so the
+* `aria-describedby` prop is properly set on the content element.
+* @see https://ariakit.com/components/hovercard
+* @example
+* ```jsx {3}
+* <HovercardProvider>
+*   <Hovercard>
+*     <HovercardDescription>Description</HovercardDescription>
+*   </Hovercard>
+* </HovercardProvider>
+* ```
+*/
+const HovercardDescription = forwardRef(function HovercardDescription(props) {
+	return createElement(TagName, useHovercardDescription(props));
+});
+//#endregion
+export { HovercardDescription, useHovercardDescription };
+
+//# sourceMappingURL=hovercard-description.js.map

package/dist/hovercard/hovercard-description.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hovercard-description.js","names":[],"sources":["../../src/hovercard/hovercard-description.tsx"],"sourcesContent":["import { createElement, createHook, forwardRef } from \"@ariakit/react-utils\";\nimport type { Props } from \"@ariakit/react-utils\";\nimport type { ElementType } from \"react\";\nimport type { PopoverDescriptionOptions } from \"../popover/popover-description.tsx\";\nimport { usePopoverDescription } from \"../popover/popover-description.tsx\";\nimport type { HovercardStore } from \"./hovercard-store.ts\";\n\nconst TagName = \"p\" satisfies ElementType;\ntype TagName = typeof TagName;\n\n/**\n * Returns props to create a `HovercardDescription` component. This hook must be\n * used in a component that's wrapped with `Hovercard` so the `aria-describedby`\n * prop is properly set on the hovercard element.\n * @see https://ariakit.com/components/hovercard\n * @example\n * ```jsx\n * // This component must be wrapped with Hovercard\n * const props = useHovercardDescription();\n * <Role {...props}>Description</Role>\n * ```\n */\nexport const useHovercardDescription = createHook<\n  TagName,\n  HovercardDescriptionOptions\n>(function useHovercardDescription(props) {\n  props = usePopoverDescription(props);\n  return props;\n});\n\n/**\n * Renders a description in a hovercard. This component must be wrapped within\n * [`Hovercard`](https://ariakit.com/reference/hovercard) so the\n * `aria-describedby` prop is properly set on the content element.\n * @see https://ariakit.com/components/hovercard\n * @example\n * ```jsx {3}\n * <HovercardProvider>\n *   <Hovercard>\n *     <HovercardDescription>Description</HovercardDescription>\n *   </Hovercard>\n * </HovercardProvider>\n * ```\n */\nexport const HovercardDescription = forwardRef(function HovercardDescription(\n  props: HovercardDescriptionProps,\n) {\n  const htmlProps = useHovercardDescription(props);\n  return createElement(TagName, htmlProps);\n});\n\nexport interface HovercardDescriptionOptions<\n  T extends ElementType = TagName,\n> extends PopoverDescriptionOptions<T> {\n  /**\n   * Object returned by the\n   * [`useHovercardStore`](https://ariakit.com/reference/use-hovercard-store)\n   * hook. If not provided, the closest\n   * [`Hovercard`](https://ariakit.com/reference/hovercard) or\n   * [`HovercardProvider`](https://ariakit.com/reference/hovercard-provider)\n   * components' context will be used.\n   */\n  store?: HovercardStore;\n}\n\nexport type HovercardDescriptionProps<T extends ElementType = TagName> = Props<\n  T,\n  HovercardDescriptionOptions<T>\n>;\n"],"mappings":";;;;;;;;;;;;;;;;;MA0BE,0BAA8B,WAAK,SAAA,wBAAA,OAAA;CACnC,QAAO,sBAAA,KAAA;CACR,OAAA;;;;;;;;;;;;;;;;MAoBC,uBAAqB,WADH,SAAA,qBACqB,OAAA;CACxC,OAAA,cAAA,SAAA,wBAAA,KAAA,CAAA"}

package/dist/hovercard/hovercard-disclosure.d.ts

@@ -0,0 +1,51 @@
+import { n as DialogDisclosureOptions } from "../dialog-disclosure-DLD10zlb.js";
+import { t as HovercardStore } from "../hovercard-store-gIeoQEn_.js";
+import { Props } from "@ariakit/react-utils";
+import { ElementType } from "react";
+
+//#region src/hovercard/hovercard-disclosure.d.ts
+declare const TagName = "button";
+type TagName = typeof TagName;
+/**
+ * Returns props to create a `HovercardDisclosure` component.
+ * @see https://ariakit.com/components/hovercard
+ * @example
+ * ```jsx
+ * const store = useHovercardStore();
+ * const props = useHovercardDisclosure({ store });
+ * <HovercardAnchor store={store}>@username</HovercardAnchor>
+ * <Role {...props} />
+ * <Hovercard store={store}>Details</Hovercard>
+ * ```
+ */
+declare const useHovercardDisclosure: import("@ariakit/react-utils").Hook<"button", HovercardDisclosureOptions<"button">>;
+/**
+ * Renders a hidden disclosure button that will be visible when the
+ * [`HovercardAnchor`](https://ariakit.com/reference/hovercard-anchor) receives
+ * keyboard focus. The user can then navigate to the button to open the
+ * hovercard when using the keyboard.
+ * @see https://ariakit.com/components/hovercard
+ * @example
+ * ```jsx {3}
+ * <HovercardProvider>
+ *   <HovercardAnchor>@username</HovercardAnchor>
+ *   <HovercardDisclosure />
+ *   <Hovercard>Details</Hovercard>
+ * </HovercardProvider>
+ * ```
+ */
+declare const HovercardDisclosure: (props: HovercardDisclosureProps) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+interface HovercardDisclosureOptions<T extends ElementType = TagName> extends DialogDisclosureOptions<T> {
+  /**
+   * Object returned by the
+   * [`useHovercardStore`](https://ariakit.com/reference/use-hovercard-store)
+   * hook. If not provided, the closest
+   * [`HovercardProvider`](https://ariakit.com/reference/hovercard-provider)
+   * component's context will be used.
+   */
+  store?: HovercardStore;
+}
+type HovercardDisclosureProps<T extends ElementType = TagName> = Props<T, HovercardDisclosureOptions<T>>;
+//#endregion
+export { HovercardDisclosure, HovercardDisclosureOptions, HovercardDisclosureProps, useHovercardDisclosure };
+//# sourceMappingURL=hovercard-disclosure.d.ts.map

package/dist/hovercard/hovercard-disclosure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hovercard-disclosure.d.ts","names":["Props","ElementType","DialogDisclosureOptions","HovercardStore","TagName","useHovercardDisclosure","HovercardDisclosureOptions","Hook","HovercardDisclosure","HovercardDisclosureProps","props","ReactElement","JSXElementConstructor","T","store"],"sources":["../../src/hovercard/hovercard-disclosure.d.ts"],"mappings":";;;;;;cAIcI,OAAAA;AAAAA,KACTA,OAAAA,UAAiBA,OAAO;AAF8B;;;;AACtC;AAAA;;;;AACQ;AAa7B;;AAf2D,cAetCC,sBAAAA,iCAAuDE,IAAAA,WAAeD,0BAA0B;;AAAA;AAgBrH;;;;;;;;;AAA+J;AAC/J;;;cADqBE,mBAAAA,GAAsBE,KAAAA,EAAOD,wBAAwB,qBAAqBE,YAAAA,+BAA2CC,qBAAAA;AAAAA,UACzHN,0BAAAA,WAAqCL,WAAAA,GAAcG,OAAAA,UAAiBF,uBAAAA,CAAwBW,CAAAA;EAAAA;;;;;;;EAQzGC,KAAAA,GAAQX,cAAAA;AAAAA;AAAAA,KAEAM,wBAAAA,WAAmCR,WAAAA,GAAcG,OAAAA,IAAWJ,KAAAA,CAAMa,CAAAA,EAAGP,0BAAAA,CAA2BO,CAAAA"}

package/dist/hovercard/hovercard-disclosure.js

@@ -0,0 +1,122 @@
+"use client";
+import { useDialogDisclosure } from "../dialog/dialog-disclosure.js";
+import { useVisuallyHidden } from "../visually-hidden/visually-hidden.js";
+import { useHovercardProviderContext } from "./hovercard-context.js";
+import { createElement, createHook, forwardRef, useEvent, useMergeRefs } from "@ariakit/react-utils";
+import { addGlobalEventListener, contains, invariant } from "@ariakit/utils";
+import { useEffect, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+import { sync } from "@ariakit/store";
+//#region src/hovercard/hovercard-disclosure.tsx
+const TagName = "button";
+/**
+* Returns props to create a `HovercardDisclosure` component.
+* @see https://ariakit.com/components/hovercard
+* @example
+* ```jsx
+* const store = useHovercardStore();
+* const props = useHovercardDisclosure({ store });
+* <HovercardAnchor store={store}>@username</HovercardAnchor>
+* <Role {...props} />
+* <Hovercard store={store}>Details</Hovercard>
+* ```
+*/
+const useHovercardDisclosure = createHook(function useHovercardDisclosure({ store, ...props }) {
+	const context = useHovercardProviderContext();
+	store = store || context;
+	invariant(store, "HovercardDisclosure must receive a `store` prop or be wrapped in a HovercardProvider component.");
+	const [visible, setVisible] = useState(false);
+	useEffect(() => {
+		if (!visible) return;
+		const onBlur = (event) => {
+			if (!store) return;
+			const nextActiveElement = event.relatedTarget;
+			if (nextActiveElement) {
+				const { anchorElement: anchor, popoverElement: popover, disclosureElement: disclosure } = store.getState();
+				if (anchor && contains(anchor, nextActiveElement)) return;
+				if (popover && contains(popover, nextActiveElement)) return;
+				if (disclosure && contains(disclosure, nextActiveElement)) return;
+				if (nextActiveElement.hasAttribute("data-focus-trap")) return;
+			}
+			setVisible(false);
+		};
+		return addGlobalEventListener("focusout", onBlur, true);
+	}, [visible, store]);
+	useEffect(() => {
+		return sync(store, ["anchorElement"], (state) => {
+			const anchor = state.anchorElement;
+			if (!anchor) return;
+			const observer = new MutationObserver(() => {
+				if (!anchor.hasAttribute("data-focus-visible")) return;
+				setVisible(true);
+			});
+			observer.observe(anchor, { attributeFilter: ["data-focus-visible"] });
+			return () => observer.disconnect();
+		});
+	}, [store]);
+	const onClickProp = props.onClick;
+	const onClick = useEvent((event) => {
+		onClickProp?.(event);
+		if (event.defaultPrevented) return;
+		store?.setAutoFocusOnShow(true);
+	});
+	const onFocusProp = props.onFocus;
+	const onFocus = useEvent((event) => {
+		onFocusProp?.(event);
+		if (event.defaultPrevented) return;
+		setVisible(true);
+	});
+	const { style } = useVisuallyHidden();
+	if (!visible) props = {
+		...props,
+		style: {
+			...style,
+			...props.style
+		}
+	};
+	props = {
+		children: /* @__PURE__ */ jsx("svg", {
+			display: "block",
+			fill: "none",
+			stroke: "currentColor",
+			strokeLinecap: "round",
+			strokeLinejoin: "round",
+			strokeWidth: 1.5,
+			viewBox: "0 0 16 16",
+			height: "1em",
+			width: "1em",
+			children: /* @__PURE__ */ jsx("polyline", { points: "4,6 8,10 12,6" })
+		}),
+		...props,
+		ref: useMergeRefs(store.setDisclosureElement, props.ref),
+		onClick,
+		onFocus
+	};
+	props = useDialogDisclosure({
+		store,
+		...props
+	});
+	return props;
+});
+/**
+* Renders a hidden disclosure button that will be visible when the
+* [`HovercardAnchor`](https://ariakit.com/reference/hovercard-anchor) receives
+* keyboard focus. The user can then navigate to the button to open the
+* hovercard when using the keyboard.
+* @see https://ariakit.com/components/hovercard
+* @example
+* ```jsx {3}
+* <HovercardProvider>
+*   <HovercardAnchor>@username</HovercardAnchor>
+*   <HovercardDisclosure />
+*   <Hovercard>Details</Hovercard>
+* </HovercardProvider>
+* ```
+*/
+const HovercardDisclosure = forwardRef(function HovercardDisclosure(props) {
+	return createElement(TagName, useHovercardDisclosure(props));
+});
+//#endregion
+export { HovercardDisclosure, useHovercardDisclosure };
+
+//# sourceMappingURL=hovercard-disclosure.js.map

package/dist/hovercard/hovercard-disclosure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hovercard-disclosure.js","names":[],"sources":["../../src/hovercard/hovercard-disclosure.tsx"],"sourcesContent":["import {\n  useEvent,\n  useMergeRefs,\n  createElement,\n  createHook,\n  forwardRef,\n} from \"@ariakit/react-utils\";\nimport type { Props } from \"@ariakit/react-utils\";\nimport { sync } from \"@ariakit/store\";\nimport { contains, addGlobalEventListener, invariant } from \"@ariakit/utils\";\nimport type {\n  ElementType,\n  MouseEvent,\n  FocusEvent as ReactFocusEvent,\n} from \"react\";\nimport { useEffect, useState } from \"react\";\nimport type { DialogDisclosureOptions } from \"../dialog/dialog-disclosure.tsx\";\nimport { useDialogDisclosure } from \"../dialog/dialog-disclosure.tsx\";\nimport { useVisuallyHidden } from \"../visually-hidden/visually-hidden.tsx\";\nimport { useHovercardProviderContext } from \"./hovercard-context.tsx\";\nimport type { HovercardStore } from \"./hovercard-store.ts\";\n\nconst TagName = \"button\" satisfies ElementType;\ntype TagName = typeof TagName;\ntype HTMLType = HTMLElementTagNameMap[TagName];\n\n/**\n * Returns props to create a `HovercardDisclosure` component.\n * @see https://ariakit.com/components/hovercard\n * @example\n * ```jsx\n * const store = useHovercardStore();\n * const props = useHovercardDisclosure({ store });\n * <HovercardAnchor store={store}>@username</HovercardAnchor>\n * <Role {...props} />\n * <Hovercard store={store}>Details</Hovercard>\n * ```\n */\nexport const useHovercardDisclosure = createHook<\n  TagName,\n  HovercardDisclosureOptions\n>(function useHovercardDisclosure({ store, ...props }) {\n  const context = useHovercardProviderContext();\n  store = store || context;\n\n  invariant(\n    store,\n    process.env.NODE_ENV !== \"production\" &&\n      \"HovercardDisclosure must receive a `store` prop or be wrapped in a HovercardProvider component.\",\n  );\n\n  const [visible, setVisible] = useState(false);\n\n  // Listens to blur events on the whole document and hides the hovercard\n  // disclosure if either the hovercard, the anchor or the disclosure button\n  // itself loses focus.\n  useEffect(() => {\n    if (!visible) return;\n    const onBlur = (event: FocusEvent) => {\n      if (!store) return;\n      const nextActiveElement = event.relatedTarget as Element | null;\n      if (nextActiveElement) {\n        const {\n          anchorElement: anchor,\n          popoverElement: popover,\n          disclosureElement: disclosure,\n        } = store.getState();\n        if (anchor && contains(anchor, nextActiveElement)) return;\n        if (popover && contains(popover, nextActiveElement)) return;\n        if (disclosure && contains(disclosure, nextActiveElement)) return;\n        // When the portal prop is set to true on the Hovercard component,\n        // it's going to render focus trap elements outside of the portal.\n        // These elements may transfer focus to the disclosure button, so we\n        // also ignore them here.\n        if (nextActiveElement.hasAttribute(\"data-focus-trap\")) return;\n      }\n      setVisible(false);\n    };\n    return addGlobalEventListener(\"focusout\", onBlur, true);\n  }, [visible, store]);\n\n  // Shows the hovercard disclosure when the anchor receives keyboard focus.\n  useEffect(() => {\n    return sync(store, [\"anchorElement\"], (state) => {\n      const anchor = state.anchorElement;\n      if (!anchor) return;\n      const observer = new MutationObserver(() => {\n        if (!anchor.hasAttribute(\"data-focus-visible\")) return;\n        setVisible(true);\n      });\n      observer.observe(anchor, { attributeFilter: [\"data-focus-visible\"] });\n      return () => observer.disconnect();\n    });\n  }, [store]);\n\n  const onClickProp = props.onClick;\n\n  // By default, hovercards don't receive focus when they are shown. When the\n  // disclosure element is clicked, though, we want it to behave like a\n  // popover, so we set the autoFocusOnShow prop to true.\n  const onClick = useEvent((event: MouseEvent<HTMLType>) => {\n    onClickProp?.(event);\n    if (event.defaultPrevented) return;\n    store?.setAutoFocusOnShow(true);\n  });\n\n  const onFocusProp = props.onFocus;\n\n  // Since the disclosure button is only visually hidden, it may receive focus\n  // when the user tabs to it. So we make sure it's visible when that happens.\n  const onFocus = useEvent((event: ReactFocusEvent<HTMLType>) => {\n    onFocusProp?.(event);\n    if (event.defaultPrevented) return;\n    setVisible(true);\n  });\n\n  const { style } = useVisuallyHidden();\n\n  if (!visible) {\n    props = {\n      ...props,\n      style: {\n        ...style,\n        ...props.style,\n      },\n    };\n  }\n\n  const children = (\n    <svg\n      display=\"block\"\n      fill=\"none\"\n      stroke=\"currentColor\"\n      strokeLinecap=\"round\"\n      strokeLinejoin=\"round\"\n      strokeWidth={1.5}\n      viewBox=\"0 0 16 16\"\n      height=\"1em\"\n      width=\"1em\"\n    >\n      <polyline points=\"4,6 8,10 12,6\" />\n    </svg>\n  );\n\n  props = {\n    children,\n    ...props,\n    ref: useMergeRefs(store.setDisclosureElement, props.ref),\n    onClick,\n    onFocus,\n  };\n\n  props = useDialogDisclosure({ store, ...props });\n\n  return props;\n});\n\n/**\n * Renders a hidden disclosure button that will be visible when the\n * [`HovercardAnchor`](https://ariakit.com/reference/hovercard-anchor) receives\n * keyboard focus. The user can then navigate to the button to open the\n * hovercard when using the keyboard.\n * @see https://ariakit.com/components/hovercard\n * @example\n * ```jsx {3}\n * <HovercardProvider>\n *   <HovercardAnchor>@username</HovercardAnchor>\n *   <HovercardDisclosure />\n *   <Hovercard>Details</Hovercard>\n * </HovercardProvider>\n * ```\n */\nexport const HovercardDisclosure = forwardRef(function HovercardDisclosure(\n  props: HovercardDisclosureProps,\n) {\n  const htmlProps = useHovercardDisclosure(props);\n  return createElement(TagName, htmlProps);\n});\n\nexport interface HovercardDisclosureOptions<\n  T extends ElementType = TagName,\n> extends DialogDisclosureOptions<T> {\n  /**\n   * Object returned by the\n   * [`useHovercardStore`](https://ariakit.com/reference/use-hovercard-store)\n   * hook. If not provided, the closest\n   * [`HovercardProvider`](https://ariakit.com/reference/hovercard-provider)\n   * component's context will be used.\n   */\n  store?: HovercardStore;\n}\n\nexport type HovercardDisclosureProps<T extends ElementType = TagName> = Props<\n  T,\n  HovercardDisclosureOptions<T>\n>;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;MA0CE,yBAAgB,WAAA,SAA4B,uBAAA,EAAA,OAAA,GAAA,SAAA;CAC5C,MAAA,UAAQ,4BAAS;CAEjB,QAAA,SAGI;CAGJ,UAAO,OAAS,iGAA4B;CAK5C,MAAA,CAAA,SAAgB,cAAA,SAAA,KAAA;iBACA;EACd,IAAA,CAAA,SAAM;QACC,UAAO,UAAA;GACZ,IAAA,CAAA,OAAM;GACN,MAAI,oBAAmB,MAAA;OACrB,mBACE;IAIF,MAAI,EAAA,eAAmB,QAAQ,gBAAA,SAAoB,mBAAA,eAAA,MAAA,SAAA;IACnD,IAAI,UAAA,SAAW,QAAS,iBAAS,GAAiB;IAClD,IAAI,WAAA,SAAc,SAAS,iBAAY,GAAA;IAKvC,IAAI,cAAA,SAAkB,YAAa,iBAAoB,GAAA;IACzD,IAAA,kBAAA,aAAA,iBAAA,GAAA;GACA;GACF,WAAA,KAAA;EACA;EACF,OAAI,uBAAe,YAAA,QAAA,IAAA;CAGnB,GAAA,CAAA,SAAA,KAAgB,CAAA;iBACF;SACJ,KAAA,OAAS,CAAA,eAAM,IAAA,UAAA;GACrB,MAAK,SAAQ,MAAA;GACb,IAAA,CAAA,QAAM;SACC,WAAO,IAAA,uBAAa;IACzB,IAAA,CAAA,OAAW,aAAI,oBAAA,GAAA;IAChB,WAAA,IAAA;GACD,CAAA;GACA,SAAA,QAAa,QAAS,EAAA,iBAAW,CAAA,oBAAA,EAAA,CAAA;GAClC,aAAA,SAAA,WAAA;EACH,CAAA;CAEA,GAAA,CAAA,KAAM,CAAA;CAKN,MAAM,cAAU,MAAU;OACxB,UAAc,UAAK,UAAA;EACnB,cAAU,KAAA;EACV,IAAA,MAAO,kBAAmB;EAC3B,OAAA,mBAAA,IAAA;CAED,CAAA;CAIA,MAAM,cAAU,MAAU;OACxB,UAAc,UAAK,UAAA;EACnB,cAAU,KAAA;EACV,IAAA,MAAA,kBAAe;EAChB,WAAA,IAAA;CAED,CAAA;CAEA,MAAK,EAAA,UACH,kBAAQ;KACH,CAAA,SAAA,QAAA;EACH,GAAA;SACK;GACH,GAAG;GACL,GAAA,MAAA;EACF;CAmBF;SACE;YAfU,oBAAA,OAAA;GACR,SAAK;GACL,MAAA;GACA,QAAA;GACA,eAAA;GACA,gBAAa;GACb,aAAQ;GACR,SAAO;GACP,QAAM;;GAOD,UAAA,oBAAA,YAAA,EAAA,QAAA,gBAAA,CAAA;EACP,CAAA;EACA,GAAA;EACA,KAAA,aAAA,MAAA,sBAAA,MAAA,GAAA;EACA;EACF;CAEA;SAA8B,oBAAA;EAAO;EAAU,GAAA;CAE/C,CAAA;CACD,OAAA;;;;;;;;;;;;;;;;;MAqBC,sBAAqB,WADH,SAAA,oBACqB,OAAA;CACxC,OAAA,cAAA,SAAA,uBAAA,KAAA,CAAA"}

package/dist/hovercard/hovercard-dismiss.d.ts

@@ -0,0 +1,50 @@
+import { t as HovercardStore } from "../hovercard-store-gIeoQEn_.js";
+import { n as PopoverDismissOptions } from "../popover-dismiss-DPeI6Zse.js";
+import { Props } from "@ariakit/react-utils";
+import { ElementType } from "react";
+
+//#region src/hovercard/hovercard-dismiss.d.ts
+declare const TagName = "button";
+type TagName = typeof TagName;
+/**
+ * Returns props to create a `HovercardDismiss` component.
+ * @see https://ariakit.com/components/hovercard
+ * @example
+ * ```jsx
+ * const store = useHovercardStore();
+ * const props = useHovercardDismiss({ store });
+ * <Hovercard store={store}>
+ *   <Role {...props} />
+ * </Hovercard>
+ * ```
+ */
+declare const useHovercardDismiss: import("@ariakit/react-utils").Hook<"button", HovercardDismissOptions<"button">>;
+/**
+ * Renders a button that hides a
+ * [`Hovercard`](https://ariakit.com/reference/hovercard) when clicked.
+ * @see https://ariakit.com/components/hovercard
+ * @example
+ * ```jsx {3}
+ * <HovercardProvider>
+ *   <Hovercard>
+ *     <HovercardDismiss />
+ *   </Hovercard>
+ * </HovercardProvider>
+ * ```
+ */
+declare const HovercardDismiss: (props: HovercardDismissProps) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+interface HovercardDismissOptions<T extends ElementType = TagName> extends PopoverDismissOptions<T> {
+  /**
+   * Object returned by the
+   * [`useHovercardStore`](https://ariakit.com/reference/use-hovercard-store)
+   * hook. If not provided, the closest
+   * [`Hovercard`](https://ariakit.com/reference/hovercard) or
+   * [`HovercardProvider`](https://ariakit.com/reference/hovercard-provider)
+   * components' context will be used.
+   */
+  store?: HovercardStore;
+}
+type HovercardDismissProps<T extends ElementType = TagName> = Props<T, HovercardDismissOptions<T>>;
+//#endregion
+export { HovercardDismiss, HovercardDismissOptions, HovercardDismissProps, useHovercardDismiss };
+//# sourceMappingURL=hovercard-dismiss.d.ts.map

package/dist/hovercard/hovercard-dismiss.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hovercard-dismiss.d.ts","names":["Props","ElementType","PopoverDismissOptions","HovercardStore","TagName","useHovercardDismiss","HovercardDismissOptions","Hook","HovercardDismiss","HovercardDismissProps","props","ReactElement","JSXElementConstructor","T","store"],"sources":["../../src/hovercard/hovercard-dismiss.d.ts"],"mappings":";;;;;;cAIcI,OAAAA;AAAAA,KACTA,OAAAA,UAAiBA,OAAO;AAF8B;;;;AACtC;AAAA;;;;AACQ;AAa7B;;AAf2D,cAetCC,mBAAAA,iCAAoDE,IAAAA,WAAeD,uBAAuB;;AAAA;AAc/G;;;;;;;;;AAAyJ;AACzJ;cADqBE,gBAAAA,GAAmBE,KAAAA,EAAOD,qBAAqB,qBAAqBE,YAAAA,+BAA2CC,qBAAAA;AAAAA,UACnHN,uBAAAA,WAAkCL,WAAAA,GAAcG,OAAAA,UAAiBF,qBAAAA,CAAsBW,CAAAA;EAArDZ;;;;;;;;EAS/Ca,KAAAA,GAAQX,cAAAA;AAAAA;AAAAA,KAEAM,qBAAAA,WAAgCR,WAAAA,GAAcG,OAAAA,IAAWJ,KAAAA,CAAMa,CAAAA,EAAGP,uBAAAA,CAAwBO,CAAAA"}

package/dist/hovercard/hovercard-dismiss.js

@@ -0,0 +1,47 @@
+"use client";
+import { useHovercardScopedContext } from "./hovercard-context.js";
+import { usePopoverDismiss } from "../popover/popover-dismiss.js";
+import { createElement, createHook, forwardRef } from "@ariakit/react-utils";
+//#region src/hovercard/hovercard-dismiss.tsx
+const TagName = "button";
+/**
+* Returns props to create a `HovercardDismiss` component.
+* @see https://ariakit.com/components/hovercard
+* @example
+* ```jsx
+* const store = useHovercardStore();
+* const props = useHovercardDismiss({ store });
+* <Hovercard store={store}>
+*   <Role {...props} />
+* </Hovercard>
+* ```
+*/
+const useHovercardDismiss = createHook(function useHovercardDismiss({ store, ...props }) {
+	const context = useHovercardScopedContext();
+	store = store || context;
+	props = usePopoverDismiss({
+		store,
+		...props
+	});
+	return props;
+});
+/**
+* Renders a button that hides a
+* [`Hovercard`](https://ariakit.com/reference/hovercard) when clicked.
+* @see https://ariakit.com/components/hovercard
+* @example
+* ```jsx {3}
+* <HovercardProvider>
+*   <Hovercard>
+*     <HovercardDismiss />
+*   </Hovercard>
+* </HovercardProvider>
+* ```
+*/
+const HovercardDismiss = forwardRef(function HovercardDismiss(props) {
+	return createElement(TagName, useHovercardDismiss(props));
+});
+//#endregion
+export { HovercardDismiss, useHovercardDismiss };
+
+//# sourceMappingURL=hovercard-dismiss.js.map

package/dist/hovercard/hovercard-dismiss.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hovercard-dismiss.js","names":[],"sources":["../../src/hovercard/hovercard-dismiss.tsx"],"sourcesContent":["import { createElement, createHook, forwardRef } from \"@ariakit/react-utils\";\nimport type { Props } from \"@ariakit/react-utils\";\nimport type { ElementType } from \"react\";\nimport type { PopoverDismissOptions } from \"../popover/popover-dismiss.tsx\";\nimport { usePopoverDismiss } from \"../popover/popover-dismiss.tsx\";\nimport { useHovercardScopedContext } from \"./hovercard-context.tsx\";\nimport type { HovercardStore } from \"./hovercard-store.ts\";\n\nconst TagName = \"button\" satisfies ElementType;\ntype TagName = typeof TagName;\n\n/**\n * Returns props to create a `HovercardDismiss` component.\n * @see https://ariakit.com/components/hovercard\n * @example\n * ```jsx\n * const store = useHovercardStore();\n * const props = useHovercardDismiss({ store });\n * <Hovercard store={store}>\n *   <Role {...props} />\n * </Hovercard>\n * ```\n */\nexport const useHovercardDismiss = createHook<TagName, HovercardDismissOptions>(\n  function useHovercardDismiss({ store, ...props }) {\n    const context = useHovercardScopedContext();\n    store = store || context;\n    props = usePopoverDismiss({ store, ...props });\n    return props;\n  },\n);\n\n/**\n * Renders a button that hides a\n * [`Hovercard`](https://ariakit.com/reference/hovercard) when clicked.\n * @see https://ariakit.com/components/hovercard\n * @example\n * ```jsx {3}\n * <HovercardProvider>\n *   <Hovercard>\n *     <HovercardDismiss />\n *   </Hovercard>\n * </HovercardProvider>\n * ```\n */\nexport const HovercardDismiss = forwardRef(function HovercardDismiss(\n  props: HovercardDismissProps,\n) {\n  const htmlProps = useHovercardDismiss(props);\n  return createElement(TagName, htmlProps);\n});\n\nexport interface HovercardDismissOptions<\n  T extends ElementType = TagName,\n> extends PopoverDismissOptions<T> {\n  /**\n   * Object returned by the\n   * [`useHovercardStore`](https://ariakit.com/reference/use-hovercard-store)\n   * hook. If not provided, the closest\n   * [`Hovercard`](https://ariakit.com/reference/hovercard) or\n   * [`HovercardProvider`](https://ariakit.com/reference/hovercard-provider)\n   * components' context will be used.\n   */\n  store?: HovercardStore;\n}\n\nexport type HovercardDismissProps<T extends ElementType = TagName> = Props<\n  T,\n  HovercardDismissOptions<T>\n>;\n"],"mappings":";;;;;;;;;;;;;;;;;;MAyBI,sBAAgB,WAAA,SAA0B,oBAAA,EAAA,OAAA,GAAA,SAAA;CAC1C,MAAA,UAAQ,0BAAS;CACjB,QAAQ,SAAA;SAAoB,kBAAA;EAAO;EAAU,GAAA;CAC7C,CAAA;CAEJ,OAAA;;;;;;;;;;;;;;;MAmBE,mBAAqB,WADH,SAAA,iBACqB,OAAA;CACxC,OAAA,cAAA,SAAA,oBAAA,KAAA,CAAA"}

package/dist/hovercard/hovercard-heading.d.ts

@@ -0,0 +1,51 @@
+import { t as HovercardStore } from "../hovercard-store-gIeoQEn_.js";
+import { n as PopoverHeadingOptions } from "../popover-heading-DGsr6D5W.js";
+import { Props } from "@ariakit/react-utils";
+import { ElementType } from "react";
+
+//#region src/hovercard/hovercard-heading.d.ts
+declare const TagName = "h1";
+type TagName = typeof TagName;
+/**
+ * Returns props to create a `HovercardHeading` component. This hook must be
+ * used in a component that's wrapped with `Hovercard` so the `aria-labelledby`
+ * prop is properly set on the hovercard element.
+ * @see https://ariakit.com/components/hovercard
+ * @example
+ * ```jsx
+ * // This component must be wrapped with Hovercard
+ * const props = useHovercardHeading();
+ * <Role {...props}>Heading</Role>
+ * ```
+ */
+declare const useHovercardHeading: import("@ariakit/react-utils").Hook<"h1", HovercardHeadingOptions<"h1">>;
+/**
+ * Renders a heading in a hovercard. This component must be wrapped within
+ * [`Hovercard`](https://ariakit.com/reference/hovercard) so the
+ * `aria-labelledby` prop is properly set on the content element.
+ * @see https://ariakit.com/components/hovercard
+ * @example
+ * ```jsx {3}
+ * <HovercardProvider>
+ *   <Hovercard>
+ *     <HovercardHeading>Heading</HovercardHeading>
+ *   </Hovercard>
+ * </HovercardProvider>
+ * ```
+ */
+declare const HovercardHeading: (props: HovercardHeadingProps) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+interface HovercardHeadingOptions<T extends ElementType = TagName> extends PopoverHeadingOptions<T> {
+  /**
+   * Object returned by the
+   * [`useHovercardStore`](https://ariakit.com/reference/use-hovercard-store)
+   * hook. If not provided, the closest
+   * [`Hovercard`](https://ariakit.com/reference/hovercard) or
+   * [`HovercardProvider`](https://ariakit.com/reference/hovercard-provider)
+   * components' context will be used.
+   */
+  store?: HovercardStore;
+}
+type HovercardHeadingProps<T extends ElementType = TagName> = Props<T, HovercardHeadingOptions<T>>;
+//#endregion
+export { HovercardHeading, HovercardHeadingOptions, HovercardHeadingProps, useHovercardHeading };
+//# sourceMappingURL=hovercard-heading.d.ts.map

package/dist/hovercard/hovercard-heading.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hovercard-heading.d.ts","names":["Props","ElementType","PopoverHeadingOptions","HovercardStore","TagName","useHovercardHeading","HovercardHeadingOptions","Hook","HovercardHeading","HovercardHeadingProps","props","ReactElement","JSXElementConstructor","T","store"],"sources":["../../src/hovercard/hovercard-heading.d.ts"],"mappings":";;;;;;cAIcI,OAAAA;AAAAA,KACTA,OAAAA,UAAiBA,OAAO;AAF8B;;;;AACtC;AAAA;;;;AACQ;AAa7B;;AAf2D,cAetCC,mBAAAA,iCAAoDE,IAAAA,OAAWD,uBAAuB;;AAAA;AAe3G;;;;;;;;;AAAyJ;AACzJ;;cADqBE,gBAAAA,GAAmBE,KAAAA,EAAOD,qBAAqB,qBAAqBE,YAAAA,+BAA2CC,qBAAAA;AAAAA,UACnHN,uBAAAA,WAAkCL,WAAAA,GAAcG,OAAAA,UAAiBF,qBAAAA,CAAsBW,CAAAA;EAAvCT;;;;;;;;EAS7DU,KAAAA,GAAQX,cAAAA;AAAAA;AAAAA,KAEAM,qBAAAA,WAAgCR,WAAAA,GAAcG,OAAAA,IAAWJ,KAAAA,CAAMa,CAAAA,EAAGP,uBAAAA,CAAwBO,CAAAA"}

package/dist/hovercard/hovercard-heading.js

@@ -0,0 +1,42 @@
+"use client";
+import { usePopoverHeading } from "../popover/popover-heading.js";
+import { createElement, createHook, forwardRef } from "@ariakit/react-utils";
+//#region src/hovercard/hovercard-heading.tsx
+const TagName = "h1";
+/**
+* Returns props to create a `HovercardHeading` component. This hook must be
+* used in a component that's wrapped with `Hovercard` so the `aria-labelledby`
+* prop is properly set on the hovercard element.
+* @see https://ariakit.com/components/hovercard
+* @example
+* ```jsx
+* // This component must be wrapped with Hovercard
+* const props = useHovercardHeading();
+* <Role {...props}>Heading</Role>
+* ```
+*/
+const useHovercardHeading = createHook(function useHovercardHeading(props) {
+	props = usePopoverHeading(props);
+	return props;
+});
+/**
+* Renders a heading in a hovercard. This component must be wrapped within
+* [`Hovercard`](https://ariakit.com/reference/hovercard) so the
+* `aria-labelledby` prop is properly set on the content element.
+* @see https://ariakit.com/components/hovercard
+* @example
+* ```jsx {3}
+* <HovercardProvider>
+*   <Hovercard>
+*     <HovercardHeading>Heading</HovercardHeading>
+*   </Hovercard>
+* </HovercardProvider>
+* ```
+*/
+const HovercardHeading = forwardRef(function HovercardHeading(props) {
+	return createElement(TagName, useHovercardHeading(props));
+});
+//#endregion
+export { HovercardHeading, useHovercardHeading };
+
+//# sourceMappingURL=hovercard-heading.js.map