ngwr 14.4.0 → 14.5.1

package/types/ngwr-popover-testing.d.ts

@@ -34,9 +34,9 @@ interface WrPopoverHarnessFilters extends BaseHarnessFilters {
  *
  * - **popover** — template content, opens on click (or hover), announces
  *   `role="dialog"` and is what the trigger's `aria-expanded` describes;
- * - **tooltip** — string content, opens on hover AND focus after a delay,
- *   announces `role="tooltip"` and DESCRIBES its trigger instead of being
- *   owned by it.
+ * - **tooltip** — string content, opens after a delay on hover or on KEYBOARD
+ *   focus (never on a `.focus()` call — see {@link focus}), announces
+ *   `role="tooltip"` and DESCRIBES its trigger instead of being owned by it.
  *
  * The panel is never inside the trigger: it is a portal in the overlay
  * container, a sibling of the whole app. It is reached through the document
@@ -112,7 +112,9 @@ declare class WrPopoverHarness extends ContentContainerComponentHarness {
      * Hover leads because a click is an outside pointer event for every OTHER open
      * panel, so leading with it would dismiss someone else's popover on the way to
      * opening this one; a click-driven popover ignores the hover outright. A
-     * tooltip is never clicked at all — hover and focus are its only gestures.
+     * tooltip is never clicked at all, and hover is the only one of its two
+     * gestures a harness can perform — the other is a keyboard focus, which is
+     * `FocusMonitor`'s to grant (see {@link focus}).
      *
      * Throws when nothing appears: a tooltip with an empty string never opens, and
      * a spec on fake timers has to advance the clock itself.
@@ -133,7 +135,22 @@ declare class WrPopoverHarness extends ContentContainerComponentHarness {
     hover(): Promise<void>;
     /** Move the pointer off the trigger. The panel goes after the grace period, not instantly. */
     mouseAway(): Promise<void>;
-    /** Focus the trigger — a tooltip's other opening gesture, so keyboard users get the hint too. */
+    /**
+     * Focus the trigger PROGRAMMATICALLY — and note that this does not open a
+     * tooltip.
+     *
+     * `TestElement.focus()` is a `.focus()` call, which is the one kind of focus a
+     * tooltip deliberately ignores: it shows for a KEYBOARD focus only, because
+     * every overlay in the catalog hands focus back to the trigger it was opened
+     * from, and a tooltip that answered those appeared with no pointer to leave and
+     * no focus to lose. So this method is the way to assert that NOTHING happens.
+     *
+     * There is no keyboard-origin twin, and it cannot be written honestly here:
+     * origin is `FocusMonitor`'s answer, this class has no injector, and the Tab
+     * that would earn it moves focus in a browser and not in jsdom. A spec that
+     * needs the opening gesture drives `FocusMonitor.focusVia(el, 'keyboard')`
+     * itself, the way `popover.spec.ts` does — or uses `hover()`.
+     */
     focus(): Promise<void>;
     /** Blur the trigger, which hides a tooltip after `hideDelay`. */
     blur(): Promise<void>;

package/types/ngwr-popover.d.ts

@@ -23,13 +23,13 @@ declare 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.
      */
     readonly mode: _angular_core.InputSignal<"popover" | "tooltip">;
     /**
-     * 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'
      */
     readonly trigger: _angular_core.InputSignal<"click" | "hover">;
     /** Anchor side. @default 'bottom' for popover, 'top' for tooltip */
@@ -57,6 +57,8 @@ declare class WrPopover {
     /** Fires after the panel closes. */
     readonly closed: _angular_core.OutputEmitterRef<void>;
     private readonly host;
+    private readonly focusMonitor;
+    private readonly keystroke;
     private readonly overlay;
     private readonly dir;
     private readonly outsideClick;
@@ -64,6 +66,7 @@ declare class WrPopover {
     private readonly vcr;
     private readonly scrollStrategies;
     private readonly destroyRef;
+    private readonly injector;
     /** @internal */
     readonly isOpen: _angular_core.WritableSignal<boolean>;
     /** @internal */
@@ -74,6 +77,8 @@ declare class WrPopover {
     private readonly resolvedPosition;
     private overlayRef;
     private textPanelRef;
+    /** Whether the HOST itself holds focus — not a descendant of it. */
+    private hostFocused;
     private hoverCloseTimer;
     private showTimer;
     private hideTimer;
@@ -88,11 +93,26 @@ declare class WrPopover {
     /** @internal */
     protected onMouseLeave(event: MouseEvent): void;
     /** @internal */
-    protected onFocus(): void;
-    /** @internal */
-    protected onBlur(): void;
-    /** @internal */
     protected onEscape(): void;
+    /**
+     * 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.
+     */
+    private fromNavigationKey;
     private scheduleShow;
     private scheduleHide;
     private clearTimers;

package/types/ngwr-segmented.d.ts

@@ -148,6 +148,22 @@ declare class WrSegmented<T = unknown> implements FormValueControl<T | null> {
     protected readonly selectedIndex: _angular_core.Signal<number>;
     /** Flips true after the first paint so the thumb only animates user-driven changes, not the initial snap. */
     private readonly mounted;
+    /**
+     * True for the tick in which the reading direction changed.
+     *
+     * Mirroring moves the thumb's SLOT by the whole width of the strip (see
+     * `thumbStyle`), and animating that is a quarter-second of the pill travelling
+     * across options it does not mark — caught under the wrong label every time the
+     * docs site's LTR / RTL switch was used, which is a strip inside an overlay that
+     * mirrors underneath it. The selection did not move, so neither should the pill:
+     * the stylesheet drops its transition while this is set, and the new slot lands
+     * in the same pass that removes it.
+     *
+     * Cleared from a task rather than `afterNextRender`, which runs inside the very
+     * change detection that set this and would put the transition back before the
+     * new position is painted.
+     */
+    private readonly flipping;
     constructor();
     protected readonly classes: _angular_core.Signal<string>;
     private readonly dir;

package/types/ngwr-select.d.ts

@@ -710,6 +710,13 @@ declare class WrSelect implements FormValueControl<unknown>, WrSelectContext {
     private readonly destroyRef;
     private readonly platformId;
     private readonly injector;
+    /**
+     * Ambient reading direction, for the open panel alone — nothing in this
+     * component reads it directly. Optional so a bare `TestBed` needs no
+     * provider; `Directionality` is root-provided anyway, and a missing one
+     * simply reads as `ltr`.
+     */
+    private readonly dir;
     private overlayRef;
     constructor();
     isSelected(value: unknown): boolean;

package/types/ngwr-table.d.ts

@@ -861,6 +861,14 @@ declare class WrTableGroupHeader {
 /**
  * Sort indicator rendered in a sortable column's header.
  *
+ * Draws an ARROW for a sorted column — up for `asc`, the same arrow turned by
+ * the stylesheet for `desc` — and a flat LINE for a column that sorts but is
+ * not sorted. A different shape rather than a fainter arrow, on purpose: a
+ * dimmed up-arrow reads as "sorted ascending", which is the one thing an
+ * unsorted column must not say, and a state told apart by opacity and colour
+ * alone is lost to anyone who cannot see that difference. A line also has no
+ * direction to mirror under RTL.
+ *
  * @internal — used internally by `<wr-table>`. Parent listens for clicks
  * on the indicator to cycle direction.
  */

package/types/ngwr-toast.d.ts

@@ -164,6 +164,8 @@ declare class WrToastRef {
 declare class WrToast {
     private readonly overlay;
     private readonly config;
+    private readonly injector;
+    private readonly dir;
     private overlayRef;
     private hostRef;
     /** Watches the overlay container for overlays opened after the host. */

package/types/ngwr-tour.d.ts

@@ -115,6 +115,12 @@ declare class WrTour {
     private anyResolvableBefore;
     private resolve;
     private openStep;
+    /**
+     * The card's fallback table for one placement, with its inline offsets already
+     * mirrored. Built per call rather than per step: the direction can change while
+     * the step is on screen, and a table is what has to be rebuilt when it does.
+     */
+    private stepPositions;
     private placeSpotlight;
     private teardownStep;
     /**

package/types/ngwr-tree.d.ts

@@ -186,7 +186,8 @@ declare class WrTree<TId = string> implements FormValueControl<unknown> {
      * anyway, and a missing one simply reads as `ltr`.
      *
      * Read at keystroke time rather than cached, so a runtime `dir` flip needs no
-     * subscription to `change`.
+     * subscription to `change` — the overlay is the half that does, and
+     * `wrFollowDirection` in `openOverlay()` is where that lives.
      */
     private readonly dir;
     /** Currently focused row's index in the flattened visible list. */

package/types/ngwr-version.d.ts

@@ -16,7 +16,7 @@ import { InjectionToken } from '@angular/core';
  * Distinct from `Version` exported by `@angular/core`, which reports the
  * loaded Angular runtime version (e.g. `'22.0.0'`), not ngwr's.
  */
-declare const NGWR_VERSION = "14.4.0";
+declare const NGWR_VERSION = "14.5.1";
 
 /**
  * @license

package/types/ngwr-window.d.ts

@@ -376,6 +376,7 @@ declare class WrWindowManager {
     private readonly parentInjector;
     private readonly storage;
     private readonly isBrowser;
+    private readonly dir;
     private readonly baseZ;
     private topZ;
     private openCount;