@radix-ng/primitives 1.0.0-beta.3 → 1.0.0-beta.5

package/fesm2022/radix-ng-primitives-tooltip.mjs

@@ -1,15 +1,15 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, inject, signal, numberAttribute, DestroyRef, input, Directive, model, booleanAttribute, output, computed, effect, untracked, isDevMode, ElementRef, afterNextRender } from '@angular/core';
-import { createContext, injectId, watch, useGraceArea } from '@radix-ng/primitives/core';
+import { InjectionToken, inject, signal, numberAttribute, DestroyRef, input, Directive, ElementRef, model, booleanAttribute, output, computed, effect, untracked, isDevMode, afterNextRender } from '@angular/core';
+import * as i1$2 from '@radix-ng/primitives/core';
+import { createContext, createFloatingRootContext, injectId, watch, createCancelableChangeEventDetails, provideFloatingTree, provideFloatingRootContext, rdxDevError, RDX_FLOATING_ROOT_CONTEXT, RDX_FLOATING_REGISTRATION, useGraceArea, RdxFloatingNodeRegistration } from '@radix-ng/primitives/core';
 import * as i1 from '@radix-ng/primitives/popper';
-import { RdxPopper, RdxPopperContentWrapper, RdxPopperArrow, RdxPopperContent, provideRdxPopperContentConfig, RdxPopperAnchor } from '@radix-ng/primitives/popper';
+import { RdxPopper, RdxPopperContentWrapper, RdxPopperArrow, RdxPopperContent, provideRdxPopperContentWrapper, provideRdxPopperContentConfig, RdxPopperAnchor } from '@radix-ng/primitives/popper';
 import { RdxVisuallyHiddenDirective } from '@radix-ng/primitives/visually-hidden';
 import * as i1$1 from '@radix-ng/primitives/portal';
 import { RdxPortalPresence } from '@radix-ng/primitives/portal';
 import { provideRdxPresenceContext } from '@radix-ng/primitives/presence';
-import { outputFromObservable, outputToObservable } from '@angular/core/rxjs-interop';
-import * as i1$2 from '@radix-ng/primitives/dismissable-layer';
-import { RdxDismissableLayer } from '@radix-ng/primitives/dismissable-layer';
+import { RdxDismiss } from '@radix-ng/primitives/dismissable-layer';
+import { createRdxTriggerInteraction } from '@radix-ng/primitives/floating-focus-manager';
 
 const defaultTooltipConfig = {
     delay: 600,
@@ -133,6 +133,15 @@ class RdxTooltip {
         this.popper = inject(RdxPopper);
         this.destroyRef = inject(DestroyRef);
         this.hasAppliedDefaultOpen = false;
+        /**
+         * Per-popup floating root context (ADR 0015) — the shared store the positioner's dismissal
+         * capability reads (`open`, `triggers`, the reference/floating elements). The tree node is
+         * registered by the positioner; this context exists independently so dismissal can read `open()`.
+         */
+        this.floatingContext = createFloatingRootContext({
+            ownerDocument: inject(ElementRef).nativeElement.ownerDocument,
+            open: () => this.open()
+        });
         /**
          * Whether the tooltip is currently open.
          */
@@ -176,7 +185,10 @@ class RdxTooltip {
         this.triggers = signal([], ...(ngDevMode ? [{ debugName: "triggers" }] : /* istanbul ignore next */ []));
         this.payload = signal(undefined, ...(ngDevMode ? [{ debugName: "payload" }] : /* istanbul ignore next */ []));
         this.cursorPosition = signal(undefined, ...(ngDevMode ? [{ debugName: "cursorPosition" }] : /* istanbul ignore next */ []));
+        this.openChangeReason = signal('none', ...(ngDevMode ? [{ debugName: "openChangeReason" }] : /* istanbul ignore next */ []));
+        this.preventUnmountOnClose = signal(false, ...(ngDevMode ? [{ debugName: "preventUnmountOnClose" }] : /* istanbul ignore next */ []));
         this.openedInstant = signal(false, ...(ngDevMode ? [{ debugName: "openedInstant" }] : /* istanbul ignore next */ []));
+        this.suppressNextOpenChangeEmit = false;
         /** Local instant window used when this tooltip is not inside a provider. */
         this.localInstant = createTooltipInstantController(() => this.defaultConfig.timeout, this.destroyRef);
         this.instantGroup = this.provider ?? this.localInstant;
@@ -190,6 +202,7 @@ class RdxTooltip {
             this.defaultConfig.closeDelay, ...(ngDevMode ? [{ debugName: "resolvedCloseDelay" }] : /* istanbul ignore next */ []));
         /** Whether the most recent open happened without the delay. */
         this.instant = this.openedInstant.asReadonly();
+        this.present = computed(() => this.open() || this.preventUnmountOnClose(), ...(ngDevMode ? [{ debugName: "present" }] : /* istanbul ignore next */ []));
         this.virtualAnchor = computed(() => {
             const axis = this.trackCursorAxis();
             const element = this.trigger();
@@ -213,7 +226,7 @@ class RdxTooltip {
                 }
             };
         }, ...(ngDevMode ? [{ debugName: "virtualAnchor" }] : /* istanbul ignore next */ []));
-        this.openTimer = useTimeoutFn(() => this.applyOpen(false), () => this.resolvedDelay(), { immediate: false }, this.destroyRef);
+        this.openTimer = useTimeoutFn(() => this.applyOpen(false, this.trigger(), this.payload(), 'trigger-hover'), () => this.resolvedDelay(), { immediate: false }, this.destroyRef);
         this.closeTimer = useTimeoutFn(() => this.applyClose(), () => this.resolvedCloseDelay(), { immediate: false }, this.destroyRef);
         effect(() => {
             const defaultOpen = this.defaultOpen();
@@ -230,9 +243,19 @@ class RdxTooltip {
         });
         // Keep the popper anchored to the active trigger, or to the cursor while tracking.
         effect(() => this.popper.anchorOverride.set(this.virtualAnchor()));
+        // Sync the dismissal reference (the active trigger) so an outside-press on the trigger counts
+        // as "inside" and never dismisses (ADR 0015).
+        effect(() => this.floatingContext.setReferenceElement(this.trigger() ?? null));
         watch([this.open], ([isOpen]) => {
-            this.onOpenChange.emit(isOpen);
+            if (this.suppressNextOpenChangeEmit) {
+                this.suppressNextOpenChangeEmit = false;
+            }
+            else {
+                const { eventDetails } = createCancelableChangeEventDetails(this.openChangeReason(), new Event('tooltip.open-change'), this.trigger());
+                this.onOpenChange.emit({ open: isOpen, eventDetails });
+            }
             if (isOpen) {
+                this.preventUnmountOnClose.set(false);
                 this.instantGroup.onOpen();
             }
             else {
@@ -242,26 +265,36 @@ class RdxTooltip {
         }, { defer: true });
     }
     /** Opens immediately, optionally switching the active trigger/payload. */
-    show(trigger = this.trigger(), payload) {
-        this.applyOpen(true, trigger, payload);
+    show(trigger = this.trigger(), payload, event) {
+        this.applyOpen(true, trigger, payload, 'trigger-focus', event);
     }
-    close() {
+    close(reason = 'none', event) {
+        this.openTimer.stop();
+        this.closeTimer.stop();
+        this.applyClose(reason, event);
+    }
+    cancelPendingOpen() {
+        this.openTimer.stop();
+    }
+    closeHoverOpen(event) {
         this.openTimer.stop();
         this.closeTimer.stop();
-        this.applyClose();
+        if (this.open() && this.openChangeReason() === 'trigger-hover') {
+            this.applyClose('trigger-hover', event);
+        }
     }
     /** Closes after the resolved close delay, e.g. when the pointer or focus leaves. */
-    scheduleClose() {
+    scheduleClose(event) {
         this.openTimer.stop();
         if (this.resolvedCloseDelay() <= 0) {
-            this.applyClose();
+            this.applyClose('trigger-hover', event);
         }
         else {
             this.closeTimer.start();
         }
     }
     /** Hover/focus entered — open after the delay, or instantly within the instant window. */
-    onTriggerEnter(trigger = this.trigger(), payload) {
+    onTriggerEnter(trigger = this.trigger(), payload, event) {
         if (this.disabled()) {
             return;
         }
@@ -271,7 +304,7 @@ class RdxTooltip {
         this.payload.set(payload);
         this.closeTimer.stop();
         if (this.instantGroup.isInstant() || this.resolvedDelay() <= 0) {
-            this.applyOpen(true, trigger, payload);
+            this.applyOpen(true, trigger, payload, 'trigger-hover', event);
         }
         else {
             this.openTimer.start();
@@ -286,16 +319,18 @@ class RdxTooltip {
     }
     registerTrigger(trigger) {
         this.triggers.update((triggers) => (triggers.includes(trigger) ? triggers : [...triggers, trigger]));
+        this.floatingContext.triggers.add(trigger);
         if (!this.trigger()) {
             this.trigger.set(trigger);
         }
         return () => {
             this.triggers.update((triggers) => triggers.filter((candidate) => candidate !== trigger));
+            this.floatingContext.triggers.delete(trigger);
             if (this.trigger() === trigger) {
                 const nextTrigger = this.triggers()[0];
                 this.trigger.set(nextTrigger);
                 if (!nextTrigger && !this.destroyRef.destroyed) {
-                    this.applyClose();
+                    this.applyClose('none');
                 }
             }
         };
@@ -308,12 +343,21 @@ class RdxTooltip {
         this.triggerDelay.set(delay);
         this.triggerCloseDelay.set(closeDelay);
     }
-    applyOpen(instant, trigger = this.trigger(), payload) {
+    applyOpen(instant, trigger = this.trigger(), payload, reason = 'none', event) {
         if (this.disabled()) {
             return;
         }
+        const wasOpen = this.open();
         this.openTimer.stop();
         this.closeTimer.stop();
+        if (!wasOpen) {
+            const { eventDetails } = createCancelableChangeEventDetails(reason, event ?? new Event('tooltip.open-change'), trigger);
+            this.onOpenChange.emit({ open: true, eventDetails });
+            if (eventDetails.isCanceled()) {
+                return;
+            }
+            this.suppressNextOpenChangeEmit = true;
+        }
         if (trigger) {
             this.trigger.set(trigger);
         }
@@ -321,21 +365,43 @@ class RdxTooltip {
             this.payload.set(payload);
         }
         this.openedInstant.set(instant || this.instantGroup.isInstant());
+        this.preventUnmountOnClose.set(false);
+        this.openChangeReason.set(reason);
         this.open.set(true);
     }
-    applyClose() {
+    applyClose(reason = 'none', event) {
+        if (!this.open()) {
+            return;
+        }
+        const change = createCancelableChangeEventDetails(reason, event ?? new Event('tooltip.open-change'), this.trigger());
+        const { eventDetails } = change;
+        this.onOpenChange.emit({ open: false, eventDetails });
+        if (eventDetails.isCanceled()) {
+            return;
+        }
+        this.suppressNextOpenChangeEmit = true;
+        this.preventUnmountOnClose.set(change.shouldPreventUnmountOnClose());
         this.openedInstant.set(this.instantGroup.isInstant());
+        this.openChangeReason.set(reason);
         this.open.set(false);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: RdxTooltip, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.9", type: RdxTooltip, isStandalone: true, selector: "[rdxTooltip]", inputs: { open: { classPropertyName: "open", publicName: "open", isSignal: true, isRequired: false, transformFunction: null }, defaultOpen: { classPropertyName: "defaultOpen", publicName: "defaultOpen", isSignal: true, isRequired: false, transformFunction: null }, delay: { classPropertyName: "delay", publicName: "delay", isSignal: true, isRequired: false, transformFunction: null }, closeDelay: { classPropertyName: "closeDelay", publicName: "closeDelay", isSignal: true, isRequired: false, transformFunction: null }, disableHoverablePopup: { classPropertyName: "disableHoverablePopup", publicName: "disableHoverablePopup", isSignal: true, isRequired: false, transformFunction: null }, trackCursorAxis: { classPropertyName: "trackCursorAxis", publicName: "trackCursorAxis", isSignal: true, isRequired: false, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "disabled", isSignal: true, isRequired: false, transformFunction: null }, handle: { classPropertyName: "handle", publicName: "handle", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { open: "openChange", onOpenChange: "onOpenChange" }, providers: [provideRdxTooltipContext(context)], exportAs: ["rdxTooltip"], hostDirectives: [{ directive: i1.RdxPopper }], ngImport: i0 }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.9", type: RdxTooltip, isStandalone: true, selector: "[rdxTooltip]", inputs: { open: { classPropertyName: "open", publicName: "open", isSignal: true, isRequired: false, transformFunction: null }, defaultOpen: { classPropertyName: "defaultOpen", publicName: "defaultOpen", isSignal: true, isRequired: false, transformFunction: null }, delay: { classPropertyName: "delay", publicName: "delay", isSignal: true, isRequired: false, transformFunction: null }, closeDelay: { classPropertyName: "closeDelay", publicName: "closeDelay", isSignal: true, isRequired: false, transformFunction: null }, disableHoverablePopup: { classPropertyName: "disableHoverablePopup", publicName: "disableHoverablePopup", isSignal: true, isRequired: false, transformFunction: null }, trackCursorAxis: { classPropertyName: "trackCursorAxis", publicName: "trackCursorAxis", isSignal: true, isRequired: false, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "disabled", isSignal: true, isRequired: false, transformFunction: null }, handle: { classPropertyName: "handle", publicName: "handle", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { open: "openChange", onOpenChange: "onOpenChange" }, providers: [
+            provideRdxTooltipContext(context),
+            provideFloatingTree(),
+            provideFloatingRootContext(() => inject(RdxTooltip).floatingContext)
+        ], exportAs: ["rdxTooltip"], hostDirectives: [{ directive: i1.RdxPopper }], ngImport: i0 }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: RdxTooltip, decorators: [{
             type: Directive,
             args: [{
                     selector: '[rdxTooltip]',
                     exportAs: 'rdxTooltip',
-                    providers: [provideRdxTooltipContext(context)],
+                    providers: [
+                        provideRdxTooltipContext(context),
+                        provideFloatingTree(),
+                        provideFloatingRootContext(() => inject(RdxTooltip).floatingContext)
+                    ],
                     hostDirectives: [RdxPopper]
                 }]
         }], ctorParameters: () => [], propDecorators: { open: [{ type: i0.Input, args: [{ isSignal: true, alias: "open", required: false }] }, { type: i0.Output, args: ["openChange"] }], defaultOpen: [{ type: i0.Input, args: [{ isSignal: true, alias: "defaultOpen", required: false }] }], delay: [{ type: i0.Input, args: [{ isSignal: true, alias: "delay", required: false }] }], closeDelay: [{ type: i0.Input, args: [{ isSignal: true, alias: "closeDelay", required: false }] }], disableHoverablePopup: [{ type: i0.Input, args: [{ isSignal: true, alias: "disableHoverablePopup", required: false }] }], trackCursorAxis: [{ type: i0.Input, args: [{ isSignal: true, alias: "trackCursorAxis", required: false }] }], disabled: [{ type: i0.Input, args: [{ isSignal: true, alias: "disabled", required: false }] }], handle: [{ type: i0.Input, args: [{ isSignal: true, alias: "handle", required: false }] }], onOpenChange: [{ type: i0.Output, args: ["onOpenChange"] }] } });
@@ -343,6 +409,7 @@ function contextFor(root) {
     return {
         contentId: root.contentId,
         isOpen: root.open,
+        present: root.present,
         instant: root.instant,
         disabled: root.disabled,
         disableHoverablePopup: root.disableHoverablePopup,
@@ -350,11 +417,14 @@ function contextFor(root) {
         trigger: root.trigger.asReadonly(),
         triggers: root.triggers.asReadonly(),
         payload: root.payload.asReadonly(),
-        open: (trigger, payload) => root.show(trigger, payload),
-        close: () => root.close(),
-        closeDelayed: () => root.scheduleClose(),
+        openChangeReason: root.openChangeReason.asReadonly(),
+        open: (trigger, payload, event) => root.show(trigger, payload, event),
+        close: (reason, event) => root.close(reason, event),
+        cancelPendingOpen: () => root.cancelPendingOpen(),
+        closeHoverOpen: (event) => root.closeHoverOpen(event),
+        closeDelayed: (event) => root.scheduleClose(event),
         registerTrigger: (trigger) => root.registerTrigger(trigger),
-        onTriggerEnter: (trigger, payload) => root.onTriggerEnter(trigger, payload),
+        onTriggerEnter: (trigger, payload, event) => root.onTriggerEnter(trigger, payload, event),
         onTriggerLeave: () => root.onTriggerLeave(),
         setCursorPosition: (position) => root.setCursorPosition(position),
         setDelays: (delay, closeDelay) => root.setDelays(delay, closeDelay)
@@ -431,7 +501,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
  */
 class RdxTooltipPortal {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: RdxTooltipPortal, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.9", type: RdxTooltipPortal, isStandalone: true, selector: "ng-template[rdxTooltipPortal]", providers: [provideRdxPresenceContext(() => ({ present: injectRdxTooltipContext().isOpen }))], exportAs: ["rdxTooltipPortal"], hostDirectives: [{ directive: i1$1.RdxPortalPresence, inputs: ["container", "container"] }], ngImport: i0 }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.9", type: RdxTooltipPortal, isStandalone: true, selector: "ng-template[rdxTooltipPortal]", providers: [provideRdxPresenceContext(() => ({ present: injectRdxTooltipContext().present }))], exportAs: ["rdxTooltipPortal"], hostDirectives: [{ directive: i1$1.RdxPortalPresence, inputs: ["container", "container"] }], ngImport: i0 }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: RdxTooltipPortal, decorators: [{
             type: Directive,
@@ -439,7 +509,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                     selector: 'ng-template[rdxTooltipPortal]',
                     exportAs: 'rdxTooltipPortal',
                     hostDirectives: [{ directive: RdxPortalPresence, inputs: ['container'] }],
-                    providers: [provideRdxPresenceContext(() => ({ present: injectRdxTooltipContext().isOpen }))]
+                    providers: [provideRdxPresenceContext(() => ({ present: injectRdxTooltipContext().present }))]
                 }]
         }] });
 /**
@@ -450,9 +520,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
 class RdxTooltipPortalMisuseGuard {
     constructor() {
         if (isDevMode()) {
-            throw new Error('[rdxTooltipPortal] is now a structural directive. ' +
+            rdxDevError('tooltip/portal-on-element', '`rdxTooltipPortal` is now a structural directive. ' +
                 'Use `*rdxTooltipPortal` on the positioner element or `<ng-template rdxTooltipPortal>`. ' +
-                'rdxTooltipPortalPresence has been removed. See https://radix-ng.com/components/tooltip.md');
+                'rdxTooltipPortalPresence has been removed.', 'components/tooltip');
         }
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: RdxTooltipPortalMisuseGuard, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
@@ -467,89 +537,41 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
 
 /**
  * Positions the tooltip popup against its trigger (or a custom anchor).
+ *
+ * A "thin" positioner (ADR 0012): it inherits the popper positioning surface (inputs, `placed`
+ * output, unified vars + placement attrs) from {@link RdxPopperContentWrapper} and adds tooltip's own
+ * concerns — Base UI-aligned defaults (`side: 'top'`) via the config provider, dismiss handling
+ * (ADR 0015 — inline {@link RdxDismiss} on the shared floating tree, dismissal-only with
+ * no focus manager), the cursor-follow pointer-through behavior (via the inherited `nonInteractive`
+ * signal), the open/closed state attributes, and the hover grace area.
  */
-class RdxTooltipPositioner {
+class RdxTooltipPositioner extends RdxPopperContentWrapper {
     constructor() {
+        super();
         this.rootContext = injectRdxTooltipContext();
-        this.wrapper = inject(RdxPopperContentWrapper);
         this.destroyRef = inject(DestroyRef);
-        this.dismissableLayer = inject(RdxDismissableLayer);
-        this.elementRef = inject(ElementRef);
-        /**
-         * An element to position the popup against. Defaults to the trigger.
-         */
-        this.anchor = input(...(ngDevMode ? [undefined, { debugName: "anchor" }] : /* istanbul ignore next */ []));
-        /**
-         * The preferred side of the anchor to render against when open.
-         */
-        this.side = input('top', ...(ngDevMode ? [{ debugName: "side" }] : /* istanbul ignore next */ []));
-        /**
-         * The distance in pixels from the anchor.
-         */
-        this.sideOffset = input(0, { ...(ngDevMode ? { debugName: "sideOffset" } : /* istanbul ignore next */ {}), transform: numberAttribute });
-        /**
-         * The preferred alignment against the anchor.
-         */
-        this.align = input('center', ...(ngDevMode ? [{ debugName: "align" }] : /* istanbul ignore next */ []));
-        /**
-         * An offset in pixels from the `start` or `end` alignment options.
-         */
-        this.alignOffset = input(0, { ...(ngDevMode ? { debugName: "alignOffset" } : /* istanbul ignore next */ {}), transform: numberAttribute });
-        /**
-         * The padding between the arrow and the edges of the content.
-         */
-        this.arrowPadding = input(5, { ...(ngDevMode ? { debugName: "arrowPadding" } : /* istanbul ignore next */ {}), transform: numberAttribute });
-        /**
-         * When `true`, overrides the `side` and `align` preferences to prevent collisions with boundary edges.
-         */
-        this.avoidCollisions = input(true, { ...(ngDevMode ? { debugName: "avoidCollisions" } : /* istanbul ignore next */ {}), transform: booleanAttribute });
-        /**
-         * The element used as the collision boundary.
-         */
-        this.collisionBoundary = input(...(ngDevMode ? [undefined, { debugName: "collisionBoundary" }] : /* istanbul ignore next */ []));
-        /**
-         * The distance in pixels from the boundary edges where collision detection should occur.
-         */
-        this.collisionPadding = input(5, ...(ngDevMode ? [{ debugName: "collisionPadding" }] : /* istanbul ignore next */ []));
-        /**
-         * The sticky behavior on the `align` axis.
-         */
-        this.sticky = input('partial', ...(ngDevMode ? [{ debugName: "sticky" }] : /* istanbul ignore next */ []));
-        /**
-         * Whether to hide the content when the trigger becomes fully occluded.
-         */
-        this.hideWhenDetached = input(false, { ...(ngDevMode ? { debugName: "hideWhenDetached" } : /* istanbul ignore next */ {}), transform: booleanAttribute });
-        /**
-         * The CSS position strategy used by Floating UI.
-         */
-        this.positionStrategy = input('fixed', ...(ngDevMode ? [{ debugName: "positionStrategy" }] : /* istanbul ignore next */ []));
-        /**
-         * Whether to update the position of the floating element on every animation frame if required.
-         */
-        this.updatePositionStrategy = input('always', ...(ngDevMode ? [{ debugName: "updatePositionStrategy" }] : /* istanbul ignore next */ []));
-        /**
-         * Emits when the element is placed.
-         */
-        this.placed = outputFromObservable(outputToObservable(this.wrapper.placed));
+        this.floatingContext = inject(RDX_FLOATING_ROOT_CONTEXT);
+        this.registration = inject(RDX_FLOATING_REGISTRATION, { optional: true });
+        this.containerRef = inject(ElementRef);
         /**
          * Event handler called when the escape key is down. Can be prevented.
          */
-        this.escapeKeyDown = outputFromObservable(outputToObservable(this.dismissableLayer.escapeKeyDown));
+        this.escapeKeyDown = output();
         /**
-         * Event handler called when a `pointerdown` event happens outside of the `DismissableLayer`. Can be prevented.
+         * Event handler called when a `pointerdown` event happens outside of the popup. Can be prevented.
          */
-        this.pointerDownOutside = outputFromObservable(outputToObservable(this.dismissableLayer.pointerDownOutside));
+        this.pointerDownOutside = output();
         this.triggerEl = signal(null, ...(ngDevMode ? [{ debugName: "triggerEl" }] : /* istanbul ignore next */ []));
         this.containerEl = signal(null, ...(ngDevMode ? [{ debugName: "containerEl" }] : /* istanbul ignore next */ []));
         this.graceArea = useGraceArea(this.triggerEl, this.containerEl, 300);
         this.afterNextRender = afterNextRender(() => {
             this.triggerEl.set(this.rootContext.trigger() ?? null);
-            this.containerEl.set(this.elementRef.nativeElement);
+            this.containerEl.set(this.containerRef.nativeElement);
             const handleScroll = (event) => {
                 const target = event.target;
                 const trigger = this.rootContext.trigger();
                 if (trigger && target?.contains(trigger)) {
-                    this.rootContext.close();
+                    this.rootContext.close('none', event);
                 }
             };
             window.addEventListener('scroll', handleScroll, { capture: true });
@@ -566,58 +588,77 @@ class RdxTooltipPositioner {
                 this.rootContext.closeDelayed();
             });
         });
-        this.dismissableLayer.focusOutside.subscribe((e) => e.preventDefault());
-        this.dismissableLayer.dismiss.subscribe(() => this.rootContext.close());
+        // Register as the floating element so dismissal containment (outside-press / focus) treats the
+        // popup as "inside".
+        this.floatingContext.setFloatingElement(this.containerRef.nativeElement);
+        // Dismissal-only (ADR 0017 §1 — a tooltip has no focus manager): Escape and an outside press
+        // close it; focus-out is intentionally a no-op (a tooltip never traps or follows focus).
+        new RdxDismiss(this.floatingContext, () => this.registration?.node() ?? null, {
+            escapeKey: () => true,
+            outsidePress: () => true,
+            focusOutside: () => false,
+            onEscapeKeyDown: (event) => this.escapeKeyDown.emit(event),
+            onPointerDownOutside: (event) => this.pointerDownOutside.emit(event),
+            onDismiss: (reason, event) => this.rootContext.close(reason === 'escape-key' ? 'escape-key' : 'outside-press', event)
+        });
         // While following the cursor the popup sits right under the pointer; if it could intercept
         // the pointer it would steal hover from the trigger and the tooltip would flicker. Render it
         // pointer-events: none so the pointer always passes through to the trigger underneath.
-        effect(() => this.wrapper.nonInteractive.set(this.rootContext.trackCursorAxis() !== 'none'));
+        effect(() => this.nonInteractive.set(this.rootContext.trackCursorAxis() !== 'none'));
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: RdxTooltipPositioner, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.9", type: RdxTooltipPositioner, isStandalone: true, selector: "[rdxTooltipPositioner]", inputs: { anchor: { classPropertyName: "anchor", publicName: "anchor", isSignal: true, isRequired: false, transformFunction: null }, side: { classPropertyName: "side", publicName: "side", isSignal: true, isRequired: false, transformFunction: null }, sideOffset: { classPropertyName: "sideOffset", publicName: "sideOffset", isSignal: true, isRequired: false, transformFunction: null }, align: { classPropertyName: "align", publicName: "align", isSignal: true, isRequired: false, transformFunction: null }, alignOffset: { classPropertyName: "alignOffset", publicName: "alignOffset", isSignal: true, isRequired: false, transformFunction: null }, arrowPadding: { classPropertyName: "arrowPadding", publicName: "arrowPadding", isSignal: true, isRequired: false, transformFunction: null }, avoidCollisions: { classPropertyName: "avoidCollisions", publicName: "avoidCollisions", isSignal: true, isRequired: false, transformFunction: null }, collisionBoundary: { classPropertyName: "collisionBoundary", publicName: "collisionBoundary", isSignal: true, isRequired: false, transformFunction: null }, collisionPadding: { classPropertyName: "collisionPadding", publicName: "collisionPadding", isSignal: true, isRequired: false, transformFunction: null }, sticky: { classPropertyName: "sticky", publicName: "sticky", isSignal: true, isRequired: false, transformFunction: null }, hideWhenDetached: { classPropertyName: "hideWhenDetached", publicName: "hideWhenDetached", isSignal: true, isRequired: false, transformFunction: null }, positionStrategy: { classPropertyName: "positionStrategy", publicName: "positionStrategy", isSignal: true, isRequired: false, transformFunction: null }, updatePositionStrategy: { classPropertyName: "updatePositionStrategy", publicName: "updatePositionStrategy", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { placed: "placed", escapeKeyDown: "escapeKeyDown", pointerDownOutside: "pointerDownOutside" }, host: { properties: { "attr.data-open": "rootContext.isOpen() ? \"\" : undefined", "attr.data-closed": "rootContext.isOpen() ? undefined : \"\"", "attr.data-side": "wrapper.placedSide()", "attr.data-align": "wrapper.placedAlign()", "style": "{\n            '--anchor-width': 'var(--radix-popper-anchor-width)',\n            '--anchor-height': 'var(--radix-popper-anchor-height)',\n            '--available-width': 'var(--radix-popper-available-width)',\n            '--available-height': 'var(--radix-popper-available-height)',\n            '--transform-origin': 'var(--radix-popper-transform-origin)'\n        }" } }, providers: [provideRdxPopperContentConfig({ side: 'top', arrowPadding: 5, collisionPadding: 5 })], hostDirectives: [{ directive: i1$2.RdxDismissableLayer }, { directive: i1.RdxPopperContentWrapper, inputs: ["anchor", "anchor", "side", "side", "sideOffset", "sideOffset", "align", "align", "alignOffset", "alignOffset", "arrowPadding", "arrowPadding", "avoidCollisions", "avoidCollisions", "collisionBoundary", "collisionBoundary", "collisionPadding", "collisionPadding", "sticky", "sticky", "hideWhenDetached", "hideWhenDetached", "positionStrategy", "positionStrategy", "updatePositionStrategy", "updatePositionStrategy"] }], ngImport: i0 }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.9", type: RdxTooltipPositioner, isStandalone: true, selector: "[rdxTooltipPositioner]", outputs: { escapeKeyDown: "escapeKeyDown", pointerDownOutside: "pointerDownOutside" }, host: { properties: { "attr.data-open": "rootContext.isOpen() ? \"\" : undefined", "attr.data-closed": "rootContext.isOpen() ? undefined : \"\"" } }, providers: [
+            ...provideRdxPopperContentWrapper(RdxTooltipPositioner),
+            provideRdxPopperContentConfig({ side: 'top', arrowPadding: 5, collisionPadding: 5 })
+        ], usesInheritance: true, hostDirectives: [{ directive: i1$2.RdxFloatingNodeRegistration }], ngImport: i0 }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: RdxTooltipPositioner, decorators: [{
             type: Directive,
             args: [{
                     selector: '[rdxTooltipPositioner]',
-                    providers: [provideRdxPopperContentConfig({ side: 'top', arrowPadding: 5, collisionPadding: 5 })],
-                    hostDirectives: [
-                        RdxDismissableLayer,
-                        {
-                            directive: RdxPopperContentWrapper,
-                            inputs: [
-                                'anchor',
-                                'side',
-                                'sideOffset',
-                                'align',
-                                'alignOffset',
-                                'arrowPadding',
-                                'avoidCollisions',
-                                'collisionBoundary',
-                                'collisionPadding',
-                                'sticky',
-                                'hideWhenDetached',
-                                'positionStrategy',
-                                'updatePositionStrategy'
-                            ]
-                        }
+                    providers: [
+                        ...provideRdxPopperContentWrapper(RdxTooltipPositioner),
+                        provideRdxPopperContentConfig({ side: 'top', arrowPadding: 5, collisionPadding: 5 })
                     ],
+                    hostDirectives: [RdxFloatingNodeRegistration],
                     host: {
                         '[attr.data-open]': 'rootContext.isOpen() ? "" : undefined',
-                        '[attr.data-closed]': 'rootContext.isOpen() ? undefined : ""',
-                        '[attr.data-side]': 'wrapper.placedSide()',
-                        '[attr.data-align]': 'wrapper.placedAlign()',
-                        '[style]': `{
-            '--anchor-width': 'var(--radix-popper-anchor-width)',
-            '--anchor-height': 'var(--radix-popper-anchor-height)',
-            '--available-width': 'var(--radix-popper-available-width)',
-            '--available-height': 'var(--radix-popper-available-height)',
-            '--transform-origin': 'var(--radix-popper-transform-origin)'
-        }`
+                        '[attr.data-closed]': 'rootContext.isOpen() ? undefined : ""'
+                        // `data-side`/`data-align`/`data-anchor-hidden` and the unified vars come from the inherited
+                        // wrapper (ADR 0012); tooltip exposes no legacy `--radix-*` aliases.
                     }
                 }]
-        }], ctorParameters: () => [], propDecorators: { anchor: [{ type: i0.Input, args: [{ isSignal: true, alias: "anchor", required: false }] }], side: [{ type: i0.Input, args: [{ isSignal: true, alias: "side", required: false }] }], sideOffset: [{ type: i0.Input, args: [{ isSignal: true, alias: "sideOffset", required: false }] }], align: [{ type: i0.Input, args: [{ isSignal: true, alias: "align", required: false }] }], alignOffset: [{ type: i0.Input, args: [{ isSignal: true, alias: "alignOffset", required: false }] }], arrowPadding: [{ type: i0.Input, args: [{ isSignal: true, alias: "arrowPadding", required: false }] }], avoidCollisions: [{ type: i0.Input, args: [{ isSignal: true, alias: "avoidCollisions", required: false }] }], collisionBoundary: [{ type: i0.Input, args: [{ isSignal: true, alias: "collisionBoundary", required: false }] }], collisionPadding: [{ type: i0.Input, args: [{ isSignal: true, alias: "collisionPadding", required: false }] }], sticky: [{ type: i0.Input, args: [{ isSignal: true, alias: "sticky", required: false }] }], hideWhenDetached: [{ type: i0.Input, args: [{ isSignal: true, alias: "hideWhenDetached", required: false }] }], positionStrategy: [{ type: i0.Input, args: [{ isSignal: true, alias: "positionStrategy", required: false }] }], updatePositionStrategy: [{ type: i0.Input, args: [{ isSignal: true, alias: "updatePositionStrategy", required: false }] }], placed: [{ type: i0.Output, args: ["placed"] }], escapeKeyDown: [{ type: i0.Output, args: ["escapeKeyDown"] }], pointerDownOutside: [{ type: i0.Output, args: ["pointerDownOutside"] }] } });
+        }], ctorParameters: () => [], propDecorators: { escapeKeyDown: [{ type: i0.Output, args: ["escapeKeyDown"] }], pointerDownOutside: [{ type: i0.Output, args: ["pointerDownOutside"] }] } });
 
+const TOOLTIP_TRIGGER_ATTR = 'data-rdx-tooltip-trigger';
+function getTargetElement(event) {
+    if ('composedPath' in event) {
+        for (const target of event.composedPath()) {
+            if (target instanceof Element) {
+                return target;
+            }
+        }
+    }
+    return event.target instanceof Element ? event.target : null;
+}
+function closestEnabledTooltipTrigger(element) {
+    let current = element;
+    while (current) {
+        if (current.hasAttribute(TOOLTIP_TRIGGER_ATTR)) {
+            return current;
+        }
+        if (current.parentElement) {
+            current = current.parentElement;
+            continue;
+        }
+        const root = current.getRootNode();
+        current = 'host' in root && root.host instanceof Element ? root.host : null;
+    }
+    return null;
+}
+function isMouseLikePointerType(pointerType) {
+    return pointerType !== 'touch';
+}
 class RdxTooltipTrigger {
     constructor() {
         this.parentRootContext = injectRdxTooltipContext(true);
@@ -660,8 +701,16 @@ class RdxTooltipTrigger {
         this.isDisabled = computed(() => (this.rootContext()?.disabled() ?? false) || this.disabled(), ...(ngDevMode ? [{ debugName: "isDisabled" }] : /* istanbul ignore next */ []));
         /** Whether this specific trigger is the active anchor of an open tooltip. */
         this.isOpen = computed(() => this.rootContext()?.isOpen() === true && this.rootContext()?.trigger() === this.elementRef.nativeElement, ...(ngDevMode ? [{ debugName: "isOpen" }] : /* istanbul ignore next */ []));
+        this.triggerInteraction = createRdxTriggerInteraction({
+            trigger: () => this.elementRef.nativeElement,
+            activeTrigger: () => this.rootContext()?.trigger(),
+            open: () => this.rootContext()?.isOpen() ?? false,
+            disabled: () => this.isDisabled(),
+            contentId: () => this.rootContext()?.contentId
+        });
         this.isPointerDown = signal(false, ...(ngDevMode ? [{ debugName: "isPointerDown" }] : /* istanbul ignore next */ []));
         this.hasPointerMoveOpened = signal(false, ...(ngDevMode ? [{ debugName: "hasPointerMoveOpened" }] : /* istanbul ignore next */ []));
+        this.isNestedTriggerHovered = signal(false, ...(ngDevMode ? [{ debugName: "isNestedTriggerHovered" }] : /* istanbul ignore next */ []));
         effect((onCleanup) => {
             const handle = this.handle();
             if (handle) {
@@ -672,22 +721,29 @@ class RdxTooltipTrigger {
             }
         });
     }
-    handleFocus() {
+    handleFocus(event) {
         const rootContext = this.rootContext();
         if (!rootContext || this.isDisabled() || this.isPointerDown()) {
             return;
         }
         rootContext.setDelays(this.delay(), this.closeDelay());
-        rootContext.open(this.elementRef.nativeElement, this.payload());
+        rootContext.open(this.elementRef.nativeElement, this.payload(), event);
     }
-    handleBlur() {
-        this.rootContext()?.closeDelayed();
+    handleBlur(event) {
+        this.rootContext()?.closeDelayed(event);
     }
-    handleClick() {
+    handleClick(event) {
         const rootContext = this.rootContext();
         if (rootContext?.isOpen() && this.closeOnClick()) {
-            rootContext.close();
+            rootContext.close('trigger-press', event);
+            return;
         }
+        if (rootContext && this.closeOnClick()) {
+            rootContext.cancelPendingOpen();
+        }
+    }
+    handlePointerEnter(event) {
+        this.pointerType = event.pointerType;
     }
     handlePointerMove(event) {
         if (event.pointerType === 'touch') {
@@ -697,12 +753,16 @@ class RdxTooltipTrigger {
         if (!rootContext || this.isDisabled()) {
             return;
         }
+        this.pointerType = event.pointerType;
+        if (this.detectNestedTriggerHover(getTargetElement(event))) {
+            return;
+        }
         if (rootContext.trackCursorAxis() !== 'none') {
             rootContext.setCursorPosition({ x: event.clientX, y: event.clientY });
         }
         if (!this.hasPointerMoveOpened()) {
             rootContext.setDelays(this.delay(), this.closeDelay());
-            rootContext.onTriggerEnter(this.elementRef.nativeElement, this.payload());
+            rootContext.onTriggerEnter(this.elementRef.nativeElement, this.payload(), event);
             this.hasPointerMoveOpened.set(true);
         }
     }
@@ -710,6 +770,35 @@ class RdxTooltipTrigger {
         this.rootContext()?.onTriggerLeave();
         this.hasPointerMoveOpened.set(false);
     }
+    handleMouseOver(event) {
+        const wasNestedTriggerHovered = this.isNestedTriggerHovered();
+        const target = getTargetElement(event);
+        const nestedTriggerHovered = this.detectNestedTriggerHover(target);
+        const trigger = this.elementRef.nativeElement;
+        const targetInsideTrigger = target ? trigger.contains(target) : false;
+        const rootContext = this.rootContext();
+        if (!rootContext) {
+            return;
+        }
+        if (nestedTriggerHovered && rootContext.isOpen() && rootContext.openChangeReason() === 'trigger-hover') {
+            rootContext.closeHoverOpen();
+            return;
+        }
+        if (wasNestedTriggerHovered &&
+            !nestedTriggerHovered &&
+            targetInsideTrigger &&
+            !this.isDisabled() &&
+            !rootContext.isOpen() &&
+            isMouseLikePointerType(this.pointerType)) {
+            rootContext.setDelays(this.delay(), this.closeDelay());
+            rootContext.onTriggerEnter(trigger, this.payload(), event);
+            this.hasPointerMoveOpened.set(true);
+        }
+    }
+    handleMouseLeave() {
+        this.isNestedTriggerHovered.set(false);
+        this.pointerType = undefined;
+    }
     async handlePointerDown(event) {
         const user = this.userOnPointerDown();
         let result;
@@ -722,13 +811,28 @@ class RdxTooltipTrigger {
             return;
         }
         this.isPointerDown.set(true);
+        this.triggerInteraction.recordPointerDown(event);
+        this.pointerType = event.pointerType;
+        if (this.closeOnClick() && !this.rootContext()?.isOpen()) {
+            this.rootContext()?.cancelPendingOpen();
+        }
         const handlePointerUp = () => {
             setTimeout(() => this.isPointerDown.set(false), 1);
         };
         document.addEventListener('pointerup', handlePointerUp, { once: true });
     }
+    detectNestedTriggerHover(target) {
+        const trigger = this.elementRef.nativeElement;
+        const nearestTrigger = closestEnabledTooltipTrigger(target);
+        const nestedTriggerHovered = nearestTrigger !== null && nearestTrigger !== trigger && trigger.contains(nearestTrigger);
+        this.isNestedTriggerHovered.set(nestedTriggerHovered);
+        if (nestedTriggerHovered) {
+            this.rootContext()?.cancelPendingOpen();
+        }
+        return nestedTriggerHovered;
+    }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: RdxTooltipTrigger, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.9", type: RdxTooltipTrigger, isStandalone: true, selector: "[rdxTooltipTrigger]", inputs: { handle: { classPropertyName: "handle", publicName: "handle", isSignal: true, isRequired: false, transformFunction: null }, payload: { classPropertyName: "payload", publicName: "payload", isSignal: true, isRequired: false, transformFunction: null }, id: { classPropertyName: "id", publicName: "id", isSignal: true, isRequired: false, transformFunction: null }, closeOnClick: { classPropertyName: "closeOnClick", publicName: "closeOnClick", isSignal: true, isRequired: false, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "disabled", isSignal: true, isRequired: false, transformFunction: null }, delay: { classPropertyName: "delay", publicName: "delay", isSignal: true, isRequired: false, transformFunction: null }, closeDelay: { classPropertyName: "closeDelay", publicName: "closeDelay", isSignal: true, isRequired: false, transformFunction: null }, userOnPointerDown: { classPropertyName: "userOnPointerDown", publicName: "rdxOnPointerDown", isSignal: true, isRequired: false, transformFunction: null } }, host: { attributes: { "type": "button", "data-grace-area-trigger": "''" }, listeners: { "pointermove": "handlePointerMove($event)", "pointerleave": "handlePointerLeave()", "pointerdown": "handlePointerDown($event)", "focus": "handleFocus()", "blur": "handleBlur()", "click": "handleClick()" }, properties: { "id": "triggerId()", "attr.aria-describedby": "isOpen() ? rootContext()?.contentId : undefined", "attr.data-popup-open": "isOpen() ? \"\" : undefined", "attr.data-trigger-disabled": "isDisabled() ? \"\" : undefined" } }, hostDirectives: [{ directive: i1.RdxPopperAnchor }], ngImport: i0 }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.9", type: RdxTooltipTrigger, isStandalone: true, selector: "[rdxTooltipTrigger]", inputs: { handle: { classPropertyName: "handle", publicName: "handle", isSignal: true, isRequired: false, transformFunction: null }, payload: { classPropertyName: "payload", publicName: "payload", isSignal: true, isRequired: false, transformFunction: null }, id: { classPropertyName: "id", publicName: "id", isSignal: true, isRequired: false, transformFunction: null }, closeOnClick: { classPropertyName: "closeOnClick", publicName: "closeOnClick", isSignal: true, isRequired: false, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "disabled", isSignal: true, isRequired: false, transformFunction: null }, delay: { classPropertyName: "delay", publicName: "delay", isSignal: true, isRequired: false, transformFunction: null }, closeDelay: { classPropertyName: "closeDelay", publicName: "closeDelay", isSignal: true, isRequired: false, transformFunction: null }, userOnPointerDown: { classPropertyName: "userOnPointerDown", publicName: "rdxOnPointerDown", isSignal: true, isRequired: false, transformFunction: null } }, host: { attributes: { "type": "button", "data-grace-area-trigger": "''" }, listeners: { "pointerenter": "handlePointerEnter($event)", "pointermove": "handlePointerMove($event)", "pointerleave": "handlePointerLeave()", "mouseover": "handleMouseOver($event)", "mouseleave": "handleMouseLeave()", "pointerdown": "handlePointerDown($event)", "focus": "handleFocus($event)", "blur": "handleBlur($event)", "click": "handleClick($event)" }, properties: { "id": "triggerId()", "attr.aria-describedby": "isOpen() ? rootContext()?.contentId : undefined", "attr.data-popup-open": "triggerInteraction.dataPopupOpen()", "attr.data-trigger-disabled": "triggerInteraction.disabled() ? \"\" : undefined", "attr.data-rdx-tooltip-trigger": "isDisabled() ? undefined : \"\"" } }, hostDirectives: [{ directive: i1.RdxPopperAnchor }], ngImport: i0 }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: RdxTooltipTrigger, decorators: [{
             type: Directive,
@@ -740,14 +844,18 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                         'data-grace-area-trigger': "''",
                         '[id]': 'triggerId()',
                         '[attr.aria-describedby]': 'isOpen() ? rootContext()?.contentId : undefined',
-                        '[attr.data-popup-open]': 'isOpen() ? "" : undefined',
-                        '[attr.data-trigger-disabled]': 'isDisabled() ? "" : undefined',
+                        '[attr.data-popup-open]': 'triggerInteraction.dataPopupOpen()',
+                        '[attr.data-trigger-disabled]': 'triggerInteraction.disabled() ? "" : undefined',
+                        '[attr.data-rdx-tooltip-trigger]': 'isDisabled() ? undefined : ""',
+                        '(pointerenter)': 'handlePointerEnter($event)',
                         '(pointermove)': 'handlePointerMove($event)',
                         '(pointerleave)': 'handlePointerLeave()',
+                        '(mouseover)': 'handleMouseOver($event)',
+                        '(mouseleave)': 'handleMouseLeave()',
                         '(pointerdown)': 'handlePointerDown($event)',
-                        '(focus)': 'handleFocus()',
-                        '(blur)': 'handleBlur()',
-                        '(click)': 'handleClick()'
+                        '(focus)': 'handleFocus($event)',
+                        '(blur)': 'handleBlur($event)',
+                        '(click)': 'handleClick($event)'
                     }
                 }]
         }], ctorParameters: () => [], propDecorators: { handle: [{ type: i0.Input, args: [{ isSignal: true, alias: "handle", required: false }] }], payload: [{ type: i0.Input, args: [{ isSignal: true, alias: "payload", required: false }] }], id: [{ type: i0.Input, args: [{ isSignal: true, alias: "id", required: false }] }], closeOnClick: [{ type: i0.Input, args: [{ isSignal: true, alias: "closeOnClick", required: false }] }], disabled: [{ type: i0.Input, args: [{ isSignal: true, alias: "disabled", required: false }] }], delay: [{ type: i0.Input, args: [{ isSignal: true, alias: "delay", required: false }] }], closeDelay: [{ type: i0.Input, args: [{ isSignal: true, alias: "closeDelay", required: false }] }], userOnPointerDown: [{ type: i0.Input, args: [{ isSignal: true, alias: "rdxOnPointerDown", required: false }] }] } });