@atlaskit/top-layer 0.17.0 → 0.18.0

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

@@ -1,93 +0,0 @@
-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` is `undefined` while the popover is closed, because
-     * the popover host element is only rendered in the DOM while open. A
-     * dangling `aria-controls` reference (pointing at a missing ID) is
-     * tolerated by assistive tech but flagged by some a11y tooling, so
-     * we leave it unset until the target exists.
-     */
-    'aria-controls': string | undefined;
-};
-/**
- * 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/placement-to-position-area.d.ts

@@ -1,21 +0,0 @@
-import { type TPlacementOptions } from '../internal/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;

package/dist/types-ts4.5/internal/placement-to-try-fallbacks.d.ts

@@ -1,36 +0,0 @@
-import { type TPlacementOptions } from '../internal/resolve-placement';
-/**
- * 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.
- *
- * **Why `flip-inline flip-block` (or `flip-block flip-inline`) is included:**
- *
- * When a popup is in a viewport corner (e.g. inline-end align-end at the
- * top-right), flipping only the primary axis (`flip-inline`) moves the popup
- * to the left but keeps the same cross-axis span direction (e.g. upward),
- * which is still off-screen. The combined keyword `flip-inline flip-block`
- * mirrors the popup diagonally. It flips BOTH the position-area AND both
- * inline and block margins simultaneously, placing the popup at the
- * diagonally opposite corner where there is always space.
- *
- * Named `position-area` entries (e.g. `inline-start span-block-end`) in
- * `position-try-fallbacks` do NOT update margins, so only the `flip-*`
- * tactic keywords correctly flip the gap margin along with the position.
- */
-export declare function placementToTryFallbacks({ placement }: {
-    placement: TPlacementOptions;
-}): string;

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

@@ -1,14 +0,0 @@
-/**
- * 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 will not
- * 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-css-length-to-pixels.d.ts

@@ -1,20 +0,0 @@
-/**
- * Resolves a CSS length value to a pixel number using a hidden DOM probe.
- *
- * Used by the JS positioning fallback: consumer offsets can be numbers,
- * `${n}px` strings, tokenised `var(--ds-space-100, 8px)` strings, `calc()`
- * expressions, viewport units, etc. Parsing arbitrary CSS in JS is fragile
- * (and impossible for `calc(var(...))` without a layout context), so we let
- * the browser do the math.
- *
- * The probe is appended to `container` so it inherits the same containing
- * block, font size, and custom-property scope as the popover.
- *
- * Cost: one synchronous reflow on first cacheable resolution per
- * (container, value) pair, then a `WeakMap` lookup. Resolutions involving
- * `var(` are intentionally not cached.
- */
-export declare function resolveCssLengthToPixels({ value, container, }: {
-    value: number | string;
-    container: HTMLElement;
-}): number;

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

@@ -1,8 +0,0 @@
-/**
- * Normalizes an offset to a CSS length string. Numbers become `${n}px`;
- * strings pass through. Apply at the API boundary so internal code only
- * deals with strings.
- */
-export declare function toCssLengthString({ value }: {
-    value: number | string;
-}): string;

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

@@ -1,58 +0,0 @@
-/**
- * Cross-axis shift. `value` is a CSS length string (consumer numbers are
- * normalized to `${n}px`). `direction` is `'forwards'` (toward end) or
- * `'backwards'` (toward start).
- */
-export type TCrossAxisShiftOffset = {
-    value: string;
-    direction: 'forwards' | 'backwards';
-};
-/**
- * Fully-resolved placement (internal). Use `getPlacement` for partial input.
- * `offset.gap` and `offset.crossAxisShift.value` are always CSS
- * length strings.
- */
-export type TPlacement = {
-    axis: 'block' | 'inline';
-    edge: 'start' | 'end';
-    align: 'start' | 'center' | 'end';
-    offset: {
-        gap: string;
-        crossAxisShift: {
-            value: string;
-            direction: 'forwards' | 'backwards';
-        };
-    };
-};
-/**
- * Partial placement options. `offset.gap` and
- * `offset.crossAxisShift.value` accept either a number (pixels) or a
- * CSS length string (e.g. `token('space.100')`).
- *
- * The two offset axes are named for clarity at the call site:
- *   - `gap`     - distance away from the trigger along the placement axis
- *   - `crossAxisShift`  - nudge along the trigger edge (perpendicular to the placement axis)
- */
-export type TPlacementOptions = {
-    axis?: 'block' | 'inline';
-    edge?: 'start' | 'end';
-    align?: 'start' | 'center' | 'end';
-    offset?: {
-        gap?: number | string;
-        crossAxisShift?: {
-            value?: number | string;
-            direction?: 'forwards' | 'backwards';
-        };
-    };
-};
-/**
- * Resolves a partial placement to its fully-specified form. Number offsets
- * are normalized to `${n}px` strings.
- *
- * Defaults: `axis: 'block'`, `edge: 'end'`, `align: 'center'`,
- * `offset.gap: token('space.100', '8px')`,
- * `offset.crossAxisShift: { value: '0px', direction: 'forwards' }`.
- */
-export declare function getPlacement({ placement }: {
-    placement: TPlacementOptions;
-}): TPlacement;

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

@@ -1,13 +0,0 @@
-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

@@ -1,71 +0,0 @@
-/**
- * Valid values for the `aria-haspopup` attribute.
- *
- * Derived from the HTML spec - maps popover roles to what the trigger
- * announces. `undefined` means the attribute is omitted entirely (used for
- * non-popup roles like `tooltip`/`status`/`alert`/`note`/`log` where
- * `aria-haspopup` would be misleading).
- *
- * `true` is intentionally NOT in the union - the runtime only ever produces
- * the explicit string forms, so widening the type would invite consumers to
- * pass `true` and get an `aria-haspopup="true"` serialisation that the
- * runtime no longer emits.
- */
-export type TAriaHasPopupValue = 'dialog' | 'menu' | 'listbox' | 'tree' | 'grid' | undefined;
-/**
- * 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);
-/**
- * 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;
-export {};

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

@@ -1,11 +0,0 @@
-/**
- * Sets inline styles on an element and returns a cleanup function that
- * restores the prior inline values (so we do not stomp consumer styles).
- */
-export declare function setStyle({ el, styles, }: {
-    el: HTMLElement;
-    styles: Array<{
-        property: string;
-        value: string;
-    }>;
-}): () => void;

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

@@ -1,8 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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-position-at-point.d.ts

@@ -1,67 +0,0 @@
-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, isOpen, }: {
-    /**
-     * 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;
-    /**
-     * Whether the popover is currently open. Forwarded to the inner
-     * `useAnchorPosition` so it re-runs across host remount cycles.
-     */
-    isOpen: boolean;
-}): void;

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

@@ -1,91 +0,0 @@
-/**
- * Anchor positioning for top-layer popovers. See
- * `notes/architecture/positioning.md` for the full model.
- *
- * Two runtime paths: CSS Anchor Positioning (modern browsers) and a JS
- * fallback that measures the trigger and writes `top`/`left`.
- *
- * Both paths honour `offset.gap` and `offset.crossAxisShift`. The
- * CSS path passes the values through as strings; the JS fallback resolves
- * them to pixels via a hidden DOM probe (see `resolveCssLengthToPixels`)
- * so tokens, `calc()`, `var()`, etc all work. The JS fallback hides the
- * popover with `opacity: 0` until the first measurement completes, so it
- * is never painted at the wrong location.
- */
-import { type RefObject } from 'react';
-import { type TPlacementOptions } from '../internal/resolve-placement';
-/**
- * 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.
- *
- * `placement` may be a fresh inline object on every render: a structural
- * comparison is used internally so re-runs are skipped when the resolved
- * placement shape is unchanged.
- */
-export declare function useAnchorPosition({ anchorRef, popoverRef, placement, forceFallbackPositioning, isEnabled, isOpen, }: {
-    /**
-     * Element to position relative to.
-     */
-    anchorRef: RefObject<HTMLElement | null>;
-    /**
-     * Element being positioned (typically a popover).
-     *
-     * The popover host may be unmounted between opens (the `Popover`
-     * primitive unmounts after its exit animation). Pass `isOpen` so the
-     * positioning effect re-runs against the freshly mounted element on
-     * the next open. Without it, the effect's bound listeners and styles
-     * would target the previous (detached) element.
-     */
-    popoverRef: RefObject<HTMLElement | null>;
-    /**
-     * Where to place the element relative to the anchor.
-     * `offset.gap` and `offset.crossAxisShift` are part of the
-     * placement object.
-     *
-     * All fields are optional. Omitted fields fall back to:
-     *   - `axis`: `'block'`
-     *   - `edge`: `'end'`
-     *   - `align`: `'center'`
-     *   - `offset.gap`: `token('space.100', '8px')`
-     *   - `offset.crossAxisShift.value`: `'0px'`
-     *   - `offset.crossAxisShift.direction`: `'forwards'`
-     *
-     * The full default placement (`{}`) renders the popover centered
-     * below the trigger with one `space.100` of gap and no cross-axis
-     * shift.
-     *
-     * `offset.gap` and `offset.crossAxisShift.value` accept either a
-     * number (pixels) or a CSS length string (eg `token('space.200')`).
-     */
-    placement?: TPlacementOptions;
-    /**
-     * 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;
-    /**
-     * When `false`, the hook is a no-op and applies no positioning.
-     * Defaults to `true`.
-     */
-    isEnabled?: boolean;
-    /**
-     * Whether the popover is currently open. Drives a re-run of the
-     * positioning effect when the popover host element is unmounted
-     * and remounted across open cycles, so listeners and styles are
-     * always wired to the live host element.
-     */
-    isOpen: boolean;
-}): void;

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

@@ -1,109 +0,0 @@
-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 entry/exit transitions.
-     * Used to listen for `transitionend`.
-     */
-    elementRef: RefObject<HTMLElement | null>;
-    /**
-     * Called after the entry animation completes (or immediately on open
-     * when there is no animation or reduced motion is active).
-     * This includes initial mount with `isOpen=true`.
-     */
-    onEnterFinish?: () => void;
-    /**
-     * Called after the exit animation completes (or immediately on close
-     * when there is no animation or reduced motion is active).
-     */
-    onExitFinish?: () => void;
-};
-type TUseAnimatedVisibilityResult = {
-    /**
-     * Current visibility phase. See `TPhase` for the full lifecycle.
-     *
-     * `phase !== 'closed'` means the host element is mounted and on
-     * screen, including during animated entry, animated exit, and the
-     * non-animated close handshake. Use this when you need "the user
-     * can still see / interact with the element" semantics (e.g. focus
-     * trapping, listeners that must outlive the exit).
-     */
-    phase: TPhase;
-    /**
-     * Resolved animation preset (with CSS injected), or `null` if
-     * animation is disabled.
-     */
-    preset: TAnimationPreset | null;
-};
-/**
- * Visibility lifecycle phase shared between `useAnimatedVisibility`,
- * `useFocusWrap`, `useInitialFocus`, and the `Popover` / `Dialog`
- * components.
- *
- * - `closed`: host element is unmounted. No DOM presence.
- * - `entering`: host element is mounted and the CSS entry transition
- *   is playing. **Only emitted when animation is enabled.** With
- *   animation disabled the lifecycle goes directly `closed → open`.
- * - `open`: host element is mounted and settled. No transition is
- *   playing.
- * - `exiting`: `isOpen` has flipped to `false` but the host element
- *   is still mounted. Emitted while the CSS exit transition is playing
- *   (animation enabled) OR while we wait for the browser's
- *   `toggle`/`close` event to fire on the still-attached element so
- *   focus restoration can run (animation disabled).
- *
- * State machine:
- * ```
- *   animation ON:   closed → entering → open → exiting → closed
- *   animation OFF:  closed →            open → exiting → closed
- *   interrupts:     entering → exiting (close mid-entry)
- *                   exiting  → entering (reopen mid-exit, animated)
- *                   exiting  → open     (reopen mid-handshake, non-animated)
- * ```
- *
- * `phase !== 'closed'` is the canonical "host is currently in the DOM
- * and on screen" predicate.
- */
-export type TPhase = 'closed' | 'entering' | 'open' | 'exiting';
-/**
- * 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
- *
- * The lifecycle is modeled as a `phase` discriminated union (`closed`,
- * `entering`, `open`, `exiting`). The host element is rendered while
- * `phase !== 'closed'`, so the `exiting` phase keeps the host mounted
- * while the CSS exit transition plays (or, with animation disabled,
- * while we wait for the browser `toggle` / `close` event to fire on the
- * still-attached element):
- *
- * ```
- * isOpen:  true ──────────────── false
- * phase:   open ──────────────── exiting ─── (exit settle) ─── closed
- * ```
- *
- * Every effect dispatches on the single `phase` value instead of a
- * cross-product of booleans.
- */
-export declare function useAnimatedVisibility({ isOpen, animate, elementRef, onEnterFinish, onExitFinish, }: TUseAnimatedVisibilityArgs): TUseAnimatedVisibilityResult;
-export {};