@atlaskit/top-layer 0.16.0 → 0.18.0

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 {};

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';