@radix-ng/primitives 0.50.0 → 1.0.0-beta.0

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

@@ -0,0 +1,416 @@
+import * as _angular_core from '@angular/core';
+import { Signal, ElementRef } from '@angular/core';
+import * as i1 from '@radix-ng/primitives/presence';
+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 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';
+
+/**
+ * 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 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>;
+
+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: (optional?: boolean) => RdxPopoverRootContext | null;
+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;
+    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>;
+    /**
+     * Whether the popover is currently open.
+     */
+    readonly open: _angular_core.ModelSignal<boolean>;
+    /**
+     * Whether the popover is initially open.
+     */
+    readonly defaultOpen: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * ID of the trigger associated with a controlled popover.
+     */
+    readonly triggerId: _angular_core.ModelSignal<string | null>;
+    /**
+     * ID of the trigger associated with an initially open uncontrolled popover.
+     */
+    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>;
+    /**
+     * ID used to identify this trigger when opening a detached popover imperatively.
+     */
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Whether the trigger should ignore user interaction.
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether the popover should also open when this trigger is hovered.
+     */
+    readonly openOnHover: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * How long to wait before opening the popover on hover, in milliseconds.
+     */
+    readonly delay: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * How long to wait before closing a hover-opened popover, in milliseconds.
+     */
+    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();
+    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: {}; }]>;
+}
+
+/**
+ * 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;
+    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.
+ */
+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: {}; }]>;
+}
+
+/**
+ * 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;
+    /**
+     * 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.
+     */
+    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();
+    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: {}; }]>;
+}
+
+/**
+ * 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();
+    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 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 { 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 };

package/{popper/index.d.ts → types/radix-ng-primitives-popper.d.ts}

@@ -1,7 +1,7 @@
 import * as _angular_core from '@angular/core';
-import { ElementRef } from '@angular/core';
-import { NumberInput, BooleanInput } from '@angular/cdk/coercion';
-import { Middleware, Placement } from '@floating-ui/dom';
+import { ElementRef, InjectionToken, Provider } from '@angular/core';
+import { ReferenceElement, Placement, Middleware, VirtualElement } from '@floating-ui/dom';
+import { NumberInput, BooleanInput } from '@radix-ng/primitives/core';
 
 declare class RdxPopperAnchor {
     readonly elementRef: ElementRef<HTMLElement>;
@@ -10,7 +10,8 @@ declare class RdxPopperAnchor {
 }
 
 declare class RdxPopper {
-    readonly anchor: _angular_core.Signal<RdxPopperAnchor>;
+    readonly anchor: _angular_core.Signal<RdxPopperAnchor | undefined>;
+    readonly anchorOverride: _angular_core.WritableSignal<ReferenceElement | undefined>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPopper, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopper, "[rdxPopperRoot]", never, {}, {}, ["anchor"], never, true, never>;
 }
@@ -23,6 +24,7 @@ declare class RdxPopperContent {
         arrowY: _angular_core.Signal<number | undefined>;
         shouldHideArrow: _angular_core.Signal<boolean>;
         isPositioned: _angular_core.Signal<boolean>;
+        anchorHidden: _angular_core.Signal<boolean>;
     };
     /**
      * if the PopperContent hasn't been placed yet (not all measurements done)
@@ -46,6 +48,7 @@ declare function transformOrigin(options: {
 }): Middleware;
 declare function getSideAndAlignFromPlacement(placement: Placement): readonly ["top" | "right" | "bottom" | "left", "start" | "center" | "end"];
 
+type RdxPopperAnchorElement = Element | ElementRef<Element> | VirtualElement | (() => Element | VirtualElement | null) | null | undefined;
 declare const context: () => {
     placedSide: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
     placedAlign: _angular_core.Signal<"start" | "center" | "end" | undefined>;
@@ -53,6 +56,7 @@ declare const context: () => {
     arrowY: _angular_core.Signal<number | undefined>;
     shouldHideArrow: _angular_core.Signal<boolean>;
     isPositioned: _angular_core.Signal<boolean>;
+    anchorHidden: _angular_core.Signal<boolean>;
 };
 type PopperContentWrapperContext = ReturnType<typeof context>;
 declare const injectPopperContentWrapperContext: (optional?: boolean) => {
@@ -62,6 +66,7 @@ declare const injectPopperContentWrapperContext: (optional?: boolean) => {
     arrowY: _angular_core.Signal<number | undefined>;
     shouldHideArrow: _angular_core.Signal<boolean>;
     isPositioned: _angular_core.Signal<boolean>;
+    anchorHidden: _angular_core.Signal<boolean>;
 } | null;
 declare const providePopperContentWrapperContext: (useFactory: () => {
     placedSide: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
@@ -70,13 +75,19 @@ declare const providePopperContentWrapperContext: (useFactory: () => {
     arrowY: _angular_core.Signal<number | undefined>;
     shouldHideArrow: _angular_core.Signal<boolean>;
     isPositioned: _angular_core.Signal<boolean>;
+    anchorHidden: _angular_core.Signal<boolean>;
 }) => _angular_core.Provider;
 declare class RdxPopperContentWrapper {
     private readonly elementRef;
-    private readonly destroyRef;
     private readonly injector;
     private readonly context;
     private readonly isBrowser;
+    /** Optional positioning defaults provided by a composing primitive (e.g. tooltip). */
+    private readonly config;
+    /**
+     * An element to position the popup against. Defaults to the popper anchor.
+     */
+    readonly anchor: _angular_core.InputSignal<RdxPopperAnchorElement>;
     /**
      * The preferred side of the anchor to render against when open.
      * Will be reversed when collisions occur and avoidCollisions is enabled.
@@ -134,13 +145,17 @@ declare class RdxPopperContentWrapper {
     readonly placed: _angular_core.OutputEmitterRef<void>;
     readonly arrow: _angular_core.Signal<any>;
     readonly shouldHideArrow: _angular_core.Signal<boolean>;
+    /** Whether the arrow could not be centered on the anchor because the popup was shifted. */
+    readonly arrowUncentered: _angular_core.Signal<boolean>;
     readonly arrowX: _angular_core.Signal<number | undefined>;
     readonly arrowY: _angular_core.Signal<number | undefined>;
+    readonly anchorHidden: _angular_core.Signal<boolean>;
     private readonly desiredPlacement;
     private readonly arrowSize;
     private readonly boundary;
     private readonly hasExplicitBoundaries;
     private readonly detectOverflowOptions;
+    private readonly resolvedAnchor;
     private readonly position;
     /**
      * Whether the panel is positioned.
@@ -173,10 +188,13 @@ declare class RdxPopperContentWrapper {
         top: string;
         left: string;
         '--radix-popper-transform-origin': string;
+        '--radix-popper-content-wrapper-width': string;
+        '--radix-popper-content-wrapper-height': string;
     }>;
-    private readonly afterNextRender;
+    private readonly afterRenderEffect;
+    constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPopperContentWrapper, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopperContentWrapper, "[rdxPopperContentWrapper]", 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; }; "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", "contentElementRef"], never, true, never>;
 }
 
 declare class RdxPopperArrow {
@@ -200,7 +218,30 @@ declare class RdxPopperArrow {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopperArrow, "[rdxPopperArrow]", never, { "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
+/**
+ * Default positioning values for `RdxPopperContentWrapper`.
+ *
+ * Lets a composing primitive (e.g. tooltip) provide its own Base UI-aligned defaults without
+ * changing the shared popper defaults that other consumers (e.g. popover) rely on. Any value left
+ * `undefined` falls back to the wrapper's built-in default. Consumer template bindings always win.
+ */
+interface RdxPopperContentConfig {
+    side?: Side;
+    align?: Align;
+    sideOffset?: number;
+    alignOffset?: number;
+    arrowPadding?: number;
+    avoidCollisions?: boolean;
+    collisionPadding?: number | Partial<Record<Side, number>>;
+    sticky?: 'partial' | 'always';
+    hideWhenDetached?: boolean;
+    positionStrategy?: 'fixed' | 'absolute';
+    updatePositionStrategy?: 'optimized' | 'always';
+}
+declare const RdxPopperContentConfigToken: InjectionToken<RdxPopperContentConfig>;
+declare function provideRdxPopperContentConfig(config: RdxPopperContentConfig): Provider;
+
 declare const popperImports: (typeof RdxPopperAnchor | typeof RdxPopper | typeof RdxPopperContent | typeof RdxPopperContentWrapper)[];
 
-export { RdxPopper, RdxPopperAnchor, RdxPopperArrow, RdxPopperContent, RdxPopperContentWrapper, getSideAndAlignFromPlacement, injectPopperContentWrapperContext, isNotNull, popperImports, providePopperContentWrapperContext, transformOrigin };
-export type { Align, PopperContentWrapperContext, Side };
+export { RdxPopper, RdxPopperAnchor, RdxPopperArrow, RdxPopperContent, RdxPopperContentConfigToken, RdxPopperContentWrapper, getSideAndAlignFromPlacement, injectPopperContentWrapperContext, isNotNull, popperImports, providePopperContentWrapperContext, provideRdxPopperContentConfig, transformOrigin };
+export type { Align, PopperContentWrapperContext, RdxPopperAnchorElement, RdxPopperContentConfig, Side };

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

@@ -0,0 +1,30 @@
+import * as _angular_core from '@angular/core';
+import { ElementRef } from '@angular/core';
+
+/**
+ * A target container for the portal. Accepts an `ElementRef`, a native element, or a CSS selector
+ * resolved against the document.
+ */
+type RdxPortalContainer = ElementRef<HTMLElement> | HTMLElement | string;
+declare class RdxPortal {
+    private readonly elementRef;
+    private readonly platformId;
+    private readonly document;
+    private readonly destroyRef;
+    /**
+     * 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>;
+    private readonly _computedContainer;
+    readonly computedContainer: _angular_core.Signal<RdxPortalContainer | undefined>;
+    private readonly elementContainer;
+    constructor();
+    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>;
+}
+
+export { RdxPortal };
+export type { RdxPortalContainer };

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

@@ -0,0 +1,55 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, Signal, Provider } from '@angular/core';
+
+/**
+ * Context interface for RdxPresence directive
+ * Contains a Signal that indicates whether the content should be present in the DOM
+ */
+type RdxPresenceContext = {
+    present: Signal<boolean>;
+};
+declare const RDX_PRESENCE_CONTEXT: InjectionToken<RdxPresenceContext>;
+/**
+ * Factory provider helper.
+ * In your parent component/directive you can write:
+ *
+ *   providers: [
+ *     provideRdxPresenceContext(() => ({ present: myBooleanSignal }))
+ *   ]
+ */
+declare function provideRdxPresenceContext(contextFactory: () => RdxPresenceContext): Provider;
+/**
+ * Headless structural directive that conditionally renders its template based on a reactive
+ * `present` signal supplied through {@link RDX_PRESENCE_CONTEXT}.
+ *
+ * Unlike a plain `*ngIf`, it keeps the content mounted while a CSS exit animation
+ * (`@keyframes` applied for the closed state) is running, and unmounts it only once that
+ * animation finishes. If the content has no exit animation, it unmounts immediately.
+ */
+declare class RdxPresenceDirective {
+    private readonly context;
+    private readonly viewContainerRef;
+    private readonly templateRef;
+    private readonly injector;
+    private readonly isBrowser;
+    private viewRef;
+    private node;
+    private removeListeners;
+    private state;
+    private prevPresent;
+    private prevAnimationName;
+    constructor();
+    /** Decides whether to suspend the unmount for an exit animation (port of Radix' logic). */
+    private evaluateExit;
+    private send;
+    private mountView;
+    private destroyView;
+    private addAnimationListeners;
+    private getComputedStyles;
+    private getAnimationName;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxPresenceDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxPresenceDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+export { RDX_PRESENCE_CONTEXT, RdxPresenceDirective, provideRdxPresenceContext };
+export type { RdxPresenceContext };