ngwr 14.3.1 → 14.5.0

package/fesm2022/ngwr-popover.mjs

@@ -1,13 +1,15 @@
+import { FocusMonitor } from '@angular/cdk/a11y';
 import { Directionality } from '@angular/cdk/bidi';
 import { coerceBooleanProperty } from '@angular/cdk/coercion';
 import { ScrollStrategyOptions } from '@angular/cdk/overlay';
 import { ComponentPortal, TemplatePortal } from '@angular/cdk/portal';
 import * as i0 from '@angular/core';
-import { input, ViewEncapsulation, Component, output, inject, ElementRef, ViewContainerRef, DestroyRef, signal, computed, effect, Directive } from '@angular/core';
+import { inject, DestroyRef, PLATFORM_ID, Service, input, ViewEncapsulation, Component, output, ElementRef, ViewContainerRef, Injector, signal, computed, effect, afterNextRender, Directive } from '@angular/core';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
 import { useI18nText } from 'ngwr/i18n';
-import { WR_OVERLAY, WrOutsideClick, WR_RESPONSIVE_OVERLAYS, wrPresentAsSheet, wrMirrorOffsets } from 'ngwr/overlay';
-import { numAttr } from 'ngwr/utils';
+import { WR_OVERLAY, WrOutsideClick, WR_RESPONSIVE_OVERLAYS, wrPresentAsSheet, wrMirrorOffsets, wrFollowDirection } from 'ngwr/overlay';
+import { KEYS, numAttr } from 'ngwr/utils';
+import { DOCUMENT, isPlatformBrowser } from '@angular/common';
 
 /**
  * @license
@@ -98,6 +100,83 @@ function wrPopoverPositions(position, paneClass) {
     }));
 }
 
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+/** `FocusMonitor._setOrigin`'s own window — see the class docs for why it matches. */
+const KEYSTROKE_WINDOW_MS = 1;
+/**
+ * The key of the keystroke being handled RIGHT NOW — `null` between them.
+ *
+ * `FocusMonitor` answers "the most recent input modality was a keyboard", which
+ * is a weaker statement than "the user's own key put focus here", and the gap
+ * between the two is exactly where a tooltip goes wrong. The origin is whatever
+ * was pressed within the last millisecond (`_setOrigin` clears it on a 1ms
+ * timer), and an overlay dismissed with Escape hands focus BACK to its trigger
+ * synchronously, inside that same keystroke — CDK's keyboard dispatcher listens
+ * on `<body>` in the bubble phase, the modality detector on `document` in
+ * capture, so the modality is always already `keyboard` by the time the drawer
+ * runs. Same for a ✕ activated with Enter. So the CDK reports `keyboard` for a
+ * hand-back and a tooltip reading the origin alone still shows itself unbidden,
+ * which is the whole failure it was meant to stop.
+ *
+ * The KEY separates them: `Tab` and the arrows are how a user moves focus,
+ * `Escape` and `Enter` dismiss and activate. A focus that lands during one of
+ * those was moved by a script.
+ *
+ * One passive capture listener for the whole app, constructed with the first
+ * `[wrPopover]` and never before it — beside the three `InputModalityDetector`
+ * already installs.
+ *
+ * The key expires on the CDK's own 1ms window rather than on a bare macrotask,
+ * and matching it is the point: the key is only ever read to EXPLAIN a keyboard
+ * origin, so it must not run out while the origin it explains is still live. A
+ * `setTimeout(0)` close would land in exactly that gap — key already forgotten,
+ * origin still `keyboard` — and read as a Tab. Everything a keystroke does
+ * synchronously, its default action and the click Enter dispatches included,
+ * happens long before either timer; anything that waits past them is judged
+ * `program` by the CDK and never reaches this question.
+ *
+ * Popover-local on purpose; no other component in the catalog asks this yet.
+ */
+class WrCurrentKeystroke {
+    doc = inject(DOCUMENT);
+    destroyRef = inject(DestroyRef);
+    isBrowser = isPlatformBrowser(inject(PLATFORM_ID));
+    current = null;
+    clearTimer = null;
+    /** `KeyboardEvent.key` for the keystroke in flight, `null` outside one. */
+    get key() {
+        return this.current;
+    }
+    constructor() {
+        if (!this.isBrowser)
+            return;
+        const record = (event) => {
+            this.current = event.key;
+            if (this.clearTimer)
+                clearTimeout(this.clearTimer);
+            this.clearTimer = setTimeout(() => (this.current = null), KEYSTROKE_WINDOW_MS);
+        };
+        // Capture, so the key is on record before any handler deeper in the tree
+        // gets to move focus with it.
+        this.doc.addEventListener('keydown', record, { capture: true, passive: true });
+        this.destroyRef.onDestroy(() => {
+            if (this.clearTimer)
+                clearTimeout(this.clearTimer);
+            this.doc.removeEventListener('keydown', record, { capture: true });
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: WrCurrentKeystroke, deps: [], target: i0.ɵɵFactoryTarget.Service });
+    static ɵprov = i0.ɵɵngDeclareService({ minVersion: "22.0.0", version: "22.1.6", ngImport: i0, type: WrCurrentKeystroke });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: WrCurrentKeystroke, decorators: [{
+            type: Service
+        }], ctorParameters: () => [] });
+
 /**
  * @license
  *
@@ -114,10 +193,10 @@ function wrPopoverPositions(position, paneClass) {
 class WrPopoverTextPanel {
     text = input.required(/* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "text" }] : /* istanbul ignore next */ []));
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.5", ngImport: i0, type: WrPopoverTextPanel, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "22.1.5", type: WrPopoverTextPanel, isStandalone: true, selector: "wr-popover-text", inputs: { text: { classPropertyName: "text", publicName: "text", isSignal: true, isRequired: true, transformFunction: null } }, host: { classAttribute: "wr-tooltip" }, ngImport: i0, template: '{{ text() }}', isInline: true, encapsulation: i0.ViewEncapsulation.None });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: WrPopoverTextPanel, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "22.1.6", type: WrPopoverTextPanel, isStandalone: true, selector: "wr-popover-text", inputs: { text: { classPropertyName: "text", publicName: "text", isSignal: true, isRequired: true, transformFunction: null } }, host: { classAttribute: "wr-tooltip" }, ngImport: i0, template: '{{ text() }}', isInline: true, encapsulation: i0.ViewEncapsulation.None });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.5", ngImport: i0, type: WrPopoverTextPanel, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: WrPopoverTextPanel, decorators: [{
             type: Component,
             args: [{
                     selector: 'wr-popover-text',
@@ -136,6 +215,27 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.5", ngImpor
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
  */
+/**
+ * Keys the USER moves focus with: Tab through the page, the arrows / Home /
+ * End through a composite that roves its own tabindex.
+ *
+ * A roving arrow move is a script `.focus()` call too — the difference from a
+ * dismissal is not who called `focus()` but whether the keystroke was a
+ * NAVIGATION or an action. Anything absent from this list (Escape, Enter,
+ * Space, a character) does something else for a living, so focus that lands
+ * during one of them was placed by a script and a tooltip stays shut.
+ */
+const NAVIGATION_KEYS = new Set([
+    KEYS.TAB,
+    KEYS.ARROW_UP,
+    KEYS.ARROW_DOWN,
+    KEYS.ARROW_LEFT,
+    KEYS.ARROW_RIGHT,
+    KEYS.HOME,
+    KEYS.END,
+    KEYS.PAGE_UP,
+    KEYS.PAGE_DOWN,
+]);
 /**
  * Anchored content panel. The same directive covers two shapes:
  *
@@ -144,9 +244,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.5", ngImpor
  *   forms, summaries, menus.
  *
  * - **Tooltip** (`mode="tooltip"`) — `[wrPopover]` takes a plain string.
- *   Shown on hover and focus, dismissed on blur / pointer-leave / Escape.
- *   Uses `aria-describedby` instead of `aria-haspopup` and is rendered into
- *   a small dark text panel.
+ *   Shown on hover and when the KEYBOARD puts focus on the trigger — never for
+ *   a `.focus()` call, which is what a dialog or drawer does when it hands
+ *   focus back. Dismissed when focus leaves / on pointer-leave / Escape. Uses
+ *   `aria-describedby` instead of `aria-haspopup` and is rendered into a small
+ *   dark text panel.
  *
  * Built on CDK Overlay so it auto-flips, closes on outside-click and Escape.
  *
@@ -179,14 +281,14 @@ class WrPopover {
      *
      * - `'popover'` (default) — template content, click trigger, dialog
      *   semantics.
-     * - `'tooltip'` — text content, hover+focus trigger, `role="tooltip"`,
-     *   `aria-describedby` on the host.
+     * - `'tooltip'` — text content, hover / keyboard-focus trigger,
+     *   `role="tooltip"`, `aria-describedby` on the host.
      */
     mode = input('popover', /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "mode" }] : /* istanbul ignore next */ []));
     /**
-     * How the popover opens. Ignored in tooltip mode — tooltips are always
-     * hover+focus. @default 'click'
+     * How the popover opens. Ignored in tooltip mode — a tooltip is always hover
+     * plus keyboard focus. @default 'click'
      */
     trigger = input('click', /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "trigger" }] : /* istanbul ignore next */ []));
@@ -217,6 +319,8 @@ class WrPopover {
     /** Fires after the panel closes. */
     closed = output();
     host = inject(ElementRef);
+    focusMonitor = inject(FocusMonitor);
+    keystroke = inject(WrCurrentKeystroke);
     overlay = inject(WR_OVERLAY);
     dir = inject(Directionality, { optional: true });
     outsideClick = inject(WrOutsideClick);
@@ -224,6 +328,7 @@ class WrPopover {
     vcr = inject(ViewContainerRef);
     scrollStrategies = inject(ScrollStrategyOptions);
     destroyRef = inject(DestroyRef);
+    injector = inject(Injector);
     /** @internal */
     isOpen = signal(false, /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "isOpen" }] : /* istanbul ignore next */ []));
@@ -237,6 +342,8 @@ class WrPopover {
     ...(ngDevMode ? [{ debugName: "resolvedPosition" }] : /* istanbul ignore next */ []));
     overlayRef = null;
     textPanelRef = null;
+    /** Whether the HOST itself holds focus — not a descendant of it. */
+    hostFocused = false;
     hoverCloseTimer = null;
     showTimer = null;
     hideTimer = null;
@@ -259,9 +366,66 @@ class WrPopover {
             const content = this.content();
             this.textPanelRef?.setInput('text', typeof content === 'string' ? content : '');
         });
+        // A tooltip answers the USER'S KEYBOARD, not every focus there is.
+        //
+        // `(focus)` fired for a programmatic one too, and something hands focus back
+        // to a trigger constantly: `WrDrawer` and `WrDialog` restore the element that
+        // was active when they opened, this directive does the same for its own
+        // popover, and any app may call `.focus()`. So closing a drawer opened from a
+        // button with a tooltip re-showed that tooltip with NOTHING left to dismiss
+        // it — the pointer is elsewhere, so no `mouseleave`, and focus stays on the
+        // button, so no blur. A pane stranded under the trigger, reported from a real
+        // app. The event alone cannot tell those apart; `FocusMonitor` is the CDK's
+        // answer to where a focus came from, and it is what Material's tooltip reads
+        // for the same reason. Mouse and touch origins are deliberately ignored:
+        // hover already drives both, and acting on them would show the tooltip twice
+        // over.
+        //
+        // The origin alone is NOT enough, though, and reading it as if it were leaves
+        // the reported bug half open: the CDK's `keyboard` means "a key went down
+        // within the last millisecond", and the dismissal that hands focus back is
+        // itself a keystroke — Escape on a drawer, Enter on its ✕. See
+        // `WrCurrentKeystroke` for the key that tells a navigation from a dismissal.
+        //
+        // Monitored in EVERY mode rather than only under `mode="tooltip"` — the mode
+        // is an input and may flip after this runs, and a subscription that only
+        // half-exists is the failure this fix is about. The handler asks instead. The
+        // cost is the CDK's own `cdk-*-focused` classes on the host, which nothing in
+        // ngwr styles.
+        //
+        // `afterNextRender` because monitoring binds document listeners: there is no
+        // DOM to bind them to on the server.
+        afterNextRender(() => {
+            this.focusMonitor
+                .monitor(this.host)
+                .pipe(takeUntilDestroyed(this.destroyRef))
+                .subscribe(origin => {
+                if (origin) {
+                    this.hostFocused = true;
+                    if (this.isTooltip() && origin === 'keyboard' && this.fromNavigationKey())
+                        this.scheduleShow();
+                    return;
+                }
+                // A null origin is a blur, and the CDK reports one for a DESCENDANT
+                // too: `_onFocus` bails when the event target is not the monitored
+                // element, `_onBlur` has no such guard. The old `(blur)` binding never
+                // bubbled, so hiding on one is new — hover a wrapper, click the button
+                // inside it, tab away, and the tooltip the POINTER opened vanished
+                // while the pointer never moved. Only the host's own focus counts.
+                if (!this.hostFocused)
+                    return;
+                this.hostFocused = false;
+                if (this.isTooltip())
+                    this.scheduleHide();
+            });
+        });
         this.destroyRef.onDestroy(() => {
             this.clearTimers();
-            this.closeOverlay();
+            this.closeOverlay(false);
+            // Completes the subject `monitor()` handed out and drops the global
+            // listeners it registered for this element; the pipe above unsubscribes
+            // either way, but the CDK's own bookkeeping only clears from here.
+            this.focusMonitor.stopMonitoring(this.host);
         });
     }
     open() {
@@ -314,24 +478,34 @@ class WrPopover {
         this.scheduleHoverClose();
     }
     /** @internal */
-    onFocus() {
-        if (!this.isTooltip())
-            return;
-        this.scheduleShow();
-    }
-    /** @internal */
-    onBlur() {
-        if (!this.isTooltip())
-            return;
-        this.scheduleHide();
-    }
-    /** @internal */
     onEscape() {
         if (!this.isTooltip())
             return;
         this.clearTimers();
         this.isOpen.set(false);
     }
+    /**
+     * Whether the keystroke in flight is one the user moves focus with.
+     *
+     * Asked only of a `keyboard` origin, which the CDK grants to any focus landing
+     * within a millisecond of a keydown — including the hand-back a drawer
+     * performs while Escape is still being handled. That is the reported bug's
+     * keyboard half, and the origin cannot see it.
+     *
+     * NO key on record answers `true`, and that polarity is chosen rather than
+     * inherited: a keyboard modality with no keystroke behind it is a screen
+     * reader's virtual cursor (the CDK reads its synthetic mousedown as
+     * `keyboard`) or a deliberate `focusVia(el, 'keyboard')`, and both are the
+     * user. Refusing wants positive evidence of a key that does something other
+     * than navigate — silence must not cost an AT user the hint. The two windows
+     * are aligned so that "keyboard origin, no key" cannot mean "the key just
+     * expired"; what it does still admit is a `FocusMonitorDetectionMode.EVENTUAL`
+     * app, where the CDK never expires an origin at all.
+     */
+    fromNavigationKey() {
+        const key = this.keystroke.key;
+        return key === null || NAVIGATION_KEYS.has(key);
+    }
     // Tooltip timers
     scheduleShow() {
         if (this.isOpen()) {
@@ -369,13 +543,17 @@ class WrPopover {
         // from the trigger and slide the panel up from the bottom edge.
         const asSheet = !tooltip && wrPresentAsSheet(this.responsive(), this.responsiveConfig);
         const paneClass = tooltip ? 'wr-tooltip-overlay' : 'wr-popover-overlay';
-        const positionStrategy = asSheet
-            ? this.overlay.position().global().centerHorizontally().bottom('0')
+        // Kept as its own binding rather than inlined into the ternary: it is the
+        // half a direction flip has to rebuild, and a sheet — anchored to nothing —
+        // has no list at all, which is what `null` says here.
+        const connected = asSheet
+            ? null
             : this.overlay
                 .position()
                 .flexibleConnectedTo(this.host)
                 .withPositions(wrMirrorOffsets(wrPopoverPositions(position, paneClass), this.isRtl()))
                 .withPush(true);
+        const positionStrategy = connected ?? this.overlay.position().global().centerHorizontally().bottom('0');
         // The `--<placement>` half is no longer set here: each fallback position
         // carries its own, so the pane names the placement it landed on instead of
         // the one that was requested, and the arrow follows a flip. A sheet has no
@@ -389,6 +567,15 @@ class WrPopover {
             backdropClass: asSheet ? 'wr-overlay-backdrop' : undefined,
             panelClass: overlayClass,
         });
+        // The CDK read the direction once, just now, and will never look again — so
+        // an app that flips while this panel is up mirrors the page around a pane
+        // still rendering `ltr`, with `wr-segmented` and friends inside it already
+        // laying themselves out the other way. Rebuilding the list matters as much
+        // as the attribute: `wrMirrorOffsets` turned the 8px gap around at open, and
+        // an unmirrored offset puts a side-placed panel back on top of its trigger.
+        // A sheet has no list, and `connected?.` is what says so — the arguments are
+        // never evaluated for one.
+        wrFollowDirection(this.overlayRef, this.dir, this.injector, direction => connected?.withPositions(wrMirrorOffsets(wrPopoverPositions(position, paneClass), direction === 'rtl')));
         if (asSheet) {
             this.overlayRef
                 .backdropClick()
@@ -469,7 +656,23 @@ class WrPopover {
         }
         this.opened.emit();
     }
-    closeOverlay() {
+    /**
+     * Tear the overlay down, and tell the host — unless the host is going away
+     * with it.
+     *
+     * `notify: false` is the DESTROY path, and it is not a nicety. An `output()`
+     * belongs to the view that declares it, so emitting from `onDestroy` is
+     * refused: Angular logs `NG0953: Unexpected emit for destroyed OutputRef` and
+     * the listener never runs. Measured — a `(closed)` handler on a dropdown whose
+     * host view is removed while the menu is open fired zero times and left a
+     * console error behind. There is nobody to notify at that point, because the
+     * consumer's own view is being torn down in the same pass; `wr-popconfirm`
+     * already disposes without emitting, and this brings the other two into line.
+     *
+     * The focus hand-back is skipped for the same reason — the host element is on
+     * its way out of the document.
+     */
+    closeOverlay(notify = true) {
         if (!this.overlayRef)
             return;
         if (this.isTooltip() || this.trigger() === 'hover') {
@@ -493,9 +696,11 @@ class WrPopover {
         this.overlayRef = null;
         // Disposing destroys the panel component; a retained ref would pin its view.
         this.textPanelRef = null;
-        if (focusWasInside)
-            this.host.nativeElement.focus();
-        this.closed.emit();
+        if (notify) {
+            if (focusWasInside)
+                this.host.nativeElement.focus();
+            this.closed.emit();
+        }
     }
     onOverlayLeave = (event) => {
         const related = event.relatedTarget;
@@ -536,10 +741,10 @@ class WrPopover {
     isRtl() {
         return this.dir?.value === 'rtl';
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.5", ngImport: i0, type: WrPopover, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.1.5", type: WrPopover, isStandalone: true, selector: "[wrPopover]", inputs: { content: { classPropertyName: "content", publicName: "wrPopover", isSignal: true, isRequired: true, transformFunction: null }, mode: { classPropertyName: "mode", publicName: "mode", isSignal: true, isRequired: false, transformFunction: null }, trigger: { classPropertyName: "trigger", publicName: "trigger", isSignal: true, isRequired: false, transformFunction: null }, position: { classPropertyName: "position", publicName: "position", isSignal: true, isRequired: false, transformFunction: null }, showDelay: { classPropertyName: "showDelay", publicName: "showDelay", isSignal: true, isRequired: false, transformFunction: null }, hideDelay: { classPropertyName: "hideDelay", publicName: "hideDelay", isSignal: true, isRequired: false, transformFunction: null }, responsive: { classPropertyName: "responsive", publicName: "responsive", isSignal: true, isRequired: false, transformFunction: null }, ariaLabel: { classPropertyName: "ariaLabel", publicName: "ariaLabel", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { opened: "opened", closed: "closed" }, host: { listeners: { "click": "onClick($event)", "mouseenter": "onMouseEnter()", "mouseleave": "onMouseLeave($event)", "focus": "onFocus()", "blur": "onBlur()", "keydown.escape": "onEscape()" }, properties: { "attr.aria-haspopup": "isTooltip() ? null : \"dialog\"", "attr.aria-expanded": "isTooltip() ? null : isOpen()", "attr.aria-controls": "!isTooltip() && isOpen() ? panelId : null", "attr.aria-describedby": "isTooltip() && isOpen() ? panelId : null" }, classAttribute: "wr-popover-trigger" }, exportAs: ["wrPopover"], ngImport: i0 });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: WrPopover, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.1.6", type: WrPopover, isStandalone: true, selector: "[wrPopover]", inputs: { content: { classPropertyName: "content", publicName: "wrPopover", isSignal: true, isRequired: true, transformFunction: null }, mode: { classPropertyName: "mode", publicName: "mode", isSignal: true, isRequired: false, transformFunction: null }, trigger: { classPropertyName: "trigger", publicName: "trigger", isSignal: true, isRequired: false, transformFunction: null }, position: { classPropertyName: "position", publicName: "position", isSignal: true, isRequired: false, transformFunction: null }, showDelay: { classPropertyName: "showDelay", publicName: "showDelay", isSignal: true, isRequired: false, transformFunction: null }, hideDelay: { classPropertyName: "hideDelay", publicName: "hideDelay", isSignal: true, isRequired: false, transformFunction: null }, responsive: { classPropertyName: "responsive", publicName: "responsive", isSignal: true, isRequired: false, transformFunction: null }, ariaLabel: { classPropertyName: "ariaLabel", publicName: "ariaLabel", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { opened: "opened", closed: "closed" }, host: { listeners: { "click": "onClick($event)", "mouseenter": "onMouseEnter()", "mouseleave": "onMouseLeave($event)", "keydown.escape": "onEscape()" }, properties: { "attr.aria-haspopup": "isTooltip() ? null : \"dialog\"", "attr.aria-expanded": "isTooltip() ? null : isOpen()", "attr.aria-controls": "!isTooltip() && isOpen() ? panelId : null", "attr.aria-describedby": "isTooltip() && isOpen() ? panelId : null" }, classAttribute: "wr-popover-trigger" }, exportAs: ["wrPopover"], ngImport: i0 });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.5", ngImport: i0, type: WrPopover, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.6", ngImport: i0, type: WrPopover, decorators: [{
             type: Directive,
             args: [{
                     selector: '[wrPopover]',
@@ -558,8 +763,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.5", ngImpor
                         '(click)': 'onClick($event)',
                         '(mouseenter)': 'onMouseEnter()',
                         '(mouseleave)': 'onMouseLeave($event)',
-                        '(focus)': 'onFocus()',
-                        '(blur)': 'onBlur()',
+                        // No `(focus)` / `(blur)` here: a tooltip answers the KEYBOARD, and a plain
+                        // focus event cannot say where the focus came from. `FocusMonitor` can — see
+                        // the constructor.
                         '(keydown.escape)': 'onEscape()',
                     },
                 }]