@radix-ng/primitives 0.26.0 → 0.28.0

package/hover-card/src/hover-card-anchor.directive.d.ts

@@ -0,0 +1,28 @@
+import { CdkOverlayOrigin } from '@angular/cdk/overlay';
+import { ElementRef } from '@angular/core';
+import { RdxHoverCardRootDirective } from './hover-card-root.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+export declare class RdxHoverCardAnchorDirective {
+    /**
+     * @ignore
+     * If outside the rootDirective then null, otherwise the rootDirective directive - with optional `true` passed in as the first param.
+     * If outside the rootDirective and non-null value that means the html structure is wrong - hover-card inside hover-card.
+     * */
+    protected rootDirective: RdxHoverCardRootDirective | null;
+    /** @ignore */
+    readonly elementRef: ElementRef<any>;
+    /** @ignore */
+    readonly overlayOrigin: CdkOverlayOrigin;
+    /** @ignore */
+    readonly document: Document;
+    /** @ignore */
+    readonly name: import("@angular/core").Signal<string>;
+    /** @ignore */
+    click(): void;
+    /** @ignore */
+    setRoot(root: RdxHoverCardRootDirective): void;
+    private emitOutsideClick;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxHoverCardAnchorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxHoverCardAnchorDirective, "[rdxHoverCardAnchor]", ["rdxHoverCardAnchor"], {}, {}, never, never, true, [{ directive: typeof i1.CdkOverlayOrigin; inputs: {}; outputs: {}; }]>;
+}

package/hover-card/src/hover-card-anchor.token.d.ts

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+import { RdxHoverCardAnchorDirective } from './hover-card-anchor.directive';
+export declare const RdxHoverCardAnchorToken: InjectionToken<RdxHoverCardAnchorDirective>;

package/hover-card/src/hover-card-arrow.directive.d.ts

@@ -0,0 +1,40 @@
+import { NumberInput } from '@angular/cdk/coercion';
+import { ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class RdxHoverCardArrowDirective {
+    /** @ignore */
+    private readonly renderer;
+    /** @ignore */
+    private readonly rootDirective;
+    /** @ignore */
+    readonly elementRef: ElementRef<any>;
+    /**
+     * @description The width of the arrow in pixels.
+     * @default 10
+     */
+    readonly width: import("@angular/core").InputSignalWithTransform<number, NumberInput>;
+    /**
+     * @description The height of the arrow in pixels.
+     * @default 5
+     */
+    readonly height: import("@angular/core").InputSignalWithTransform<number, NumberInput>;
+    /** @ignore */
+    readonly arrowSvgElement: import("@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: i0.ɵɵFactoryDeclaration<RdxHoverCardArrowDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxHoverCardArrowDirective, "[rdxHoverCardArrow]", never, { "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/hover-card/src/hover-card-arrow.token.d.ts

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+import { RdxHoverCardArrowDirective } from './hover-card-arrow.directive';
+export declare const RdxHoverCardArrowToken: InjectionToken<RdxHoverCardArrowDirective>;

package/hover-card/src/hover-card-close.directive.d.ts

@@ -0,0 +1,18 @@
+import { ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * TODO: to be removed? But it seems to be useful when controlled from outside
+ */
+export declare class RdxHoverCardCloseDirective {
+    /** @ignore */
+    protected readonly rootDirective: import("@radix-ng/primitives/hover-card").RdxHoverCardRootDirective;
+    /** @ignore */
+    readonly elementRef: ElementRef<any>;
+    /** @ignore */
+    private readonly renderer;
+    constructor();
+    /** @ignore */
+    private onIsControlledExternallyEffect;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxHoverCardCloseDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxHoverCardCloseDirective, "[rdxHoverCardClose]", never, {}, {}, never, never, true, never>;
+}

package/hover-card/src/hover-card-close.token.d.ts

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+import { RdxHoverCardCloseDirective } from './hover-card-close.directive';
+export declare const RdxHoverCardCloseToken: InjectionToken<RdxHoverCardCloseDirective>;

package/hover-card/src/hover-card-content-attributes.component.d.ts

@@ -0,0 +1,25 @@
+import * as i0 from "@angular/core";
+export declare class RdxHoverCardContentAttributesComponent {
+    /** @ignore */
+    protected readonly rootDirective: import("@radix-ng/primitives/hover-card").RdxHoverCardRootDirective;
+    /** @ignore */
+    readonly name: import("@angular/core").Signal<string>;
+    /** @ignore */
+    readonly disableAnimation: import("@angular/core").Signal<boolean>;
+    /** @ignore */
+    protected onAnimationStart(_: AnimationEvent): void;
+    /** @ignore */
+    protected onAnimationEnd(_: AnimationEvent): void;
+    /** @ignore */
+    protected pointerenter(): void;
+    /** @ignore */
+    protected pointerleave(): void;
+    /** @ignore */
+    protected focus(): void;
+    /** @ignore */
+    protected blur(): void;
+    /** @ignore */
+    private canAnimate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxHoverCardContentAttributesComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RdxHoverCardContentAttributesComponent, "[rdxHoverCardContentAttributes]", never, {}, {}, never, ["*"], true, never>;
+}

package/hover-card/src/hover-card-content-attributes.token.d.ts

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+import { RdxHoverCardContentAttributesComponent } from './hover-card-content-attributes.component';
+export declare const RdxHoverCardContentAttributesToken: InjectionToken<RdxHoverCardContentAttributesComponent>;

package/hover-card/src/hover-card-content.directive.d.ts

@@ -0,0 +1,104 @@
+import { BooleanInput, NumberInput } from '@angular/cdk/coercion';
+import { OnInit } from '@angular/core';
+import { RdxPositionAlign, RdxPositionSide } from '@radix-ng/primitives/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+export declare class RdxHoverCardContentDirective implements OnInit {
+    /** @ignore */
+    private readonly rootDirective;
+    /** @ignore */
+    private readonly templateRef;
+    /** @ignore */
+    private readonly overlay;
+    /** @ignore */
+    private readonly destroyRef;
+    /** @ignore */
+    private readonly connectedOverlay;
+    /** @ignore */
+    readonly name: import("@angular/core").Signal<string>;
+    /**
+     * @description The preferred side of the trigger to render against when open. Will be reversed when collisions occur and avoidCollisions is enabled.
+     * @default top
+     */
+    readonly side: import("@angular/core").InputSignal<RdxPositionSide>;
+    /**
+     * @description The distance in pixels from the trigger.
+     * @default undefined
+     */
+    readonly sideOffset: import("@angular/core").InputSignalWithTransform<number, NumberInput>;
+    /**
+     * @description The preferred alignment against the trigger. May change when collisions occur.
+     * @default center
+     */
+    readonly align: import("@angular/core").InputSignal<RdxPositionAlign>;
+    /**
+     * @description An offset in pixels from the "start" or "end" alignment options.
+     * @default undefined
+     */
+    readonly alignOffset: import("@angular/core").InputSignalWithTransform<number, NumberInput>;
+    /**
+     * @description Whether to add some alternate positions of the content.
+     * @default false
+     */
+    readonly alternatePositionsDisabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /** @description Whether to prevent `onOverlayEscapeKeyDown` handler from calling. */
+    readonly onOverlayEscapeKeyDownDisabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /** @description Whether to prevent `onOverlayOutsideClick` handler from calling. */
+    readonly onOverlayOutsideClickDisabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * @description Event handler called when the escape key is down.
+     * It can be prevented by setting `onOverlayEscapeKeyDownDisabled` input to `true`.
+     */
+    readonly onOverlayEscapeKeyDown: import("@angular/core").OutputEmitterRef<KeyboardEvent>;
+    /**
+     * @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`.
+     */
+    readonly onOverlayOutsideClick: import("@angular/core").OutputEmitterRef<MouseEvent>;
+    /**
+     * @description Event handler called after the overlay is open
+     */
+    readonly onOpen: import("@angular/core").OutputEmitterRef<void>;
+    /**
+     * @description Event handler called after the overlay is closed
+     */
+    readonly onClosed: import("@angular/core").OutputEmitterRef<void>;
+    /** @ingore */
+    readonly positions: import("@angular/core").Signal<import("@angular/cdk/overlay").ConnectedPosition[]>;
+    constructor();
+    /** @ignore */
+    ngOnInit(): void;
+    /** @ignore */
+    open(): void;
+    /** @ignore */
+    close(): void;
+    /** @ignore */
+    positionChange(): import("rxjs").Observable<import("@angular/cdk/overlay").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: i0.ɵɵFactoryDeclaration<RdxHoverCardContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxHoverCardContentDirective, "[rdxHoverCardContent]", 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: {}; }]>;
+}

package/hover-card/src/hover-card-root.directive.d.ts

@@ -0,0 +1,168 @@
+import { BooleanInput, NumberInput } from '@angular/cdk/coercion';
+import { DestroyRef, ViewContainerRef } from '@angular/core';
+import { Subject } from 'rxjs';
+import { RdxHoverCardAnchorDirective } from './hover-card-anchor.directive';
+import { RdxHoverCardContentDirective } from './hover-card-content.directive';
+import { RdxHoverCardTriggerDirective } from './hover-card-trigger.directive';
+import { RdxHoverCardAction, RdxHoverCardAnimationStatus, RdxHoverCardAttachDetachEvent, RdxHoverCardState } from './hover-card.types';
+import * as i0 from "@angular/core";
+export declare class RdxHoverCardRootDirective {
+    /** @ignore */
+    readonly uniqueId: import("@angular/core").WritableSignal<number>;
+    /** @ignore */
+    readonly name: import("@angular/core").Signal<string>;
+    /**
+     * @description The anchor directive that comes form outside the hover-card rootDirective
+     * @default undefined
+     */
+    readonly anchor: import("@angular/core").InputSignal<RdxHoverCardAnchorDirective | undefined>;
+    /**
+     * @description The open state of the hover-card when it is initially rendered. Use when you do not need to control its open state.
+     * @default false
+     */
+    readonly defaultOpen: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * @description The controlled state of the hover-card. `open` input take precedence of `defaultOpen` input.
+     * @default undefined
+     */
+    readonly open: import("@angular/core").InputSignalWithTransform<boolean | undefined, BooleanInput>;
+    /**
+     * To customise the open delay for a specific hover-card.
+     */
+    readonly openDelay: import("@angular/core").InputSignalWithTransform<number, NumberInput>;
+    /**
+     * To customise the close delay for a specific hover-card.
+     */
+    readonly closeDelay: import("@angular/core").InputSignalWithTransform<number, NumberInput>;
+    /**
+     * @description Whether to control the state of the hover-card from external. Use in conjunction with `open` input.
+     * @default undefined
+     */
+    readonly externalControl: import("@angular/core").InputSignalWithTransform<boolean | undefined, BooleanInput>;
+    /**
+     * @description Whether to take into account CSS opening/closing animations.
+     * @default false
+     */
+    readonly cssAnimation: import("@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: import("@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: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /** @ignore */
+    readonly cssAnimationStatus: import("@angular/core").WritableSignal<RdxHoverCardAnimationStatus | null>;
+    /** @ignore */
+    readonly contentDirective: import("@angular/core").Signal<RdxHoverCardContentDirective>;
+    /** @ignore */
+    readonly triggerDirective: import("@angular/core").Signal<RdxHoverCardTriggerDirective>;
+    /** @ignore */
+    readonly arrowDirective: import("@angular/core").Signal<import("@radix-ng/primitives/hover-card").RdxHoverCardArrowDirective | undefined>;
+    /** @ignore */
+    readonly closeDirective: import("@angular/core").Signal<import("@radix-ng/primitives/hover-card").RdxHoverCardCloseDirective | undefined>;
+    /** @ignore */
+    readonly contentAttributesComponent: import("@angular/core").Signal<import("@radix-ng/primitives/hover-card").RdxHoverCardContentAttributesComponent | undefined>;
+    /** @ignore */
+    private readonly internalAnchorDirective;
+    /** @ignore */
+    readonly viewContainerRef: ViewContainerRef;
+    /** @ignore */
+    readonly rdxCdkEventService: {
+        document: Document;
+        destroyRef: DestroyRef;
+        ngZone: import("@angular/core").NgZone;
+        renderer2: import("@angular/core").Renderer2;
+        window: Window & typeof globalThis;
+        primitiveConfigs?: import("./utils/types").PrimitiveConfigs;
+        onDestroyCallbacks: Set<() => void>;
+        "__#5803@#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: import("./utils/types").EventType): void;
+        allowPrimitiveForCdkEvent<T extends object>(primitiveInstance: T, eventType: import("./utils/types").EventType): void;
+        preventPrimitiveFromCdkMultiEvents<T extends object>(primitiveInstance: T, eventTypes: import("./utils/types").EventType[]): void;
+        allowPrimitiveForCdkMultiEvents<T extends object>(primitiveInstance: T, eventTypes: import("./utils/types").EventType[]): void;
+        setPreventPrimitiveFromCdkMixEvents<T extends object>(primitiveInstance: T, eventTypes: import("./utils/types").PrimitiveConfig): void;
+        primitivePreventedFromCdkEvent<T extends object>(primitiveInstance: T, eventType: import("./utils/types").EventType): boolean | undefined;
+        addClickDomRootEventCallback(callback: (event: MouseEvent) => void): void;
+        removeClickDomRootEventCallback(callback: (event: MouseEvent) => void): boolean;
+        "__#5803@#setPreventPrimitiveFromCdkEvent"<T extends object, R extends import("./utils/types").EventType, K extends import("./utils/types").PrimitiveConfig[`prevent${Capitalize<R>}`]>(primitiveInstance: T, eventType: R, value: K): void;
+        "__#5803@#registerOnDestroyCallbacks"(): void;
+        "__#5803@#listenToClickDomRootEvent"(): void;
+    } | null;
+    /** @ignore */
+    readonly destroyRef: DestroyRef;
+    /** @ignore */
+    readonly state: import("@angular/core").WritableSignal<RdxHoverCardState>;
+    /** @ignore */
+    readonly attachDetachEvent: import("@angular/core").WritableSignal<RdxHoverCardAttachDetachEvent>;
+    /** @ignore */
+    private readonly isFirstDefaultOpen;
+    /** @ignore */
+    readonly anchorDirective: import("@angular/core").Signal<RdxHoverCardAnchorDirective | undefined>;
+    /** @ignore */
+    readonly actionSubject$: Subject<RdxHoverCardAction>;
+    constructor();
+    /** @ignore */
+    getAnimationParamsSnapshot(): {
+        cssAnimation: boolean;
+        cssOpeningAnimation: boolean;
+        cssClosingAnimation: boolean;
+        cssAnimationStatus: RdxHoverCardAnimationStatus | null;
+        attachDetachEvent: RdxHoverCardAttachDetachEvent;
+        state: RdxHoverCardState;
+        canEmitOnOpenOrOnClosed: boolean;
+    };
+    /** @ignore */
+    controlledExternally(): import("@angular/core").InputSignalWithTransform<boolean | undefined, BooleanInput>;
+    /** @ignore */
+    firstDefaultOpen(): boolean;
+    /** @ignore */
+    handleOpen(): void;
+    /** @ignore */
+    handleClose(closeButton?: boolean): void;
+    /** @ignore */
+    handleToggle(): void;
+    /** @ignore */
+    isOpen(state?: RdxHoverCardState): 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;
+    /** @ignore */
+    private actionSubscription;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxHoverCardRootDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxHoverCardRootDirective, "[rdxHoverCardRoot]", ["rdxHoverCardRoot"], { "anchor": { "alias": "anchor"; "required": false; "isSignal": true; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "openDelay": { "alias": "openDelay"; "required": false; "isSignal": true; }; "closeDelay": { "alias": "closeDelay"; "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; }; }, {}, ["contentDirective", "triggerDirective", "arrowDirective", "closeDirective", "contentAttributesComponent", "internalAnchorDirective"], never, true, never>;
+}

package/hover-card/src/hover-card-root.inject.d.ts

@@ -0,0 +1,3 @@
+import { RdxHoverCardRootDirective } from './hover-card-root.directive';
+export declare function injectHoverCardRoot(optional?: false): RdxHoverCardRootDirective;
+export declare function injectHoverCardRoot(optional: true): RdxHoverCardRootDirective | null;

package/hover-card/src/hover-card-trigger.directive.d.ts

@@ -0,0 +1,26 @@
+import { CdkOverlayOrigin } from '@angular/cdk/overlay';
+import { ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+export declare class RdxHoverCardTriggerDirective {
+    /** @ignore */
+    protected readonly rootDirective: import("@radix-ng/primitives/hover-card").RdxHoverCardRootDirective;
+    /** @ignore */
+    readonly elementRef: ElementRef<HTMLElement>;
+    /** @ignore */
+    readonly overlayOrigin: CdkOverlayOrigin;
+    /** @ignore */
+    readonly name: import("@angular/core").Signal<string>;
+    /** @ignore */
+    protected pointerenter(): void;
+    /** @ignore */
+    protected pointerleave(): void;
+    /** @ignore */
+    protected focus(): void;
+    /** @ignore */
+    protected blur(): void;
+    /** @ignore */
+    protected click(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxHoverCardTriggerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxHoverCardTriggerDirective, "[rdxHoverCardTrigger]", never, {}, {}, never, never, true, [{ directive: typeof i1.CdkOverlayOrigin; inputs: {}; outputs: {}; }]>;
+}

package/hover-card/src/hover-card.types.d.ts

@@ -0,0 +1,18 @@
+export declare enum RdxHoverCardState {
+    OPEN = "open",
+    CLOSED = "closed"
+}
+export declare enum RdxHoverCardAction {
+    OPEN = "open",
+    CLOSE = "close"
+}
+export declare enum RdxHoverCardAttachDetachEvent {
+    ATTACH = "attach",
+    DETACH = "detach"
+}
+export declare enum RdxHoverCardAnimationStatus {
+    OPEN_STARTED = "open_started",
+    OPEN_ENDED = "open_ended",
+    CLOSED_STARTED = "closed_started",
+    CLOSED_ENDED = "closed_ended"
+}

package/hover-card/src/utils/cdk-event.service.d.ts

@@ -0,0 +1,30 @@
+import { DestroyRef, EnvironmentProviders, NgZone, Provider, Renderer2 } from '@angular/core';
+import { EventType, PrimitiveConfig, PrimitiveConfigs } from './types';
+import * as i0 from "@angular/core";
+declare class RdxCdkEventService {
+    #private;
+    document: Document;
+    destroyRef: DestroyRef;
+    ngZone: NgZone;
+    renderer2: Renderer2;
+    window: Window & typeof globalThis;
+    primitiveConfigs?: PrimitiveConfigs;
+    onDestroyCallbacks: Set<() => void>;
+    constructor();
+    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;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxCdkEventService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RdxCdkEventService>;
+}
+export declare const provideRdxCdkEventServiceInRoot: () => EnvironmentProviders;
+export declare const provideRdxCdkEventService: () => Provider;
+export declare const injectRdxCdkEventService: () => RdxCdkEventService | null;
+export {};

package/hover-card/src/utils/constants.d.ts

@@ -0,0 +1 @@
+export declare const RdxCdkEventServiceWindowKey: unique symbol;

package/hover-card/src/utils/types.d.ts

@@ -0,0 +1,7 @@
+export type EventType = 'cdkOverlayOutsideClick' | 'cdkOverlayEscapeKeyDown';
+export type EventTypeCapitalized<R extends EventType = EventType> = Capitalize<R>;
+export type EventTypeAsPrimitiveConfigKey<R extends EventType = EventType> = `prevent${EventTypeCapitalized<R>}`;
+export type PrimitiveConfig = {
+    [value in EventTypeAsPrimitiveConfigKey]?: boolean;
+};
+export type PrimitiveConfigs = Map<object, PrimitiveConfig>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@radix-ng/primitives",
-  "version": "0.26.0",
+  "version": "0.28.0",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
@@ -75,6 +75,10 @@
       "types": "./dropdown-menu/index.d.ts",
       "default": "./fesm2022/radix-ng-primitives-dropdown-menu.mjs"
     },
+    "./hover-card": {
+      "types": "./hover-card/index.d.ts",
+      "default": "./fesm2022/radix-ng-primitives-hover-card.mjs"
+    },
     "./label": {
       "types": "./label/index.d.ts",
       "default": "./fesm2022/radix-ng-primitives-label.mjs"
@@ -91,6 +95,10 @@
       "types": "./popover/index.d.ts",
       "default": "./fesm2022/radix-ng-primitives-popover.mjs"
     },
+    "./presence": {
+      "types": "./presence/index.d.ts",
+      "default": "./fesm2022/radix-ng-primitives-presence.mjs"
+    },
     "./progress": {
       "types": "./progress/index.d.ts",
       "default": "./fesm2022/radix-ng-primitives-progress.mjs"

package/popover/src/popover-root.directive.d.ts

@@ -70,7 +70,7 @@ export declare class RdxPopoverRootDirective {
         window: Window & typeof globalThis;
         primitiveConfigs?: import("./utils/types").PrimitiveConfigs;
         onDestroyCallbacks: Set<() => void>;
-        "__#6181@#clickDomRootEventCallbacks": Set<(event: MouseEvent) => void>;
+        "__#7452@#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: import("./utils/types").EventType): void;
@@ -81,9 +81,9 @@ export declare class RdxPopoverRootDirective {
         primitivePreventedFromCdkEvent<T extends object>(primitiveInstance: T, eventType: import("./utils/types").EventType): boolean | undefined;
         addClickDomRootEventCallback(callback: (event: MouseEvent) => void): void;
         removeClickDomRootEventCallback(callback: (event: MouseEvent) => void): boolean;
-        "__#6181@#setPreventPrimitiveFromCdkEvent"<T extends object, R extends import("./utils/types").EventType, K extends import("./utils/types").PrimitiveConfig[`prevent${Capitalize<R>}`]>(primitiveInstance: T, eventType: R, value: K): void;
-        "__#6181@#registerOnDestroyCallbacks"(): void;
-        "__#6181@#listenToClickDomRootEvent"(): void;
+        "__#7452@#setPreventPrimitiveFromCdkEvent"<T extends object, R extends import("./utils/types").EventType, K extends import("./utils/types").PrimitiveConfig[`prevent${Capitalize<R>}`]>(primitiveInstance: T, eventType: R, value: K): void;
+        "__#7452@#registerOnDestroyCallbacks"(): void;
+        "__#7452@#listenToClickDomRootEvent"(): void;
     } | null;
     /** @ignore */
     readonly destroyRef: DestroyRef;

package/popover/src/popover-trigger.directive.d.ts

@@ -12,7 +12,7 @@ export declare class RdxPopoverTriggerDirective {
     /** @ignore */
     readonly name: import("@angular/core").Signal<string>;
     /** @ignore */
-    click(): void;
+    protected click(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxPopoverTriggerDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<RdxPopoverTriggerDirective, "[rdxPopoverTrigger]", never, {}, {}, never, never, true, [{ directive: typeof i1.CdkOverlayOrigin; inputs: {}; outputs: {}; }]>;
 }

package/presence/index.d.ts

@@ -0,0 +1,4 @@
+export * from './src/presence';
+export * from './src/transitions/transition.collapse';
+export * from './src/transitions/transition.toast';
+export * from './src/types';

package/presence/src/presence.d.ts

@@ -0,0 +1,42 @@
+import { NgZone } from '@angular/core';
+import { Observable } from 'rxjs';
+import { TransitionOptions, TransitionStartFn } from './types';
+/**
+ * Manages the presence of an element with optional transition animation.
+ *
+ * @template T - The type of the context object used in the transition.
+ * @param {NgZone} zone - The Angular zone to control the change detection context.
+ * @param {HTMLElement} element - The target HTML element to apply the transition.
+ * @param {TransitionOptions<T>} options - Options for controlling the transition behavior.
+ *   @param {T} [options.context] - An optional context object to pass through the transition.
+ *   @param {boolean} options.animation - A flag indicating if the transition should be animated.
+ *   @param {'start' | 'continue' | 'stop'} options.state - The desired state of the transition.
+ * @param {TransitionStartFn<T>} startFn - A function to start the transition.
+ * @returns {Observable<void>} - An observable that emits when the transition completes.
+ *
+ * The `usePresence` function is designed to manage the presence and visibility of an HTML element,
+ * optionally applying a transition animation. It utilizes Angular's NgZone for efficient change
+ * detection management and allows for different states of transitions ('start', 'continue', 'stop').
+ * The function takes a start function to handle the beginning of the transition and returns an
+ * observable that completes when the transition ends.
+ *
+ * Example usage:
+ *
+ * const options: TransitionOptions<MyContext> = {
+ *   context: {}, // your context object
+ *   animation: true,
+ *   state: 'start'
+ * };
+ *
+ * const startFn: TransitionStartFn<MyContext> = (el, animation, context) => {
+ *   el.classList.add('active');
+ *   return () => el.classList.remove('active');
+ * };
+ *
+ * usePresence(zone, element, startFn, options).subscribe(() => {
+ *   console.log('Transition completed');
+ * });
+ */
+declare const usePresence: <T>(zone: NgZone, element: HTMLElement, startFn: TransitionStartFn<T>, options: TransitionOptions<T>) => Observable<void>;
+declare const completeTransition: (element: HTMLElement) => void;
+export { completeTransition, usePresence };

package/presence/src/transitions/transition.collapse.d.ts

@@ -0,0 +1,15 @@
+import { TransitionStartFn } from '../types';
+export type CollapseContext = {
+    direction: 'show' | 'hide';
+    dimension: 'width' | 'height';
+    maxSize?: string;
+};
+/**
+ * Function to handle the start of a collapsing transition.
+ *
+ * @param element - The HTML element to animate.
+ * @param animation - Whether to use animation or not.
+ * @param context - The context containing direction and dimension information.
+ * @returns A function to clean up the animation.
+ */
+export declare const transitionCollapsing: TransitionStartFn<CollapseContext>;

package/presence/src/transitions/transition.toast.d.ts

@@ -0,0 +1,3 @@
+import { TransitionStartFn } from '../types';
+export declare const toastFadeInTransition: TransitionStartFn;
+export declare const toastFadeOutTransition: TransitionStartFn;