@radix-ng/primitives 0.25.0 → 0.27.0

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>;
+        "__#5800@#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;
+        "__#5800@#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;
+        "__#5800@#registerOnDestroyCallbacks"(): void;
+        "__#5800@#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.25.0",
+  "version": "0.27.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"

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

@@ -1,3 +1,4 @@
+import { NumberInput } from '@angular/cdk/coercion';
 import { ElementRef } from '@angular/core';
 import * as i0 from "@angular/core";
 export declare class RdxPopoverArrowDirective {
@@ -11,12 +12,12 @@ export declare class RdxPopoverArrowDirective {
      * @description The width of the arrow in pixels.
      * @default 10
      */
-    readonly width: import("@angular/core").InputSignal<number>;
+    readonly width: import("@angular/core").InputSignalWithTransform<number, NumberInput>;
     /**
      * @description The height of the arrow in pixels.
      * @default 5
      */
-    readonly height: import("@angular/core").InputSignal<number>;
+    readonly height: import("@angular/core").InputSignalWithTransform<number, NumberInput>;
     /** @ignore */
     readonly arrowSvgElement: import("@angular/core").Signal<HTMLElement>;
     /** @ignore */

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

@@ -1,3 +1,4 @@
+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";
@@ -24,7 +25,7 @@ export declare class RdxPopoverContentDirective implements OnInit {
      * @description The distance in pixels from the trigger.
      * @default undefined
      */
-    readonly sideOffset: import("@angular/core").InputSignal<number | undefined>;
+    readonly sideOffset: import("@angular/core").InputSignalWithTransform<number, NumberInput>;
     /**
      * @description The preferred alignment against the trigger. May change when collisions occur.
      * @default center
@@ -34,16 +35,16 @@ export declare class RdxPopoverContentDirective implements OnInit {
      * @description An offset in pixels from the "start" or "end" alignment options.
      * @default undefined
      */
-    readonly alignOffset: import("@angular/core").InputSignal<number | 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").InputSignal<boolean>;
+    readonly alternatePositionsDisabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
     /** @description Whether to prevent `onOverlayEscapeKeyDown` handler from calling. */
-    readonly onOverlayEscapeKeyDownDisabled: import("@angular/core").InputSignal<boolean>;
+    readonly onOverlayEscapeKeyDownDisabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
     /** @description Whether to prevent `onOverlayOutsideClick` handler from calling. */
-    readonly onOverlayOutsideClickDisabled: import("@angular/core").InputSignal<boolean>;
+    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`.

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

@@ -19,17 +19,17 @@ export declare class RdxPopoverRootDirective {
      * @description The open state of the popover when it is initially rendered. Use when you do not need to control its open state.
      * @default false
      */
-    readonly defaultOpen: import("@angular/core").InputSignal<boolean>;
+    readonly defaultOpen: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
     /**
      * @description The controlled state of the popover. `open` input take precedence of `defaultOpen` input.
      * @default undefined
      */
-    readonly open: import("@angular/core").InputSignal<boolean | undefined>;
+    readonly open: import("@angular/core").InputSignalWithTransform<boolean | undefined, BooleanInput>;
     /**
      * @description Whether to control the state of the popover from external. Use in conjunction with `open` input.
      * @default undefined
      */
-    readonly externalControl: import("@angular/core").InputSignal<boolean | undefined>;
+    readonly externalControl: import("@angular/core").InputSignalWithTransform<boolean | undefined, BooleanInput>;
     /**
      * @description Whether to take into account CSS opening/closing animations.
      * @default false
@@ -70,7 +70,7 @@ export declare class RdxPopoverRootDirective {
         window: Window & typeof globalThis;
         primitiveConfigs?: import("./utils/types").PrimitiveConfigs;
         onDestroyCallbacks: Set<() => void>;
-        "__#6158@#clickDomRootEventCallbacks": Set<(event: MouseEvent) => void>;
+        "__#7449@#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;
-        "__#6158@#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;
-        "__#6158@#registerOnDestroyCallbacks"(): void;
-        "__#6158@#listenToClickDomRootEvent"(): void;
+        "__#7449@#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;
+        "__#7449@#registerOnDestroyCallbacks"(): void;
+        "__#7449@#listenToClickDomRootEvent"(): void;
     } | null;
     /** @ignore */
     readonly destroyRef: DestroyRef;
@@ -107,7 +107,7 @@ export declare class RdxPopoverRootDirective {
         canEmitOnOpenOrOnClosed: boolean;
     };
     /** @ignore */
-    controlledExternally(): import("@angular/core").InputSignal<boolean | undefined>;
+    controlledExternally(): import("@angular/core").InputSignalWithTransform<boolean | undefined, BooleanInput>;
     /** @ignore */
     firstDefaultOpen(): boolean;
     /** @ignore */

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/tooltip/README.md

@@ -1 +1,3 @@
 # @radix-ng/primitives/tooltip
+
+Secondary entry point of `@radix-ng/primitives`. It can be used by importing from `@radix-ng/primitives/tooltip`.

package/tooltip/index.d.ts

@@ -1,17 +1,20 @@
 import * as i0 from "@angular/core";
 import * as i1 from "./src/tooltip-arrow.directive";
-import * as i2 from "./src/tooltip-content.directive";
-import * as i3 from "./src/tooltip-trigger.directive";
-import * as i4 from "./src/tooltip-content-attributes.directive";
+import * as i2 from "./src/tooltip-close.directive";
+import * as i3 from "./src/tooltip-content.directive";
+import * as i4 from "./src/tooltip-trigger.directive";
 import * as i5 from "./src/tooltip-root.directive";
+import * as i6 from "./src/tooltip-anchor.directive";
+import * as i7 from "./src/tooltip-content-attributes.component";
+export * from './src/tooltip-anchor.directive';
 export * from './src/tooltip-arrow.directive';
-export * from './src/tooltip-content-attributes.directive';
+export * from './src/tooltip-close.directive';
+export * from './src/tooltip-content-attributes.component';
 export * from './src/tooltip-content.directive';
 export * from './src/tooltip-root.directive';
 export * from './src/tooltip-trigger.directive';
-export * from './src/tooltip.types';
 export declare class RdxTooltipModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxTooltipModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxTooltipModule, never, [typeof i1.RdxTooltipArrowDirective, typeof i2.RdxTooltipContentDirective, typeof i3.RdxTooltipTriggerDirective, typeof i4.RdxTooltipContentAttributesDirective, typeof i5.RdxTooltipRootDirective], [typeof i1.RdxTooltipArrowDirective, typeof i2.RdxTooltipContentDirective, typeof i3.RdxTooltipTriggerDirective, typeof i4.RdxTooltipContentAttributesDirective, typeof i5.RdxTooltipRootDirective]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxTooltipModule, never, [typeof i1.RdxTooltipArrowDirective, typeof i2.RdxTooltipCloseDirective, typeof i3.RdxTooltipContentDirective, typeof i4.RdxTooltipTriggerDirective, typeof i5.RdxTooltipRootDirective, typeof i6.RdxTooltipAnchorDirective, typeof i7.RdxTooltipContentAttributesComponent], [typeof i1.RdxTooltipArrowDirective, typeof i2.RdxTooltipCloseDirective, typeof i3.RdxTooltipContentDirective, typeof i4.RdxTooltipTriggerDirective, typeof i5.RdxTooltipRootDirective, typeof i6.RdxTooltipAnchorDirective, typeof i7.RdxTooltipContentAttributesComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<RdxTooltipModule>;
 }

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

@@ -0,0 +1,28 @@
+import { CdkOverlayOrigin } from '@angular/cdk/overlay';
+import { ElementRef } from '@angular/core';
+import { RdxTooltipRootDirective } from './tooltip-root.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+export declare class RdxTooltipAnchorDirective {
+    /**
+     * @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 - tooltip inside tooltip.
+     * */
+    protected rootDirective: RdxTooltipRootDirective | 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: RdxTooltipRootDirective): void;
+    private emitOutsideClick;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxTooltipAnchorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxTooltipAnchorDirective, "[rdxTooltipAnchor]", ["rdxTooltipAnchor"], {}, {}, never, never, true, [{ directive: typeof i1.CdkOverlayOrigin; inputs: {}; outputs: {}; }]>;
+}

package/tooltip/src/tooltip-anchor.token.d.ts

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+import { RdxTooltipAnchorDirective } from './tooltip-anchor.directive';
+export declare const RdxTooltipAnchorToken: InjectionToken<RdxTooltipAnchorDirective>;

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

@@ -1,38 +1,40 @@
+import { NumberInput } from '@angular/cdk/coercion';
+import { ElementRef } from '@angular/core';
 import * as i0 from "@angular/core";
 export declare class RdxTooltipArrowDirective {
-    /** @ignore */
-    readonly tooltipRoot: import("./tooltip-root.directive").RdxTooltipRootDirective;
     /** @ignore */
     private readonly renderer;
     /** @ignore */
-    private readonly contentDirective;
+    private readonly rootDirective;
     /** @ignore */
-    private readonly elementRef;
+    readonly elementRef: ElementRef<any>;
     /**
-     * The width of the arrow in pixels.
+     * @description The width of the arrow in pixels.
+     * @default 10
      */
-    readonly width: import("@angular/core").InputSignal<number>;
+    readonly width: import("@angular/core").InputSignalWithTransform<number, NumberInput>;
     /**
-     * The height of the arrow in pixels.
+     * @description The height of the arrow in pixels.
+     * @default 5
      */
-    readonly height: import("@angular/core").InputSignal<number>;
-    /**
-     * @ignore
-     * */
-    private triggerRect;
+    readonly height: import("@angular/core").InputSignalWithTransform<number, NumberInput>;
+    /** @ignore */
+    readonly arrowSvgElement: import("@angular/core").Signal<HTMLElement>;
     /** @ignore */
     private readonly currentArrowSvgElement;
     /** @ignore */
-    readonly arrowSvgElement: import("@angular/core").Signal<HTMLElement>;
+    private readonly position;
+    /** @ignore */
+    private anchorOrTriggerRect;
     constructor();
     /** @ignore */
-    private setTriggerRect;
+    private setAnchorOrTriggerRect;
     /** @ignore */
     private setPosition;
     /** @ignore */
-    private readonly onArrowSvgElementChangeEffect;
+    private onArrowSvgElementChangeEffect;
     /** @ignore */
-    private readonly onContentPositionAndArrowDimensionsChangeEffect;
+    private onContentPositionAndArrowDimensionsChangeEffect;
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxTooltipArrowDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<RdxTooltipArrowDirective, "[rdxTooltipArrow]", never, { "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/tooltip/src/tooltip-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 RdxTooltipCloseDirective {
+    /** @ignore */
+    protected readonly rootDirective: import("@radix-ng/primitives/tooltip").RdxTooltipRootDirective;
+    /** @ignore */
+    readonly elementRef: ElementRef<any>;
+    /** @ignore */
+    private readonly renderer;
+    constructor();
+    /** @ignore */
+    private onIsControlledExternallyEffect;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxTooltipCloseDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxTooltipCloseDirective, "[rdxTooltipClose]", never, {}, {}, never, never, true, never>;
+}

package/tooltip/src/tooltip-close.token.d.ts

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+import { RdxTooltipCloseDirective } from './tooltip-close.directive';
+export declare const RdxTooltipCloseToken: InjectionToken<RdxTooltipCloseDirective>;

package/tooltip/src/tooltip-content-attributes.component.d.ts

@@ -0,0 +1,25 @@
+import * as i0 from "@angular/core";
+export declare class RdxTooltipContentAttributesComponent {
+    /** @ignore */
+    protected readonly rootDirective: import("@radix-ng/primitives/tooltip").RdxTooltipRootDirective;
+    /** @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<RdxTooltipContentAttributesComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RdxTooltipContentAttributesComponent, "[rdxTooltipContentAttributes]", never, {}, {}, never, ["*"], true, never>;
+}

package/tooltip/src/tooltip-content-attributes.token.d.ts

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+import { RdxTooltipContentAttributesComponent } from './tooltip-content-attributes.component';
+export declare const RdxTooltipContentAttributesToken: InjectionToken<RdxTooltipContentAttributesComponent>;