@radix-ng/primitives 0.51.0 → 1.0.0-beta.1

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

@@ -1,402 +1,417 @@
 import * as _angular_core from '@angular/core';
-import { ElementRef, OnInit, ViewContainerRef, DestroyRef } from '@angular/core';
-import { NumberInput, BooleanInput } from '@angular/cdk/coercion';
+import { Signal, ElementRef } from '@angular/core';
+import * as i1 from '@radix-ng/primitives/presence';
+import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
+import { RdxTransitionStatus, BooleanInput, NumberInput } from '@radix-ng/primitives/core';
+import * as i1$1 from '@radix-ng/primitives/popper';
+import { RdxPopperContentWrapper, RdxPopperAnchorElement } from '@radix-ng/primitives/popper';
 import * as _radix_ng_primitives_popover from '@radix-ng/primitives/popover';
-import * as rxjs from 'rxjs';
-import * as i1 from '@angular/cdk/overlay';
-import { CdkOverlayOrigin } from '@angular/cdk/overlay';
-import { RdxPositionSide, RdxPositionAlign } from '@radix-ng/primitives/core';
-import * as i1$1 from '@angular/cdk/a11y';
+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';
 
-declare class RdxPopoverArrowDirective {
-    /** @ignore */
-    private readonly renderer;
-    /** @ignore */
-    private readonly popoverRoot;
-    /** @ignore */
-    readonly elementRef: ElementRef<any>;
-    /**
-     * @description The width of the arrow in pixels.
-     * @default 10
-     */
-    readonly width: _angular_core.InputSignalWithTransform<number, NumberInput>;
-    /**
-     * @description The height of the arrow in pixels.
-     * @default 5
-     */
-    readonly height: _angular_core.InputSignalWithTransform<number, NumberInput>;
-    /** @ignore */
-    readonly arrowSvgElement: _angular_core.Signal<HTMLElement>;
-    /** @ignore */
-    private readonly currentArrowSvgElement;
-    /** @ignore */
-    private readonly position;
-    /** @ignore */
-    private anchorOrTriggerRect;
-    constructor();
-    /** @ignore */
-    private setAnchorOrTriggerRect;
-    /** @ignore */
-    private setPosition;
-    /** @ignore */
-    private onArrowSvgElementChangeEffect;
-    /** @ignore */
-    private onContentPositionAndArrowDimensionsChangeEffect;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPopoverArrowDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopoverArrowDirective, "[rdxPopoverArrow]", never, { "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+/**
+ * Mounts the portal while the popover is open and waits for CSS exit keyframes before unmounting.
+ */
+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 RdxPopoverCloseDirective {
-    /** @ignore */
-    protected readonly popoverRoot: _radix_ng_primitives_popover.RdxPopoverRootDirective;
-    /** @ignore */
-    readonly elementRef: ElementRef<any>;
-    /** @ignore */
-    private readonly renderer;
-    constructor();
-    /** @ignore */
-    private onIsControlledExternallyEffect;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPopoverCloseDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopoverCloseDirective, "[rdxPopoverClose]", never, {}, {}, never, never, true, never>;
+declare class RdxPopoverHandle<Payload = unknown> {
+    private readonly rootContext;
+    private readonly triggers;
+    private readonly rootTriggerCleanups;
+    readonly isOpen: _angular_core.Signal<boolean>;
+    open(triggerId: string): void;
+    close(): void;
+    toggle(triggerId: string, event?: Event): void;
+    registerRoot(rootContext: RdxPopoverRootContext): () => void;
+    registerTrigger(id: string, trigger: HTMLElement, payload: () => Payload | undefined): () => void;
+    context(): RdxPopoverRootContext | undefined;
 }
+declare function createRdxPopoverHandle<Payload = unknown>(): RdxPopoverHandle<Payload>;
 
-declare class RdxPopoverContentDirective implements OnInit {
-    /** @ignore */
-    private readonly popoverRoot;
-    /** @ignore */
-    private readonly templateRef;
-    /** @ignore */
-    private readonly overlay;
-    /** @ignore */
+type RdxPopoverModal = boolean | 'trap-focus';
+type RdxPopoverOpenChangeReason = 'trigger-hover' | 'trigger-focus' | 'trigger-press' | 'outside-press' | 'escape-key' | 'close-press' | 'focus-out' | 'imperative-action' | 'none';
+interface RdxPopoverOpenChange {
+    open: boolean;
+    triggerId: string | null;
+    trigger: HTMLElement | undefined;
+    reason: RdxPopoverOpenChangeReason;
+    event: Event;
+}
+interface RdxPopoverRootContext {
+    contentId: string;
+    descriptionId: Signal<string | undefined>;
+    isOpen: Signal<boolean>;
+    modal: Signal<RdxPopoverModal>;
+    titleId: Signal<string | undefined>;
+    trigger: Signal<HTMLElement | undefined>;
+    triggers: Signal<HTMLElement[]>;
+    hasPopupClose: Signal<boolean>;
+    isHoverActive: Signal<boolean>;
+    instant: Signal<boolean>;
+    openChangeReason: Signal<RdxPopoverOpenChangeReason>;
+    isPointerDownOnTrigger: Signal<boolean>;
+    close: (reason?: RdxPopoverOpenChangeReason, event?: Event) => void;
+    cancelHoverClose: () => void;
+    cancelHoverOpen: () => void;
+    closeOnHover: () => void;
+    payload: Signal<unknown>;
+    open: (trigger?: HTMLElement, payload?: unknown, triggerId?: string, reason?: RdxPopoverOpenChangeReason, event?: Event) => void;
+    openOnHover: (trigger: HTMLElement, payload: unknown, triggerId: string, event: PointerEvent) => void;
+    registerTrigger: (id: string, trigger: HTMLElement, payload: () => unknown) => () => void;
+    setDescriptionId: (id: string | undefined) => void;
+    setTitleId: (id: string | undefined) => void;
+    setPointerDownOnTrigger: (pointerDown: boolean) => void;
+    setHoverDelays: (delay: number, closeDelay: number) => void;
+    registerPopupClose: () => () => void;
+    registerTransitionElement: (element: HTMLElement) => () => void;
+    transitionStatus: Signal<RdxPopoverTransitionStatus>;
+    registerViewport: (onTriggerChange: (previous: HTMLElement, next: HTMLElement) => void) => () => void;
+    toggle: (triggerId: string, trigger: HTMLElement, payload?: unknown, event?: Event) => void;
+}
+declare const injectRdxPopoverRootContext: _radix_ng_primitives_core.InjectContext<RdxPopoverRootContext>;
+declare const provideRdxPopoverRootContext: (useFactory: () => RdxPopoverRootContext) => _angular_core.Provider;
+type RdxPopoverTransitionStatus = RdxTransitionStatus;
+/**
+ * Groups all parts of the popover.
+ */
+declare class RdxPopoverRoot {
+    private readonly popper;
     private readonly destroyRef;
-    /** @ignore */
-    private readonly connectedOverlay;
-    /** @ignore */
-    readonly name: _angular_core.Signal<string>;
+    private hasAppliedDefaultOpen;
+    private hasAppliedDefaultTriggerId;
+    private openTimer;
+    private closeTimer;
+    private hoverDelay;
+    private hoverCloseDelay;
+    private instantFrame;
+    private readonly transition;
+    readonly isHoverActive: _angular_core.WritableSignal<boolean>;
+    readonly instant: _angular_core.WritableSignal<boolean>;
+    readonly openChangeReason: _angular_core.WritableSignal<RdxPopoverOpenChangeReason>;
+    readonly transitionStatus: Signal<RdxTransitionStatus>;
     /**
-     * @description The preferred side of the trigger to render against when open. Will be reversed when collisions occur and avoidCollisions is enabled.
-     * @default top
+     * Whether the popover is currently open.
      */
-    readonly side: _angular_core.InputSignal<RdxPositionSide>;
+    readonly open: _angular_core.ModelSignal<boolean>;
     /**
-     * @description The distance in pixels from the trigger.
-     * @default undefined
+     * Whether the popover is initially open.
      */
-    readonly sideOffset: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    readonly defaultOpen: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     /**
-     * @description The preferred alignment against the trigger. May change when collisions occur.
-     * @default center
+     * ID of the trigger associated with a controlled popover.
      */
-    readonly align: _angular_core.InputSignal<RdxPositionAlign>;
+    readonly triggerId: _angular_core.ModelSignal<string | null>;
     /**
-     * @description An offset in pixels from the "start" or "end" alignment options.
-     * @default undefined
+     * ID of the trigger associated with an initially open uncontrolled popover.
      */
-    readonly alignOffset: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    readonly defaultTriggerId: _angular_core.InputSignal<string | null>;
+    /**
+     * Determines whether the popover blocks outside interaction or only traps focus.
+     */
+    readonly modal: _angular_core.InputSignalWithTransform<RdxPopoverModal, BooleanInput>;
+    /**
+     * Associates this root with detached trigger elements.
+     */
+    readonly handle: _angular_core.InputSignal<RdxPopoverHandle<any> | undefined>;
+    readonly contentId: string;
+    readonly descriptionId: _angular_core.WritableSignal<string | undefined>;
+    readonly titleId: _angular_core.WritableSignal<string | undefined>;
+    readonly trigger: _angular_core.WritableSignal<HTMLElement | undefined>;
+    readonly triggers: _angular_core.WritableSignal<HTMLElement[]>;
+    readonly payload: _angular_core.WritableSignal<unknown>;
+    readonly isPointerDownOnTrigger: _angular_core.WritableSignal<boolean>;
+    readonly popupCloseCount: _angular_core.WritableSignal<number>;
+    readonly onOpenChange: _angular_core.OutputEmitterRef<RdxPopoverOpenChange>;
+    readonly onOpenChangeComplete: _angular_core.OutputEmitterRef<boolean>;
+    private readonly registeredTriggers;
+    private readonly viewportTriggerChange;
+    readonly state: Signal<"open" | "closed">;
+    constructor();
+    show(trigger?: HTMLElement | undefined, payload?: unknown, triggerId?: string, reason?: RdxPopoverOpenChangeReason, event?: Event, fromHover?: boolean): void;
+    close(reason?: RdxPopoverOpenChangeReason, event?: Event): void;
+    toggle(triggerId: string, trigger: HTMLElement, payload?: unknown, event?: Event): void;
+    openOnHover(trigger: HTMLElement, payload: unknown, triggerId: string, event: PointerEvent): void;
+    closeOnHover(): void;
+    cancelHoverClose(): void;
+    cancelHoverOpen(): void;
+    setHoverDelays(delay: number, closeDelay: number): void;
+    registerTrigger(id: string, trigger: HTMLElement, payload: () => unknown): () => void;
+    registerViewport(onTriggerChange: (previous: HTMLElement, next: HTMLElement) => void): () => boolean;
+    registerTransitionElement(element: HTMLElement): () => void;
+    private syncTriggerId;
+    private emitOpenChange;
+    private clearHoverTimers;
+    private clearOpenTimer;
+    private clearCloseTimer;
+    private scheduleInstantReset;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPopoverRoot, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopoverRoot, "[rdxPopoverRoot]", ["rdxPopoverRoot"], { "open": { "alias": "open"; "required": false; "isSignal": true; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; "triggerId": { "alias": "triggerId"; "required": false; "isSignal": true; }; "defaultTriggerId": { "alias": "defaultTriggerId"; "required": false; "isSignal": true; }; "modal": { "alias": "modal"; "required": false; "isSignal": true; }; "handle": { "alias": "handle"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "triggerId": "triggerIdChange"; "onOpenChange": "onOpenChange"; "onOpenChangeComplete": "onOpenChangeComplete"; }, never, never, true, [{ directive: typeof i1$1.RdxPopper; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * A button that opens the popover.
+ */
+declare class RdxPopoverTrigger {
+    private readonly parentRootContext;
+    readonly elementRef: ElementRef<HTMLElement>;
+    /**
+     * Associates this trigger with a detached popover root.
+     */
+    readonly handle: _angular_core.InputSignal<RdxPopoverHandle<any> | undefined>;
+    /**
+     * Data associated with this trigger while it is active.
+     */
+    readonly payload: _angular_core.InputSignal<unknown>;
     /**
-     * @description Whether to add some alternate positions of the content.
-     * @default false
+     * ID used to identify this trigger when opening a detached popover imperatively.
      */
-    readonly alternatePositionsDisabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
-    /** @description Whether to prevent `onOverlayEscapeKeyDown` handler from calling. */
-    readonly onOverlayEscapeKeyDownDisabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
-    /** @description Whether to prevent `onOverlayOutsideClick` handler from calling. */
-    readonly onOverlayOutsideClickDisabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly id: _angular_core.InputSignal<string | undefined>;
     /**
-     * @description Event handler called when the escape key is down.
-     * It can be prevented by setting `onOverlayEscapeKeyDownDisabled` input to `true`.
+     * Whether the trigger should ignore user interaction.
      */
-    readonly onOverlayEscapeKeyDown: _angular_core.OutputEmitterRef<KeyboardEvent>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /**
-     * @description Event handler called when a pointer event occurs outside the bounds of the component.
-     * It can be prevented by setting `onOverlayOutsideClickDisabled` input to `true`.
+     * Whether the popover should also open when this trigger is hovered.
      */
-    readonly onOverlayOutsideClick: _angular_core.OutputEmitterRef<MouseEvent>;
+    readonly openOnHover: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /**
-     * @description Event handler called after the overlay is open
+     * How long to wait before opening the popover on hover, in milliseconds.
      */
-    readonly onOpen: _angular_core.OutputEmitterRef<void>;
+    readonly delay: _angular_core.InputSignalWithTransform<number, NumberInput>;
     /**
-     * @description Event handler called after the overlay is closed
+     * How long to wait before closing a hover-opened popover, in milliseconds.
      */
-    readonly onClosed: _angular_core.OutputEmitterRef<void>;
-    /** @ingore */
-    readonly positions: _angular_core.Signal<i1.ConnectedPosition[]>;
+    readonly closeDelay: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    protected readonly triggerId: _angular_core.Signal<string>;
+    protected readonly rootContext: _angular_core.Signal<_radix_ng_primitives_popover.RdxPopoverRootContext | null>;
+    protected readonly isOpen: _angular_core.Signal<boolean>;
+    protected readonly isPressed: _angular_core.Signal<boolean>;
+    private readonly generatedId;
     constructor();
-    /** @ignore */
-    ngOnInit(): void;
-    /** @ignore */
-    open(): void;
-    /** @ignore */
-    close(): void;
-    /** @ignore */
-    positionChange(): rxjs.Observable<i1.ConnectedOverlayPositionChange>;
-    /** @ignore */
-    private connectKeydownEscape;
-    /** @ignore */
-    private connectOutsideClick;
-    /** @ignore */
-    private onAttach;
-    /** @ignore */
-    private onDetach;
-    /** @ignore */
-    private setScrollStrategy;
-    /** @ignore */
-    private setHasBackdrop;
-    /** @ignore */
-    private setDisableClose;
-    /** @ignore */
-    private setOrigin;
-    /** @ignore */
-    private setPositions;
-    /** @ignore */
-    private computePositions;
-    private onOriginChangeEffect;
-    /** @ignore */
-    private onPositionChangeEffect;
-    /** @ignore */
-    private fireOverlayNgOnChanges;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPopoverContentDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopoverContentDirective, "[rdxPopoverContent]", never, { "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; }; "alternatePositionsDisabled": { "alias": "alternatePositionsDisabled"; "required": false; "isSignal": true; }; "onOverlayEscapeKeyDownDisabled": { "alias": "onOverlayEscapeKeyDownDisabled"; "required": false; "isSignal": true; }; "onOverlayOutsideClickDisabled": { "alias": "onOverlayOutsideClickDisabled"; "required": false; "isSignal": true; }; }, { "onOverlayEscapeKeyDown": "onOverlayEscapeKeyDown"; "onOverlayOutsideClick": "onOverlayOutsideClick"; "onOpen": "onOpen"; "onClosed": "onClosed"; }, never, never, true, [{ directive: typeof i1.CdkConnectedOverlay; inputs: {}; outputs: {}; }]>;
+    protected handleClick(event: MouseEvent): void;
+    protected handlePointerEnter(event: PointerEvent): void;
+    protected handlePointerLeave(event: PointerEvent): void;
+    protected handlePointerDown(): 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: {}; }]>;
 }
 
-declare class RdxPopoverTriggerDirective {
-    /** @ignore */
-    protected readonly popoverRoot: _radix_ng_primitives_popover.RdxPopoverRootDirective;
-    /** @ignore */
-    readonly elementRef: ElementRef<HTMLElement>;
-    /** @ignore */
-    readonly overlayOrigin: CdkOverlayOrigin;
-    /** @ignore */
-    readonly name: _angular_core.Signal<string>;
-    /** @ignore */
-    protected click(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPopoverTriggerDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopoverTriggerDirective, "[rdxPopoverTrigger]", never, {}, {}, never, never, true, [{ directive: typeof i1.CdkOverlayOrigin; 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: {}; }]>;
 }
 
-type EventType = 'cdkOverlayOutsideClick' | 'cdkOverlayEscapeKeyDown';
-type EventTypeCapitalized<R extends EventType = EventType> = Capitalize<R>;
-type EventTypeAsPrimitiveConfigKey<R extends EventType = EventType> = `prevent${EventTypeCapitalized<R>}`;
-type PrimitiveConfig = {
-    [value in EventTypeAsPrimitiveConfigKey]?: boolean;
-};
-type PrimitiveConfigs = Map<object, PrimitiveConfig>;
-
-declare class RdxPopoverAnchorDirective {
-    /**
-     * @ignore
-     * If outside the root then null, otherwise the root directive - with optional `true` passed in as the first param.
-     * If outside the root and non-null value that means the html structure is wrong - popover inside popover.
-     * */
-    protected popoverRoot: RdxPopoverRootDirective | null;
-    /** @ignore */
-    readonly elementRef: ElementRef<any>;
-    /** @ignore */
-    readonly overlayOrigin: CdkOverlayOrigin;
-    /** @ignore */
-    readonly document: Document;
-    /** @ignore */
-    readonly name: _angular_core.Signal<string>;
-    /** @ignore */
-    click(): void;
-    /** @ignore */
-    setPopoverRoot(popoverRoot: RdxPopoverRootDirective): void;
-    private emitOutsideClick;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPopoverAnchorDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopoverAnchorDirective, "[rdxPopoverAnchor]", ["rdxPopoverAnchor"], {}, {}, never, never, true, [{ directive: typeof i1.CdkOverlayOrigin; inputs: {}; outputs: {}; }]>;
+/**
+ * An optional backdrop rendered behind the popup.
+ */
+declare class RdxPopoverBackdrop {
+    protected readonly rootContext: _radix_ng_primitives_popover.RdxPopoverRootContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPopoverBackdrop, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopoverBackdrop, "[rdxPopoverBackdrop]", never, {}, {}, never, never, true, never>;
 }
 
-declare enum RdxPopoverState {
-    OPEN = "open",
-    CLOSED = "closed"
-}
-declare enum RdxPopoverAttachDetachEvent {
-    ATTACH = "attach",
-    DETACH = "detach"
-}
-declare enum RdxPopoverAnimationStatus {
-    OPEN_STARTED = "open_started",
-    OPEN_ENDED = "open_ended",
-    CLOSED_STARTED = "closed_started",
-    CLOSED_ENDED = "closed_ended"
+/**
+ * Positions the popover against its trigger.
+ */
+declare class RdxPopoverPositioner {
+    protected readonly rootContext: _radix_ng_primitives_popover.RdxPopoverRootContext;
+    protected readonly wrapper: RdxPopperContentWrapper;
+    private readonly elementRef;
+    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: {}; }]>;
 }
 
-declare class RdxPopoverRootDirective {
-    /** @ignore */
-    readonly uniqueId: _angular_core.WritableSignal<number>;
-    /** @ignore */
-    readonly name: _angular_core.Signal<string>;
+/**
+ * A container for the popover contents.
+ */
+declare class RdxPopoverPopup {
+    protected readonly rootContext: _radix_ng_primitives_popover.RdxPopoverRootContext;
+    private readonly dismissableLayer;
+    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;
     /**
-     * @description The anchor directive that comes form outside the popover root
-     * @default undefined
+     * Event handler called when the escape key is down. Can be prevented.
      */
-    readonly anchor: _angular_core.InputSignal<RdxPopoverAnchorDirective | undefined>;
+    readonly escapeKeyDown: _angular_core.OutputRef<KeyboardEvent>;
     /**
-     * @description The open state of the popover when it is initially rendered. Use when you do not need to control its open state.
-     * @default false
+     * Event handler called when a pointerdown event happens outside of the popup. Can be prevented.
      */
-    readonly defaultOpen: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly pointerDownOutside: _angular_core.OutputRef<PointerEvent>;
     /**
-     * @description The controlled state of the popover. `open` input take precedence of `defaultOpen` input.
-     * @default undefined
-     */
-    readonly open: _angular_core.InputSignalWithTransform<boolean | undefined, BooleanInput>;
-    /**
-     * @description Whether to control the state of the popover from external. Use in conjunction with `open` input.
-     * @default undefined
-     */
-    readonly externalControl: _angular_core.InputSignalWithTransform<boolean | undefined, BooleanInput>;
-    /**
-     * @description Whether to take into account CSS opening/closing animations.
-     * @default false
-     */
-    readonly cssAnimation: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
-    /**
-     * @description Whether to take into account CSS opening animations. `cssAnimation` input must be set to 'true'
-     * @default false
-     */
-    readonly cssOpeningAnimation: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
-    /**
-     * @description Whether to take into account CSS closing animations. `cssAnimation` input must be set to 'true'
-     * @default false
-     */
-    readonly cssClosingAnimation: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
-    /** @ignore */
-    readonly cssAnimationStatus: _angular_core.WritableSignal<RdxPopoverAnimationStatus | null>;
-    /** @ignore */
-    readonly popoverContentDirective: _angular_core.Signal<RdxPopoverContentDirective>;
-    /** @ignore */
-    readonly popoverTriggerDirective: _angular_core.Signal<RdxPopoverTriggerDirective>;
-    /** @ignore */
-    readonly popoverArrowDirective: _angular_core.Signal<_radix_ng_primitives_popover.RdxPopoverArrowDirective | undefined>;
-    /** @ignore */
-    readonly popoverCloseDirective: _angular_core.Signal<_radix_ng_primitives_popover.RdxPopoverCloseDirective | undefined>;
-    /** @ignore */
-    readonly popoverContentAttributesComponent: _angular_core.Signal<_radix_ng_primitives_popover.RdxPopoverContentAttributesComponent | undefined>;
-    /** @ignore */
-    private readonly internalPopoverAnchorDirective;
-    /** @ignore */
-    readonly viewContainerRef: ViewContainerRef;
-    /** @ignore */
-    readonly rdxCdkEventService: {
-        document: Document;
-        destroyRef: DestroyRef;
-        ngZone: _angular_core.NgZone;
-        renderer2: _angular_core.Renderer2;
-        window: Window & typeof globalThis;
-        primitiveConfigs?: PrimitiveConfigs;
-        onDestroyCallbacks: Set<() => void>;
-        #clickDomRootEventCallbacks: Set<(event: MouseEvent) => void>;
-        registerPrimitive<T extends object>(primitiveInstance: T): void;
-        deregisterPrimitive<T extends object>(primitiveInstance: T): void;
-        preventPrimitiveFromCdkEvent<T extends object>(primitiveInstance: T, eventType: EventType): void;
-        allowPrimitiveForCdkEvent<T extends object>(primitiveInstance: T, eventType: EventType): void;
-        preventPrimitiveFromCdkMultiEvents<T extends object>(primitiveInstance: T, eventTypes: EventType[]): void;
-        allowPrimitiveForCdkMultiEvents<T extends object>(primitiveInstance: T, eventTypes: EventType[]): void;
-        setPreventPrimitiveFromCdkMixEvents<T extends object>(primitiveInstance: T, eventTypes: PrimitiveConfig): void;
-        primitivePreventedFromCdkEvent<T extends object>(primitiveInstance: T, eventType: EventType): boolean | undefined;
-        addClickDomRootEventCallback(callback: (event: MouseEvent) => void): void;
-        removeClickDomRootEventCallback(callback: (event: MouseEvent) => void): boolean;
-        #setPreventPrimitiveFromCdkEvent<T extends object, R extends EventType, K extends PrimitiveConfig[`prevent${Capitalize<R>}`]>(primitiveInstance: T, eventType: R, value: K): void;
-        #registerOnDestroyCallbacks(): void;
-        #listenToClickDomRootEvent(): void;
-    } | null;
-    /** @ignore */
-    readonly destroyRef: DestroyRef;
-    /** @ignore */
-    readonly state: _angular_core.WritableSignal<RdxPopoverState>;
-    /** @ignore */
-    readonly attachDetachEvent: _angular_core.WritableSignal<RdxPopoverAttachDetachEvent>;
-    /** @ignore */
-    private readonly isFirstDefaultOpen;
-    /** @ignore */
-    readonly popoverAnchorDirective: _angular_core.Signal<RdxPopoverAnchorDirective | undefined>;
+     * 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.
+     */
+    readonly openAutoFocus: _angular_core.OutputRef<Event>;
+    /**
+     * Event handler called before focus returns after the popup is removed. Can be prevented.
+     */
+    readonly closeAutoFocus: _angular_core.OutputRef<Event>;
     constructor();
-    /** @ignore */
-    getAnimationParamsSnapshot(): {
-        cssAnimation: boolean;
-        cssOpeningAnimation: boolean;
-        cssClosingAnimation: boolean;
-        cssAnimationStatus: RdxPopoverAnimationStatus | null;
-        attachDetachEvent: RdxPopoverAttachDetachEvent;
-        state: RdxPopoverState;
-        canEmitOnOpenOrOnClosed: boolean;
-    };
-    /** @ignore */
-    controlledExternally(): _angular_core.InputSignalWithTransform<boolean | undefined, BooleanInput>;
-    /** @ignore */
-    firstDefaultOpen(): boolean;
-    /** @ignore */
-    handleOpen(): void;
-    /** @ignore */
-    handleClose(): void;
-    /** @ignore */
-    handleToggle(): void;
-    /** @ignore */
-    isOpen(state?: RdxPopoverState): boolean;
-    /** @ignore */
-    private setState;
-    /** @ignore */
-    private openContent;
-    /** @ignore */
-    private closeContent;
-    /** @ignore */
-    private emitOnOpen;
-    /** @ignore */
-    private emitOnClosed;
-    /** @ignore */
-    private ifOpenOrCloseWithoutAnimations;
-    /** @ignore */
-    private ifOpenOrCloseWithAnimations;
-    /** @ignore */
-    private openOrClose;
-    /** @ignore */
-    private emitOnOpenOrOnClosed;
-    /** @ignore */
-    private canEmitOnOpenOrOnClosed;
-    /** @ignore */
-    private onStateChangeEffect;
-    /** @ignore */
-    private onCssAnimationStatusChangeChangeEffect;
-    /** @ignore */
-    private emitOpenOrClosedEventEffect;
-    /** @ignore */
-    private onOpenChangeEffect;
-    /** @ignore */
-    private onIsFirstDefaultOpenChangeEffect;
-    /** @ignore */
-    private onAnchorChangeEffect;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPopoverRootDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopoverRootDirective, "[rdxPopoverRoot]", ["rdxPopoverRoot"], { "anchor": { "alias": "anchor"; "required": false; "isSignal": true; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "externalControl": { "alias": "externalControl"; "required": false; "isSignal": true; }; "cssAnimation": { "alias": "cssAnimation"; "required": false; "isSignal": true; }; "cssOpeningAnimation": { "alias": "cssOpeningAnimation"; "required": false; "isSignal": true; }; "cssClosingAnimation": { "alias": "cssClosingAnimation"; "required": false; "isSignal": true; }; }, {}, ["popoverContentDirective", "popoverTriggerDirective", "popoverArrowDirective", "popoverCloseDirective", "popoverContentAttributesComponent", "internalPopoverAnchorDirective"], never, true, never>;
+    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: {}; }]>;
 }
 
-declare class RdxPopoverContentAttributesComponent {
-    /** @ignore */
-    private readonly focusTrapDirective;
-    /** @ignore */
-    private readonly focusInitialDirective;
-    /** @ignore */
-    protected readonly popoverRoot: _radix_ng_primitives_popover.RdxPopoverRootDirective;
-    /** @ignore */
-    readonly name: _angular_core.Signal<string>;
-    /** @ignore */
-    readonly disableAnimation: _angular_core.Signal<boolean>;
+/**
+ * An optional arrow element rendered alongside the popover.
+ */
+declare class RdxPopoverArrow {
+    protected readonly rootContext: _radix_ng_primitives_popover.RdxPopoverRootContext;
+    private readonly wrapper;
+    protected readonly side: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
+    protected readonly align: _angular_core.Signal<"start" | "center" | "end" | undefined>;
+    protected readonly uncentered: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPopoverArrow, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopoverArrow, "[rdxPopoverArrow]", never, {}, {}, never, never, true, [{ directive: typeof i1$1.RdxPopperArrow; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * An accessible title for the popover.
+ */
+declare class RdxPopoverTitle {
+    private readonly rootContext;
+    readonly id: string;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPopoverTitle, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopoverTitle, "[rdxPopoverTitle]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * An accessible description for the popover.
+ */
+declare class RdxPopoverDescription {
+    private readonly rootContext;
+    readonly id: string;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPopoverDescription, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopoverDescription, "[rdxPopoverDescription]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * A button that closes the popover.
+ */
+declare class RdxPopoverClose {
+    protected readonly rootContext: _radix_ng_primitives_popover.RdxPopoverRootContext;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPopoverClose, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopoverClose, "button[rdxPopoverClose]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * A viewport for animating content changes when a popover moves between triggers.
+ *
+ * Render one direct child inside the viewport. It is marked with `data-current`;
+ * when the active trigger changes, a DOM snapshot is retained as `data-previous`
+ * until its CSS animation or transition completes.
+ */
+declare class RdxPopoverViewport {
+    private readonly rootContext;
+    private readonly elementRef;
+    private readonly destroyRef;
+    private previous;
+    private cleanupTimer;
+    private observer;
+    protected readonly activationDirection: _angular_core.WritableSignal<string | undefined>;
+    protected readonly transitioning: _angular_core.WritableSignal<boolean>;
     constructor();
-    /** @ignore */
-    protected onAnimationStart(_: AnimationEvent): void;
-    /** @ignore */
-    protected onAnimationEnd(_: AnimationEvent): void;
-    /** @ignore */
-    private canAnimate;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPopoverContentAttributesComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RdxPopoverContentAttributesComponent, "[rdxPopoverContentAttributes]", never, {}, {}, ["focusInitialDirective"], ["*"], true, [{ directive: typeof i1$1.CdkTrapFocus; inputs: {}; outputs: {}; }]>;
+    private startTransition;
+    private markCurrent;
+    private current;
+    private scheduleCleanup;
+    private cleanupPrevious;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPopoverViewport, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopoverViewport, "[rdxPopoverViewport]", never, {}, {}, never, never, true, never>;
 }
 
+declare const popoverImports: (typeof RdxPopoverPortalPresence)[];
 declare class RdxPopoverModule {
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPopoverModule, never>;
-    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<RdxPopoverModule, never, [typeof RdxPopoverArrowDirective, typeof RdxPopoverCloseDirective, typeof RdxPopoverContentDirective, typeof RdxPopoverTriggerDirective, typeof RdxPopoverRootDirective, typeof RdxPopoverAnchorDirective, typeof RdxPopoverContentAttributesComponent], [typeof RdxPopoverArrowDirective, typeof RdxPopoverCloseDirective, typeof RdxPopoverContentDirective, typeof RdxPopoverTriggerDirective, typeof RdxPopoverRootDirective, typeof RdxPopoverAnchorDirective, typeof RdxPopoverContentAttributesComponent]>;
+    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 ɵinj: _angular_core.ɵɵInjectorDeclaration<RdxPopoverModule>;
 }
 
-export { RdxPopoverAnchorDirective, RdxPopoverArrowDirective, RdxPopoverCloseDirective, RdxPopoverContentAttributesComponent, RdxPopoverContentDirective, RdxPopoverModule, RdxPopoverRootDirective, RdxPopoverTriggerDirective };
+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 };