@atlaskit/top-layer 0.1.0

package/dist/esm/dialog/dialog-content.compiled.css

@@ -0,0 +1,14 @@
+
+._19itglyw{border:none}._18u01wug{margin-left:auto}
+._19pk1wug{margin-top:auto}
+._1ltk1i5c::-ms-backdrop{background-color:var(--ds-blanket,#050c1f75)}
+._1ltk1i5c::backdrop{background-color:var(--ds-blanket,#050c1f75)}
+._1q51ze3t{padding-block-start:var(--ds-space-0,0)}
+._2hwx1wug{margin-right:auto}
+._85i5ze3t{padding-block-end:var(--ds-space-0,0)}
+._bfhk1j28{background-color:transparent}
+._bozgze3t{padding-inline-start:var(--ds-space-0,0)}
+._c71lglyw{max-height:none}
+._otyr1wug{margin-bottom:auto}
+._p12fglyw{max-width:none}
+._y4tize3t{padding-inline-end:var(--ds-space-0,0)}

package/dist/esm/dialog/dialog-content.js

@@ -0,0 +1,135 @@
+/* dialog-content.tsx generated by @compiled/babel-plugin v0.39.1 */
+import _extends from "@babel/runtime/helpers/extends";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import "./dialog-content.compiled.css";
+import { ax, ix } from "@compiled/react/runtime";
+import React, { forwardRef, useCallback, useEffect, useId, useLayoutEffect, useRef } from 'react';
+import { bind } from 'bind-event-listener';
+import mergeRefs from '@atlaskit/ds-lib/merge-refs';
+import { useAnimatedVisibility } from '../internal/use-animated-visibility';
+import { useFocusWrap } from '../internal/use-focus-wrap';
+// eslint-disable-next-line @atlaskit/ui-styling-standard/no-unsafe-values -- dialog reset requires values not in cssMap's type union
+var styles = {
+  dialog: "_19itglyw _19pk1wug _2hwx1wug _otyr1wug _18u01wug _1q51ze3t _y4tize3t _85i5ze3t _bozgze3t _p12fglyw _c71lglyw _bfhk1j28 _1ltk1i5c"
+};
+
+/**
+ * Low-level `<dialog>` primitive. No visual opinions — no width, height,
+ * background, border-radius, or layout. Consumers provide their own styling.
+ *
+ * Visibility is controlled declaratively via `isOpen`:
+ * - `isOpen={true}` calls `.showModal()` (entry animation via `@starting-style`)
+ * - `isOpen={false}` calls `.close()` (exit animation via `allow-discrete`)
+ *
+ * Handles native `cancel` event (Escape) and backdrop click detection.
+ *
+ * Close flow: we never call `dialog.close()` from event handlers. We always call
+ * `onClose`; the consumer decides whether to set `isOpen={false}`.
+ */
+export var Dialog = /*#__PURE__*/forwardRef(function Dialog(_ref, ref) {
+  var children = _ref.children,
+    isOpen = _ref.isOpen,
+    onClose = _ref.onClose,
+    onExitFinish = _ref.onExitFinish,
+    animate = _ref.animate,
+    style = _ref.style,
+    testId = _ref.testId,
+    providedId = _ref.id,
+    label = _ref.label,
+    labelledBy = _ref.labelledBy,
+    shouldHideBackdrop = _ref.shouldHideBackdrop;
+  var generatedId = useId();
+  var dialogId = providedId !== null && providedId !== void 0 ? providedId : generatedId;
+  var ownRef = useRef(null);
+  var combinedRef = mergeRefs([ownRef, ref]);
+
+  // ── Animation lifecycle ──
+  var _useAnimatedVisibilit = useAnimatedVisibility({
+      isOpen: isOpen,
+      animate: animate,
+      elementRef: ownRef,
+      onExitFinish: onExitFinish
+    }),
+    showChildren = _useAnimatedVisibilit.showChildren,
+    preset = _useAnimatedVisibilit.preset;
+
+  // ── Focus wrap ──
+  // Native <dialog>.showModal() traps focus but wraps through <body> at
+  // the boundary (A → B → C → body → A). This hook intercepts Tab to
+  // wrap directly (A → B → C → A), matching the WAI-ARIA APG pattern.
+  useFocusWrap({
+    elementRef: ownRef,
+    role: 'dialog'
+  });
+
+  // Show/hide the dialog in response to isOpen changes.
+  useLayoutEffect(function () {
+    var dialog = ownRef.current;
+    if (!dialog) {
+      return;
+    }
+    if (isOpen) {
+      if (!dialog.open) {
+        dialog.showModal();
+      }
+      return function () {
+        if (dialog.open) {
+          dialog.close();
+        }
+      };
+    }
+    if (dialog.open) {
+      dialog.close();
+    }
+  }, [isOpen]);
+
+  // ── Handle native Escape (cancel event) ──
+  var handleCancel = useCallback(function (event) {
+    event.preventDefault();
+    onClose({
+      reason: 'escape'
+    });
+  }, [onClose]);
+
+  // ── Handle backdrop click ──
+  // Attached via bind-event-listener rather than a React prop so we avoid
+  // a11y lint suppressions on the <dialog> element.
+  // Keyboard dismiss is already handled natively (Escape → onCancel above).
+  useEffect(function () {
+    var dialog = ownRef.current;
+    if (!dialog) {
+      return;
+    }
+    return bind(dialog, {
+      type: 'click',
+      listener: function listener(event) {
+        if (event.target === event.currentTarget) {
+          onClose({
+            reason: 'overlay-click'
+          });
+        }
+      }
+    });
+  }, [onClose]);
+
+  // Atomic CSS (Compiled) deduplicates ::backdrop { background-color }
+  // into a single class, making it impossible to toggle between two values
+  // via cssMap entries. An ID-scoped <style> has higher specificity than
+  // any atomic class, so the override always wins.
+  var escapedId = CSS.escape(dialogId);
+  return /*#__PURE__*/React.createElement("dialog", _extends({
+    ref: combinedRef,
+    id: dialogId,
+    "aria-label": label,
+    "aria-labelledby": label ? undefined : labelledBy,
+    // eslint-disable-next-line @atlaskit/ui-styling-standard/enforce-style-prop
+    style: style,
+    onCancel: handleCancel,
+    "data-testid": testId
+  }, preset ? _defineProperty({}, "data-ds-".concat(preset.name), '') : undefined, {
+    className: ax([styles.dialog])
+  }), shouldHideBackdrop &&
+  /*#__PURE__*/
+  // eslint-disable-next-line @atlaskit/ui-styling-standard/no-global-styles
+  React.createElement("style", null, "#".concat(escapedId, "::backdrop{background-color:transparent}")), showChildren ? children : null);
+});

package/dist/esm/dialog/index.js

@@ -0,0 +1,2 @@
+export { createCloseEvent } from './create-close-event';
+export { Dialog } from './dialog-content';

package/dist/esm/dialog/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/dialog-scroll-lock/index.js

@@ -0,0 +1,41 @@
+import { useLayoutEffect } from 'react';
+import { getDocument } from '@atlaskit/browser-apis';
+
+/**
+ * __DialogScrollLock__
+ *
+ * Prevents background page scrolling while mounted. Designed to be rendered
+ * inside a `Dialog` so that the scroll lock is automatically removed when the
+ * dialog closes (unmounts its children).
+ *
+ * Native `<dialog>.showModal()` makes background content _inert_ (not
+ * focusable/clickable), but does **not** prevent scroll events from reaching
+ * the document body. This component fills that gap by setting
+ * `overflow: hidden` on `document.body`.
+ *
+ * @example
+ * ```tsx
+ * import { Dialog } from '@atlaskit/top-layer/dialog';
+ * import { DialogScrollLock } from '@atlaskit/top-layer/dialog-scroll-lock';
+ *
+ * <Dialog isOpen={isOpen} onClose={onClose}>
+ *   <DialogScrollLock />
+ *   {children}
+ * </Dialog>
+ * ```
+ */
+export function DialogScrollLock() {
+  useLayoutEffect(function () {
+    var _getDocument;
+    var body = (_getDocument = getDocument()) === null || _getDocument === void 0 ? void 0 : _getDocument.body;
+    if (!body) {
+      return;
+    }
+    var previousOverflow = body.style.overflow;
+    body.style.overflow = 'hidden';
+    return function () {
+      body.style.overflow = previousOverflow;
+    };
+  }, []);
+  return null;
+}

package/dist/esm/entry-points/animations.js

@@ -0,0 +1 @@
+export { slideAndFade, fade, scaleAndFade, dialogSlideUpAndFade, dialogFade } from '../animations/presets';

package/dist/esm/entry-points/arrow.js

@@ -0,0 +1 @@
+export { arrow } from '../arrow';

package/dist/esm/entry-points/create-close-event.js

@@ -0,0 +1,2 @@
+export { createCloseEvent } from '../dialog';
+export { createPopoverCloseEvent } from '../popover/create-close-event';

package/dist/esm/entry-points/dialog-scroll-lock.js

@@ -0,0 +1 @@
+export { DialogScrollLock } from '../dialog-scroll-lock';

package/dist/esm/entry-points/dialog.js

@@ -0,0 +1 @@
+export { Dialog } from '../dialog';

package/dist/esm/entry-points/focus.js

@@ -0,0 +1 @@
+export { getFirstFocusable, getLastFocusable, getNextFocusable } from '../focus';

package/dist/esm/entry-points/placement-map.js

@@ -0,0 +1 @@
+export { fromLegacyPlacement, placementMapping } from '../placement-map';

package/dist/esm/entry-points/popover.js

@@ -0,0 +1 @@
+export { Popover } from '../popover';

package/dist/esm/entry-points/popup-surface.js

@@ -0,0 +1 @@
+export { PopupSurface } from '../popup/popup-surface';

package/dist/esm/entry-points/popup.js

@@ -0,0 +1 @@
+export { Popup } from '../popup';

package/dist/esm/entry-points/use-anchor-position.js

@@ -0,0 +1 @@
+export { useAnchorPosition } from '../internal/use-anchor-positioning';

package/dist/esm/entry-points/use-arrow-navigation.js

@@ -0,0 +1 @@
+export { useArrowNavigation, isAtCurrentMenuLevel } from '../use-arrow-navigation';

package/dist/esm/entry-points/use-simple-light-dismiss.js

@@ -0,0 +1 @@
+export { useSimpleLightDismiss } from '../use-simple-light-dismiss';

package/dist/esm/focus/focus.js

@@ -0,0 +1,107 @@
+/**
+ * Focusable element selectors and navigation helpers.
+ *
+ * Uses CSS selectors to discover focusable elements within a container,
+ * avoiding the need for a manual registration system. Disabled elements
+ * (both HTML `disabled` attribute and `aria-disabled="true"`) and elements
+ * with `tabindex="-1"` are excluded automatically.
+ *
+ * All public functions accept an optional `filter` callback to further
+ * restrict which focusable elements are included.
+ */
+
+var selectors = function () {
+  // Common exclusion filter applied to every selector.
+  var not = ':not([tabindex="-1"]):not([aria-disabled="true"]):not([aria-hidden="true"])';
+  var notDisabled = ":not([disabled])".concat(not);
+  var focusable = ["a[href]".concat(not), "area[href]".concat(not), "input".concat(notDisabled, ":not([type=\"hidden\"])"), "select".concat(notDisabled), "textarea".concat(notDisabled), "button".concat(notDisabled), "iframe".concat(not), "audio[controls]".concat(not), "video[controls]".concat(not), "[contenteditable]:not([contenteditable=\"false\"])".concat(not), "[tabindex]".concat(notDisabled).concat(not)];
+  return {
+    focusable: focusable.join(','),
+    focused: focusable.join(':focus,') + ':focus'
+  };
+}();
+
+/**
+ * An optional callback to restrict which focusable elements are included.
+ * Return `true` to include the element, `false` to skip it.
+ */
+
+/**
+ * Returns all focusable HTMLElements within the container, optionally filtered.
+ *
+ * Note: this searches the full subtree and does not stop at nested
+ * popover/dialog boundaries. In practice this is fine because nested
+ * popovers are not rendered until they are opened, so their content
+ * is not in the DOM when the parent's initial focus runs. If that
+ * assumption changes, this would need to be scoped to the current layer.
+ */
+function getFocusables(_ref) {
+  var container = _ref.container,
+    filter = _ref.filter;
+  return Array.from(container.querySelectorAll(selectors.focusable)).filter(function (el) {
+    return el instanceof HTMLElement;
+  }).filter(function (el) {
+    return !filter || filter(el, container);
+  });
+}
+
+/**
+ * Returns the first focusable element within the container.
+ */
+export function getFirstFocusable(_ref2) {
+  var container = _ref2.container,
+    filter = _ref2.filter;
+  var items = getFocusables({
+    container: container,
+    filter: filter
+  });
+  return items.length > 0 ? items[0] : null;
+}
+
+/**
+ * Returns the last focusable element within the container.
+ */
+export function getLastFocusable(_ref3) {
+  var container = _ref3.container,
+    filter = _ref3.filter;
+  var items = getFocusables({
+    container: container,
+    filter: filter
+  });
+  return items.length > 0 ? items[items.length - 1] : null;
+}
+
+/**
+ * Returns the next focusable element in the given direction relative to the
+ * currently focused element within the container. Wraps around at both ends.
+ *
+ * Returns `null` if there is no focused element within the container or if
+ * the focused element is not in the list of focusable elements.
+ */
+export function getNextFocusable(_ref4) {
+  var _all$nextIndex;
+  var container = _ref4.container,
+    direction = _ref4.direction,
+    filter = _ref4.filter;
+  var all = getFocusables({
+    container: container,
+    filter: filter
+  });
+  var current = container.querySelector(selectors.focused);
+  if (!(current instanceof HTMLElement)) {
+    return null;
+  }
+  var index = all.indexOf(current);
+  if (index === -1) {
+    return null;
+  }
+  var nextIndex = function () {
+    if (direction === 'forwards') {
+      return (index + 1) % all.length;
+    }
+    var proposed = index - 1;
+    // if going into negative numbers, loop back to the last item
+    return proposed < 0 ? all.length - 1 : proposed;
+  }();
+  return (_all$nextIndex = all[nextIndex]) !== null && _all$nextIndex !== void 0 ? _all$nextIndex : null;
+}

package/dist/esm/focus/index.js

@@ -0,0 +1 @@
+export { getFirstFocusable, getLastFocusable, getNextFocusable } from './focus';

package/dist/esm/index.js

@@ -0,0 +1,7 @@
+// This file exists for module resolution purposes.
+// Not exporting anything from the root entry point.
+// Please use individual entry points for minimum bundle size:
+//
+//   import { Popup } from '@atlaskit/top-layer/popup';
+//   import { Dialog } from '@atlaskit/top-layer/dialog';
+//   import { Popover } from '@atlaskit/top-layer/popover';

package/dist/esm/internal/anchor-positioning-fallback.js

@@ -0,0 +1,147 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+/**
+ * Computes the base {top, left} position based on the primary edge,
+ * flipping to the opposite side when there is not enough space.
+ */
+function computeEdgePosition(_ref) {
+  var axis = _ref.axis,
+    edge = _ref.edge,
+    triggerRect = _ref.triggerRect,
+    popoverWidth = _ref.popoverWidth,
+    popoverHeight = _ref.popoverHeight,
+    viewport = _ref.viewport,
+    offset = _ref.offset;
+  if (axis === 'block' && edge === 'end') {
+    // Below trigger
+    var spaceBelow = viewport.height - triggerRect.bottom;
+    var spaceAbove = triggerRect.top;
+    return {
+      top: spaceBelow >= popoverHeight + offset || spaceBelow >= spaceAbove ? triggerRect.bottom + offset : triggerRect.top - popoverHeight - offset,
+      left: triggerRect.left + triggerRect.width / 2 - popoverWidth / 2
+    };
+  }
+  if (axis === 'block' && edge === 'start') {
+    // Above trigger
+    var _spaceAbove = triggerRect.top;
+    var _spaceBelow = viewport.height - triggerRect.bottom;
+    return {
+      top: _spaceAbove >= popoverHeight + offset || _spaceAbove >= _spaceBelow ? triggerRect.top - popoverHeight - offset : triggerRect.bottom + offset,
+      left: triggerRect.left + triggerRect.width / 2 - popoverWidth / 2
+    };
+  }
+  if (axis === 'inline' && edge === 'end') {
+    // Right of trigger
+    var spaceRight = viewport.width - triggerRect.right;
+    var spaceLeft = triggerRect.left;
+    return {
+      top: triggerRect.top + triggerRect.height / 2 - popoverHeight / 2,
+      left: spaceRight >= popoverWidth + offset || spaceRight >= spaceLeft ? triggerRect.right + offset : triggerRect.left - popoverWidth - offset
+    };
+  }
+  if (axis === 'inline' && edge === 'start') {
+    // Left of trigger
+    var _spaceLeft = triggerRect.left;
+    var _spaceRight = viewport.width - triggerRect.right;
+    return {
+      top: triggerRect.top + triggerRect.height / 2 - popoverHeight / 2,
+      left: _spaceLeft >= popoverWidth + offset || _spaceLeft >= _spaceRight ? triggerRect.left - popoverWidth - offset : triggerRect.right + offset
+    };
+  }
+
+  // Unreachable for valid placements; defaults to below trigger
+  return {
+    top: triggerRect.bottom + offset,
+    left: triggerRect.left + triggerRect.width / 2 - popoverWidth / 2
+  };
+}
+
+/**
+ * Adjusts the base (centered) position for non-center alignments.
+ *
+ * `align: 'start'` → popover start edge at trigger start edge
+ * `align: 'end'`   → popover end edge at trigger end edge
+ */
+function applyAlignment(_ref2) {
+  var position = _ref2.position,
+    axis = _ref2.axis,
+    align = _ref2.align,
+    triggerRect = _ref2.triggerRect,
+    popoverWidth = _ref2.popoverWidth,
+    popoverHeight = _ref2.popoverHeight;
+  if (align === 'center') {
+    return position;
+  }
+  if (axis === 'block') {
+    // Block-axis placement → cross-axis is inline (left/right)
+    if (align === 'start') {
+      return _objectSpread(_objectSpread({}, position), {}, {
+        left: triggerRect.left
+      });
+    }
+    // align === 'end'
+    return _objectSpread(_objectSpread({}, position), {}, {
+      left: triggerRect.right - popoverWidth
+    });
+  }
+
+  // Inline-axis placement → cross-axis is block (top/bottom)
+  if (align === 'start') {
+    return _objectSpread(_objectSpread({}, position), {}, {
+      top: triggerRect.top
+    });
+  }
+  // align === 'end'
+  return _objectSpread(_objectSpread({}, position), {}, {
+    top: triggerRect.bottom - popoverHeight
+  });
+}
+
+/**
+ * JS fallback: compute popover position from trigger rect and viewport.
+ *
+ * Placement algorithm (from the document):
+ * - "block" placement: show above/below, picking the side with more space if flipping needed
+ * - "inline" placement: show left/right, picking the side with more space if flipping needed
+ * - "auto" placement: show on the edge with the most available space
+ *
+ * Re-runs on scroll (capture on window) and resize events.
+ */
+export function computeFallbackPosition(_ref3) {
+  var triggerRect = _ref3.triggerRect,
+    popoverEl = _ref3.popoverEl,
+    placement = _ref3.placement,
+    viewport = _ref3.viewport,
+    offset = _ref3.offset;
+  var axis = placement.axis,
+    edge = placement.edge,
+    align = placement.align;
+
+  // Measure popover dimensions (it might not have layout yet if just shown)
+  var popoverWidth = popoverEl.offsetWidth;
+  var popoverHeight = popoverEl.offsetHeight;
+  var basePosition = computeEdgePosition({
+    axis: axis,
+    edge: edge,
+    triggerRect: triggerRect,
+    popoverWidth: popoverWidth,
+    popoverHeight: popoverHeight,
+    viewport: viewport,
+    offset: offset
+  });
+  var alignedPosition = applyAlignment({
+    position: basePosition,
+    axis: axis,
+    align: align,
+    triggerRect: triggerRect,
+    popoverWidth: popoverWidth,
+    popoverHeight: popoverHeight
+  });
+
+  // Clamp to viewport so the popover is never offscreen
+  return {
+    top: Math.max(0, Math.min(alignedPosition.top, viewport.height - popoverHeight)),
+    left: Math.max(0, Math.min(alignedPosition.left, viewport.width - popoverWidth))
+  };
+}

package/dist/esm/internal/combine.js

@@ -0,0 +1,23 @@
+/**
+ * Combine multiple cleanup functions into a single cleanup function.
+ *
+ * @example
+ * ```ts
+ * useEffect(() => {
+ *   return combine(
+ *     bind(window, { type: 'resize', listener: onResize }),
+ *     bind(window, { type: 'scroll', listener: onScroll, options: { capture: true } }),
+ *   );
+ * }, []);
+ * ```
+ */
+export function combine() {
+  for (var _len = arguments.length, cleanupFns = new Array(_len), _key = 0; _key < _len; _key++) {
+    cleanupFns[_key] = arguments[_key];
+  }
+  return function cleanup() {
+    cleanupFns.forEach(function (fn) {
+      return fn === null || fn === void 0 ? void 0 : fn();
+    });
+  };
+}

package/dist/esm/internal/ensure-preset-styles.js

@@ -0,0 +1,28 @@
+/**
+ * Per-preset CSS injection.
+ *
+ * Each preset's CSS is injected at most once into `<head>`.
+ * Shared by both PopoverContent and DialogContent.
+ *
+ * Note: injected `<style>` elements and the tracking Set are append-only —
+ * they are never removed. This is intentional: the number of distinct
+ * presets is bounded (handful of animation + arrow presets), so the
+ * memory footprint is negligible. Removing styles would risk breaking
+ * other instances of the same preset that are still mounted.
+ *
+ * Decision (2026-03-17 audit): Accepted as a non-issue. The bounded
+ * preset count (~5 presets) makes cleanup unnecessary. We plan to move
+ * to a Compiled-based solution which will handle style injection and
+ * deduplication natively.
+ */
+var injectedPresets = new Set();
+export function ensurePresetStyles(_ref) {
+  var preset = _ref.preset;
+  if (injectedPresets.has(preset.name) || typeof document === 'undefined') {
+    return;
+  }
+  injectedPresets.add(preset.name);
+  var style = document.createElement('style');
+  style.textContent = preset.css;
+  document.head.appendChild(style);
+}

package/dist/esm/internal/reduced-motion.js

@@ -0,0 +1,21 @@
+import once from '@atlaskit/ds-lib/once';
+
+/**
+ * Returns `true` when the user prefers reduced motion.
+ *
+ * Safe for SSR (returns `false` when `window` is unavailable).
+ *
+ * The result is cached after the first call via `once`. This avoids
+ * calling `matchMedia` on every render. The trade-off is that if a user
+ * toggles the OS reduced-motion setting mid-session, the change won't
+ * take effect until the next page load. This is acceptable because
+ * toggling this system-level preference mid-session is extremely rare,
+ * and a page refresh is a reasonable expectation for system accessibility
+ * settings to take effect.
+ */
+export var prefersReducedMotion = once(function () {
+  if (typeof window === 'undefined' || !('matchMedia' in window)) {
+    return false;
+  }
+  return window.matchMedia('(prefers-reduced-motion: reduce)').matches;
+});

package/dist/esm/internal/resolve-placement.js

@@ -0,0 +1,18 @@
+/**
+ * Fully-resolved placement (internal). All fields are required.
+ * Use getPlacement({ placement: partial }) to obtain from partial input.
+ */
+
+/**
+ * Resolves a partial placement to its fully-specified form.
+ * Defaults: `axis: 'block'`, `edge: 'end'`, `align: 'center'`.
+ */
+export function getPlacement(_ref) {
+  var _placement$axis, _placement$edge, _placement$align;
+  var placement = _ref.placement;
+  return {
+    axis: (_placement$axis = placement.axis) !== null && _placement$axis !== void 0 ? _placement$axis : 'block',
+    edge: (_placement$edge = placement.edge) !== null && _placement$edge !== void 0 ? _placement$edge : 'end',
+    align: (_placement$align = placement.align) !== null && _placement$align !== void 0 ? _placement$align : 'center'
+  };
+}

package/dist/esm/internal/role-types.js

@@ -0,0 +1,60 @@
+/**
+ * Valid values for the `aria-haspopup` attribute.
+ * Derived from the HTML spec — maps popover roles to what the trigger announces.
+ */
+
+/**
+ * Roles that require an accessible name (`label` or `labelledBy`) per WCAG 4.1.2.
+ * Without a name, assistive technology cannot identify these landmarks.
+ */
+
+/**
+ * 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).
+ */
+
+// ── Shared ARIA role discrimination types ──
+//
+// These encode the WCAG 4.1.2 constraint: roles like `dialog`, `alertdialog`,
+// and `menu` MUST have an accessible name (either `label` or `labelledBy`).
+// TypeScript enforces this at compile time via discriminated unions.
+
+/**
+ * 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.
+ */
+
+/**
+ * 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.
+ */
+
+/**
+ * Maps a popover content role to the correct `aria-haspopup` value
+ * for its trigger element.
+ */
+export function roleToAriaHasPopup(_ref) {
+  var role = _ref.role;
+  if (role === 'menu') {
+    return 'menu';
+  }
+  if (role === 'listbox') {
+    return 'listbox';
+  }
+  if (role === 'tree') {
+    return 'tree';
+  }
+  if (role === 'grid') {
+    return 'grid';
+  }
+  // Default: return 'dialog' for all unmapped roles (tooltip, alertdialog,
+  // note, status, alert, log, etc). This is a kinder API — rather than
+  // throwing on unknown roles, we fall back to the most common popup type.
+  // New roles that need specific aria-haspopup values should be added
+  // as explicit cases above.
+  return 'dialog';
+}