@atlaskit/top-layer 0.17.0 → 1.0.0

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

@@ -1,11 +0,0 @@
-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 do not 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

@@ -1,25 +0,0 @@
-import { type RefObject } from 'react';
-import { type TPhase } from './use-animated-visibility';
-/**
- * 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, phase, }: {
-    elementRef: RefObject<HTMLElement | null>;
-    role: string | undefined;
-    /**
-     * Whether the element is open. Used to attach the Tab listener.
-     */
-    phase: TPhase;
-}): void;

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

@@ -1,73 +0,0 @@
-import { type RefObject } from 'react';
-import { type TPhase } from './use-animated-visibility';
-/**
- * Moves focus into a popover element when it opens, based on its ARIA role.
- *
- * Follows the WAI-ARIA APG initial-focus patterns for each role:
- * - `dialog` / `alertdialog` → focus first focusable (or `[autofocus]`)
- * - `menu` → focus first menu item
- * - `listbox` → focus selected or first option
- * - `tooltip` / no role → no focus movement (focus must remain on trigger;
- *   moving focus into the tooltip would dismiss it)
- *
- * Role is taken from the typed `role` prop - this is the consumer's contract
- * and is not subject to drift from a directly-mutated DOM attribute.
- *
- * Always call this hook unconditionally. Focus is moved on each transition
- * into a visible phase, the moment the host element first becomes visible
- * for that open intent:
- *
- * - Animated path: on `closed → entering`. The host has just been mounted
- *   and the layout effect that calls `showPopover()` / `showModal()` has
- *   already run, so the element is in the top layer. We focus before the
- *   entry transition settles to match the WAI-ARIA APG expectation that
- *   focus lands on the new menu / dialog the instant it opens, not after
- *   the CSS finishes animating.
- * - Non-animated path: on `closed → open` (the entering phase is skipped).
- * - Reopen mid-exit: on `exiting → entering`. When a user dismisses the
- *   popup (Escape, close button, light dismiss) the browser natively
- *   restores focus to the trigger as part of `hidePopover()` /
- *   `<dialog>.close()`. If the consumer reopens before the exit transition
- *   has settled, the phase machine jumps `exiting → entering` without
- *   passing through `closed`, so without this branch the popup would be
- *   visible again with focus stranded on the trigger — a keyboard usability
- *   gap for menu/dialog/listbox roles.
- *
- * Note: there is a rare programmatic path where a consumer flips `isOpen`
- * false → true without any user-initiated close gesture and had moved focus
- * to a non-default target inside the popup. In that scenario this hook
- * re-focuses the role-appropriate default (e.g. first menu item) rather
- * than preserving the consumer-chosen target. This matches the documented
- * `closed → entering` behavior and is considered acceptable given how
- * abstract the scenario is. See `notes/architecture/focus.md`.
- *
- * Pure `entering → exiting → entering` stutters where the popup never
- * reaches `closed` and the consumer toggles in the same frame are still
- * collapsed: the `prevPhase` ref guard rejects any transition whose
- * previous phase was not `closed` or `exiting`.
- *
- * Tradeoff vs the previous `requestAnimationFrame` based approach: we no
- * longer wait one paint before focusing. The element is already attached
- * and in the top layer when this effect runs (the show / hide layout
- * effect runs first), so screen-reader announcement and visible focus
- * land together. If a regression appears that needs the extra paint
- * (e.g. browsers that require a layout pass before `focus()` works on a
- * freshly promoted top-layer element), wrap the `focus()` call in a
- * single `requestAnimationFrame` here and re-add a same-element ref
- * check inside the RAF callback.
- */
-export declare function useInitialFocus({ elementRef, phase, role, }: {
-    elementRef: RefObject<HTMLElement | null>;
-    /**
-     * Current visibility phase from `useAnimatedVisibility`. Initial
-     * focus is moved on the transition out of `'closed'`:
-     *
-     * - Animated path: fires on `closed → entering`, immediately after
-     *   the host element mounts and `showPopover()` / `showModal()` has
-     *   run in the preceding layout effect.
-     * - Non-animated path: fires on `closed → open` (entering phase is
-     *   skipped entirely when animation is disabled).
-     */
-    phase: TPhase;
-    role: string | undefined;
-}): void;

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

@@ -1,15 +0,0 @@
-type TPresetWithCssAndName = {
-    css: string;
-    name: string;
-};
-/**
- * Normalizes a preset prop to a value (or null) and ensures its CSS
- * is injected once into `document.head`.
- *
- * Works with any preset that has `{ css, name }` - animation presets
- * (TAnimationPreset) satisfies this shape.
- */
-export declare function usePresetStyles<T extends TPresetWithCssAndName>({ preset, }: {
-    preset: T | false | null | undefined;
-}): T | null;
-export {};

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

@@ -1,21 +0,0 @@
-import { type RefObject } from 'react';
-import type { TWidthFromAnchorMode } from '../popover/types';
-/**
- * Sets the width of a popover element relative to its anchor element.
- *
- * - `'match-anchor'` → `width: anchor-size(width)` - popover matches anchor width exactly.
- * - `'min-anchor'`   → `min-width: anchor-size(width)` - popover is at least as wide as anchor,
- *   but can grow wider.
- * - `'none'`         → no explicit width is set (default behaviour)
- *
- * Uses CSS `anchor-size(width)` when the browser supports it, falling back to a
- * one-off measurement of `anchor.offsetWidth`.
- *
- * Designed to be composed alongside `useAnchorPosition` for top-layer popovers.
- */
-export declare function useWidthFromAnchor({ mode, popoverRef, anchorRef, isOpen, }: {
-    mode: TWidthFromAnchorMode;
-    popoverRef: RefObject<HTMLElement | null>;
-    anchorRef: RefObject<HTMLElement | null>;
-    isOpen: boolean;
-}): void;

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

@@ -1,51 +0,0 @@
-import { type TPlacementOptions } from '../internal/resolve-placement';
-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`.
- *
- * **Mapping logic:**
- *
- * | Legacy (Popper.js)  | New (Placement object)                              |
- * | ------------------- | --------------------------------------------------- |
- * | `top`               | `{ axis: 'block', edge: 'start', align: 'center' }`  |
- * | `top-start`         | `{ axis: 'block', edge: 'start', align: 'start' }`   |
- * | `top-center`        | `{ axis: 'block', edge: 'start', align: 'center' }`  |
- * | `top-end`           | `{ axis: 'block', edge: 'start', align: 'end' }`     |
- * | `bottom`            | `{ axis: 'block', edge: 'end', align: 'center' }`    |
- * | `bottom-start`      | `{ axis: 'block', edge: 'end', align: 'start' }`     |
- * | `bottom-center`     | `{ axis: 'block', edge: 'end', align: 'center' }`    |
- * | `bottom-end`        | `{ axis: 'block', edge: 'end', align: 'end' }`       |
- * | `right`             | `{ axis: 'inline', edge: 'end', align: 'center' }`   |
- * | `right-start`       | `{ axis: 'inline', edge: 'end', align: 'start' }`    |
- * | `right-end`         | `{ axis: 'inline', edge: 'end', align: 'end' }`      |
- * | `left`              | `{ axis: 'inline', edge: 'start', align: 'center' }` |
- * | `left-start`        | `{ axis: 'inline', edge: 'start', align: 'start' }`  |
- * | `left-end`          | `{ axis: 'inline', edge: 'start', align: 'end' }`    |
- * | `auto`              | `{ axis: 'block', edge: 'end', align: 'center' }`    |
- * | `auto-start`        | `{ axis: 'block', edge: 'end', align: 'start' }`     |
- * | `auto-end`          | `{ axis: 'block', edge: 'end', align: 'end' }`       |
- *
- * `auto*` is mapped to `block-end` (a reduction in expressiveness vs Popper's
- * runtime auto-flip). CSS `position-try-fallbacks` provides flipping at the
- * edge - but the initial placement is fixed. If migrating away from Popper's
- * dynamic auto, prefer an explicit placement.
- *
- * @example
- * ```ts
- * import { fromLegacyPlacement } from '@atlaskit/top-layer/placement-map';
- *
- * // In a migration from @atlaskit/popup:
- * const oldPlacement: TLegacyPlacement = 'bottom-start';
- * const newPlacement: TPlacementOptions = fromLegacyPlacement({ legacy: oldPlacement });
- * // newPlacement === { axis: 'block', edge: 'end', align: 'start' }
- * ```
- */
-export declare function fromLegacyPlacement({ legacy, offset, }: {
-    legacy: TLegacyPlacement;
-    offset?: [
-        along: number,
-        away: number
-    ];
-}): TPlacementOptions;
-export type { TLegacyPlacement, TPlacementOptions };

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

@@ -1,27 +0,0 @@
-/**
- * Legacy Popper.js placement values (used by `@atlaskit/popper`,
- * `@atlaskit/popup`, `@atlaskit/tooltip`, etc.). Re-exported from
- * `@atlaskit/top-layer/placement-map` for migration consumers that need
- * to enumerate every placement (e.g. for a settings dropdown). New code
- * should use the object-based `TPlacementOptions` directly.
- */
-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];

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

@@ -1,13 +0,0 @@
-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-ts4.5/popover/create-close-event.d.ts

@@ -1,25 +0,0 @@
-import type { TPopoverCloseReason } from './types';
-/**
- * Creates a synthetic DOM event from a `TPopoverCloseReason`.
- *
- * Useful when bridging the Popover primitive's `onClose({ reason })` callback
- * to a legacy API that expects a native DOM event - for example,
- * `@atlaskit/inline-dialog`'s `onClose(event)` contract.
- *
- * - `'escape'` → `KeyboardEvent('keydown', { key: 'Escape' })`
- * - `'light-dismiss'` → `MouseEvent('click')`
- *
- * For any other reason, a generic `Event('close')` is returned as a fallback.
- *
- * @example
- * ```tsx
- * import { createPopoverCloseEvent, type TPopoverCloseReason } from '@atlaskit/top-layer/popover';
- *
- * function onPopoverClose({ reason }: { reason: TPopoverCloseReason }) {
- *   legacyOnClose(createPopoverCloseEvent({ reason }));
- * }
- * ```
- */
-export declare function createPopoverCloseEvent({ reason, }: {
-    reason: TPopoverCloseReason;
-}): KeyboardEvent | MouseEvent | Event;

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

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

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

@@ -1,17 +0,0 @@
-/**
- * @jsxRuntime classic
- * @jsx jsx
- */
-import React from 'react';
-import { type TPopoverForwardedProps } from './types';
-/**
- * Unopinionated top-layer primitive. Manages visibility and animation only;
- * compose with `useAnchorPosition` / `useWidthFromAnchor` for positioning.
- *
- * `isOpen={true}` calls `showPopover()` (entry via `@starting-style`);
- * `isOpen={false}` calls `hidePopover()` (exit via `allow-discrete`).
- *
- * 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-ts4.5/popover/types.d.ts

@@ -1,193 +0,0 @@
-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';
-/**
- * The reason a popover was closed.
- *
- * - `'escape'`: The user pressed the Escape key.
- * - `'light-dismiss'`: The user clicked outside the popover (or the browser
- *   dismissed it for another auto-mode reason).
- * - `'programmatic'`: The popover was closed programmatically.
- */
-export type TPopoverCloseReason = 'escape' | 'light-dismiss' | 'programmatic';
-/**
- * Flat (non-discriminated) props accepted by the Popover component internally.
- *
- * TypeScript limitation: when PopupContent destructures props from a
- * discriminated union (role, label, labelledBy) and re-passes them individually
- * to Popover, TypeScript cannot prove the individual fields still satisfy the
- * union constraint. This flat type accepts all role/label combinations without
- * the union, since ARIA correctness is enforced at the TPopupContentProps
- * boundary where consumers interact.
- */
-export type TPopoverForwardedProps = TPopoverBaseProps & {
-    mode?: 'auto' | 'hint' | 'manual';
-    onClose?: (args: {
-        reason: TPopoverCloseReason;
-    }) => void;
-    role?: TRoleRequiringAccessibleName | TRoleWithImplicitName;
-    label?: string;
-    labelledBy?: string;
-};
-export type { TPlacementOptions };
-type TPopoverBaseProps = {
-    children: ReactNode;
-    /**
-     * Additional CSS styles applied to the popover root element.
-     * Use to set `backgroundColor` to match the popup surface colour.
-     */
-    xcss?: StrictXCSSProp<'backgroundColor', never>;
-    /**
-     * Animation preset for entry/exit transitions.
-     *
-     * Animations use `@starting-style` and `allow-discrete` for progressive
-     * enhancement: browsers without support show/hide instantly.
-     */
-    animate?: false | TAnimationPreset;
-    /**
-     * Test ID applied to the popover element.
-     */
-    testId?: string;
-    /**
-     * HTML `id` attribute for the popover element. When omitted, a unique ID
-     * 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;
-    /**
-     * Whether the popover is open.
-     *
-     * - **`true`:** show the popover (calls `showPopover()`, entry animation plays via `@starting-style`).
-     * - **`false`:** hide the popover. When an `animate` preset is provided, the exit
-     *   animation plays (via `allow-discrete`) before the popover becomes logically closed.
-     *   Otherwise hides instantly.
-     *
-     * The consumer does not conditionally render the `Popover` — visibility is driven
-     * by this prop.
-     *
-     * **Lifecycle observable to consumers:**
-     *
-     * - The host element is in the DOM only while the popover is open or its exit
-     *   animation is playing. After exit completes the element is unmounted so it
-     *   does not leave an empty `role` / `popover` element in the accessibility tree.
-     *   The exact unmount timing is private and may change.
-     * - The `id` (supplied or generated via `usePopoverId()`) is stable across opens.
-     * - The `ref` is populated only while the host element is rendered. Consumers
-     *   that read from the ref outside of `onOpenChange` / `onEnterFinish` should
-     *   gate the read on `isOpen` being `true`.
-     *
-     * **Important:** For `mode="auto"` popovers, the browser can dismiss the popover
-     * via light dismiss (Escape, click outside) independently of this prop. When that
-     * happens, `onClose` is called and the consumer should respond by setting `isOpen`
-     * to `false`. If `isOpen` remains `true` after a browser dismiss, the DOM and
-     * React state will be out of sync (the popover will be hidden despite `isOpen={true}`).
-     */
-    isOpen: boolean;
-    /**
-     * Called when the popover's open state changes via browser toggle events.
-     *
-     * Receives the new open state and a reference to the popover element,
-     * which is useful for focus management (e.g. focusing the first interactive
-     * child on open via `getFirstFocusable` from `@atlaskit/top-layer/focus`).
-     *
-     * @example
-     * ```tsx
-     * <Popover
-     *   onOpenChange={({ isOpen, element }) => {
-     *     if (isOpen) {
-     *       getFirstFocusable({ container: element })?.focus();
-     *     }
-     *   }}
-     * />
-     * ```
-     */
-    onOpenChange?: (args: {
-        isOpen: boolean;
-        element: HTMLDivElement;
-    }) => void;
-    /**
-     * Placement hint for directional animations (e.g. `slideAndFade`).
-     *
-     * When `animate` is provided, the preset's `getProperties(placement)` is
-     * called to set CSS custom properties (like `--ds-popover-tx`, `--ds-popover-ty`)
-     * that control the slide direction. Has no effect without `animate`.
-     *
-     * This does NOT control positioning. Use `useAnchorPosition` for that.
-     */
-    placement?: TPlacementOptions;
-    /**
-     * 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
-     * that the show sequence is finished.
-     */
-    onEnterFinish?: () => void;
-    /**
-     * 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. notifying a manager
-     * that the hide sequence is finished, or firing an `onCloseComplete` callback.
-     */
-    onExitFinish?: () => void;
-};
-/**
- * Unopinionated top-layer primitive.
- *
- * `Popover` manages only top-layer visibility and animation. It has no
- * knowledge of positioning. For anchor positioning, compose with the
- * `useAnchorPosition` hook separately.
- *
- * Use `Popover` directly for custom trigger lifecycles (hover, timers,
- * external state) or trigger-less UI (flags, toasts). For the common
- * button-opens-content pattern, use the `Popup` compound instead.
- *
- * Dismiss behavior:
- * - `'auto'` (default): Escape to close, click-outside to close, focus restoration,
- *   automatic nesting, mutual exclusivity.
- * - `'hint'`: ephemeral UI (e.g. tooltips) that does not close other `auto`
- *   popovers. Falls back silently to `auto` semantics in browsers without
- *   `popover='hint'` support, meaning the hint will close any other `auto`
- *   popovers in those browsers. If cross-browser uniformity matters more
- *   than the no-close behaviour, pass `auto` explicitly.
- * - `'manual'`: no light dismiss. Consumer controls show/hide entirely. Only
- *   appropriate for persistent UI (e.g. flags, banners).
- */
-export type TPopoverProps = TPopoverBaseProps & TAriaRoleRequired & ({
-    mode?: 'auto' | 'hint';
-    /**
-     * Called when the popover is dismissed via light dismiss
-     * (Escape, click outside).
-     *
-     * Required for `auto` and `hint` modes - without it, browser
-     * dismissals leave the consumer's `isOpen` stuck at `true` while
-     * the DOM is hidden, producing a stale-open state.
-     *
-     * The `reason` field indicates how the dismiss occurred:
-     * - `'escape'`: the user pressed the Escape key.
-     * - `'light-dismiss'`: the user clicked outside (or another auto-dismiss).
-     */
-    onClose: (args: {
-        reason: TPopoverCloseReason;
-    }) => void;
-} | {
-    mode: 'manual';
-    onClose?: never;
-});
-/**
- * The width mode of the popover relative to its anchor element.
- *
- * - `'none'` (default): popover sizes to its content, ignoring the anchor width.
- * - `'match-anchor'`: popover matches the anchor element's width exactly
- *   via CSS `anchor-size(width)`. Falls back to a one-off measurement
- *   of `anchorRef.current.offsetWidth` when CSS Anchor Positioning
- *   is not supported.
- * - `'min-anchor'`: popover is at least as wide as the anchor, but
- *   can grow wider if content requires it. Uses `min-width: anchor-size(width)`.
- *   Falls back to a one-off measurement of the anchor's width.
- */
-export type TWidthFromAnchorMode = 'none' | 'match-anchor' | 'min-anchor';

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

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

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

@@ -1,21 +0,0 @@
-/**
- * @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-ts4.5/testing/polyfill.d.ts

@@ -1,25 +0,0 @@
-/**
- * Popover API & HTMLDialogElement polyfills for jsdom.
- *
- * jsdom does not implement the Popover API or the HTMLDialogElement methods
- * (showModal, show, close). This polyfill provides faithful implementations,
- * including timing semantics validated against Chromium via Playwright.
- *
- * Behaviour:
- *  - beforetoggle: sync, cancelable on popover show only. toggle: async task, never cancelable.
- *  - Rapid show/hide coalesces into one toggle event (originalOldState to finalNewState).
- *  - Dialog: showModal/show fire beforetoggle+toggle. close fires toggle then close event.
- *  - Popover open state tracked via `data-popover-open` (no `:popover-open` in jsdom).
- *  - Auto popovers: maintain an open stack, perform light-dismiss on document mousedown
- *    outside the open chain, and dismiss the topmost on Escape.
- *  - On open, removes any inline `opacity: 0` from the popover element so callers that
- *    rely on a `ResizeObserver` reveal callback (e.g. `use-anchor-position`) become
- *    visible in jsdom, where layout-driven RO callbacks never fire.
- *
- * Companion `toBeVisible` patch lives at `./to-be-visible`.
- *
- * Importing this module has the side-effect of patching the relevant
- * prototypes. It is safe to import multiple times; each branch is guarded
- * to avoid overwriting native implementations or re-patching.
- */
-export {};

package/dist/types-ts4.5/testing/to-be-visible.d.ts

@@ -1,23 +0,0 @@
-/**
- * Patches `toBeVisible()` to understand popover and dialog visibility.
- *
- * jest-dom's `toBeVisible()` does not know about the Popover API. In real
- * browsers the UA stylesheet hides `[popover]` with `display: none`, but
- * jsdom has no such stylesheet - so closed popovers incorrectly appear visible.
- *
- * Raw jest-dom results in jsdom:
- *
- *   closed popover / child  → true  (WRONG - should be false)
- *   open popover / child    → true  (correct)
- *   closed dialog / child   → false (correct - jsdom natively hides <dialog>)
- *   open dialog / child     → true  (correct)
- *
- * We correct both false positives and false negatives:
- *   1. Delegate to the original first.
- *   2. If it says "visible" → check for closed top-layer hosts (false positive).
- *   3. If it says "not visible" → check for open top-layer hosts (false negative).
- *
- * Must load via `setupFilesAfterEnv` (after jest-dom registers its matchers).
- * Polyfills live in `./polyfill` (loaded via `setupFiles`).
- */
-export {};

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

@@ -1,3 +0,0 @@
-export { useArrowNavigation } from './use-arrow-navigation';
-export type { TUseArrowNavigationArgs } from './use-arrow-navigation';
-export { isAtCurrentMenuLevel } from './is-at-current-menu-level';

package/dist/types-ts4.5/use-arrow-navigation/is-at-current-menu-level.d.ts

@@ -1,48 +0,0 @@
-/**
- * Returns true if the element belongs to the current menu level of the
- * container, i.e. it is NOT inside a nested `role="menu"` sub-container.
- *
- * Uses `element.closest('[role="menu"]')` to determine the nearest menu
- * scope. If the nearest scope is the container's own `role="menu"` element,
- * the element belongs to this level. If it is a different (nested) menu,
- * the element belongs to a child level and should be excluded.
- *
- * Supports two container patterns:
- *
- * **1. Container has `role="menu"` directly** (preferred, used by avatar-group):
- *   ```
- *   <div ref={containerRef} role="menu">
- *     <button role="menuitem" />   ← isAtCurrentMenuLevel → true
- *     <div role="menu">            ← nested sub-menu
- *       <button role="menuitem" /> ← isAtCurrentMenuLevel → false
- *     </div>
- *   </div>
- *   ```
- *   Uses the simple check: `element.closest('[role="menu"]') === container`
- *
- * **2. Container is a wrapper without `role="menu"`** (used by dropdown-menu,
- *   where `MenuGroup` owns `role="menu"` but does not accept a ref):
- *   ```
- *   <div ref={containerRef}>         ← wrapper (no role="menu")
- *     <MenuGroup role="menu">
- *       <button role="menuitem" />   ← isAtCurrentMenuLevel → true
- *       <div role="menu">            ← nested sub-menu
- *         <button role="menuitem" /> ← isAtCurrentMenuLevel → false
- *       </div>
- *     </MenuGroup>
- *   </div>
- *   ```
- *   Falls back to walking the DOM to check that the element's closest
- *   `role="menu"` is the container's own menu (not doubly nested).
- *
- * Ideally all consumers should use pattern 1 (place the ref directly on the
- * `role="menu"` element). Pattern 2 exists because `@atlaskit/menu`'s
- * `MenuGroup` does not currently accept a ref. If `MenuGroup` gains ref
- * support in the future, dropdown-menu should switch to pattern 1 and the
- * fallback path can be removed.
- *
- * Used both as a `TFocusableFilter` (to scope getNextFocusable etc.) and as
- * a guard to prevent parent menu handlers from acting on events that
- * belong to a nested menu.
- */
-export declare function isAtCurrentMenuLevel(element: Element, container: HTMLElement): boolean;