@atlaskit/popper 8.0.1 → 8.2.0

package/dist/cjs/manager.js

@@ -0,0 +1,37 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Manager = Manager;
+var _react = _interopRequireDefault(require("react"));
+var _reactPopper = require("react-popper");
+var _anchorContext = require("./internal/anchor-context");
+var _anchorSetterContext = require("./internal/anchor-setter-context");
+var _useAnchorState2 = require("./internal/use-anchor-state");
+// Derive the wrapper's props from `react-popper`'s own `ManagerProps` so the
+// public surface provably accepts exactly what the underlying `<Manager>`
+// accepts (today just `children`) and stays in sync if that contract changes.
+
+/**
+ * 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.
+ */
+function Manager(_ref) {
+  var children = _ref.children;
+  // `setAnchor` is the `useState` setter, which React guarantees is stable
+  // across renders, so it can be passed straight to the context provider.
+  var _useAnchorState = (0, _useAnchorState2.useAnchorState)(),
+    anchor = _useAnchorState.anchor,
+    setAnchor = _useAnchorState.setAnchor;
+  return /*#__PURE__*/_react.default.createElement(_reactPopper.Manager, null, /*#__PURE__*/_react.default.createElement(_anchorSetterContext.AnchorSetterContext.Provider, {
+    value: setAnchor
+  }, /*#__PURE__*/_react.default.createElement(_anchorContext.AnchorContext.Provider, {
+    value: anchor
+  }, children)));
+}

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

@@ -0,0 +1,286 @@
+/* popper-top-layer.tsx generated by @compiled/babel-plugin v0.39.1 */
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PopperTopLayer = PopperTopLayer;
+var _runtime = require("@compiled/react/runtime");
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _react = _interopRequireWildcard(require("react"));
+var _browserApis = require("@atlaskit/browser-apis");
+var _noop = _interopRequireDefault(require("@atlaskit/ds-lib/noop"));
+var _placementMap = require("@atlaskit/top-layer/placement-map");
+var _popover = require("@atlaskit/top-layer/popover");
+var _useAnchorPosition = require("@atlaskit/top-layer/use-anchor-position");
+var _useAnchorPositionAtPoint = require("@atlaskit/top-layer/use-anchor-position-at-point");
+var _usePopoverId = require("@atlaskit/top-layer/use-popover-id");
+var _useWidthFromAnchor = require("@atlaskit/top-layer/use-width-from-anchor");
+var _rectPointForPlacement = require("./internal/rect-point-for-placement");
+var _useFitViewportMaxSize = require("./internal/use-fit-viewport-max-size");
+var _useManagerAnchor = require("./internal/use-manager-anchor");
+var _useReferenceVisibility = require("./internal/use-reference-visibility");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+/**
+ * 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.default;
+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 = (0, _browserApis.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 = (0, _slicedToArray2.default)(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`.
+ */
+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 = (0, _useManagerAnchor.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 = (0, _react.useRef)(htmlAnchor);
+  htmlAnchorRef.current = htmlAnchor;
+  var popoverRef = (0, _react.useRef)(null);
+  var popoverId = (0, _usePopoverId.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 = (0, _react.useState)(htmlAnchor),
+    _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+    resolvedAnchor = _useState2[0],
+    setResolvedAnchor = _useState2[1];
+  if (resolvedAnchor !== htmlAnchor) {
+    setResolvedAnchor(htmlAnchor);
+  }
+  var topLayerPlacement = (0, _react.useMemo)(function () {
+    return (0, _placementMap.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.
+  (0, _useAnchorPosition.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 = (0, _react.useRef)(virtualReference);
+  virtualReferenceRef.current = virtualReference;
+  var topLayerPlacementRef = (0, _react.useRef)(topLayerPlacement);
+  topLayerPlacementRef.current = topLayerPlacement;
+  var isVirtualEnabled = virtualReference != null;
+  (0, _useAnchorPositionAtPoint.useAnchorPositionAtPoint)({
+    popoverRef: popoverRef,
+    placement: topLayerPlacement,
+    isEnabled: isVirtualEnabled,
+    isOpen: isOpen,
+    getPoint: function getPoint() {
+      var current = virtualReferenceRef.current;
+      if (!current) {
+        return null;
+      }
+      return (0, _rectPointForPlacement.rectPointForPlacement)({
+        rect: current.getBoundingClientRect(),
+        placement: topLayerPlacementRef.current,
+        isRtl: isPageRtl()
+      });
+    }
+  });
+  var _useReferenceVisibili = (0, _useReferenceVisibility.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.
+  (0, _useWidthFromAnchor.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);
+  (0, _useFitViewportMaxSize.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.default.createElement(_popover.Popover, {
+    ref: popoverRef,
+    id: popoverId,
+    isOpen: isOpen,
+    mode: "manual",
+    animate: false
+  }, content);
+}

package/dist/cjs/popper.js

@@ -16,7 +16,9 @@ var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers
 var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
 var _react = _interopRequireWildcard(require("react"));
 var _reactPopper = require("react-popper");
+var _platformFeatureFlags = require("@atlaskit/platform-feature-flags");
 var _maxSize = require("./max-size");
+var _popperTopLayer = require("./popper-top-layer");
 var _core = require("@popperjs/core");
 function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
 // Export types from PopperJS / React Popper
@@ -36,19 +38,53 @@ function defaultChildrenFn() {
 }
 var defaultOffset = [0, 8];
 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 ((0, _platformFeatureFlags.fg)('platform-dst-top-layer')) {
+    return /*#__PURE__*/_react.default.createElement(_popperTopLayer.PopperTopLayer, {
+      children: children,
+      offset: offset,
+      placement: placement,
+      referenceElement: referenceElement,
+      modifiers: modifiers,
+      strategy: strategy,
+      shouldFitViewport: shouldFitViewport
+    });
+  }
+  return /*#__PURE__*/_react.default.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 = (0, _slicedToArray2.default)(offset, 2),
     offsetX = _offset[0],
     offsetY = _offset[1];

package/dist/cjs/reference.js

@@ -0,0 +1,44 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Reference = Reference;
+var _react = _interopRequireWildcard(require("react"));
+var _reactPopper = require("react-popper");
+var _mergeRefs = _interopRequireDefault(require("@atlaskit/ds-lib/merge-refs"));
+var _useManagerAnchorSetter = require("./internal/use-manager-anchor-setter");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+// `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`.
+ */
+function Reference(_ref) {
+  var children = _ref.children,
+    innerRef = _ref.innerRef;
+  var publishAnchor = (0, _useManagerAnchorSetter.useManagerAnchorSetter)();
+  var composedRef = (0, _react.useMemo)(function () {
+    return (0, _mergeRefs.default)([publishAnchor, innerRef]);
+  }, [publishAnchor, innerRef]);
+  return /*#__PURE__*/_react.default.createElement(_reactPopper.Reference, {
+    innerRef: composedRef
+  }, children);
+}

package/dist/es2019/index.js

@@ -1,2 +1,7 @@
 export { Popper, placements } from './popper';
-export { Manager, Reference } from 'react-popper';
+// `Manager` and `Reference` are re-exported through our own wrappers so
+// the anchor element captured by `<Reference>` reaches `<Popper>` via a
+// single shared context instance, sidestepping the dual CJS/ESM context
+// duplication shipped by `react-popper`.
+export { Manager } from './manager';
+export { Reference } from './reference';

package/dist/es2019/internal/anchor-context.js

@@ -0,0 +1,12 @@
+import { createContext } 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 const AnchorContext = /*#__PURE__*/createContext(null);

package/dist/es2019/internal/anchor-setter-context.js

@@ -0,0 +1,9 @@
+import { createContext } from 'react';
+/**
+ * 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 const AnchorSetterContext = /*#__PURE__*/createContext(() => undefined);

package/dist/es2019/internal/read-viewport.js

@@ -0,0 +1,25 @@
+/**
+ * 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 function readViewport() {
+  if (typeof window === 'undefined') {
+    return {
+      width: 0,
+      height: 0
+    };
+  }
+  const visual = window.visualViewport;
+  if (visual) {
+    return {
+      width: visual.width,
+      height: visual.height
+    };
+  }
+  return {
+    width: window.innerWidth,
+    height: window.innerHeight
+  };
+}

package/dist/es2019/internal/rect-point-for-placement.js

@@ -0,0 +1,91 @@
+/**
+ * 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 function rectPointForPlacement({
+  rect,
+  placement,
+  isRtl
+}) {
+  var _placement$axis, _placement$edge, _placement$align;
+  const axis = (_placement$axis = placement.axis) !== null && _placement$axis !== void 0 ? _placement$axis : 'block';
+  const edge = (_placement$edge = placement.edge) !== null && _placement$edge !== void 0 ? _placement$edge : 'end';
+  const align = (_placement$align = placement.align) !== null && _placement$align !== void 0 ? _placement$align : 'center';
+  if (axis === 'block') {
+    // Popover sits above (`edge: 'start'`) or below (`edge: 'end'`)
+    // the anchor. Hug the matching horizontal edge; align along x.
+    const y = edge === 'start' ? rect.top : rect.bottom;
+    const x = horizontalForAlign({
+      rect,
+      align,
+      isRtl
+    });
+    return {
+      x,
+      y
+    };
+  }
+
+  // `axis: 'inline'`: popover sits inline-start or inline-end of the
+  // anchor. Hug the matching vertical edge; align along y.
+  const x = inlineEdgeX({
+    rect,
+    edge,
+    isRtl
+  });
+  const y = verticalForAlign({
+    rect,
+    align
+  });
+  return {
+    x,
+    y
+  };
+}
+function horizontalForAlign({
+  rect,
+  align,
+  isRtl
+}) {
+  if (align === 'center') {
+    return rect.left + rect.width / 2;
+  }
+  // `start` / `end` are logical. In LTR, `start` is the left edge.
+  // In RTL, `start` is the right edge.
+  const isStartLeft = !isRtl;
+  if (align === 'start') {
+    return isStartLeft ? rect.left : rect.right;
+  }
+  return isStartLeft ? rect.right : rect.left;
+}
+function verticalForAlign({
+  rect,
+  align
+}) {
+  if (align === 'center') {
+    return rect.top + rect.height / 2;
+  }
+  if (align === 'start') {
+    return rect.top;
+  }
+  return rect.bottom;
+}
+function inlineEdgeX({
+  rect,
+  edge,
+  isRtl
+}) {
+  const isStartLeft = !isRtl;
+  if (edge === 'start') {
+    return isStartLeft ? rect.left : rect.right;
+  }
+  return isStartLeft ? rect.right : rect.left;
+}

package/dist/es2019/internal/set-style.js

@@ -0,0 +1,39 @@
+/**
+ * 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 function setStyle({
+  element,
+  styles
+}) {
+  // Snapshot the prior inline value (NOT the computed style - we only want
+  // to restore values that the consumer/our previous run inlined). An empty
+  // string means "no inline value", in which case cleanup uses removeProperty.
+  const priorValues = styles.map(({
+    property
+  }) => ({
+    property,
+    value: element.style.getPropertyValue(property)
+  }));
+  styles.forEach(({
+    property,
+    value
+  }) => {
+    element.style.setProperty(property, value);
+  });
+  return function cleanup() {
+    priorValues.forEach(({
+      property,
+      value
+    }) => {
+      if (value === '') {
+        element.style.removeProperty(property);
+        return;
+      }
+      element.style.setProperty(property, value);
+    });
+  };
+}

package/dist/es2019/internal/use-anchor-state.js

@@ -0,0 +1,12 @@
+import { useState } from 'react';
+/**
+ * Returns the local state used by `<Manager>` to publish the anchor
+ * captured by `<Reference>` to descendant `<Popper>` instances.
+ */
+export function useAnchorState() {
+  const [anchor, setAnchor] = useState(null);
+  return {
+    anchor,
+    setAnchor
+  };
+}