@atlaskit/top-layer 0.12.2 → 0.14.0

package/dist/types/internal/role-to-aria-has-popup.d.ts

@@ -0,0 +1,13 @@
+import type { TAriaHasPopupValue, TRoleRequiringAccessibleName, TRoleWithImplicitName } from './role-types';
+/**
+ * Maps a popover content role to the correct `aria-haspopup` value
+ * for its trigger element.
+ *
+ * Returns `undefined` for roles that are not popups in the ARIA sense
+ * (`tooltip`, `note`, `status`, `alert`, `log`). Triggers for those roles
+ * should not announce a popup at all - emitting `aria-haspopup="dialog"`
+ * on a tooltip trigger would mislead assistive technology.
+ */
+export declare function roleToAriaHasPopup({ role, }: {
+    role: TRoleRequiringAccessibleName | TRoleWithImplicitName | undefined;
+}): TAriaHasPopupValue;

package/dist/types/internal/role-types.d.ts

@@ -61,18 +61,6 @@ export type TAriaRoleOptional = ({
 } & TAccessibleNameRequired) | ({
     role?: TRoleWithImplicitName;
 } & TAccessibleNameOptional);
-/**
- * Maps a popover content role to the correct `aria-haspopup` value
- * for its trigger element.
- *
- * Returns `undefined` for roles that are not popups in the ARIA sense
- * (`tooltip`, `note`, `status`, `alert`, `log`). Triggers for those roles
- * should not announce a popup at all - emitting `aria-haspopup="dialog"`
- * on a tooltip trigger would mislead assistive technology.
- */
-export declare function roleToAriaHasPopup({ role, }: {
-    role: TRoleRequiringAccessibleName | TRoleWithImplicitName | undefined;
-}): TAriaHasPopupValue;
 /**
  * Returns `true` when the given popover role moves focus into the popover
  * on open, and `false` otherwise (including when `role` is `undefined`).

package/dist/types/internal/should-focus-into-popover.d.ts

@@ -0,0 +1,8 @@
+import type { TRoleRequiringAccessibleName, TRoleWithImplicitName } from './role-types';
+/**
+ * Returns `true` when the given popover role moves focus into the popover
+ * on open, and `false` otherwise (including when `role` is `undefined`).
+ */
+export declare function shouldFocusIntoPopover({ role, }: {
+    role: TRoleRequiringAccessibleName | TRoleWithImplicitName | undefined;
+}): boolean;

package/dist/types/internal/slot.d.ts

@@ -2,7 +2,7 @@ import { type ForwardRefExoticComponent, type ReactNode, type RefAttributes } fr
 /**
  * Extra DOM/event props are passed through to the cloned child.
  */
-export type TSlotProps = {
+export type SlotProps = {
     children: ReactNode;
 } & Record<string, unknown>;
 /**
@@ -26,4 +26,4 @@ export type TSlotProps = {
  * </Slot>
  * ```
  */
-export declare const Slot: ForwardRefExoticComponent<TSlotProps & RefAttributes<HTMLElement>>;
+export declare const Slot: ForwardRefExoticComponent<SlotProps & RefAttributes<HTMLElement>>;

package/dist/types/internal/use-anchor-position-at-point.d.ts

@@ -0,0 +1,62 @@
+import { type RefObject } from 'react';
+import { type TPlacementOptions } from './resolve-placement';
+/**
+ * A point in viewport coordinates (CSS pixels) at which the synthetic
+ * anchor should be placed.
+ *
+ * Axis-named (`x`/`y`) rather than edge-named (`left`/`top`) so the
+ * shape is unambiguous in RTL writing modes — there is no ambiguity
+ * about whether a coordinate is logical (`inline-start`/`block-start`)
+ * or physical (`left`/`top`). Viewport coordinates are always
+ * physical, so we name them with the physical axis labels.
+ */
+export type TAnchorPoint = {
+    x: number;
+    y: number;
+};
+/**
+ * Positions a popover at a consumer-supplied viewport coordinate using a
+ * hidden synthetic anchor.
+ *
+ * @example
+ * ```tsx
+ * function PointPositionedPopover({ popoverRef, placement, mousePos }) {
+ *   useAnchorPositionAtPoint({
+ *     popoverRef,
+ *     placement,
+ *     isEnabled: Boolean(mousePos),
+ *     getPoint: () => {
+ *       if (!mousePos) return null;
+ *       return { x: mousePos.clientX, y: mousePos.clientY };
+ *     },
+ *   });
+ *   return <Popover ref={popoverRef}>...</Popover>;
+ * }
+ * ```
+ */
+export declare function useAnchorPositionAtPoint({ popoverRef, placement, getPoint, isEnabled, }: {
+    /**
+     * Element being positioned. Passed to `useAnchorPosition`.
+     */
+    popoverRef: RefObject<HTMLElement | null>;
+    /**
+     * Where the popover sits relative to the anchor.
+     */
+    placement: TPlacementOptions;
+    /**
+     * Lazy callback returning the viewport coordinate to anchor at.
+     * Called once per activation (every `isEnabled: false → true`
+     * transition); the result is latched and not re-read.
+     *
+     * Return `null` to signal "no point yet" — the hook stays in a
+     * no-DOM state so another positioning strategy can own the popover.
+     *
+     * Read from a ref, so it does not need to be memoized.
+     */
+    getPoint: () => TAnchorPoint | null;
+    /**
+     * When `false`, the hook is a no-op: no synthetic anchor is created
+     * and no positioning is applied. Defaults to `true`.
+     */
+    isEnabled?: boolean;
+}): void;

package/dist/types/internal/use-anchor-position.d.ts

@@ -34,7 +34,7 @@ import { type TPlacementOptions } from '../internal/resolve-placement';
  * comparison is used internally so re-runs are skipped when the resolved
  * placement shape is unchanged.
  */
-export declare function useAnchorPosition({ anchorRef, popoverRef, placement, forceFallbackPositioning, }: {
+export declare function useAnchorPosition({ anchorRef, popoverRef, placement, forceFallbackPositioning, isEnabled, }: {
     /**
      * Element to position relative to.
      */
@@ -70,4 +70,9 @@ export declare function useAnchorPosition({ anchorRef, popoverRef, placement, fo
      * behavior in any environment, including production.
      */
     forceFallbackPositioning?: boolean;
+    /**
+     * When `false`, the hook is a no-op and applies no positioning.
+     * Defaults to `true`.
+     */
+    isEnabled?: boolean;
 }): void;

package/dist/types/placement-map/index.d.ts

@@ -1,5 +1,5 @@
 import { type TPlacementOptions } from '../internal/resolve-placement';
-import { type TLegacyPlacement } from './legacy-placements';
+import type { TLegacyPlacement } from './legacy-placements';
 /**
  * Maps legacy Popper.js placement values to the new object-based
  * `Placement` values used by `@atlaskit/top-layer/popover`.

package/dist/types/placement-map/legacy-placements.d.ts

@@ -1,4 +1,3 @@
-import { type TPlacementOptions } from '../internal/resolve-placement';
 /**
  * Legacy Popper.js placement values (used by `@atlaskit/popper`,
  * `@atlaskit/popup`, `@atlaskit/tooltip`, etc.). Re-exported from
@@ -8,14 +7,3 @@ import { type TPlacementOptions } from '../internal/resolve-placement';
  */
 export declare const LEGACY_PLACEMENTS: readonly ["auto", "auto-start", "auto-end", "top", "top-start", "top-center", "top-end", "bottom", "bottom-start", "bottom-center", "bottom-end", "right", "right-start", "right-end", "left", "left-start", "left-end"];
 export type TLegacyPlacement = (typeof LEGACY_PLACEMENTS)[number];
-/**
- * The full mapping record. Internal - use `fromLegacyPlacement` from the
- * public entry-point so the offset-tuple translation is applied consistently.
- *
- * Note: `auto`, `auto-start`, `auto-end` map to `block-end` placements. This
- * is a reduction in expressiveness vs Popper.js (which picked the best
- * placement at runtime). CSS `position-try-fallbacks` flips at the edge but
- * the initial placement is fixed. Migration consumers who relied on Popper's
- * dynamic auto-flip should pick an explicit placement instead.
- */
-export declare const placementMapping: Record<TLegacyPlacement, TPlacementOptions>;

package/dist/types/placement-map/placement-mapping.d.ts

@@ -0,0 +1,13 @@
+import { type TPlacementOptions } from '../internal/resolve-placement';
+import type { TLegacyPlacement } from './legacy-placements';
+/**
+ * The full mapping record. Internal - use `fromLegacyPlacement` from the
+ * public entry-point so the offset-tuple translation is applied consistently.
+ *
+ * Note: `auto`, `auto-start`, `auto-end` map to `block-end` placements. This
+ * is a reduction in expressiveness vs Popper.js (which picked the best
+ * placement at runtime). CSS `position-try-fallbacks` flips at the edge but
+ * the initial placement is fixed. Migration consumers who relied on Popper's
+ * dynamic auto-flip should pick an explicit placement instead.
+ */
+export declare const placementMapping: Record<TLegacyPlacement, TPlacementOptions>;

package/dist/types/popover/index.d.ts

@@ -1,3 +1,3 @@
 export { Popover } from './popover';
 export { createPopoverCloseEvent } from './create-close-event';
-export type { TPopoverCloseReason, TPopoverProps } from './types';
+export type { TPopoverCloseReason, TPopoverProps, TPlacementOptions } from './types';

package/dist/types/popover/popover.d.ts

@@ -5,20 +5,13 @@
 import React from 'react';
 import { type TPopoverForwardedProps } from './types';
 /**
- * Unopinionated top-layer primitive.
+ * Unopinionated top-layer primitive. Manages visibility and animation only;
+ * compose with `useAnchorPosition` / `useWidthFromAnchor` for positioning.
  *
- * Manages only visibility (isOpen) and animation (animate). Has no knowledge
- * of positioning - compose with `useAnchorPosition` for anchor positioning
- * and optionally `useWidthFromAnchor` for setting the width of a popover element
- * relative to its anchor trigger.
+ * `isOpen={true}` calls `showPopover()` (entry via `@starting-style`);
+ * `isOpen={false}` calls `hidePopover()` (exit via `allow-discrete`).
  *
- * Visibility is driven by the `isOpen` prop:
- * - `isOpen={true}` → `showPopover()`, entry animation via `@starting-style`
- * - `isOpen={false}` → `hidePopover()`, exit animation via `allow-discrete`
- *
- * For `mode="auto"`, the browser can dismiss the popover via light dismiss
- * (Escape, click outside). When that happens, `onClose` is called and the
- * consumer must set `isOpen` to `false`. The DOM owns the dismiss; React
- * must follow.
+ * In `mode="auto"`, the browser can light-dismiss (Escape, click outside).
+ * `onClose` fires; the consumer must then set `isOpen` to `false`.
  */
 export declare const Popover: React.ForwardRefExoticComponent<TPopoverForwardedProps & React.RefAttributes<HTMLDivElement>>;

package/dist/types/popover/types.d.ts

@@ -1,8 +1,8 @@
 import { type ReactNode } from 'react';
 import { type StrictXCSSProp } from '@atlaskit/css';
 import { type TAnimationPreset } from '../animations/types';
+import { type TPlacementOptions } from '../internal/resolve-placement';
 import { type TAriaRoleRequired, type TRoleRequiringAccessibleName, type TRoleWithImplicitName } from '../internal/role-types';
-import { type TPlacementOptions } from '../popup/types';
 /**
  * The reason a popover was closed.
  *
@@ -31,6 +31,7 @@ export type TPopoverForwardedProps = TPopoverBaseProps & {
     label?: string;
     labelledBy?: string;
 };
+export type { TPlacementOptions };
 type TPopoverBaseProps = {
     children: ReactNode;
     /**
@@ -51,8 +52,9 @@ type TPopoverBaseProps = {
     testId?: string;
     /**
      * HTML `id` attribute for the popover element. When omitted, a unique ID
-     * is generated automatically. The `<Popup>` compound passes its context ID
-     * so that `Popup.Trigger` can reference it via `aria-controls` / `popovertarget`.
+     * is generated automatically. Pair the trigger with this ID via `aria-controls`
+     * and the popover with `popovertarget`. Use `usePopoverId()` to generate a
+     * stable, CSS-safe id.
      */
     id?: string;
     /**
@@ -109,7 +111,7 @@ type TPopoverBaseProps = {
      * Called after the entry animation completes (or immediately on open when
      * there is no animation or reduced motion is active).
      *
-     * Use this for external lifecycle coordination — e.g. notifying a manager
+     * Use this for external lifecycle coordination - e.g. notifying a manager
      * that the show sequence is finished.
      */
     onEnterFinish?: () => void;
@@ -178,4 +180,3 @@ export type TPopoverProps = TPopoverBaseProps & TAriaRoleRequired & ({
  *   Falls back to a one-off measurement of the anchor's width.
  */
 export type TWidthFromAnchorMode = 'none' | 'match-anchor' | 'min-anchor';
-export {};

package/dist/types/popover-surface/index.d.ts

@@ -0,0 +1,2 @@
+export { PopoverSurface } from './popover-surface';
+export type { TPopoverSurfaceProps } from './popover-surface';

package/dist/types/popover-surface/popover-surface.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @jsxRuntime classic
+ * @jsx jsx
+ */
+import React, { type ReactNode } from 'react';
+export type TPopoverSurfaceProps = {
+    children: ReactNode;
+};
+/**
+ * Optional styled wrapper for popover content.
+ *
+ * Adds default visual styling (background, border-radius, box-shadow)
+ * using design tokens.
+ *
+ * Presentational primitive - `children`-only by design. This component
+ * intentionally exposes no `style`, `className`, `xcss`, `id`, or `ref`
+ * props. If you need any of those, render your own wrapper element inside
+ * `Popover` instead. `PopoverSurface` is the no-config "give me the default
+ * ADS overlay look" surface, nothing more.
+ */
+export declare function PopoverSurface({ children }: TPopoverSurfaceProps): React.ReactElement;

package/dist/types/use-arrow-navigation/use-arrow-navigation.d.ts

@@ -1,5 +1,5 @@
 import { type RefObject } from 'react';
-import { type TFocusableFilter } from '../focus';
+import { type TFocusableFilter } from '../focus/types';
 /**
  * Args for `useArrowNavigation`.
  *

package/dist/types-ts4.5/animations/presets.d.ts

@@ -18,10 +18,10 @@ type TSlideAndFadeOptions = {
  * import { slideAndFade } from '@atlaskit/top-layer/animations';
  *
  * // Default 4px slide (tooltip)
- * <Popup.Content animate={slideAndFade()} />
+ * <Popover animate={slideAndFade()} />
  *
  * // Custom 8px slide (popup / dropdown)
- * <Popup.Content animate={slideAndFade({ distance: 8 })} />
+ * <Popover animate={slideAndFade({ distance: 8 })} />
  * ```
  */
 export declare function slideAndFade(options?: TSlideAndFadeOptions): TAnimationPreset;
@@ -34,7 +34,7 @@ export declare function slideAndFade(options?: TSlideAndFadeOptions): TAnimation
  * ```tsx
  * import { fade } from '@atlaskit/top-layer/animations';
  *
- * <Popup.Content animate={fade()} />
+ * <Popover animate={fade()} />
  * ```
  */
 export declare function fade(): TAnimationPreset;
@@ -47,7 +47,7 @@ export declare function fade(): TAnimationPreset;
  * ```tsx
  * import { scaleAndFade } from '@atlaskit/top-layer/animations';
  *
- * <Popup.Content animate={scaleAndFade()} />
+ * <Popover animate={scaleAndFade()} />
  * ```
  */
 export declare function scaleAndFade(): TAnimationPreset;

package/dist/types-ts4.5/animations/types.d.ts

@@ -1,4 +1,4 @@
-import type { TPlacementOptions } from '../popup/types';
+import type { TPlacementOptions } from '../internal/resolve-placement';
 /**
  * A self-contained animation preset for top-layer elements (popovers and dialogs).
  *

package/dist/types-ts4.5/dialog/types.d.ts

@@ -49,14 +49,6 @@ type TDialogBaseProps = {
      * Additional inline styles applied to the `<dialog>` element.
      *
      * Use for custom width, height, transform, or other overrides.
-     *
-     * Rule deviation: the house rules ban unbounded `style` props on
-     * components. `Dialog` is a low-level primitive that intentionally has
-     * no visual opinions of its own; consumers such as `@atlaskit/modal-dialog`
-     * must be able to set width, height, and transforms on the native
-     * `<dialog>` element. Removing this prop would be a breaking change
-     * and is tracked separately. Keep until an xcss-based replacement
-     * exists on the primitive.
      */
     style?: CSSProperties;
     /**

package/dist/types-ts4.5/entry-points/focus.d.ts

@@ -1,2 +1,4 @@
-export { getFirstFocusable, getLastFocusable, getNextFocusable } from '../focus';
-export type { TFocusableFilter } from '../focus';
+export type { TFocusableFilter } from '../focus/types';
+export { getFirstFocusable } from '../focus/get-first-focusable';
+export { getLastFocusable } from '../focus/get-last-focusable';
+export { getNextFocusable } from '../focus/get-next-focusable';

package/dist/types-ts4.5/entry-points/get-aria-for-trigger.d.ts

@@ -0,0 +1 @@
+export { getAriaForTrigger } from '../internal/get-aria-for-trigger';

package/dist/types-ts4.5/entry-points/popover-surface.d.ts

@@ -0,0 +1,2 @@
+export { PopoverSurface } from '../popover-surface';
+export type { TPopoverSurfaceProps } from '../popover-surface';

package/dist/types-ts4.5/entry-points/popover.d.ts

@@ -1,2 +1,2 @@
 export { Popover } from '../popover';
-export type { TPopoverProps, TPopoverCloseReason } from '../popover';
+export type { TPopoverProps, TPopoverCloseReason, TPlacementOptions } from '../popover';

package/dist/types-ts4.5/entry-points/use-anchor-position-at-point.d.ts

@@ -0,0 +1 @@
+export { useAnchorPositionAtPoint, type TAnchorPoint, } from '../internal/use-anchor-position-at-point';

package/dist/types-ts4.5/entry-points/use-popover-id.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Returns a stable HTML `id` used to wire a trigger element to its popover
+ * via ARIA (`aria-controls`) and the Popover API (`popovertarget`).
+ *
+ * The returned value is intended for the `id` attribute on the popover and
+ * for the matching `aria-controls` / `popovertarget` references on the
+ * trigger. It is NOT a CSS `anchor-name` value: CSS anchor positioning is
+ * handled internally by `useAnchorPosition`, which mints and applies its
+ * own `anchor-name` on the trigger element.
+ */
+export declare function usePopoverId(): string;

package/dist/types-ts4.5/focus/get-first-focusable.d.ts

@@ -0,0 +1,8 @@
+import type { TFocusableFilter } from './types';
+/**
+ * Returns the first focusable element within the container.
+ */
+export declare function getFirstFocusable({ container, filter, }: {
+    container: HTMLElement;
+    filter?: TFocusableFilter;
+}): HTMLElement | null;

package/dist/types-ts4.5/focus/get-focusables.d.ts

@@ -0,0 +1,13 @@
+import type { TFocusableFilter } from './types';
+/**
+ * Returns all focusable HTMLElements within the container, optionally filtered.
+ *
+ * Focusables that belong to a nested top-layer scope (a `[popover]` or
+ * `<dialog>` descendant of the container) are excluded - those elements
+ * are owned by the inner layer's focus management. The container itself
+ * is allowed to be a popover/dialog; only nested ones are filtered.
+ */
+export declare function getFocusables({ container, filter, }: {
+    container: HTMLElement;
+    filter?: TFocusableFilter;
+}): HTMLElement[];

package/dist/types-ts4.5/focus/get-last-focusable.d.ts

@@ -0,0 +1,8 @@
+import type { TFocusableFilter } from './types';
+/**
+ * Returns the last focusable element within the container.
+ */
+export declare function getLastFocusable({ container, filter, }: {
+    container: HTMLElement;
+    filter?: TFocusableFilter;
+}): HTMLElement | null;

package/dist/types-ts4.5/focus/get-next-focusable.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Returns the next focusable element in the given direction relative to the
+ * currently focused element within the container. Wraps around at both ends.
+ *
+ * Returns `null` if there is no focused element within the container or if
+ * the focused element is not in the list of focusable elements.
+ */
+import type { TFocusableFilter } from './types';
+export declare function getNextFocusable({ container, direction, filter, }: {
+    container: HTMLElement;
+    direction: 'forwards' | 'backwards';
+    filter?: TFocusableFilter;
+}): HTMLElement | null;

package/dist/types-ts4.5/focus/is-in-same-layer.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns true when `element` and `container` resolve to the same nearest
+ * top-layer host (or both resolve to `null`, meaning the document layer).
+ */
+export declare function isInSameLayer({ element, container, }: {
+    element: HTMLElement;
+    container: HTMLElement;
+}): boolean;

package/dist/types-ts4.5/focus/is-nested-layer-focused.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns `true` when `document.activeElement` is inside a nested top-layer
+ * descendant of `container` (a `[popover]`, `<dialog>`, `[role="dialog"]` or
+ * `[role="alertdialog"]` that is itself a descendant of `container`).
+ */
+export declare function isNestedLayerFocused({ container }: {
+    container: HTMLElement;
+}): boolean;

package/dist/types-ts4.5/focus/selectors.d.ts

@@ -0,0 +1,4 @@
+export declare const selectors: {
+    focusable: string;
+    focused: string;
+};

package/dist/types-ts4.5/focus/types.d.ts

@@ -0,0 +1,5 @@
+/**
+ * An optional callback to restrict which focusable elements are included.
+ * Return `true` to include the element, `false` to skip it.
+ */
+export type TFocusableFilter = (element: HTMLElement, container: HTMLElement) => boolean;

package/dist/types-ts4.5/internal/get-aria-for-trigger.d.ts

@@ -0,0 +1,86 @@
+import { type TAriaHasPopupValue, type TRoleRequiringAccessibleName } from './role-types';
+/**
+ * Roles accepted by `getAriaForTrigger`.
+ *
+ * Excludes tooltip-family roles (`tooltip`, `note`, `status`, `alert`, `log`)
+ * because the correct trigger wiring for those is `aria-describedby`, not
+ * `aria-haspopup` / `aria-expanded` / `aria-controls`. Use `aria-describedby`
+ * manually for tooltip triggers.
+ */
+type TAriaForTriggerRole = TRoleRequiringAccessibleName | 'listbox' | 'tree' | 'grid';
+type TGetAriaForTriggerOptions = {
+    /**
+     * The `role` that will be set on the `<Popover>` element. Used to derive
+     * the correct `aria-haspopup` value for the trigger.
+     */
+    role: TAriaForTriggerRole;
+    /**
+     * Whether the popover is currently open. Drives `aria-expanded`.
+     */
+    isOpen: boolean;
+    /**
+     * The popover identifier - the value returned by `usePopoverId()`,
+     * passed as `id` to `<Popover>` and referenced here via `aria-controls`.
+     */
+    popoverId: string;
+};
+/**
+ * Non-undefined subset of `TAriaHasPopupValue`. Every role accepted by
+ * `getAriaForTrigger` maps to a concrete `aria-haspopup` string, so the
+ * trigger always receives a defined attribute value.
+ */
+type TAriaHasPopupForTrigger = Exclude<TAriaHasPopupValue, undefined>;
+type TAriaForTrigger = {
+    'aria-haspopup': TAriaHasPopupForTrigger;
+    'aria-expanded': boolean;
+    'aria-controls': string;
+};
+/**
+ * Returns the ARIA attributes to spread onto a click-activated popover trigger.
+ *
+ * Centralises three attributes that are easy to forget or get wrong individually:
+ *
+ * - `aria-haspopup` - derived from the popover's role (e.g. `dialog → "dialog"`,
+ *   `menu → "menu"`, `tooltip → undefined`). React omits the attribute when
+ *   the value is `undefined`.
+ * - `aria-expanded` - reflects the current open state.
+ * - `aria-controls` - references the popover element by its id, even
+ *   while the popover is closed. The relationship is stable; `aria-expanded`
+ *   carries the current visibility state.
+ *
+ * **This function is for click/keyboard-activated popovers only.** For
+ * hover-driven tooltips, the trigger should use `aria-describedby` instead.
+ *
+ * @example
+ * ```tsx
+ * import { getAriaForTrigger } from '@atlaskit/top-layer/get-aria-for-trigger';
+ * import { usePopoverId } from '@atlaskit/top-layer/use-popover-id';
+ *
+ * const popoverId = usePopoverId();
+ * const [isOpen, setIsOpen] = useState(false);
+ *
+ * return (
+ *   <>
+ *     <button
+ *       ref={triggerRef}
+ *       onClick={() => setIsOpen((previous) => !previous)}
+ *       {...getAriaForTrigger({ role: 'dialog', isOpen, popoverId })}
+ *     >
+ *       Open
+ *     </button>
+ *     <Popover
+ *       id={popoverId}
+ *       role="dialog"
+ *       label="My dialog"
+ *       isOpen={isOpen}
+ *       triggerRef={triggerRef}
+ *       onClose={() => setIsOpen(false)}
+ *     >
+ *       …
+ *     </Popover>
+ *   </>
+ * );
+ * ```
+ */
+export declare function getAriaForTrigger({ role, isOpen, popoverId, }: TGetAriaForTriggerOptions): TAriaForTrigger;
+export {};

package/dist/types-ts4.5/internal/role-to-aria-has-popup.d.ts

@@ -0,0 +1,13 @@
+import type { TAriaHasPopupValue, TRoleRequiringAccessibleName, TRoleWithImplicitName } from './role-types';
+/**
+ * Maps a popover content role to the correct `aria-haspopup` value
+ * for its trigger element.
+ *
+ * Returns `undefined` for roles that are not popups in the ARIA sense
+ * (`tooltip`, `note`, `status`, `alert`, `log`). Triggers for those roles
+ * should not announce a popup at all - emitting `aria-haspopup="dialog"`
+ * on a tooltip trigger would mislead assistive technology.
+ */
+export declare function roleToAriaHasPopup({ role, }: {
+    role: TRoleRequiringAccessibleName | TRoleWithImplicitName | undefined;
+}): TAriaHasPopupValue;

package/dist/types-ts4.5/internal/role-types.d.ts

@@ -61,18 +61,6 @@ export type TAriaRoleOptional = ({
 } & TAccessibleNameRequired) | ({
     role?: TRoleWithImplicitName;
 } & TAccessibleNameOptional);
-/**
- * Maps a popover content role to the correct `aria-haspopup` value
- * for its trigger element.
- *
- * Returns `undefined` for roles that are not popups in the ARIA sense
- * (`tooltip`, `note`, `status`, `alert`, `log`). Triggers for those roles
- * should not announce a popup at all - emitting `aria-haspopup="dialog"`
- * on a tooltip trigger would mislead assistive technology.
- */
-export declare function roleToAriaHasPopup({ role, }: {
-    role: TRoleRequiringAccessibleName | TRoleWithImplicitName | undefined;
-}): TAriaHasPopupValue;
 /**
  * Returns `true` when the given popover role moves focus into the popover
  * on open, and `false` otherwise (including when `role` is `undefined`).

package/dist/types-ts4.5/internal/should-focus-into-popover.d.ts

@@ -0,0 +1,8 @@
+import type { TRoleRequiringAccessibleName, TRoleWithImplicitName } from './role-types';
+/**
+ * Returns `true` when the given popover role moves focus into the popover
+ * on open, and `false` otherwise (including when `role` is `undefined`).
+ */
+export declare function shouldFocusIntoPopover({ role, }: {
+    role: TRoleRequiringAccessibleName | TRoleWithImplicitName | undefined;
+}): boolean;

package/dist/types-ts4.5/internal/slot.d.ts

@@ -2,7 +2,7 @@ import { type ForwardRefExoticComponent, type ReactNode, type RefAttributes } fr
 /**
  * Extra DOM/event props are passed through to the cloned child.
  */
-export type TSlotProps = {
+export type SlotProps = {
     children: ReactNode;
 } & Record<string, unknown>;
 /**
@@ -26,4 +26,4 @@ export type TSlotProps = {
  * </Slot>
  * ```
  */
-export declare const Slot: ForwardRefExoticComponent<TSlotProps & RefAttributes<HTMLElement>>;
+export declare const Slot: ForwardRefExoticComponent<SlotProps & RefAttributes<HTMLElement>>;