@radix-ng/primitives 0.24.0 → 0.26.0

package/tooltip/src/tooltip-content.directive.d.ts

@@ -1,36 +1,104 @@
-import { ConnectedPosition } from '@angular/cdk/overlay';
-import { TemplateRef } from '@angular/core';
-import { RdxTooltipAlign, RdxTooltipSide } from './tooltip.types';
+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";
-export declare class RdxTooltipContentDirective {
+import * as i1 from "@angular/cdk/overlay";
+export declare class RdxTooltipContentDirective implements OnInit {
     /** @ignore */
-    readonly templateRef: TemplateRef<any>;
+    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>;
     /**
-     * The preferred side of the trigger to render against when open. Will be reversed when collisions occur and avoidCollisions is enabled.
+     * @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<RdxTooltipSide>;
+    readonly side: import("@angular/core").InputSignal<RdxPositionSide>;
     /**
-     * The distance in pixels from the trigger.
+     * @description The distance in pixels from the trigger.
+     * @default undefined
      */
-    readonly sideOffset: import("@angular/core").InputSignal<number>;
+    readonly sideOffset: import("@angular/core").InputSignalWithTransform<number, NumberInput>;
     /**
-     * The preferred alignment against the trigger. May change when collisions occur.
+     * @description The preferred alignment against the trigger. May change when collisions occur.
+     * @default center
      */
-    readonly align: import("@angular/core").InputSignal<RdxTooltipAlign>;
+    readonly align: import("@angular/core").InputSignal<RdxPositionAlign>;
     /**
-     * An offset in pixels from the "start" or "end" alignment options.
+     * @description An offset in pixels from the "start" or "end" alignment options.
+     * @default undefined
      */
-    readonly alignOffset: import("@angular/core").InputSignal<number>;
-    /** @ingore */
-    readonly position: import("@angular/core").Signal<ConnectedPosition>;
+    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>;
     /**
-     * Event handler called when the escape key is down. It can be prevented by calling event.preventDefault.
+     * @description Event handler called when the escape key is down.
+     * It can be prevented by setting `onOverlayEscapeKeyDownDisabled` input to `true`.
      */
-    readonly onEscapeKeyDown: import("@angular/core").OutputEmitterRef<KeyboardEvent>;
+    readonly onOverlayEscapeKeyDown: import("@angular/core").OutputEmitterRef<KeyboardEvent>;
     /**
-     * Event handler called when a pointer event occurs outside the bounds of the component. It can be prevented by calling event.preventDefault.
+     * @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 onPointerDownOutside: import("@angular/core").OutputEmitterRef<MouseEvent>;
+    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<RdxTooltipContentDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxTooltipContentDirective, "[rdxTooltipContent]", 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; }; }, { "onEscapeKeyDown": "onEscapeKeyDown"; "onPointerDownOutside": "onPointerDownOutside"; }, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxTooltipContentDirective, "[rdxTooltipContent]", 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/tooltip/src/tooltip-root.directive.d.ts

@@ -1,103 +1,168 @@
-import { ElementRef, InjectionToken, OnInit } from '@angular/core';
-import { RdxTooltipState } from './tooltip.types';
+import { BooleanInput, NumberInput } from '@angular/cdk/coercion';
+import { DestroyRef, ViewContainerRef } from '@angular/core';
+import { Subject } from 'rxjs';
+import { RdxTooltipAnchorDirective } from './tooltip-anchor.directive';
+import { RdxTooltipContentDirective } from './tooltip-content.directive';
+import { RdxTooltipTriggerDirective } from './tooltip-trigger.directive';
+import { RdxTooltipAction, RdxTooltipAnimationStatus, RdxTooltipAttachDetachEvent, RdxTooltipState } from './tooltip.types';
 import * as i0 from "@angular/core";
-export declare const RdxTooltipRootToken: InjectionToken<RdxTooltipRootDirective>;
-export declare function injectTooltipRoot(): RdxTooltipRootDirective;
-export declare class RdxTooltipRootDirective implements OnInit {
+export declare class RdxTooltipRootDirective {
     /** @ignore */
-    private readonly viewContainerRef;
+    readonly uniqueId: import("@angular/core").WritableSignal<number>;
     /** @ignore */
-    private readonly destroyRef;
-    /** @ignore */
-    private readonly overlay;
-    /** @ignore */
-    private readonly platformId;
-    /** @ignore */
-    private readonly document;
-    /** @ignore */
-    readonly tooltipConfig: import("./tooltip.types").RdxTooltipConfig;
+    readonly name: import("@angular/core").Signal<string>;
     /**
-     * The open state of the tooltip when it is initially rendered. Use when you do not need to control its open state.
+     * @description The anchor directive that comes form outside the tooltip rootDirective
+     * @default undefined
      */
-    readonly defaultOpen: import("@angular/core").InputSignal<boolean>;
+    readonly anchor: import("@angular/core").InputSignal<RdxTooltipAnchorDirective | undefined>;
     /**
-     * The controlled open state of the tooltip. Must be used in conjunction with onOpenChange.
+     * @description The open state of the tooltip when it is initially rendered. Use when you do not need to control its open state.
+     * @default false
      */
-    readonly open: import("@angular/core").InputSignal<boolean | undefined>;
+    readonly defaultOpen: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
     /**
-     * Override the duration given to the configuration to customise the open delay for a specific tooltip.
+     * @description The controlled state of the tooltip. `open` input take precedence of `defaultOpen` input.
+     * @default undefined
      */
-    readonly delayDuration: import("@angular/core").InputSignal<number>;
-    /** @ignore */
-    readonly disableHoverableContent: import("@angular/core").InputSignal<boolean>;
+    readonly open: import("@angular/core").InputSignalWithTransform<boolean | undefined, BooleanInput>;
+    /**
+     * To customise the open delay for a specific tooltip.
+     */
+    readonly openDelay: import("@angular/core").InputSignalWithTransform<number, NumberInput>;
+    /**
+     * To customise the close delay for a specific tooltip.
+     */
+    readonly closeDelay: import("@angular/core").InputSignalWithTransform<number, NumberInput>;
+    /**
+     * @description Whether to control the state of the tooltip from external. Use in conjunction with `open` input.
+     * @default undefined
+     */
+    readonly externalControl: import("@angular/core").InputSignalWithTransform<boolean | undefined, BooleanInput>;
     /**
-     * Event handler called when the open state of the tooltip changes.
+     * @description Whether to take into account CSS opening/closing animations.
+     * @default false
      */
-    readonly onOpenChange: import("@angular/core").OutputEmitterRef<boolean>;
+    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<RdxTooltipAnimationStatus | null>;
     /** @ignore */
-    readonly isOpen: import("@angular/core").WritableSignal<boolean>;
+    readonly contentDirective: import("@angular/core").Signal<RdxTooltipContentDirective>;
     /** @ignore */
-    readonly isOpenDelayed: import("@angular/core").WritableSignal<boolean>;
+    readonly triggerDirective: import("@angular/core").Signal<RdxTooltipTriggerDirective>;
     /** @ignore */
-    readonly wasOpenDelayed: import("@angular/core").WritableSignal<boolean>;
+    readonly arrowDirective: import("@angular/core").Signal<import("@radix-ng/primitives/tooltip").RdxTooltipArrowDirective | undefined>;
     /** @ignore */
-    readonly state: import("@angular/core").Signal<RdxTooltipState>;
+    readonly closeDirective: import("@angular/core").Signal<import("@radix-ng/primitives/tooltip").RdxTooltipCloseDirective | undefined>;
     /** @ignore */
-    readonly tooltipContentDirective: import("@angular/core").Signal<import("@radix-ng/primitives/tooltip").RdxTooltipContentDirective>;
+    readonly contentAttributesComponent: import("@angular/core").Signal<import("@radix-ng/primitives/tooltip").RdxTooltipContentAttributesComponent | undefined>;
     /** @ignore */
-    readonly tooltipTriggerElementRef: import("@angular/core").Signal<ElementRef<any>>;
+    private readonly internalAnchorDirective;
     /** @ignore */
-    private openTimer;
+    readonly viewContainerRef: ViewContainerRef;
     /** @ignore */
-    private skipDelayTimer;
+    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>;
+        "__#10376@#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;
+        "__#10376@#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;
+        "__#10376@#registerOnDestroyCallbacks"(): void;
+        "__#10376@#listenToClickDomRootEvent"(): void;
+    } | null;
     /** @ignore */
-    private overlayRef?;
+    readonly destroyRef: DestroyRef;
     /** @ignore */
-    private instance?;
+    readonly state: import("@angular/core").WritableSignal<RdxTooltipState>;
     /** @ignore */
-    private portal;
+    readonly attachDetachEvent: import("@angular/core").WritableSignal<RdxTooltipAttachDetachEvent>;
     /** @ignore */
-    private isControlledExternally;
+    private readonly isFirstDefaultOpen;
     /** @ignore */
-    ngOnInit(): void;
+    readonly anchorDirective: import("@angular/core").Signal<RdxTooltipAnchorDirective | undefined>;
     /** @ignore */
-    onTriggerEnter(): void;
+    readonly actionSubject$: Subject<RdxTooltipAction>;
+    constructor();
     /** @ignore */
-    onTriggerLeave(): void;
+    getAnimationParamsSnapshot(): {
+        cssAnimation: boolean;
+        cssOpeningAnimation: boolean;
+        cssClosingAnimation: boolean;
+        cssAnimationStatus: RdxTooltipAnimationStatus | null;
+        attachDetachEvent: RdxTooltipAttachDetachEvent;
+        state: RdxTooltipState;
+        canEmitOnOpenOrOnClosed: boolean;
+    };
     /** @ignore */
-    onOpen(): void;
+    controlledExternally(): import("@angular/core").InputSignalWithTransform<boolean | undefined, BooleanInput>;
     /** @ignore */
-    onClose(): void;
+    firstDefaultOpen(): boolean;
     /** @ignore */
     handleOpen(): void;
     /** @ignore */
-    handleClose(): void;
+    handleClose(closeButton?: boolean): void;
+    /** @ignore */
+    handleToggle(): void;
+    /** @ignore */
+    isOpen(state?: RdxTooltipState): boolean;
+    /** @ignore */
+    private setState;
+    /** @ignore */
+    private openContent;
+    /** @ignore */
+    private closeContent;
+    /** @ignore */
+    private emitOnOpen;
     /** @ignore */
-    private handleOverlayKeydown;
+    private emitOnClosed;
     /** @ignore */
-    private handlePointerDownOutside;
+    private ifOpenOrCloseWithoutAnimations;
     /** @ignore */
-    private handleDelayedOpen;
+    private ifOpenOrCloseWithAnimations;
     /** @ignore */
-    private setOpen;
+    private openOrClose;
     /** @ignore */
-    private createOverlayRef;
+    private emitOnOpenOrOnClosed;
     /** @ignore */
-    private show;
+    private canEmitOnOpenOrOnClosed;
     /** @ignore */
-    private detach;
+    private onStateChangeEffect;
     /** @ignore */
-    private hide;
+    private onCssAnimationStatusChangeChangeEffect;
     /** @ignore */
-    private getPositionStrategy;
+    private emitOpenOrClosedEventEffect;
     /** @ignore */
-    private clearTimeout;
+    private onOpenChangeEffect;
     /** @ignore */
-    private readonly onIsOpenChangeEffect;
+    private onIsFirstDefaultOpenChangeEffect;
     /** @ignore */
-    private readonly onPositionChangeEffect;
+    private onAnchorChangeEffect;
     /** @ignore */
-    private readonly onOpenChangeEffect;
+    private actionSubscription;
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxTooltipRootDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxTooltipRootDirective, "[rdxTooltipRoot]", ["rdxTooltipRoot"], { "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "delayDuration": { "alias": "delayDuration"; "required": false; "isSignal": true; }; "disableHoverableContent": { "alias": "disableHoverableContent"; "required": false; "isSignal": true; }; }, { "onOpenChange": "onOpenChange"; }, ["tooltipContentDirective", "tooltipTriggerElementRef"], never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxTooltipRootDirective, "[rdxTooltipRoot]", ["rdxTooltipRoot"], { "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/tooltip/src/tooltip-root.inject.d.ts

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

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

@@ -1,26 +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 RdxTooltipTriggerDirective {
     /** @ignore */
-    readonly tooltipRoot: import("./tooltip-root.directive").RdxTooltipRootDirective;
+    protected readonly rootDirective: import("@radix-ng/primitives/tooltip").RdxTooltipRootDirective;
     /** @ignore */
     readonly elementRef: ElementRef<HTMLElement>;
     /** @ignore */
-    private isPointerDown;
+    readonly overlayOrigin: CdkOverlayOrigin;
     /** @ignore */
-    private isPointerInside;
+    readonly name: import("@angular/core").Signal<string>;
     /** @ignore */
-    onPointerMove(event: PointerEvent): void;
+    pointerenter(): void;
     /** @ignore */
-    onPointerLeave(): void;
+    pointerleave(): void;
     /** @ignore */
-    onPointerDown(): void;
+    focus(): void;
     /** @ignore */
-    onFocus(): void;
+    blur(): void;
     /** @ignore */
-    onBlur(): void;
-    /** @ignore */
-    onClick(): void;
+    click(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxTooltipTriggerDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxTooltipTriggerDirective, "[rdxTooltipTrigger]", never, {}, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxTooltipTriggerDirective, "[rdxTooltipTrigger]", never, {}, {}, never, never, true, [{ directive: typeof i1.CdkOverlayOrigin; inputs: {}; outputs: {}; }]>;
 }

package/tooltip/src/tooltip.types.d.ts

@@ -1,18 +1,18 @@
-export declare enum RdxTooltipSide {
-    Top = "top",
-    Right = "right",
-    Bottom = "bottom",
-    Left = "left"
+export declare enum RdxTooltipState {
+    OPEN = "open",
+    CLOSED = "closed"
 }
-export declare enum RdxTooltipAlign {
-    Start = "start",
-    Center = "center",
-    End = "end"
+export declare enum RdxTooltipAction {
+    OPEN = "open",
+    CLOSE = "close"
+}
+export declare enum RdxTooltipAttachDetachEvent {
+    ATTACH = "attach",
+    DETACH = "detach"
+}
+export declare enum RdxTooltipAnimationStatus {
+    OPEN_STARTED = "open_started",
+    OPEN_ENDED = "open_ended",
+    CLOSED_STARTED = "closed_started",
+    CLOSED_ENDED = "closed_ended"
 }
-export type RdxTooltipConfig = {
-    delayDuration: number;
-    skipDelayDuration: number;
-    disableHoverableContent?: boolean;
-    hideDelayDuration?: number;
-};
-export type RdxTooltipState = 'delayed-open' | 'instant-open' | 'closed';

package/tooltip/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/tooltip/src/utils/constants.d.ts

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

package/tooltip/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/core/src/control-value-accessor/index.d.ts

@@ -1,75 +0,0 @@
-/**
- * Based On:
- * Copyright (c) flebee Authors. Licensed under the MIT License.
- */
-import { BooleanInput } from '@angular/cdk/coercion';
-import { Injector } from '@angular/core';
-import { ControlValueAccessor } from '@angular/forms';
-import * as i0 from "@angular/core";
-export type RdxControlValueAccessorCompareTo<T = any> = (a?: T, b?: T) => boolean;
-export declare const injectCvaCompareTo: {
-    (): RdxControlValueAccessorCompareTo<any>;
-    (injectOptions: import("@angular/core").InjectOptions & {
-        optional?: false;
-    } & {
-        injector?: Injector;
-    }): RdxControlValueAccessorCompareTo<any>;
-    (injectOptions: import("@angular/core").InjectOptions & {
-        injector?: Injector;
-    }): RdxControlValueAccessorCompareTo<any> | null;
-}, provideCvaCompareTo: (() => import("@angular/core").Provider) & ((value: RdxControlValueAccessorCompareTo<any> | (() => RdxControlValueAccessorCompareTo<any>), isFunctionValue: boolean) => import("@angular/core").Provider);
-/**
- * Provides a {@link RdxControlValueAccessorCompareTo comparator} based on a property of `T`.
- *
- * @example
- * ```ts
- * interface User {
- * 	id: string;
- * 	name: string;
- * }
- *
- * provideCvaCompareToByProp<User>('id');
- * ```
- */
-export declare const provideCvaCompareToByProp: <T>(prop: keyof T) => import("@angular/core").Provider;
-export declare class RdxControlValueAccessor<Value> implements ControlValueAccessor {
-    private readonly ngControl;
-    private readonly destroyRef;
-    private readonly injector;
-    /**
-     * A comparator, which determines value changes. Should return true, if two values are considered semantic equal.
-     *
-     * Defaults to {@link Object.is} in order to align with change detection behavior for inputs.
-     */
-    readonly compareTo: RdxControlValueAccessorCompareTo<Value>;
-    /** Whether this is disabled. If a control is present, it reflects it's disabled state. */
-    inputDisabled: import("@angular/core").ModelSignal<BooleanInput>;
-    disabled: import("@angular/core").Signal<boolean>;
-    /** The value of this. If a control is present, it reflects it's value. */
-    value: import("@angular/core").ModelSignal<Value>;
-    /**
-     * `NgModel` sets up the control in `ngOnChanges`. Idk if bug or on purpose, but `writeValue` and `setDisabledState` are called before the inputs are set.
-     * {@link https://github.com/angular/angular/blob/main/packages/forms/src/directives/ng_model.ts#L223}
-     *
-     * @ignore
-     */
-    private get registered();
-    constructor();
-    private _onChange;
-    private _onTouched;
-    /**
-     * This function should be called when this host is considered `touched`.
-     *
-     * NOTE: Whenever a `blur` event is triggered on this host, this function is called.
-     *
-     * @see {@link RdxControlValueAccessor.registerOnTouched}
-     * @see {@link RdxControlValueAccessor._ngControl}
-     */
-    markAsTouched(): void;
-    setDisabledState(disabled: boolean): void;
-    writeValue(value: Value): void;
-    registerOnChange(onChange: (value: Value) => void): void;
-    registerOnTouched(onTouched: () => void): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxControlValueAccessor<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxControlValueAccessor<any>, never, never, { "inputDisabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "inputDisabled": "disabledChange"; "value": "valueChange"; }, never, never, true, never>;
-}

package/core/src/create-inject-context/assert-injector.d.ts

@@ -1,51 +0,0 @@
-/**
- * This code is adapted from the original implementation by the ngxTension team.
- * Source: https://github.com/ngxtension/ngxtension-platform/blob/main/libs/ngxtension/assert-injector/src/assert-injector.ts
- *
- * Copyright (c) ngxtension Authors. Licensed under the MIT License.
- */
-import { Injector } from '@angular/core';
-import { Nullable, SafeFunction } from '../types';
-/**
- * `assertInjector` extends `assertInInjectionContext` with an optional `Injector`
- * After assertion, `assertInjector` runs the `runner` function with the guaranteed `Injector`
- * whether it is the default `Injector` within the current **Injection Context**
- * or the custom `Injector` that was passed in.
- *
- * @template {() => unknown} Runner - Runner is a function that can return anything
- * @param {SafeFunction} fn - the Function to pass in `assertInInjectionContext`
- * @param {Nullable<Injector>} injector - the optional "custom" Injector
- * @param {Runner} runner - the runner fn
- * @returns {ReturnType<Runner>} result - returns the result of the Runner
- *
- * @example
- * ```ts
- * function injectValue(injector?: Injector) {
- *  return assertInjector(injectValue, injector, () => 'value');
- * }
- *
- * injectValue(); // string
- * ```
- */
-export declare function assertInjector<Runner extends () => unknown>(fn: SafeFunction, injector: Nullable<Injector>, runner: Runner): ReturnType<Runner>;
-/**
- * `assertInjector` extends `assertInInjectionContext` with an optional `Injector`
- * After assertion, `assertInjector` returns a guaranteed `Injector` whether it is the default `Injector`
- * within the current **Injection Context** or the custom `Injector` that was passed in.
- *
- * @param {SafeFunction} fn - the Function to pass in `assertInInjectionContext`
- * @param {Nullable<Injector>} injector - the optional "custom" Injector
- * @returns Injector
- *
- * @example
- * ```ts
- * function injectDestroy(injector?: Injector) {
- *  injector = assertInjector(injectDestroy, injector);
- *
- *  return runInInjectionContext(injector, () => {
- *    // code
- *  })
- * }
- * ```
- */
-export declare function assertInjector(fn: SafeFunction, injector: Nullable<Injector>): Injector;