@atlaskit/top-layer 0.1.0

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

@@ -0,0 +1,20 @@
+/**
+ * @jsxRuntime classic
+ * @jsx jsx
+ */
+import React from 'react';
+import { type TDialogProps } from './types';
+/**
+ * Low-level `<dialog>` primitive. No visual opinions — no width, height,
+ * background, border-radius, or layout. Consumers provide their own styling.
+ *
+ * Visibility is controlled declaratively via `isOpen`:
+ * - `isOpen={true}` calls `.showModal()` (entry animation via `@starting-style`)
+ * - `isOpen={false}` calls `.close()` (exit animation via `allow-discrete`)
+ *
+ * Handles native `cancel` event (Escape) and backdrop click detection.
+ *
+ * Close flow: we never call `dialog.close()` from event handlers. We always call
+ * `onClose`; the consumer decides whether to set `isOpen={false}`.
+ */
+export declare const Dialog: React.ForwardRefExoticComponent<TDialogProps & React.RefAttributes<HTMLDialogElement>>;

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

@@ -0,0 +1,3 @@
+export { createCloseEvent } from './create-close-event';
+export { Dialog } from './dialog-content';
+export type { TDialogCloseReason, TDialogProps } from './types';

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

@@ -0,0 +1,92 @@
+import { type CSSProperties, type ReactNode } from 'react';
+import { type TAnimationPreset } from '../animations/types';
+/**
+ * Close reasons produced by the Dialog primitive.
+ *
+ * - `'escape'` — user pressed Escape (native `cancel` event on `<dialog>`).
+ * - `'overlay-click'` — user clicked the backdrop / overlay area.
+ *
+ * Consumer-initiated ("programmatic") close is not a reason the primitive
+ * produces — the consumer simply sets `isOpen={false}`.
+ */
+export type TDialogCloseReason = 'escape' | 'overlay-click';
+/**
+ * Props for the `Dialog` primitive.
+ *
+ * Low-level wrapper around the native `<dialog>` element.
+ * Manages visibility (`showModal()` / `close()`), animation, Escape handling,
+ * and backdrop-click detection. Has no visual opinions — no width, height,
+ * background, border-radius, or layout. Consumers (e.g. `@atlaskit/modal-dialog`)
+ * provide their own visual styling.
+ */
+export type TDialogProps = {
+    children: ReactNode;
+    /**
+     * Whether the dialog is open.
+     *
+     * - `true`: calls `showModal()`, entry animation plays via `@starting-style`.
+     * - `false`: calls `close()`. When an `animate` preset is provided, the exit
+     *   animation plays (via `allow-discrete`) before the dialog becomes logically closed.
+     *
+     * The element stays mounted in the DOM — visibility is controlled declaratively.
+     */
+    isOpen: boolean;
+    /**
+     * Called when the user triggers close via Escape or backdrop click.
+     *
+     * The dialog does **not** close itself — the consumer decides whether to
+     * set `isOpen={false}` (e.g. gate by reason).
+     */
+    onClose: (args: {
+        reason: TDialogCloseReason;
+    }) => void;
+    /**
+     * Animation preset for entry/exit transitions.
+     *
+     * Pass an `TAnimationPreset` (e.g. `dialogSlideUpAndFade()`) to enable
+     * CSS-based entry and exit animation. Pass `false` (or omit) to disable.
+     */
+    animate?: TAnimationPreset | false;
+    /**
+     * Additional inline styles applied to the `<dialog>` element.
+     *
+     * Use for custom width, height, transform, or other overrides.
+     */
+    style?: CSSProperties;
+    /**
+     * Test ID applied to the `<dialog>` element.
+     */
+    testId?: string;
+    /**
+     * HTML `id` attribute for the `<dialog>` element.
+     */
+    id?: string;
+    /**
+     * Accessible label (`aria-label`).
+     *
+     * When provided, `aria-labelledby` is not set.
+     * Use when there is no visible title element to reference.
+     */
+    label?: string;
+    /**
+     * ID of the element that labels the dialog (`aria-labelledby`).
+     *
+     * Ignored when `label` is provided.
+     */
+    labelledBy?: string;
+    /**
+     * When true, the `::backdrop` pseudo-element is rendered transparent.
+     *
+     * Useful for stacked dialogs where only the foreground dialog should
+     * show a visible backdrop, or when the consumer wants no overlay.
+     */
+    shouldHideBackdrop?: boolean;
+    /**
+     * Called after the exit animation completes (or immediately on close when
+     * there is no animation or reduced motion is active).
+     *
+     * Use this for external lifecycle coordination — e.g. firing an
+     * `onCloseComplete` callback or notifying ExitingPersistence.
+     */
+    onExitFinish?: () => void;
+};

package/dist/types-ts4.5/dialog-scroll-lock/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * __DialogScrollLock__
+ *
+ * Prevents background page scrolling while mounted. Designed to be rendered
+ * inside a `Dialog` so that the scroll lock is automatically removed when the
+ * dialog closes (unmounts its children).
+ *
+ * Native `<dialog>.showModal()` makes background content _inert_ (not
+ * focusable/clickable), but does **not** prevent scroll events from reaching
+ * the document body. This component fills that gap by setting
+ * `overflow: hidden` on `document.body`.
+ *
+ * @example
+ * ```tsx
+ * import { Dialog } from '@atlaskit/top-layer/dialog';
+ * import { DialogScrollLock } from '@atlaskit/top-layer/dialog-scroll-lock';
+ *
+ * <Dialog isOpen={isOpen} onClose={onClose}>
+ *   <DialogScrollLock />
+ *   {children}
+ * </Dialog>
+ * ```
+ */
+export declare function DialogScrollLock(): null;

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

@@ -0,0 +1,2 @@
+export { slideAndFade, fade, scaleAndFade, dialogSlideUpAndFade, dialogFade, } from '../animations/presets';
+export type { TAnimationPreset, TPopoverAnimationPreset, TDialogAnimationPreset, } from '../animations/types';

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

@@ -0,0 +1,2 @@
+export { arrow } from '../arrow';
+export type { TArrowPreset } from '../arrow/types';

package/dist/types-ts4.5/entry-points/create-close-event.d.ts

@@ -0,0 +1,4 @@
+export { createCloseEvent } from '../dialog';
+export { createPopoverCloseEvent } from '../popover/create-close-event';
+export type { TDialogCloseReason } from '../dialog';
+export type { TPopoverCloseReason } from '../popover';

package/dist/types-ts4.5/entry-points/dialog-scroll-lock.d.ts

@@ -0,0 +1 @@
+export { DialogScrollLock } from '../dialog-scroll-lock';

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

@@ -0,0 +1,2 @@
+export { Dialog } from '../dialog';
+export type { TDialogCloseReason, TDialogProps } from '../dialog';

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

@@ -0,0 +1,2 @@
+export { getFirstFocusable, getLastFocusable, getNextFocusable } from '../focus';
+export type { TFocusableFilter } from '../focus';

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

@@ -0,0 +1,2 @@
+export { fromLegacyPlacement, placementMapping } from '../placement-map';
+export type { TLegacyPlacement, TPlacementOptions } from '../placement-map';

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

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

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

@@ -0,0 +1,2 @@
+export { PopupSurface } from '../popup/popup-surface';
+export type { TPopupSurfaceProps } from '../popup/types';

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

@@ -0,0 +1,2 @@
+export { Popup } from '../popup';
+export type { TPlacementOptions, TPopupProps, TPopupContentProps, TPopupRole, TPopupTriggerProps, TTriggerFunctionRenderProps, } from '../popup';

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

@@ -0,0 +1 @@
+export { useAnchorPosition } from '../internal/use-anchor-positioning';

package/dist/types-ts4.5/entry-points/use-arrow-navigation.d.ts

@@ -0,0 +1,2 @@
+export { useArrowNavigation, isAtCurrentMenuLevel } from '../use-arrow-navigation';
+export type { TUseArrowNavigationArgs } from '../use-arrow-navigation';

package/dist/types-ts4.5/entry-points/use-simple-light-dismiss.d.ts

@@ -0,0 +1,2 @@
+export { useSimpleLightDismiss } from '../use-simple-light-dismiss';
+export type { TUseSimpleLightDismissOptions } from '../use-simple-light-dismiss';

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

@@ -0,0 +1,42 @@
+/**
+ * Focusable element selectors and navigation helpers.
+ *
+ * Uses CSS selectors to discover focusable elements within a container,
+ * avoiding the need for a manual registration system. Disabled elements
+ * (both HTML `disabled` attribute and `aria-disabled="true"`) and elements
+ * with `tabindex="-1"` are excluded automatically.
+ *
+ * All public functions accept an optional `filter` callback to further
+ * restrict which focusable elements are included.
+ */
+/**
+ * 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;
+/**
+ * Returns the first focusable element within the container.
+ */
+export declare function getFirstFocusable({ container, filter, }: {
+    container: HTMLElement;
+    filter?: TFocusableFilter;
+}): HTMLElement | null;
+/**
+ * Returns the last focusable element within the container.
+ */
+export declare function getLastFocusable({ container, filter, }: {
+    container: HTMLElement;
+    filter?: TFocusableFilter;
+}): HTMLElement | null;
+/**
+ * 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.
+ */
+export declare function getNextFocusable({ container, direction, filter, }: {
+    container: HTMLElement;
+    direction: 'forwards' | 'backwards';
+    filter?: TFocusableFilter;
+}): HTMLElement | null;

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

@@ -0,0 +1,2 @@
+export { getFirstFocusable, getLastFocusable, getNextFocusable } from './focus';
+export type { TFocusableFilter } from './focus';

package/dist/types-ts4.5/internal/anchor-positioning-fallback.d.ts

@@ -0,0 +1,24 @@
+import { type TPlacement } from './resolve-placement';
+/**
+ * JS fallback: compute popover position from trigger rect and viewport.
+ *
+ * Placement algorithm (from the document):
+ * - "block" placement: show above/below, picking the side with more space if flipping needed
+ * - "inline" placement: show left/right, picking the side with more space if flipping needed
+ * - "auto" placement: show on the edge with the most available space
+ *
+ * Re-runs on scroll (capture on window) and resize events.
+ */
+export declare function computeFallbackPosition({ triggerRect, popoverEl, placement, viewport, offset, }: {
+    triggerRect: DOMRect;
+    popoverEl: HTMLElement;
+    placement: TPlacement;
+    viewport: {
+        width: number;
+        height: number;
+    };
+    offset: number;
+}): {
+    top: number;
+    left: number;
+};

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

@@ -0,0 +1,14 @@
+/**
+ * Combine multiple cleanup functions into a single cleanup function.
+ *
+ * @example
+ * ```ts
+ * useEffect(() => {
+ *   return combine(
+ *     bind(window, { type: 'resize', listener: onResize }),
+ *     bind(window, { type: 'scroll', listener: onScroll, options: { capture: true } }),
+ *   );
+ * }, []);
+ * ```
+ */
+export declare function combine(...cleanupFns: ((() => void) | undefined)[]): () => void;

package/dist/types-ts4.5/internal/ensure-preset-styles.d.ts

@@ -0,0 +1,6 @@
+export declare function ensurePresetStyles({ preset }: {
+    preset: {
+        css: string;
+        name: string;
+    };
+}): void;

package/dist/types-ts4.5/internal/reduced-motion.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Returns `true` when the user prefers reduced motion.
+ *
+ * Safe for SSR (returns `false` when `window` is unavailable).
+ *
+ * The result is cached after the first call via `once`. This avoids
+ * calling `matchMedia` on every render. The trade-off is that if a user
+ * toggles the OS reduced-motion setting mid-session, the change won't
+ * take effect until the next page load. This is acceptable because
+ * toggling this system-level preference mid-session is extremely rare,
+ * and a page refresh is a reasonable expectation for system accessibility
+ * settings to take effect.
+ */
+export declare const prefersReducedMotion: () => boolean;

package/dist/types-ts4.5/internal/resolve-placement.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Fully-resolved placement (internal). All fields are required.
+ * Use getPlacement({ placement: partial }) to obtain from partial input.
+ */
+export type TPlacement = {
+    axis: 'block' | 'inline';
+    edge: 'start' | 'end';
+    align: 'start' | 'center' | 'end';
+};
+/**
+ * Resolves a partial placement to its fully-specified form.
+ * Defaults: `axis: 'block'`, `edge: 'end'`, `align: 'center'`.
+ */
+export declare function getPlacement({ placement }: {
+    placement: Partial<TPlacement>;
+}): TPlacement;

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

@@ -0,0 +1,62 @@
+/**
+ * Valid values for the `aria-haspopup` attribute.
+ * Derived from the HTML spec — maps popover roles to what the trigger announces.
+ */
+export type TAriaHasPopupValue = 'dialog' | 'menu' | 'listbox' | 'tree' | 'grid' | true;
+/**
+ * Roles that require an accessible name (`label` or `labelledBy`) per WCAG 4.1.2.
+ * Without a name, assistive technology cannot identify these landmarks.
+ */
+export type TRoleRequiringAccessibleName = 'dialog' | 'alertdialog' | 'menu';
+/**
+ * Roles where the accessible name is derived from content or provided externally
+ * (e.g. a combobox labels its listbox, tooltip content IS the accessible name).
+ */
+export type TRoleWithImplicitName = 'tooltip' | 'listbox' | 'tree' | 'grid' | 'note' | 'status' | 'alert' | 'log';
+type TAccessibleNameRequired = {
+    /**
+     * Accessible name via `aria-label`.
+     */
+    label: string;
+    labelledBy?: string;
+} | {
+    label?: string;
+    /**
+     * Accessible name via `aria-labelledby`.
+     */
+    labelledBy: string;
+};
+type TAccessibleNameOptional = {
+    label?: string;
+    labelledBy?: string;
+};
+/**
+ * ARIA role props where a role is always required.
+ *
+ * Used by `TPopupContentProps` — popup content must always declare
+ * its role so assistive technology can identify the layer.
+ */
+export type TAriaRoleRequired = ({
+    role: TRoleRequiringAccessibleName;
+} & TAccessibleNameRequired) | ({
+    role: TRoleWithImplicitName;
+} & TAccessibleNameOptional);
+/**
+ * ARIA role props where a role is optional.
+ *
+ * Used by `TPopoverProps` — the low-level primitive allows omitting
+ * the role for cases where it is set externally or not needed.
+ */
+export type TAriaRoleOptional = ({
+    role: TRoleRequiringAccessibleName;
+} & TAccessibleNameRequired) | ({
+    role?: TRoleWithImplicitName;
+} & TAccessibleNameOptional);
+/**
+ * Maps a popover content role to the correct `aria-haspopup` value
+ * for its trigger element.
+ */
+export declare function roleToAriaHasPopup({ role, }: {
+    role: TRoleRequiringAccessibleName | TRoleWithImplicitName | undefined;
+}): TAriaHasPopupValue;
+export {};

package/dist/types-ts4.5/internal/set-style.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Sets inline styles on an element and returns a cleanup function
+ * that removes only the styles that were applied.
+ *
+ * Uses `style.setProperty()` / `style.removeProperty()` so that
+ * hyphenated CSS property names (e.g. `position-area`, `anchor-name`)
+ * work correctly. These newer properties do not have camelCase
+ * mappings in `CSSStyleDeclaration` yet.
+ *
+ * @example
+ * ```ts
+ * const cleanup = setStyle({ el: popover, styles: [
+ *   { property: 'position-anchor', value: '--my-anchor' },
+ *   { property: 'position-area', value: 'block-end' },
+ *   { property: 'margin', value: '0' },
+ * ] });
+ *
+ * // Later: removes all three properties
+ * cleanup();
+ * ```
+ */
+export declare function setStyle({ el, styles, }: {
+    el: HTMLElement;
+    styles: Array<{
+        property: string;
+        value: string;
+    }>;
+}): () => void;

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

@@ -0,0 +1,29 @@
+import { type ForwardRefExoticComponent, type ReactNode, type RefAttributes } from 'react';
+/**
+ * Extra DOM/event props are passed through to the cloned child.
+ */
+export type SlotProps = {
+    children: ReactNode;
+} & Record<string, unknown>;
+/**
+ * Merges props (including ref) onto a single React element child.
+ *
+ * A safer alternative to raw `cloneElement` that:
+ * 1. Guards with `isValidElement` — non-element children (strings,
+ *    fragments, null) are returned as-is instead of crashing.
+ * 2. Merges refs via `mergeRefs` so both the caller's ref and the
+ *    child's existing ref are honoured.
+ * 3. Spreads any additional props (ARIA attributes, event handlers, etc.)
+ *    onto the child element.
+ *
+ * Event handlers (e.g. `onClick`) are **not** auto-merged — the caller's
+ * handler replaces the child's. Compose handlers before passing them in.
+ *
+ * @example
+ * ```tsx
+ * <Slot ref={triggerRef} onClick={handleClick} aria-expanded={isOpen}>
+ *   <button>Open</button>
+ * </Slot>
+ * ```
+ */
+export declare const Slot: ForwardRefExoticComponent<SlotProps & RefAttributes<HTMLElement>>;

package/dist/types-ts4.5/internal/use-anchor-positioning.d.ts

@@ -0,0 +1,95 @@
+import { type RefObject } from 'react';
+import { type TArrowPreset } from '../arrow/types';
+import { type TPlacementOptions } from '../popup/types';
+export { getPlacement } from './resolve-placement';
+/**
+ * Resolves placement options to CSS `position-area` syntax.
+ *
+ * The `align` field represents the *visual* alignment:
+ * - `align: 'start'` means "aligned to the trigger's start edge" (left in LTR for block axis)
+ * - `align: 'end'` means "aligned to the trigger's end edge"
+ * - `align: 'center'` means centered (single-axis position-area)
+ *
+ * CSS `position-area` uses `span-*` keywords which indicate the *expansion direction*.
+ * Visual start-alignment requires `span-{cross-axis}-end` (expand toward end = start-aligned).
+ * This function handles the inversion internally.
+ *
+ * @example
+ * placementToPositionArea({ placement: { axis: 'block', edge: 'end', align: 'center' } }) // → 'block-end'
+ * placementToPositionArea({ placement: { axis: 'block', edge: 'end', align: 'start' } }) // → 'block-end span-inline-end'
+ * placementToPositionArea({ placement: { axis: 'block', edge: 'end', align: 'end' } })   // → 'block-end span-inline-start'
+ */
+export declare function placementToPositionArea({ placement }: {
+    placement: TPlacementOptions;
+}): string;
+/**
+ * Returns `position-try-fallbacks` value based on placement.
+ *
+ * For centered placements, includes cross-axis aligned position-area
+ * values so the browser can shift the popover along the cross-axis
+ * when the centered position would overflow the viewport edge.
+ *
+ * Fallback order for centered placements (e.g. `block-end`):
+ * 1. Same edge, start-aligned (shift for near-edge overflow)
+ * 2. Same edge, end-aligned (shift for far-edge overflow)
+ * 3. Flipped edge, centered
+ * 4. Flipped edge, start-aligned
+ * 5. Flipped edge, end-aligned
+ *
+ * For aligned placements (start/end), includes the same-edge centered
+ * position as fallbacks so the browser can try centering when the aligned
+ * position would overflow, before flipping to the opposite edge.
+ */
+export declare function placementToTryFallbacks({ placement }: {
+    placement: TPlacementOptions;
+}): string;
+/**
+ * Hook that positions an element relative to an anchor element using
+ * CSS Anchor Positioning (with a JS fallback for older browsers).
+ *
+ * This hook is the positioning primitive — it has no knowledge of popovers,
+ * visibility, or animation. Compose it with `Popover` for anchor-positioned
+ * top-layer content.
+ *
+ * When CSS Anchor Positioning is supported, it sets CSS properties
+ * (`anchor-name`, `position-anchor`, `position-area`, `position-try-fallbacks`)
+ * directly on the elements via `el.style.setProperty()`.
+ *
+ * When not supported, it falls back to JavaScript-based positioning using
+ * `position: fixed` with measured coordinates, re-running on scroll (capture)
+ * and resize events.
+ */
+export declare function useAnchorPosition({ anchorRef, popoverRef, placement, offset, forceFallbackPositioning, arrow, }: {
+    /**
+     * Element to position relative to.
+     */
+    anchorRef: RefObject<HTMLElement | null>;
+    /**
+     * Element being positioned (typically a popover).
+     */
+    popoverRef: RefObject<HTMLElement | null>;
+    /**
+     * Where to place the element relative to the anchor.
+     */
+    placement: TPlacementOptions;
+    /**
+     * Gap between the positioned element and the anchor, in pixels.
+     * Defaults to 8 (`space.100`). Tooltip uses 4.
+     */
+    offset?: number;
+    /**
+     * Forces the JavaScript positioning fallback even when the browser
+     * supports CSS Anchor Positioning. Useful for testing fallback
+     * behavior in any environment, including production.
+     */
+    forceFallbackPositioning?: boolean;
+    /**
+     * Arrow preset from `@atlaskit/top-layer/arrow`. When provided, uses
+     * the preset's named `@position-try` rules (which update both
+     * `position-area` and `margin` on flip) and sets `--ds-arrow-size`.
+     *
+     * Pass `null` to disable. Has no effect in the JS fallback path —
+     * arrows are CSS-only.
+     */
+    arrow?: TArrowPreset | null;
+}): void;

package/dist/types-ts4.5/internal/use-animated-visibility.d.ts

@@ -0,0 +1,74 @@
+import { type RefObject } from 'react';
+import { type TAnimationPreset } from '../animations/types';
+type TUseAnimatedVisibilityArgs = {
+    /**
+     * Whether the element is logically open.
+     */
+    isOpen: boolean;
+    /**
+     * Animation preset for entry/exit transitions.
+     * Pass `false` or `undefined` to disable animation.
+     */
+    animate: TAnimationPreset | false | undefined;
+    /**
+     * Ref to the DOM element that plays the exit transition.
+     * Used to listen for `transitionend`.
+     */
+    elementRef: RefObject<HTMLElement | null>;
+    /**
+     * Called after the exit animation completes (or immediately on close
+     * when there is no animation or reduced motion is active).
+     */
+    onExitFinish?: () => void;
+};
+type TUseAnimatedVisibilityResult = {
+    /**
+     * Whether children should be rendered. Stays `true` during exit
+     * animations so content remains visible while transitioning out.
+     */
+    showChildren: boolean;
+    /**
+     * Resolved animation preset (with CSS injected), or `null` if
+     * animation is disabled.
+     */
+    preset: TAnimationPreset | null;
+};
+/**
+ * Manages the children mount/unmount lifecycle around CSS exit transitions.
+ *
+ * Used by both `Popover` and `Dialog` to share the same animation lifecycle
+ * logic. Those components own their own show/hide mechanisms (showPopover /
+ * hidePopover vs showModal / close) and event handling — this hook only
+ * manages the relationship between `isOpen` and when children are rendered.
+ *
+ * ## Problem
+ *
+ * We want to delay the unmount of children until a CSS exit transition has
+ * finished playing. If we unmount children the moment `isOpen` becomes
+ * `false`, the exit animation is never visible — the content just disappears.
+ *
+ * ## How it works
+ *
+ * `showChildren` tracks whether the consumer's children should be in the DOM.
+ * It does not mirror `isOpen` exactly — it intentionally lags behind during
+ * exit animations:
+ *
+ * ```
+ * isOpen:        true ──────────────── false
+ * showChildren:  true ──────────────── true ─── (exit animation) ─── false
+ * ```
+ *
+ * Two close paths exist:
+ *
+ * 1. **Animated close** (`willAnimate === true`):
+ *    `isOpen` goes `false` → `showChildren` stays `true` → the CSS exit
+ *    transition plays → `transitionend` fires → `showChildren` → `false`
+ *    → `onExitFinish` fires. A timeout fallback ensures we still unmount
+ *    if `transitionend` never fires (e.g. browser quirks, zero-duration).
+ *
+ * 2. **Non-animated close** (`willAnimate === false`):
+ *    `isOpen` goes `false` → `showChildren` → `false` synchronously during
+ *    the same render → `onExitFinish` fires in a follow-up effect.
+ */
+export declare function useAnimatedVisibility({ isOpen, animate, elementRef, onExitFinish, }: TUseAnimatedVisibilityArgs): TUseAnimatedVisibilityResult;
+export {};

package/dist/types-ts4.5/internal/use-animation-preset.d.ts

@@ -0,0 +1,11 @@
+type TPresetWithCssAndName = {
+    css: string;
+    name: string;
+};
+/**
+ * Normalizes the `animate` prop to a preset (or null) and ensures its CSS
+ * is injected once into document.head. Used by PopupContent, Popover, and
+ * DialogContent so they don't duplicate this logic.
+ */
+export declare function useAnimationPreset<T extends TPresetWithCssAndName>(animate: T | false | null | undefined): T | null;
+export {};

package/dist/types-ts4.5/internal/use-focus-wrap.d.ts

@@ -0,0 +1,20 @@
+import { type RefObject } from 'react';
+/**
+ * Wraps Tab/Shift+Tab focus within a popover element when its role
+ * semantically requires it (dialog, alertdialog).
+ *
+ * While the popover is open, Tab and Shift+Tab are intercepted
+ * (via `preventDefault`) and remapped to cycle through focusable
+ * elements within the container using wrapping navigation.
+ *
+ * Light dismiss (Escape, click outside) continues to work natively
+ * via `popover="auto"` — this hook only intercepts Tab.
+ *
+ * Always call this hook unconditionally. The listener is only
+ * attached when the role requires focus wrapping, and is cleaned
+ * up and re-evaluated when the role changes.
+ */
+export declare function useFocusWrap({ elementRef, role, }: {
+    elementRef: RefObject<HTMLElement | null>;
+    role: string | undefined;
+}): void;