@radix-ng/primitives 1.0.0-beta.2 → 1.0.0-beta.4

package/types/radix-ng-primitives-popover.d.ts

@@ -1,22 +1,35 @@
 import * as _angular_core from '@angular/core';
 import { Signal, ElementRef } from '@angular/core';
-import * as i1 from '@radix-ng/primitives/presence';
+import * as i1 from '@radix-ng/primitives/portal';
 import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
-import { RdxTransitionStatus, BooleanInput, NumberInput } from '@radix-ng/primitives/core';
+import { RdxTransitionStatus, RdxFloatingRootContext, BooleanInput, RdxCancelableChangeEventDetails, NumberInput } from '@radix-ng/primitives/core';
 import * as i1$1 from '@radix-ng/primitives/popper';
-import { RdxPopperContentWrapper, RdxPopperAnchorElement } from '@radix-ng/primitives/popper';
+import { RdxPopperContentWrapper } from '@radix-ng/primitives/popper';
 import * as _radix_ng_primitives_popover from '@radix-ng/primitives/popover';
-import * as i1$2 from '@radix-ng/primitives/portal';
-import { RdxPortalContainer } from '@radix-ng/primitives/portal';
-import * as i2 from '@radix-ng/primitives/dismissable-layer';
-import * as i3 from '@radix-ng/primitives/focus-scope';
+import { RdxOutsidePressDomEvent } from '@radix-ng/primitives/dismissable-layer';
+import * as i3 from '@radix-ng/primitives/floating-focus-manager';
 
 /**
- * Mounts the portal while the popover is open and waits for CSS exit keyframes before unmounting.
+ * Structural directive that teleports the popover content into a container (default `document.body`)
+ * while the popover is open, and keeps it mounted until any CSS exit `@keyframes` finishes.
+ *
+ * Apply it with the `*` microsyntax on the positioner — `<div *rdxPopoverPortal rdxPopoverPositioner>`
+ * — or as an explicit `<ng-template rdxPopoverPortal>`. For a custom container use the explicit form
+ * with `[container]`.
+ */
+declare class RdxPopoverPortal {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPopoverPortal, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopoverPortal, "ng-template[rdxPopoverPortal]", ["rdxPopoverPortal"], {}, {}, never, never, true, [{ directive: typeof i1.RdxPortalPresence; inputs: { "container": "container"; }; outputs: {}; }]>;
+}
+/**
+ * Dev-mode guard: `rdxPopoverPortal` used to be an attribute directive on a `<div>`. It is now
+ * structural, so the old `<div rdxPopoverPortal>` markup would silently stop portaling — fail loudly
+ * instead.
  */
-declare class RdxPopoverPortalPresence {
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPopoverPortalPresence, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopoverPortalPresence, "ng-template[rdxPopoverPortalPresence]", never, {}, {}, never, never, true, [{ directive: typeof i1.RdxPresenceDirective; inputs: {}; outputs: {}; }]>;
+declare class RdxPopoverPortalMisuseGuard {
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPopoverPortalMisuseGuard, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopoverPortalMisuseGuard, "[rdxPopoverPortal]:not(ng-template)", never, {}, {}, never, never, true, never>;
 }
 
 declare class RdxPopoverHandle<Payload = unknown> {
@@ -35,17 +48,20 @@ declare function createRdxPopoverHandle<Payload = unknown>(): RdxPopoverHandle<P
 
 type RdxPopoverModal = boolean | 'trap-focus';
 type RdxPopoverOpenChangeReason = 'trigger-hover' | 'trigger-focus' | 'trigger-press' | 'outside-press' | 'escape-key' | 'close-press' | 'focus-out' | 'imperative-action' | 'none';
+type RdxPopoverOpenChangeEventDetails = RdxCancelableChangeEventDetails<RdxPopoverOpenChangeReason>;
 interface RdxPopoverOpenChange {
     open: boolean;
     triggerId: string | null;
     trigger: HTMLElement | undefined;
     reason: RdxPopoverOpenChangeReason;
     event: Event;
+    eventDetails: RdxPopoverOpenChangeEventDetails;
 }
 interface RdxPopoverRootContext {
     contentId: string;
     descriptionId: Signal<string | undefined>;
     isOpen: Signal<boolean>;
+    present: Signal<boolean>;
     modal: Signal<RdxPopoverModal>;
     titleId: Signal<string | undefined>;
     trigger: Signal<HTMLElement | undefined>;
@@ -55,6 +71,8 @@ interface RdxPopoverRootContext {
     instant: Signal<boolean>;
     openChangeReason: Signal<RdxPopoverOpenChangeReason>;
     isPointerDownOnTrigger: Signal<boolean>;
+    /** Whether the current open was initiated by touch (ADR 0016 §3 — gates the anchored scroll lock). */
+    openedByTouch: Signal<boolean>;
     close: (reason?: RdxPopoverOpenChangeReason, event?: Event) => void;
     cancelHoverClose: () => void;
     cancelHoverOpen: () => void;
@@ -66,6 +84,7 @@ interface RdxPopoverRootContext {
     setDescriptionId: (id: string | undefined) => void;
     setTitleId: (id: string | undefined) => void;
     setPointerDownOnTrigger: (pointerDown: boolean) => void;
+    setOpenedByTouch: (value: boolean) => void;
     setHoverDelays: (delay: number, closeDelay: number) => void;
     registerPopupClose: () => () => void;
     registerTransitionElement: (element: HTMLElement) => () => void;
@@ -82,6 +101,8 @@ type RdxPopoverTransitionStatus = RdxTransitionStatus;
 declare class RdxPopoverRoot {
     private readonly popper;
     private readonly destroyRef;
+    /** Shared per-popup floating context (ADR 0015 §1): `open`, trigger registry, reference / floating els. */
+    readonly floatingContext: RdxFloatingRootContext;
     private hasAppliedDefaultOpen;
     private hasAppliedDefaultTriggerId;
     private openTimer;
@@ -125,12 +146,16 @@ declare class RdxPopoverRoot {
     readonly triggers: _angular_core.WritableSignal<HTMLElement[]>;
     readonly payload: _angular_core.WritableSignal<unknown>;
     readonly isPointerDownOnTrigger: _angular_core.WritableSignal<boolean>;
+    /** Whether the current open was initiated by touch (ADR 0016 §3 — gates the anchored scroll lock). */
+    readonly openedByTouch: _angular_core.WritableSignal<boolean>;
     readonly popupCloseCount: _angular_core.WritableSignal<number>;
+    private readonly preventUnmountOnClose;
     readonly onOpenChange: _angular_core.OutputEmitterRef<RdxPopoverOpenChange>;
     readonly onOpenChangeComplete: _angular_core.OutputEmitterRef<boolean>;
     private readonly registeredTriggers;
     private readonly viewportTriggerChange;
     readonly state: Signal<"open" | "closed">;
+    readonly present: Signal<boolean>;
     constructor();
     show(trigger?: HTMLElement | undefined, payload?: unknown, triggerId?: string, reason?: RdxPopoverOpenChangeReason, event?: Event, fromHover?: boolean): void;
     close(reason?: RdxPopoverOpenChangeReason, event?: Event): void;
@@ -144,7 +169,7 @@ declare class RdxPopoverRoot {
     registerViewport(onTriggerChange: (previous: HTMLElement, next: HTMLElement) => void): () => boolean;
     registerTransitionElement(element: HTMLElement): () => void;
     private syncTriggerId;
-    private emitOpenChange;
+    private createOpenChangeEvent;
     private clearHoverTimers;
     private clearOpenTimer;
     private clearCloseTimer;
@@ -159,6 +184,8 @@ declare class RdxPopoverRoot {
 declare class RdxPopoverTrigger {
     private readonly parentRootContext;
     readonly elementRef: ElementRef<HTMLElement>;
+    /** Pointer type of the most recent `pointerdown`, used to detect a touch open (ADR 0016 §3). */
+    private lastPointerType;
     /**
      * Associates this trigger with a detached popover root.
      */
@@ -196,143 +223,83 @@ declare class RdxPopoverTrigger {
     protected handleClick(event: MouseEvent): void;
     protected handlePointerEnter(event: PointerEvent): void;
     protected handlePointerLeave(event: PointerEvent): void;
-    protected handlePointerDown(): void;
+    protected handlePointerDown(event: PointerEvent): void;
     protected handlePointerUp(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPopoverTrigger, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopoverTrigger, "button[rdxPopoverTrigger]", never, { "handle": { "alias": "handle"; "required": false; "isSignal": true; }; "payload": { "alias": "payload"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "openOnHover": { "alias": "openOnHover"; "required": false; "isSignal": true; }; "delay": { "alias": "delay"; "required": false; "isSignal": true; }; "closeDelay": { "alias": "closeDelay"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$1.RdxPopperAnchor; inputs: {}; outputs: {}; }]>;
 }
 
-/**
- * Moves the popover to a different part of the DOM.
- */
-declare class RdxPopoverPortal {
-    protected readonly rootContext: _radix_ng_primitives_popover.RdxPopoverRootContext;
-    /**
-     * Optional container to portal the content into. Defaults to `document.body`.
-     */
-    readonly container: _angular_core.InputSignal<RdxPortalContainer | undefined>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPopoverPortal, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopoverPortal, "[rdxPopoverPortal]", never, { "container": { "alias": "container"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$2.RdxPortal; inputs: { "container": "container"; }; outputs: {}; }]>;
-}
-
 /**
  * An optional backdrop rendered behind the popup.
  */
 declare class RdxPopoverBackdrop {
     protected readonly rootContext: _radix_ng_primitives_popover.RdxPopoverRootContext;
+    constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPopoverBackdrop, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopoverBackdrop, "[rdxPopoverBackdrop]", never, {}, {}, never, never, true, never>;
 }
 
 /**
  * Positions the popover against its trigger.
+ *
+ * A "thin" positioner (ADR 0012): it inherits the popper positioning surface (inputs, `placed`
+ * output, unified vars + placement attrs) from {@link RdxPopperContentWrapper} and adds popover's own
+ * concerns — Base UI-aligned defaults via the config provider, the open/closed/instant state
+ * attributes, the deprecated `--radix-popover-*` aliases, and the grace-area hover bridge.
  */
-declare class RdxPopoverPositioner {
+declare class RdxPopoverPositioner extends RdxPopperContentWrapper {
     protected readonly rootContext: _radix_ng_primitives_popover.RdxPopoverRootContext;
-    protected readonly wrapper: RdxPopperContentWrapper;
-    private readonly elementRef;
+    protected readonly legacyVars: Record<string, string>;
+    private readonly containerRef;
     private readonly triggerEl;
     private readonly containerEl;
     private readonly graceArea;
-    /**
-     * An element to position the popup against. Defaults to the trigger.
-     */
-    readonly anchor: _angular_core.InputSignal<RdxPopperAnchorElement>;
-    /**
-     * The preferred side of the trigger to render against when open.
-     */
-    readonly side: _angular_core.InputSignal<"top" | "right" | "bottom" | "left">;
-    /**
-     * Distance between the trigger and the popup in pixels.
-     */
-    readonly sideOffset: _angular_core.InputSignalWithTransform<number, NumberInput>;
-    /**
-     * How to align the popup relative to the specified side.
-     */
-    readonly align: _angular_core.InputSignal<"start" | "center" | "end">;
-    /**
-     * An offset in pixels from the `start` or `end` alignment options.
-     */
-    readonly alignOffset: _angular_core.InputSignalWithTransform<number, NumberInput>;
-    /**
-     * Minimum distance to maintain between the arrow and the edges of the popup.
-     */
-    readonly arrowPadding: _angular_core.InputSignalWithTransform<number, NumberInput>;
-    /**
-     * Whether to override side and alignment preferences to prevent collisions.
-     */
-    readonly avoidCollisions: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
-    /**
-     * The element used as the collision boundary.
-     */
-    readonly collisionBoundary: _angular_core.InputSignal<ElementRef<HTMLElement> | ElementRef<HTMLElement>[] | undefined>;
-    /**
-     * Distance in pixels from the boundary edges where collision detection should occur.
-     */
-    readonly collisionPadding: _angular_core.InputSignal<number | Partial<Record<"top" | "right" | "bottom" | "left", number>>>;
-    /**
-     * The sticky behavior on the alignment axis.
-     */
-    readonly sticky: _angular_core.InputSignal<"always" | "partial">;
-    /**
-     * Whether to hide the popup when the trigger becomes fully occluded.
-     */
-    readonly hideWhenDetached: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
-    /**
-     * The CSS position strategy used by Floating UI.
-     */
-    readonly positionStrategy: _angular_core.InputSignal<"fixed" | "absolute">;
-    /**
-     * Whether to update position on every animation frame.
-     */
-    readonly updatePositionStrategy: _angular_core.InputSignal<"always" | "optimized">;
-    /**
-     * Emits when the popup has been placed.
-     */
-    readonly placed: _angular_core.OutputRef<void>;
     constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPopoverPositioner, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopoverPositioner, "[rdxPopoverPositioner]", never, { "anchor": { "alias": "anchor"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "sideOffset": { "alias": "sideOffset"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "alignOffset": { "alias": "alignOffset"; "required": false; "isSignal": true; }; "arrowPadding": { "alias": "arrowPadding"; "required": false; "isSignal": true; }; "avoidCollisions": { "alias": "avoidCollisions"; "required": false; "isSignal": true; }; "collisionBoundary": { "alias": "collisionBoundary"; "required": false; "isSignal": true; }; "collisionPadding": { "alias": "collisionPadding"; "required": false; "isSignal": true; }; "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; "hideWhenDetached": { "alias": "hideWhenDetached"; "required": false; "isSignal": true; }; "positionStrategy": { "alias": "positionStrategy"; "required": false; "isSignal": true; }; "updatePositionStrategy": { "alias": "updatePositionStrategy"; "required": false; "isSignal": true; }; }, { "placed": "placed"; }, never, never, true, [{ directive: typeof i1$1.RdxPopperContentWrapper; inputs: { "anchor": "anchor"; "side": "side"; "sideOffset": "sideOffset"; "align": "align"; "alignOffset": "alignOffset"; "arrowPadding": "arrowPadding"; "avoidCollisions": "avoidCollisions"; "collisionBoundary": "collisionBoundary"; "collisionPadding": "collisionPadding"; "sticky": "sticky"; "hideWhenDetached": "hideWhenDetached"; "positionStrategy": "positionStrategy"; "updatePositionStrategy": "updatePositionStrategy"; }; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopoverPositioner, "[rdxPopoverPositioner]", never, {}, {}, never, never, true, never>;
 }
 
 /**
  * A container for the popover contents.
+ *
+ * **ADR 0015/0017 Phase-4 migration** onto the new floating dismissal + focus engine (same pattern as
+ * Dialog; browser-verified via `popover.behavior` Playwright). Popover-specific:
+ * - **Hover-open disables the manager** (`enabled = isOpen && !isHoverActive`) — Base UI parity
+ *   (`disabled={!mounted || openReason === triggerHover}`); a hover-opened popover does not trap / mark.
+ *   (The legacy only suppressed auto-focus while still trapping — that Radix divergence is dropped.)
+ * - Trap = `'trap-focus' || (modal === true && hasPopupClose())`; scroll lock + real outside `inert`
+ *   isolation key off the full modal (`modal === true`).
+ * - No `disablePointerDismissal` — outside-press + focus-out always close.
+ *
+ * Note: a positioned popover does **not** auto-focus into the popup on open (pre-existing — the legacy
+ * behaved the same; verified). The trap holds focus once it is inside. Auto-focus-on-open + redirecting a
+ * Tab from the trigger into the popup needs the deferred portal-focus bridge / guards (ADR 0017 §6a).
  */
 declare class RdxPopoverPopup {
     protected readonly rootContext: _radix_ng_primitives_popover.RdxPopoverRootContext;
-    private readonly dismissableLayer;
+    private readonly host;
+    private readonly floatingContext;
+    private readonly registration;
+    private readonly focusManager;
     private readonly focusScope;
     private readonly wrapper;
     protected readonly align: _angular_core.Signal<"start" | "center" | "end" | undefined>;
     protected readonly side: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
-    private dismissDetails;
-    /**
-     * Event handler called when the escape key is down. Can be prevented.
-     */
-    readonly escapeKeyDown: _angular_core.OutputRef<KeyboardEvent>;
-    /**
-     * Event handler called when a pointerdown event happens outside of the popup. Can be prevented.
-     */
-    readonly pointerDownOutside: _angular_core.OutputRef<PointerEvent>;
-    /**
-     * Event handler called when focus moves outside of the popup. Can be prevented.
-     */
-    readonly focusOutside: _angular_core.OutputRef<FocusEvent>;
-    /**
-     * Event handler called when an interaction happens outside of the popup. Can be prevented.
-     */
-    readonly interactOutside: _angular_core.OutputRef<PointerEvent | FocusEvent>;
-    /**
-     * Event handler called before focus moves into the popup. Can be prevented.
-     */
+    /** Event handler called when the escape key is down. Can be prevented. */
+    readonly escapeKeyDown: _angular_core.OutputEmitterRef<KeyboardEvent>;
+    /** Event handler called when a pointerdown event happens outside of the popup. Can be prevented. */
+    readonly pointerDownOutside: _angular_core.OutputEmitterRef<RdxOutsidePressDomEvent>;
+    /** Event handler called when focus moves outside of the popup. Can be prevented. */
+    readonly focusOutside: _angular_core.OutputEmitterRef<FocusEvent>;
+    /** Event handler called when an interaction (pointer / focus) happens outside of the popup. */
+    readonly interactOutside: _angular_core.OutputEmitterRef<RdxOutsidePressDomEvent | FocusEvent>;
+    /** Event handler called before focus moves into the popup. Can be prevented. */
     readonly openAutoFocus: _angular_core.OutputRef<Event>;
-    /**
-     * Event handler called before focus returns after the popup is removed. Can be prevented.
-     */
+    /** Event handler called before focus returns after the popup is removed. Can be prevented. */
     readonly closeAutoFocus: _angular_core.OutputRef<Event>;
     constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPopoverPopup, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopoverPopup, "[rdxPopoverPopup]", never, {}, { "escapeKeyDown": "escapeKeyDown"; "pointerDownOutside": "pointerDownOutside"; "focusOutside": "focusOutside"; "interactOutside": "interactOutside"; "openAutoFocus": "openAutoFocus"; "closeAutoFocus": "closeAutoFocus"; }, never, never, true, [{ directive: typeof i1$1.RdxPopperContent; inputs: {}; outputs: {}; }, { directive: typeof i2.RdxDismissableLayer; inputs: {}; outputs: {}; }, { directive: typeof i3.RdxFocusScope; inputs: {}; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopoverPopup, "[rdxPopoverPopup]", never, {}, { "escapeKeyDown": "escapeKeyDown"; "pointerDownOutside": "pointerDownOutside"; "focusOutside": "focusOutside"; "interactOutside": "interactOutside"; "openAutoFocus": "openAutoFocus"; "closeAutoFocus": "closeAutoFocus"; }, never, never, true, [{ directive: typeof i1$1.RdxPopperContent; inputs: {}; outputs: {}; }, { directive: typeof _radix_ng_primitives_core.RdxFloatingNodeRegistration; inputs: {}; outputs: {}; }, { directive: typeof i3.RdxFloatingFocusManager; inputs: {}; outputs: {}; }]>;
 }
 
 /**
@@ -406,12 +373,12 @@ declare class RdxPopoverViewport {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopoverViewport, "[rdxPopoverViewport]", never, {}, {}, never, never, true, never>;
 }
 
-declare const popoverImports: (typeof RdxPopoverPortalPresence)[];
+declare const popoverImports: (typeof RdxPopoverPortal)[];
 declare class RdxPopoverModule {
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPopoverModule, never>;
-    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<RdxPopoverModule, never, [typeof RdxPopoverRoot, typeof RdxPopoverTrigger, typeof RdxPopoverPortalPresence, typeof RdxPopoverPortal, typeof RdxPopoverBackdrop, typeof RdxPopoverPositioner, typeof RdxPopoverPopup, typeof RdxPopoverArrow, typeof RdxPopoverTitle, typeof RdxPopoverDescription, typeof RdxPopoverClose, typeof RdxPopoverViewport], [typeof RdxPopoverRoot, typeof RdxPopoverTrigger, typeof RdxPopoverPortalPresence, typeof RdxPopoverPortal, typeof RdxPopoverBackdrop, typeof RdxPopoverPositioner, typeof RdxPopoverPopup, typeof RdxPopoverArrow, typeof RdxPopoverTitle, typeof RdxPopoverDescription, typeof RdxPopoverClose, typeof RdxPopoverViewport]>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<RdxPopoverModule, never, [typeof RdxPopoverRoot, typeof RdxPopoverTrigger, typeof RdxPopoverPortal, typeof RdxPopoverPortalMisuseGuard, typeof RdxPopoverBackdrop, typeof RdxPopoverPositioner, typeof RdxPopoverPopup, typeof RdxPopoverArrow, typeof RdxPopoverTitle, typeof RdxPopoverDescription, typeof RdxPopoverClose, typeof RdxPopoverViewport], [typeof RdxPopoverRoot, typeof RdxPopoverTrigger, typeof RdxPopoverPortal, typeof RdxPopoverPortalMisuseGuard, typeof RdxPopoverBackdrop, typeof RdxPopoverPositioner, typeof RdxPopoverPopup, typeof RdxPopoverArrow, typeof RdxPopoverTitle, typeof RdxPopoverDescription, typeof RdxPopoverClose, typeof RdxPopoverViewport]>;
     static ɵinj: _angular_core.ɵɵInjectorDeclaration<RdxPopoverModule>;
 }
 
-export { RdxPopoverArrow, RdxPopoverBackdrop, RdxPopoverClose, RdxPopoverDescription, RdxPopoverHandle, RdxPopoverModule, RdxPopoverPopup, RdxPopoverPortal, RdxPopoverPortalPresence, RdxPopoverPositioner, RdxPopoverRoot, RdxPopoverTitle, RdxPopoverTrigger, RdxPopoverViewport, createRdxPopoverHandle, injectRdxPopoverRootContext, popoverImports, provideRdxPopoverRootContext };
-export type { RdxPopoverModal, RdxPopoverOpenChange, RdxPopoverOpenChangeReason, RdxPopoverRootContext, RdxPopoverTransitionStatus };
+export { RdxPopoverArrow, RdxPopoverBackdrop, RdxPopoverClose, RdxPopoverDescription, RdxPopoverHandle, RdxPopoverModule, RdxPopoverPopup, RdxPopoverPortal, RdxPopoverPortalMisuseGuard, RdxPopoverPositioner, RdxPopoverRoot, RdxPopoverTitle, RdxPopoverTrigger, RdxPopoverViewport, createRdxPopoverHandle, injectRdxPopoverRootContext, popoverImports, provideRdxPopoverRootContext };
+export type { RdxPopoverModal, RdxPopoverOpenChange, RdxPopoverOpenChangeEventDetails, RdxPopoverOpenChangeReason, RdxPopoverRootContext, RdxPopoverTransitionStatus };

package/types/radix-ng-primitives-popper.d.ts

@@ -1,5 +1,5 @@
 import * as _angular_core from '@angular/core';
-import { ElementRef, InjectionToken, Provider } from '@angular/core';
+import { ElementRef, Provider, Type, InjectionToken } from '@angular/core';
 import { ReferenceElement, Placement, Middleware, VirtualElement } from '@floating-ui/dom';
 import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
 import { NumberInput, BooleanInput } from '@radix-ng/primitives/core';
@@ -18,6 +18,12 @@ declare class RdxPopper {
 }
 
 declare class RdxPopperContent {
+    /**
+     * Optional so the directive can be composed onto a content part that is also used outside Popper
+     * positioning (e.g. select's `item-aligned` mode, where there is no `RdxPopperContentWrapper`
+     * ancestor). With no wrapper the `data-side` / `data-align` bindings and the animation guard
+     * simply no-op.
+     */
     protected readonly popperContentWrapper: {
         placedSide: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
         placedAlign: _angular_core.Signal<"start" | "center" | "end" | undefined>;
@@ -26,7 +32,7 @@ declare class RdxPopperContent {
         shouldHideArrow: _angular_core.Signal<boolean>;
         isPositioned: _angular_core.Signal<boolean>;
         anchorHidden: _angular_core.Signal<boolean>;
-    };
+    } | null;
     /**
      * if the PopperContent hasn't been placed yet (not all measurements done)
      * we prevent animations so that users's animation don't kick in too early referring wrong sides
@@ -77,12 +83,11 @@ declare const providePopperContentWrapperContext: (useFactory: () => {
     shouldHideArrow: _angular_core.Signal<boolean>;
     isPositioned: _angular_core.Signal<boolean>;
     anchorHidden: _angular_core.Signal<boolean>;
-}) => _angular_core.Provider;
+}) => Provider;
 declare class RdxPopperContentWrapper {
     private readonly elementRef;
     private readonly injector;
     private readonly context;
-    private readonly isBrowser;
     /** Optional positioning defaults provided by a composing primitive (e.g. tooltip). */
     private readonly config;
     /**
@@ -193,26 +198,57 @@ declare class RdxPopperContentWrapper {
      * The current alignment of the panel.
      */
     readonly placedAlign: _angular_core.Signal<"start" | "center" | "end" | undefined>;
-    private readonly contentElementRef;
-    protected readonly contentZIndex: _angular_core.Signal<string | 0>;
     protected readonly style: _angular_core.Signal<{
         visibility: string;
         pointerEvents: string;
         position: "fixed" | "absolute";
         transform: string;
         minWidth: string;
-        zIndex: string | number;
         top: string;
         left: string;
         '--radix-popper-transform-origin': string;
         '--radix-popper-content-wrapper-width': string;
         '--radix-popper-content-wrapper-height': string;
+        '--anchor-width': string;
+        '--anchor-height': string;
+        '--available-width': string;
+        '--available-height': string;
+        '--positioner-width': string;
+        '--positioner-height': string;
+        '--transform-origin': string;
     }>;
     private readonly afterRenderEffect;
     constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPopperContentWrapper, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopperContentWrapper, "[rdxPopperContentWrapper]", never, { "anchor": { "alias": "anchor"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "sideOffset": { "alias": "sideOffset"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "alignOffset": { "alias": "alignOffset"; "required": false; "isSignal": true; }; "arrowPadding": { "alias": "arrowPadding"; "required": false; "isSignal": true; }; "avoidCollisions": { "alias": "avoidCollisions"; "required": false; "isSignal": true; }; "collisionBoundary": { "alias": "collisionBoundary"; "required": false; "isSignal": true; }; "collisionPadding": { "alias": "collisionPadding"; "required": false; "isSignal": true; }; "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; "hideWhenDetached": { "alias": "hideWhenDetached"; "required": false; "isSignal": true; }; "positionStrategy": { "alias": "positionStrategy"; "required": false; "isSignal": true; }; "updatePositionStrategy": { "alias": "updatePositionStrategy"; "required": false; "isSignal": true; }; }, { "placed": "placed"; }, ["arrow", "contentElementRef"], never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopperContentWrapper, "[rdxPopperContentWrapper]", never, { "anchor": { "alias": "anchor"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "sideOffset": { "alias": "sideOffset"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "alignOffset": { "alias": "alignOffset"; "required": false; "isSignal": true; }; "arrowPadding": { "alias": "arrowPadding"; "required": false; "isSignal": true; }; "avoidCollisions": { "alias": "avoidCollisions"; "required": false; "isSignal": true; }; "collisionBoundary": { "alias": "collisionBoundary"; "required": false; "isSignal": true; }; "collisionPadding": { "alias": "collisionPadding"; "required": false; "isSignal": true; }; "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; "hideWhenDetached": { "alias": "hideWhenDetached"; "required": false; "isSignal": true; }; "positionStrategy": { "alias": "positionStrategy"; "required": false; "isSignal": true; }; "updatePositionStrategy": { "alias": "updatePositionStrategy"; "required": false; "isSignal": true; }; }, { "placed": "placed"; }, ["arrow"], never, true, never>;
 }
+/**
+ * Providers a "thin" positioner that `extends RdxPopperContentWrapper` must include. Angular
+ * inherits a base directive's inputs/outputs/host bindings/queries but **not** its `providers`, so
+ * the `useExisting` alias (lets the popup and arrow resolve the subclass through the
+ * {@link RdxPopperContentWrapper} token) and the wrapper context provider (what
+ * `injectPopperContentWrapperContext()` reads) are re-declared here in one place.
+ *
+ * Combine with {@link provideRdxPopperContentConfig} for per-primitive positioning defaults:
+ *
+ * ```ts
+ * providers: [
+ *   ...provideRdxPopperContentWrapper(RdxComboboxPositioner),
+ *   provideRdxPopperContentConfig({ sideOffset: 4, align: 'start' })
+ * ]
+ * ```
+ */
+declare function provideRdxPopperContentWrapper(positioner: Type<RdxPopperContentWrapper>): Provider[];
+/**
+ * Deprecated per-primitive aliases of the unified popper variables (ADR 0012). Since the wrapper now
+ * emits the unified `--anchor-*` / `--available-*` / `--transform-origin` set itself, a positioner no
+ * longer hand-writes a re-namespacing `[style]` map; it spreads this helper into a host `[style]`
+ * binding only to keep the legacy `--radix-<name>-content-*` / `--radix-<name>-trigger-*` names alive
+ * for one release of consumer back-compat. Migrate to the unified set; these are removed next minor.
+ *
+ * @deprecated Use the unified `--anchor-*` / `--available-*` / `--transform-origin` variables.
+ */
+declare function legacyPopperVars(name: string): Record<string, string>;
 
 declare class RdxPopperArrow {
     private readonly popperContentContext;
@@ -258,7 +294,7 @@ interface RdxPopperContentConfig {
 declare const RdxPopperContentConfigToken: InjectionToken<RdxPopperContentConfig>;
 declare function provideRdxPopperContentConfig(config: RdxPopperContentConfig): Provider;
 
-declare const popperImports: (typeof RdxPopperAnchor | typeof RdxPopper | typeof RdxPopperContent | typeof RdxPopperContentWrapper)[];
+declare const popperImports: (typeof RdxPopperAnchor | typeof RdxPopper | typeof RdxPopperContentWrapper | typeof RdxPopperContent)[];
 
-export { RdxPopper, RdxPopperAnchor, RdxPopperArrow, RdxPopperContent, RdxPopperContentConfigToken, RdxPopperContentWrapper, getSideAndAlignFromPlacement, injectPopperContentWrapperContext, isNotNull, popperImports, providePopperContentWrapperContext, provideRdxPopperContentConfig, transformOrigin };
+export { RdxPopper, RdxPopperAnchor, RdxPopperArrow, RdxPopperContent, RdxPopperContentConfigToken, RdxPopperContentWrapper, getSideAndAlignFromPlacement, injectPopperContentWrapperContext, isNotNull, legacyPopperVars, popperImports, providePopperContentWrapperContext, provideRdxPopperContentConfig, provideRdxPopperContentWrapper, transformOrigin };
 export type { Align, PopperContentWrapperContext, RdxPopperAnchorElement, RdxPopperContentConfig, Side };

package/types/radix-ng-primitives-portal.d.ts

@@ -1,11 +1,18 @@
-import * as _angular_core from '@angular/core';
+import * as i0 from '@angular/core';
 import { ElementRef } from '@angular/core';
 
 /**
- * A target container for the portal. Accepts an `ElementRef`, a native element, or a CSS selector
+ * A target container for a portal. Accepts an `ElementRef`, a native element, or a CSS selector
  * resolved against the document.
  */
 type RdxPortalContainer = ElementRef<HTMLElement> | HTMLElement | string;
+/**
+ * Resolve a {@link RdxPortalContainer} to a concrete element. Returns `null` when nothing usable is
+ * provided (a missing container, a selector matching nothing, or a non-element value), so callers can
+ * fall back to `document.body`. Shared by `RdxPortal` and `RdxPortalPresence`.
+ */
+declare function resolvePortalContainer(container: RdxPortalContainer | undefined, document: Document | null): HTMLElement | null;
+
 declare class RdxPortal {
     private readonly elementRef;
     private readonly platformId;
@@ -15,16 +22,54 @@ declare class RdxPortal {
      * Specify a container to portal the content into. Can be an `ElementRef`, a native element, or a
      * CSS selector. Defaults to `document.body` when not set (or when a selector matches nothing).
      */
-    readonly container: _angular_core.InputSignal<RdxPortalContainer | undefined>;
+    readonly container: i0.InputSignal<RdxPortalContainer | undefined>;
+    private readonly _computedContainer;
+    readonly computedContainer: i0.Signal<RdxPortalContainer | undefined>;
+    private readonly elementContainer;
+    constructor();
+    setContainer(container: RdxPortalContainer): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxPortal, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxPortal, "[rdxPortal]", ["rdxPortal"], { "container": { "alias": "container"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Structural directive merging what `RdxPortal` + `RdxPresenceDirective` did as a pair: it mounts its
+ * template while `present()` (from {@link RDX_PRESENCE_CONTEXT}) is `true`, **relocates every root
+ * node into a portal container** (default `document.body`), and on close runs the presence exit state
+ * machine — keeping the content mounted until every running CSS exit `@keyframes` on any root node
+ * finishes.
+ *
+ * Unlike `RdxPortal`, it adds **no wrapper element**: the template's root nodes become direct children
+ * of the container. Use the `*` microsyntax for the common single-root case
+ * (`<div *rdxXxxPortal rdxXxxPositioner>`) or the explicit `<ng-template rdxXxxPortal>` form for a
+ * custom container or multiple root nodes (e.g. a dialog backdrop + popup).
+ *
+ * SSR: on the server the view renders in place and is never relocated; after hydration the relocation
+ * effect moves the nodes into the container (same browser-guarded split `RdxPortal` uses).
+ */
+declare class RdxPortalPresence {
+    private readonly viewContainerRef;
+    private readonly templateRef;
+    private readonly document;
+    private readonly isBrowser;
+    /**
+     * Container to portal the content into. Can be an `ElementRef`, a native element, or a CSS
+     * selector. Defaults to `document.body` (or when a selector matches nothing).
+     */
+    readonly container: i0.InputSignal<RdxPortalContainer | undefined>;
     private readonly _computedContainer;
-    readonly computedContainer: _angular_core.Signal<RdxPortalContainer | undefined>;
     private readonly elementContainer;
+    /** The live view's root nodes, exposed as a signal so the relocation effect re-runs on (re)mount. */
+    private readonly mountedNodes;
+    private viewRef;
     constructor();
+    /** Imperatively override the portal container (parity with `RdxPortal.setContainer`). */
     setContainer(container: RdxPortalContainer): void;
-    private resolveContainer;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPortal, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPortal, "[rdxPortal]", ["rdxPortal"], { "container": { "alias": "container"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    private mountView;
+    private destroyView;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxPortalPresence, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxPortalPresence, never, never, { "container": { "alias": "container"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-export { RdxPortal };
+export { RdxPortal, RdxPortalPresence, resolvePortalContainer };
 export type { RdxPortalContainer };