@atlaskit/popper 8.0.0 → 8.1.0

package/dist/esm/popper-top-layer.js

@@ -0,0 +1,277 @@
+/* popper-top-layer.tsx generated by @compiled/babel-plugin v0.39.1 */
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import { ax, ix } from "@compiled/react/runtime";
+import React, { useMemo, useRef, useState } from 'react';
+import { getDocument } from '@atlaskit/browser-apis';
+import noop from '@atlaskit/ds-lib/noop';
+import { fromLegacyPlacement } from '@atlaskit/top-layer/placement-map';
+import { Popover } from '@atlaskit/top-layer/popover';
+import { useAnchorPosition } from '@atlaskit/top-layer/use-anchor-position';
+import { useAnchorPositionAtPoint } from '@atlaskit/top-layer/use-anchor-position-at-point';
+import { usePopoverId } from '@atlaskit/top-layer/use-popover-id';
+import { useWidthFromAnchor } from '@atlaskit/top-layer/use-width-from-anchor';
+import { rectPointForPlacement } from './internal/rect-point-for-placement';
+import { useFitViewportMaxSize } from './internal/use-fit-viewport-max-size';
+import { useManagerAnchor } from './internal/use-manager-anchor';
+import { useReferenceVisibility } from './internal/use-reference-visibility';
+/**
+ * Inert render-prop values. The browser owns positioning under CSS Anchor
+ * Positioning, so `style` / `ref` / `arrowProps` / `update` / `forceUpdate`
+ * are no-ops that consumers can safely spread. Module scope keeps identities
+ * stable for effect dep arrays.
+ */
+var noopStyle = {};
+var noopSetRef = noop;
+var noopUpdate = function noopUpdate() {
+  return Promise.resolve(null);
+};
+var noopForceUpdate = function noopForceUpdate() {
+  return {};
+};
+
+/**
+ * `react-popper` stamps `data-popper-arrow` on the arrow element at runtime
+ * but does not declare it on `arrowProps`. Widen the type so consumers that
+ * rely on the attribute (CSS selectors, snapshots, tests) keep working.
+ */
+
+var noopArrowProps = {
+  ref: noopSetRef,
+  style: noopStyle,
+  'data-popper-arrow': true
+};
+
+/**
+ * Returns whether the current page is laid out right-to-left.
+ */
+function isPageRtl() {
+  var document = getDocument();
+  if (!document) {
+    return false;
+  }
+  return document.dir === 'rtl' || document.body.dir === 'rtl' || document.documentElement.dir === 'rtl';
+}
+
+/**
+ * `@popperjs/core`'s `Placement` union is a strict subset of
+ * `TLegacyPlacement` (the placement-map adds `top-center` /
+ * `bottom-center` on top of popper's enum), so every value popper hands
+ * us is a valid legacy placement. The cast keeps the runtime path free
+ * of an extra module-level lookup that bundlers can occasionally fail
+ * to wire up (observed as `Cannot read properties of undefined (reading
+ * 'includes')` in component-test bundles).
+ */
+function toLegacyPlacement(placement) {
+  return placement;
+}
+
+/**
+ * Returns the primary axis (`top` / `bottom` / `left` / `right`) of a popper
+ * placement, used to pick which axis `useFitViewportMaxSize` caps to the
+ * anchor edge.
+ */
+function getPlacementAxis(placement) {
+  if (placement.startsWith('top')) {
+    return 'top';
+  }
+  if (placement.startsWith('bottom')) {
+    return 'bottom';
+  }
+  if (placement.startsWith('left')) {
+    return 'left';
+  }
+  if (placement.startsWith('right')) {
+    return 'right';
+  }
+  // `auto*` placements have no fixed axis. Default to `bottom` to match the
+  // `auto -> block-end` mapping in `fromLegacyPlacement`.
+  return 'bottom';
+}
+
+/**
+ * Normalises popper's `[along, away]` offset (which may include `null` or
+ * `undefined` entries) into the `[along, away]` number tuple
+ * `fromLegacyPlacement` expects.
+ */
+function popperToTopLayerOffset(offset) {
+  if (!offset) {
+    return undefined;
+  }
+  var _offset = _slicedToArray(offset, 2),
+    along = _offset[0],
+    away = _offset[1];
+  if (along == null && away == null) {
+    return undefined;
+  }
+  return [along !== null && along !== void 0 ? along : 0, away !== null && away !== void 0 ? away : 0];
+}
+
+/**
+ * FF-on implementation of `@atlaskit/popper`'s `<Popper>` primitive.
+ *
+ * Renders the consumer's render-prop output into a `<Popover>` from
+ * `@atlaskit/top-layer`, which lifts the element into the browser top
+ * layer and positions it via CSS Anchor Positioning. The render-prop
+ * contract (`PopperChildrenProps`) is preserved at the type level;
+ * `style` and `arrowProps.style` are inert at runtime because the
+ * browser owns positioning.
+ *
+ * Gated behind the `platform-dst-top-layer` feature flag from
+ * `popper.tsx`.
+ */
+export function PopperTopLayer(_ref) {
+  var _ref2;
+  var children = _ref.children,
+    offset = _ref.offset,
+    _ref$placement = _ref.placement,
+    placement = _ref$placement === void 0 ? 'bottom-start' : _ref$placement,
+    referenceElement = _ref.referenceElement,
+    _ref$shouldFitViewpor = _ref.shouldFitViewport,
+    shouldFitViewport = _ref$shouldFitViewpor === void 0 ? false : _ref$shouldFitViewpor;
+  // `modifiers` and `strategy` are accepted for source compatibility but have
+  // no runtime effect; CSS Anchor Positioning + top-layer rendering replaces
+  // them. See `top-layer/notes/migrations/popper-migration.md`.
+
+  // Anchor resolution: `referenceElement` prop, then `<Manager>` context.
+  var managerAnchor = useManagerAnchor();
+  var effectiveReference = (_ref2 = referenceElement !== null && referenceElement !== void 0 ? referenceElement : managerAnchor) !== null && _ref2 !== void 0 ? _ref2 : undefined;
+
+  // Real DOM nodes go to `useAnchorPosition`; popper `VirtualElement`s are
+  // bridged through `useAnchorPositionAtPoint`, which owns its own synthetic
+  // anchor.
+  var htmlAnchor = effectiveReference instanceof HTMLElement ? effectiveReference : null;
+  var virtualReference = effectiveReference != null && !(effectiveReference instanceof HTMLElement) ? effectiveReference : null;
+  var htmlAnchorRef = useRef(htmlAnchor);
+  htmlAnchorRef.current = htmlAnchor;
+  var popoverRef = useRef(null);
+  var popoverId = usePopoverId();
+
+  // Track the resolved DOM anchor in state so visibility / max-size hooks
+  // re-run when its identity changes. Virtual anchors do not feed these
+  // hooks because their probe is outside the consumer's DOM.
+  //
+  // Adjust state during render by comparing against the state itself: the
+  // conditional guard means `setResolvedAnchor` is skipped once they match,
+  // so it converges in one extra render. This is the React-documented pattern
+  // and is side-effect-free — no ref mutation during render.
+  var _useState = useState(htmlAnchor),
+    _useState2 = _slicedToArray(_useState, 2),
+    resolvedAnchor = _useState2[0],
+    setResolvedAnchor = _useState2[1];
+  if (resolvedAnchor !== htmlAnchor) {
+    setResolvedAnchor(htmlAnchor);
+  }
+  var topLayerPlacement = useMemo(function () {
+    return fromLegacyPlacement({
+      legacy: toLegacyPlacement(placement),
+      offset: popperToTopLayerOffset(offset)
+    });
+  }, [placement, offset]);
+  var isOpen = effectiveReference != null;
+
+  // HTML-element path. No-op when the reference is virtual or absent.
+  useAnchorPosition({
+    anchorRef: htmlAnchorRef,
+    popoverRef: popoverRef,
+    placement: topLayerPlacement,
+    isEnabled: htmlAnchor != null,
+    isOpen: isOpen
+  });
+
+  // Virtual-element path. `useAnchorPositionAtPoint` owns a synthetic
+  // anchor in `document.body` and latches `getPoint` once per
+  // `isEnabled` activation. Reading the latest `virtualReference` and
+  // `topLayerPlacement` via refs ensures the latched closure always
+  // sees the current values rather than the ones captured at first
+  // activation, which would otherwise go stale if either prop changes
+  // while the popper stays open.
+  var virtualReferenceRef = useRef(virtualReference);
+  virtualReferenceRef.current = virtualReference;
+  var topLayerPlacementRef = useRef(topLayerPlacement);
+  topLayerPlacementRef.current = topLayerPlacement;
+  var isVirtualEnabled = virtualReference != null;
+  useAnchorPositionAtPoint({
+    popoverRef: popoverRef,
+    placement: topLayerPlacement,
+    isEnabled: isVirtualEnabled,
+    isOpen: isOpen,
+    getPoint: function getPoint() {
+      var current = virtualReferenceRef.current;
+      if (!current) {
+        return null;
+      }
+      return rectPointForPlacement({
+        rect: current.getBoundingClientRect(),
+        placement: topLayerPlacementRef.current,
+        isRtl: isPageRtl()
+      });
+    }
+  });
+  var _useReferenceVisibili = useReferenceVisibility({
+      anchor: resolvedAnchor,
+      popoverRef: popoverRef
+    }),
+    isReferenceHidden = _useReferenceVisibili.isReferenceHidden,
+    hasPopperEscaped = _useReferenceVisibili.hasPopperEscaped;
+
+  // Restore legacy `react-popper`'s natural-width behaviour. Under CSS
+  // Anchor Positioning the `position-area` grid cell becomes the popover
+  // host's containing block, so an auto-width host shrinks to that cell.
+  // When the anchor sits near a viewport edge the cell is narrow, so the
+  // content wraps far more than it did under `react-popper` (which kept the
+  // content's natural width and shifted/flipped to stay on screen).
+  // `min-inline-size: max-content` (mode `'none'`) floors the host at its
+  // content's intrinsic width, so a too-narrow span overflows the viewport
+  // (driving `position-try-fallbacks`) instead of wrapping. This is safe
+  // alongside `shouldFitViewport`: the fit caps clamp the host on both axes,
+  // so the host never exceeds the viewport / anchor-edge cap.
+  useWidthFromAnchor({
+    mode: 'none',
+    popoverRef: popoverRef,
+    anchorRef: htmlAnchorRef,
+    isOpen: isOpen
+  });
+
+  // `shouldFitViewport` caps are applied directly to the `position-area`
+  // host, whose containing block is the cell between the anchor edge and the
+  // viewport edge — so a pure-CSS `calc(100% - 5px - gap)` reproduces the
+  // legacy per-placement anchor-edge cap with no measurement. The gap mirrors
+  // `getPlacement`: an omitted offset resolves to `space.100`, otherwise the
+  // consumer's `away` value.
+  var resolvedOffset = popperToTopLayerOffset(offset);
+  var fitGap = resolvedOffset ? "".concat(resolvedOffset[1], "px") : "var(--ds-space-100, 8px)";
+  var placementAxis = getPlacementAxis(placement);
+  useFitViewportMaxSize({
+    target: popoverRef,
+    placementAxis: placementAxis,
+    gap: fitGap,
+    isEnabled: shouldFitViewport,
+    isOpen: isOpen
+  });
+  var renderChildren = children;
+  if (typeof renderChildren !== 'function') {
+    return null;
+  }
+  var renderPropArg = {
+    ref: noopSetRef,
+    style: noopStyle,
+    placement: placement,
+    isReferenceHidden: isReferenceHidden,
+    hasPopperEscaped: hasPopperEscaped,
+    update: noopUpdate,
+    forceUpdate: noopForceUpdate,
+    arrowProps: noopArrowProps
+  };
+  var content = renderChildren(renderPropArg);
+
+  // The `shouldFitViewport` size caps live on the `<Popover>` host itself
+  // (applied by `useFitViewportMaxSize` above), so the consumer's content is
+  // rendered directly with no intermediate wrapper.
+  return /*#__PURE__*/React.createElement(Popover, {
+    ref: popoverRef,
+    id: popoverId,
+    isOpen: isOpen,
+    mode: "manual",
+    animate: false
+  }, content);
+}

package/dist/esm/popper.js

@@ -2,7 +2,9 @@ import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 import React, { useMemo } from 'react';
 import { Popper as ReactPopper } from 'react-popper';
+import { fg } from '@atlaskit/platform-feature-flags';
 import { getMaxSizeModifiers } from './max-size';
+import { PopperTopLayer } from './popper-top-layer';
 export { placements } from '@popperjs/core';
 // Export types from PopperJS / React Popper
 
@@ -21,19 +23,53 @@ function defaultChildrenFn() {
 }
 var defaultOffset = [0, 8];
 export function Popper(_ref) {
-  var _ref$children = _ref.children,
-    children = _ref$children === void 0 ? defaultChildrenFn : _ref$children,
-    _ref$offset = _ref.offset,
-    offset = _ref$offset === void 0 ? defaultOffset : _ref$offset,
-    _ref$placement = _ref.placement,
-    placement = _ref$placement === void 0 ? 'bottom-start' : _ref$placement,
-    _ref$referenceElement = _ref.referenceElement,
-    referenceElement = _ref$referenceElement === void 0 ? undefined : _ref$referenceElement,
+  var children = _ref.children,
+    offset = _ref.offset,
+    placement = _ref.placement,
+    referenceElement = _ref.referenceElement,
     modifiers = _ref.modifiers,
-    _ref$strategy = _ref.strategy,
-    strategy = _ref$strategy === void 0 ? 'fixed' : _ref$strategy,
-    _ref$shouldFitViewpor = _ref.shouldFitViewport,
-    shouldFitViewport = _ref$shouldFitViewpor === void 0 ? false : _ref$shouldFitViewpor;
+    strategy = _ref.strategy,
+    shouldFitViewport = _ref.shouldFitViewport;
+  // The FF check sits at the very top of the public Popper so the
+  // rest of the function (which has its own hooks) does not violate
+  // the rules of hooks. Each branch is its own component with its
+  // own complete hook order. Props are forwarded explicitly to
+  // satisfy `no-unsafe-spread-props`.
+  if (fg('platform-dst-top-layer')) {
+    return /*#__PURE__*/React.createElement(PopperTopLayer, {
+      children: children,
+      offset: offset,
+      placement: placement,
+      referenceElement: referenceElement,
+      modifiers: modifiers,
+      strategy: strategy,
+      shouldFitViewport: shouldFitViewport
+    });
+  }
+  return /*#__PURE__*/React.createElement(LegacyPopper, {
+    children: children,
+    offset: offset,
+    placement: placement,
+    referenceElement: referenceElement,
+    modifiers: modifiers,
+    strategy: strategy,
+    shouldFitViewport: shouldFitViewport
+  });
+}
+function LegacyPopper(_ref2) {
+  var _ref2$children = _ref2.children,
+    children = _ref2$children === void 0 ? defaultChildrenFn : _ref2$children,
+    _ref2$offset = _ref2.offset,
+    offset = _ref2$offset === void 0 ? defaultOffset : _ref2$offset,
+    _ref2$placement = _ref2.placement,
+    placement = _ref2$placement === void 0 ? 'bottom-start' : _ref2$placement,
+    _ref2$referenceElemen = _ref2.referenceElement,
+    referenceElement = _ref2$referenceElemen === void 0 ? undefined : _ref2$referenceElemen,
+    modifiers = _ref2.modifiers,
+    _ref2$strategy = _ref2.strategy,
+    strategy = _ref2$strategy === void 0 ? 'fixed' : _ref2$strategy,
+    _ref2$shouldFitViewpo = _ref2.shouldFitViewport,
+    shouldFitViewport = _ref2$shouldFitViewpo === void 0 ? false : _ref2$shouldFitViewpo;
   var _offset = _slicedToArray(offset, 2),
     offsetX = _offset[0],
     offsetY = _offset[1];

package/dist/esm/reference.js

@@ -0,0 +1,36 @@
+import React, { useMemo } from 'react';
+import { Reference as ReactPopperReference } from 'react-popper';
+import mergeRefs from '@atlaskit/ds-lib/merge-refs';
+import { useManagerAnchorSetter } from './internal/use-manager-anchor-setter';
+
+// `react-popper`'s `Reference` exposes a loosely-typed callback ref so
+// consumers can attach it to any host element. We mirror that shape
+// instead of locking the children ref to `HTMLElement`, which would
+// break legacy consumers that pass it to `<button>` / `<div>` directly.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- mirroring react-popper's public ref shape
+
+/**
+ * Wraps `react-popper`'s `<Reference>` so the anchor element it captures
+ * is also published through `@atlaskit/popper`'s own bridge context.
+ * The bridge lets the FF-on top-layer adapter discover the anchor even
+ * when `react-popper`'s CJS and ESM builds resolve to different context
+ * instances (Jest vs production bundlers).
+ *
+ * The bridge + consumer refs are composed into a single stable callback and
+ * passed to `react-popper` as `innerRef`, so the (stable) ref `react-popper`
+ * hands to `children` never changes identity. Composing inline instead would
+ * produce a new ref callback every render, making React detach/reattach the
+ * anchor each commit — firing `publishAnchor(null)` then `publishAnchor(el)`
+ * and churning the `Manager`.
+ */
+export function Reference(_ref) {
+  var children = _ref.children,
+    innerRef = _ref.innerRef;
+  var publishAnchor = useManagerAnchorSetter();
+  var composedRef = useMemo(function () {
+    return mergeRefs([publishAnchor, innerRef]);
+  }, [publishAnchor, innerRef]);
+  return /*#__PURE__*/React.createElement(ReactPopperReference, {
+    innerRef: composedRef
+  }, children);
+}

package/dist/types/index.d.ts

@@ -1,3 +1,4 @@
 export { Popper, placements } from './popper';
 export type { ManagerProps, ReferenceProps, PopperProps, PopperArrowProps, PopperChildrenProps, StrictModifier, Modifier, Placement, CustomPopperProps, } from './popper';
-export { Manager, Reference } from 'react-popper';
+export { Manager } from './manager';
+export { Reference } from './reference';

package/dist/types/internal/anchor-context.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+/**
+ * Module-private context used to bridge the anchor element from our
+ * `<Reference>` wrapper to `<Popper>`. Deliberately separate from
+ * `react-popper`'s own `ManagerReferenceNodeContext`: `react-popper`
+ * ships dual CJS and ESM builds, each with its own
+ * `React.createContext()` instance, and bundlers and Jest can resolve
+ * different builds. Bridging through a context we control guarantees a
+ * single shared instance across every consumer of `@atlaskit/popper`.
+ */
+export declare const AnchorContext: React.Context<HTMLElement | null>;

package/dist/types/internal/anchor-setter-context.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+type TSetAnchor = (element: HTMLElement | null) => void;
+/**
+ * Module-private context that exposes the anchor setter to descendant
+ * `<Reference>` instances inside the same `<Manager>` subtree. The
+ * setter forwards the captured element into `AnchorContext` so
+ * descendant `<Popper>` instances can discover the anchor without
+ * reaching into `react-popper`'s internal context.
+ */
+export declare const AnchorSetterContext: React.Context<TSetAnchor>;
+export type { TSetAnchor };

package/dist/types/internal/read-viewport.d.ts

@@ -0,0 +1,12 @@
+type TViewport = {
+    width: number;
+    height: number;
+};
+/**
+ * Returns the current viewport size in CSS pixels, preferring the visual
+ * viewport (which accounts for pinch-zoom on touch devices) over the
+ * layout viewport. Returns `{ width: 0, height: 0 }` in non-DOM
+ * environments so callers can use the result unconditionally.
+ */
+export declare function readViewport(): TViewport;
+export type { TViewport };

package/dist/types/internal/rect-point-for-placement.d.ts

@@ -0,0 +1,19 @@
+import type { TPlacementOptions } from '@atlaskit/top-layer/placement-map';
+import type { TAnchorPoint } from '@atlaskit/top-layer/use-anchor-position-at-point';
+/**
+ * Reduces an anchor rect to the single viewport point that, wrapped in a
+ * zero-size synthetic anchor, produces the same popover position
+ * `useAnchorPosition` would for the given placement. This works because
+ * `useAnchorPosition` only reads the edge / alignment corner of the rect,
+ * so a coincident zero-size point is geometrically equivalent.
+ *
+ * RTL is resolved here so the downstream synthetic anchor only sees physical
+ * coordinates. Defaults mirror `getPlacement` in
+ * `@atlaskit/top-layer/placement-map` (`axis: 'block'`, `edge: 'end'`,
+ * `align: 'center'`).
+ */
+export declare function rectPointForPlacement({ rect, placement, isRtl, }: {
+    rect: DOMRect;
+    placement: TPlacementOptions;
+    isRtl: boolean;
+}): TAnchorPoint;

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

@@ -0,0 +1,14 @@
+/**
+ * Sets inline styles on an element and returns a cleanup function that
+ * restores the prior inline values (so we do not stomp consumer styles).
+ *
+ * Copied from `@atlaskit/top-layer`'s internal `setStyle` (not exported there
+ * yet); inline here until top-layer exposes it via a subpath export.
+ */
+export declare function setStyle({ element, styles, }: {
+    element: HTMLElement;
+    styles: Array<{
+        property: string;
+        value: string;
+    }>;
+}): () => void;

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

@@ -0,0 +1,10 @@
+type TAnchorState = {
+    anchor: HTMLElement | null;
+    setAnchor: (element: HTMLElement | null) => void;
+};
+/**
+ * Returns the local state used by `<Manager>` to publish the anchor
+ * captured by `<Reference>` to descendant `<Popper>` instances.
+ */
+export declare function useAnchorState(): TAnchorState;
+export {};

package/dist/types/internal/use-fit-viewport-max-size.d.ts

@@ -0,0 +1,53 @@
+import { type RefObject } from 'react';
+/**
+ * Applies the `shouldFitViewport` size caps directly to the
+ * `position-area`-anchored popover host. Pure CSS — the browser owns every
+ * value, so there is no measurement, no scroll/resize listeners, and no
+ * `--ds-popper-anchor-*` custom properties.
+ *
+ * **Primary (placement) axis** is capped to `calc(100% - 5px - gap)`. Because
+ * the host carries `position-area`, its containing block *is* the position-area
+ * cell — the region between the anchor edge and the viewport edge — so `100%`
+ * resolves to that distance. The popover is pushed `gap` into the cell by its
+ * offset margin (`margin-*`, set by `useAnchorPosition`), so the gap is
+ * subtracted as well to keep the legacy `viewportPadding = 5` on the far edge.
+ * The cap is also more correct than measuring the requested placement: the cell
+ * follows whichever side `position-try-fallbacks` actually flips to, so it
+ * tracks the flip automatically.
+ *
+ * **Cross axis** is capped to `calc(100dvw|dvh - 10px)` (viewport, legacy
+ * `2 * viewportPadding`). `display: flex` (plus a `min-*-size: 0` reset on the
+ * child) lets an oversized child shrink and reflow to the cap. The host stays
+ * `overflow: visible` so it never clips the consumer surface's `box-shadow`;
+ * scrolling content that cannot reflow is the consumer surface's own
+ * responsibility (it owns `overflow`), matching legacy `react-popper`, which
+ * applied the cap to the consumer's own element.
+ *
+ * `min-inline-size` is reset to `0`. `useWidthFromAnchor({ mode: 'none' })`
+ * floors the host at `max-content` so a too-narrow span overflows and drives
+ * `position-try-fallbacks` rather than wrapping. That floor is the opposite of
+ * fitting: when it exceeds a cap, CSS min/max resolution lets the min win and
+ * the host overflows the viewport. In fit mode the caps must win, so the floor
+ * is neutralised here; `setStyle` restores the prior inline value on cleanup.
+ *
+ * Verified in Chromium: `max-block-size: calc(100% - …)` on a `position: fixed`
+ * + `position-area` element resolves `100%` to the cell, not the viewport.
+ */
+type TPlacementAxis = 'top' | 'bottom' | 'left' | 'right';
+/**
+ * @param target        the `position-area`-anchored popover host
+ * @param placementAxis the primary axis derived from the popper placement
+ * @param gap           the offset distance the popover is pushed from the
+ *                      anchor (CSS length), subtracted from the primary cap
+ * @param isEnabled     mirrors the consumer's `shouldFitViewport` prop
+ * @param isOpen        re-applies the caps after the host unmounts/remounts
+ *                      across open cycles (the host is torn down on exit)
+ */
+export declare function useFitViewportMaxSize({ target, placementAxis, gap, isEnabled, isOpen, }: {
+    target: RefObject<HTMLElement | null>;
+    placementAxis: TPlacementAxis;
+    gap: string;
+    isEnabled: boolean;
+    isOpen: boolean;
+}): void;
+export {};

package/dist/types/internal/use-manager-anchor-setter.d.ts

@@ -0,0 +1,7 @@
+import { type TSetAnchor } from './anchor-setter-context';
+/**
+ * Returns the setter that an ancestor `<Manager>` exposes to publish
+ * the anchor element from `<Reference>`. Returns a no-op when there is
+ * no surrounding `<Manager>`.
+ */
+export declare function useManagerAnchorSetter(): TSetAnchor;

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

@@ -0,0 +1,6 @@
+/**
+ * Returns the current anchor element published by an ancestor
+ * `<Reference>` via the shared `<Manager>` provider. Returns `null`
+ * when there is no surrounding `<Manager>` / `<Reference>` pair.
+ */
+export declare function useManagerAnchor(): HTMLElement | null;

package/dist/types/internal/use-reference-visibility.d.ts

@@ -0,0 +1,32 @@
+import { type RefObject } from 'react';
+type TUseReferenceVisibilityArgs = {
+    anchor: HTMLElement | null;
+    popoverRef: RefObject<HTMLElement | null>;
+};
+type TVisibility = {
+    isReferenceHidden: boolean;
+    hasPopperEscaped: boolean;
+};
+/**
+ * Exists **only** to preserve API parity with the legacy popper.js
+ * implementation. The top-layer popper does not natively expose
+ * popper.js's `isReferenceHidden` / `hasPopperEscaped` render-prop
+ * modifiers, but existing consumers still branch on those values, so
+ * this hook reconstructs them from live DOM measurement.
+ *
+ * Do not reach for this hook in new code. If you find yourself wanting
+ * these signals for a new feature, prefer a first-class top-layer or
+ * anchor-positioning primitive instead.
+ *
+ * - `isReferenceHidden`: the anchor's bounding rect is fully outside the
+ *   visual viewport OR is clipped to zero area by any scrollable
+ *   ancestor.
+ * - `hasPopperEscaped`: the popover surface's rect is fully outside the
+ *   visual viewport.
+ *
+ * Measurement runs in a `useLayoutEffect` so the first paint already
+ * reflects the correct values, preventing consumers from animating
+ * from `opacity: 1` to `opacity: 0` on mount.
+ */
+export declare function useReferenceVisibility({ anchor, popoverRef, }: TUseReferenceVisibilityArgs): TVisibility;
+export {};

package/dist/types/manager.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import { type ManagerProps } from 'react-popper';
+type TManagerProps = ManagerProps;
+/**
+ * Wraps `react-popper`'s `<Manager>` so the anchor that `<Reference>`
+ * captures is published through `@atlaskit/popper`'s own bridge context.
+ * Doing so insulates `<Popper>` consumers from `react-popper`'s dual
+ * CJS / ESM builds, which otherwise create two unrelated context
+ * instances that prevent the FF-on top-layer adapter from discovering
+ * the anchor.
+ */
+export declare function Manager({ children }: TManagerProps): React.JSX.Element;
+export {};

package/dist/types/popper-top-layer.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @jsxRuntime classic
+ * @jsx jsx
+ */
+import React from 'react';
+import type { CustomPopperProps } from './popper';
+/**
+ * FF-on implementation of `@atlaskit/popper`'s `<Popper>` primitive.
+ *
+ * Renders the consumer's render-prop output into a `<Popover>` from
+ * `@atlaskit/top-layer`, which lifts the element into the browser top
+ * layer and positions it via CSS Anchor Positioning. The render-prop
+ * contract (`PopperChildrenProps`) is preserved at the type level;
+ * `style` and `arrowProps.style` are inert at runtime because the
+ * browser owns positioning.
+ *
+ * Gated behind the `platform-dst-top-layer` feature flag from
+ * `popper.tsx`.
+ */
+export declare function PopperTopLayer<CustomModifiers>({ children, offset, placement, referenceElement, shouldFitViewport, }: CustomPopperProps<CustomModifiers>): React.JSX.Element | null;

package/dist/types/reference.d.ts

@@ -0,0 +1,25 @@
+import React, { type ReactNode, type Ref } from 'react';
+type TReferenceRef = Ref<any>;
+type TChildrenArgs = {
+    ref: TReferenceRef;
+};
+type TReferenceProps = {
+    children: (args: TChildrenArgs) => ReactNode;
+    innerRef?: TReferenceRef;
+};
+/**
+ * Wraps `react-popper`'s `<Reference>` so the anchor element it captures
+ * is also published through `@atlaskit/popper`'s own bridge context.
+ * The bridge lets the FF-on top-layer adapter discover the anchor even
+ * when `react-popper`'s CJS and ESM builds resolve to different context
+ * instances (Jest vs production bundlers).
+ *
+ * The bridge + consumer refs are composed into a single stable callback and
+ * passed to `react-popper` as `innerRef`, so the (stable) ref `react-popper`
+ * hands to `children` never changes identity. Composing inline instead would
+ * produce a new ref callback every render, making React detach/reattach the
+ * anchor each commit — firing `publishAnchor(null)` then `publishAnchor(el)`
+ * and churning the `Manager`.
+ */
+export declare function Reference({ children, innerRef }: TReferenceProps): React.JSX.Element;
+export {};