ngwr 10.2.0 → 10.2.1

package/types/ngwr-calendar.d.ts

@@ -56,10 +56,20 @@ declare class WrCalendar {
     readonly max: _angular_core.InputSignal<Date | null>;
     /** Predicate — return `false` to disable specific dates (e.g. weekends only). */
     readonly dateFilter: _angular_core.InputSignal<((date: Date) => boolean) | null>;
+    /**
+     * Move real focus onto the roving cell as soon as the grid is on screen.
+     *
+     * Off by default: a standalone `<wr-calendar>` sitting in a page must not
+     * steal focus on load. `wr-date-picker` turns it on for the popup it opens
+     * from its trigger, where the user asked to be taken to the calendar.
+     * @default false
+     */
+    readonly autoFocus: _angular_core.InputSignalWithTransform<boolean, any>;
     /** Disable interaction entirely. @default false */
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, any>;
     private readonly adapter;
     private readonly host;
+    private readonly injector;
     /** Currently displayed month (any date inside it). */
     protected readonly viewDate: _angular_core.WritableSignal<Date>;
     /** Date currently focused by keyboard (single roving tabindex). */
@@ -105,11 +115,27 @@ declare class WrCalendar {
     protected onCellLeave(): void;
     private applyRangeClick;
     protected onKeyDown(event: KeyboardEvent): void;
+    /**
+     * The first selectable day at or after `candidate`, else the first before it,
+     * else `candidate` unchanged when everything nearby is closed off. Bounded at
+     * a year each way so a pathological `dateFilter` cannot spin.
+     */
+    private nearestEnabled;
+    /**
+     * The first selectable day at `candidate` or beyond it in `step`'s direction,
+     * else null when that whole direction is closed off — which is the answer for
+     * an ArrowLeft that would cross `min`: stay put.
+     *
+     * Direction matters. Reusing `nearestEnabled`, which probes forward first,
+     * would send an ArrowLeft over a disabled weekend straight back to the day it
+     * started from, so the ring could never cross the hole.
+     */
+    private nearestEnabledToward;
     private focusActiveCell;
     /** Used by the template's `track` expression. */
     protected trackByTime(_: number, date: Date): number;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrCalendar, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrCalendar, "wr-calendar", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "date": { "alias": "date"; "required": false; "isSignal": true; }; "range": { "alias": "range"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "dateFilter": { "alias": "dateFilter"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "date": "dateChange"; "range": "rangeChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrCalendar, "wr-calendar", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "date": { "alias": "date"; "required": false; "isSignal": true; }; "range": { "alias": "range"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "dateFilter": { "alias": "dateFilter"; "required": false; "isSignal": true; }; "autoFocus": { "alias": "autoFocus"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "date": "dateChange"; "range": "rangeChange"; }, never, never, true, never>;
 }
 
 export { WrCalendar };

package/types/ngwr-clipboard.d.ts

@@ -54,7 +54,14 @@ declare class WrClipboard {
      * return `'unsupported'` when the capability genuinely isn't there.
      */
     permission(name: 'read' | 'write'): Promise<WrClipboardPermission>;
-    /** Hidden-textarea + `execCommand('copy')` write. Synchronous, no permissions. */
+    /**
+     * Hidden-textarea + `execCommand('copy')` write. Synchronous, no permissions.
+     *
+     * `select()` takes focus, and the textarea is removed a moment later — so
+     * without putting focus back, every copy on a non-secure origin (plain
+     * `http://`, which is exactly where the async clipboard is missing) leaves
+     * focus on `<body>` and the user's next Tab restarts from the top of the page.
+     */
     private legacyWrite;
     static ɵfac: i0.ɵɵFactoryDeclaration<WrClipboard, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<WrClipboard>;

package/types/ngwr-date-picker.d.ts

@@ -84,6 +84,7 @@ declare class WrDatePicker implements FormValueControl<Date | null> {
     private readonly host;
     private readonly destroyRef;
     protected readonly inputEl: _angular_core.Signal<ElementRef<HTMLInputElement>>;
+    protected readonly triggerEl: _angular_core.Signal<ElementRef<HTMLButtonElement> | undefined>;
     /** The picked Date. Bound by `[formField]`, or two-way via `[(value)]`. */
     readonly value: _angular_core.ModelSignal<Date | null>;
     /** Emitted on blur so a bound field can mark itself touched. */
@@ -92,6 +93,14 @@ declare class WrDatePicker implements FormValueControl<Date | null> {
     protected readonly text: _angular_core.WritableSignal<string>;
     /** Whether the popover is currently open. */
     protected readonly overlayOpen: _angular_core.WritableSignal<boolean>;
+    /**
+     * Where focus came from, captured as an explicit argument at open time —
+     * never read off `document.activeElement`, which by then may already be the
+     * pane. Every close path that took focus INTO the panel hands it back here.
+     */
+    private openedFrom;
+    /** Whether the panel this open cycle should take focus. */
+    private autoFocusPanel;
     /** Resolved format — falls back to a mode-appropriate default. */
     protected readonly resolvedFormat: _angular_core.Signal<string>;
     protected readonly isTime: _angular_core.Signal<boolean>;
@@ -99,6 +108,9 @@ declare class WrDatePicker implements FormValueControl<Date | null> {
     private readonly labelDate;
     private readonly labelTime;
     private readonly labelDateTime;
+    private readonly panelLabelDate;
+    private readonly panelLabelTime;
+    private readonly panelLabelDateTime;
     /**
      * Accessible name of the text field. Falls back to the placeholder, then to
      * the same catalog string the calendar button uses — the field is a
@@ -108,6 +120,16 @@ declare class WrDatePicker implements FormValueControl<Date | null> {
     private readonly fieldLabel;
     protected readonly resolvedAriaLabel: _angular_core.Signal<string>;
     protected readonly triggerLabel: _angular_core.Signal<string>;
+    /**
+     * Accessible name of the popup. The trigger advertises
+     * `aria-haspopup="dialog"`, so the panel is a `role="dialog"` — and an unnamed
+     * dialog announces as a bare "dialog". Defaults to the catalog's
+     * `datePicker.panel*` string for the current `mode`.
+     */
+    readonly panelAriaLabel: _angular_core.InputSignal<string | null>;
+    /** Popup id — what the trigger's `aria-controls` points at while open. */
+    protected readonly panelId: string;
+    protected readonly resolvedPanelLabel: _angular_core.Signal<string>;
     protected readonly classes: _angular_core.Signal<string>;
     private overlayRef;
     /** Live calendar ref while the date popover is open — lets the panel track
@@ -123,6 +145,24 @@ declare class WrDatePicker implements FormValueControl<Date | null> {
     /** Called by the input's click — opens the overlay if it isn't open already. */
     protected openOnInput(): void;
     protected toggleOverlay(): void;
+    /**
+     * The keyboard route into the panel, per the APG date-picker pattern.
+     *
+     * `Alt+ArrowDown` opens and takes focus; a bare arrow moves focus in when the
+     * panel is ALREADY open, which is how someone who opened it by clicking the
+     * field gets to the grid. Every other key — characters, Backspace, the
+     * horizontal arrows, Home / End — is left to the field untouched, so typing a
+     * date keeps working exactly as before.
+     */
+    protected onFieldKey(event: KeyboardEvent): void;
+    /**
+     * Move focus into an already-mounted panel. A plain query is right HERE and
+     * wrong at mount time: the panel has settled, so there is no deferral to get
+     * wrong — and it keeps `autoFocus` as the single piece of panel API.
+     */
+    private focusPanel;
+    /** Hand focus back to whatever opened the panel, if it is still on the page. */
+    private restoreFocus;
     private openOverlay;
     private attachDate;
     private attachTime;
@@ -131,12 +171,19 @@ declare class WrDatePicker implements FormValueControl<Date | null> {
     /** Push a value to the model while remembering it, so the sync effect treats
      * the resulting change as an echo and leaves the display text alone. */
     private commitValue;
+    /**
+     * Focus goes back to the opener only when it was still INSIDE the panel —
+     * dropped there, it would land on `<body>` and the next Tab would restart
+     * from the top of the page. When focus had already moved elsewhere (a click
+     * on another control, which is itself what closed us) it is left alone:
+     * stealing it back would fight the user for the caret.
+     */
     private closeOverlay;
     private dispose;
     private isOutOfBounds;
     private sameDate;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrDatePicker, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrDatePicker, "wr-date-picker", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "dateFilter": { "alias": "dateFilter"; "required": false; "isSignal": true; }; "timeFormat": { "alias": "timeFormat"; "required": false; "isSignal": true; }; "showSeconds": { "alias": "showSeconds"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrDatePicker, "wr-date-picker", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "dateFilter": { "alias": "dateFilter"; "required": false; "isSignal": true; }; "timeFormat": { "alias": "timeFormat"; "required": false; "isSignal": true; }; "showSeconds": { "alias": "showSeconds"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "panelAriaLabel": { "alias": "panelAriaLabel"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; }, never, never, true, never>;
 }
 
 /**
@@ -154,6 +201,8 @@ declare class WrDatePicker implements FormValueControl<Date | null> {
  */
 type WrDateRange = readonly [Date | null, Date | null];
 
+/** Which end of the range an edit applies to. */
+type RangeEnd = 0 | 1;
 /**
  * Date-range picker — two text inputs sharing one range calendar.
  *
@@ -224,7 +273,17 @@ declare class WrDateRangePicker implements FormValueControl<WrDateRange | null>
      * @default false
      */
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, any>;
-    /** Read-only — inputs not typeable, but the trigger icon still opens the overlay. @default false */
+    /**
+     * Read-only — neither the inputs nor the calendar can change the value.
+     *
+     * Deliberately stricter than `wr-date-picker`, which still opens its popup
+     * while read-only: with two fields feeding one calendar there is no reading
+     * of "untypeable" that leaves the grid free to rewrite both ends. The doc
+     * used to promise the trigger still opened; the code has always refused, and
+     * refusing is the behaviour worth keeping.
+     *
+     * @default false
+     */
     readonly readonly: _angular_core.InputSignalWithTransform<boolean, any>;
     private readonly adapter;
     private readonly overlay;
@@ -233,6 +292,8 @@ declare class WrDateRangePicker implements FormValueControl<WrDateRange | null>
     private readonly host;
     private readonly destroyRef;
     protected readonly startEl: _angular_core.Signal<ElementRef<HTMLInputElement>>;
+    protected readonly endEl: _angular_core.Signal<ElementRef<HTMLInputElement>>;
+    protected readonly triggerEl: _angular_core.Signal<ElementRef<HTMLButtonElement> | undefined>;
     /** The picked range. Bound by `[formField]`, or two-way via `[(value)]`. */
     readonly value: _angular_core.ModelSignal<WrDateRange | null>;
     /** Emitted on blur so a bound field can mark itself touched. */
@@ -242,12 +303,34 @@ declare class WrDateRangePicker implements FormValueControl<WrDateRange | null>
     protected readonly endText: _angular_core.WritableSignal<string>;
     /** Whether the popover is currently open. */
     protected readonly overlayOpen: _angular_core.WritableSignal<boolean>;
+    /**
+     * Which element opened the popup — captured as an argument, never read off
+     * `document.activeElement`, which by then may already be the pane. With TWO
+     * text inputs this is the whole point: "restore focus to the field" is
+     * ambiguous here, and the old code resolved it by always picking the START
+     * input, so closing from the end input threw the caret across the control.
+     */
+    private openedFrom;
+    /** Whether the panel this open cycle should take focus. */
+    private autoFocusPanel;
     /** Resolved format — falls back to a mode-appropriate default. */
     protected readonly resolvedFormat: _angular_core.Signal<string>;
     protected readonly isDateTime: _angular_core.Signal<boolean>;
     protected readonly triggerLabel: string;
     protected readonly startLabel: string;
     protected readonly endLabel: string;
+    private readonly panelLabelRange;
+    private readonly panelLabelRangeDateTime;
+    /**
+     * Accessible name of the popup. The trigger advertises
+     * `aria-haspopup="dialog"`, so the pane is a `role="dialog"` — and an unnamed
+     * dialog announces as a bare "dialog". Defaults to the catalog's
+     * `datePicker.panelRange*` string for the current `mode`.
+     */
+    readonly panelAriaLabel: _angular_core.InputSignal<string | null>;
+    /** Popup id — what the trigger's `aria-controls` points at while open. */
+    protected readonly panelId: string;
+    protected readonly resolvedPanelLabel: _angular_core.Signal<string>;
     protected readonly classes: _angular_core.Signal<string>;
     private overlayRef;
     /** Live panel ref while the popover is open — lets typed edits move the
@@ -261,15 +344,39 @@ declare class WrDateRangePicker implements FormValueControl<WrDateRange | null>
     protected onEndInput(event: Event): void;
     protected onBlur(event: FocusEvent): void;
     /** Called by an input's click — opens the overlay if it isn't open already. */
-    protected openOnInput(): void;
+    protected openOnInput(end: RangeEnd): void;
     protected toggleOverlay(): void;
+    /**
+     * The keyboard route into the popup, per the APG date-picker pattern, and the
+     * only one either field has. `Alt+ArrowDown` opens and takes focus; a bare
+     * vertical arrow walks focus in when the popup is ALREADY open, which is how
+     * someone who opened it by clicking a field reaches the grid. Every other key
+     * belongs to the field, so typing a date keeps working with the popup open.
+     */
+    protected onFieldKey(event: KeyboardEvent, end: RangeEnd): void;
+    /** The input element for an end — the two are otherwise addressed by index. */
+    private fieldEl;
+    /**
+     * Move focus into an already-mounted panel. A plain query is right HERE and
+     * wrong at mount time: the panel has settled, so there is no deferral to get
+     * wrong — and it keeps `autoFocus` as the single piece of panel API.
+     */
+    private focusPanel;
+    /** Hand focus back to whatever opened the popup, if it is still on the page. */
+    private restoreFocus;
     private onRangeInput;
     private openOverlay;
     /**
-     * Close the popover. `restoreFocus` returns focus to the start input — needed
-     * when the overlay is dismissed while focus lives inside it (picking the
-     * second date), because disposing then leaves focus on a removed element and
-     * the browser falls back to `<body>`.
+     * Close the popover, handing focus back to whichever field or button opened
+     * it — but ONLY when focus was still inside the pane. Dropped there it would
+     * land on `<body>` and the next Tab would restart from the top of the page;
+     * moved on by the user, it must be left where they put it.
+     *
+     * There is deliberately no "always restore" escape hatch. Escape reaches this
+     * overlay from anywhere in the document (the CDK dispatches it to the topmost
+     * one), so forcing a restore would drag the caret backwards out of the field
+     * the user was actually typing in — into the one that happened to open the
+     * popup, possibly several Tab stops away.
      */
     private closeOverlay;
     private dispose;
@@ -300,9 +407,18 @@ declare class WrDateRangePicker implements FormValueControl<WrDateRange | null>
      */
     private isOutOfBounds;
     private sameDate;
+    /**
+     * `null` and `[null, null]` are the same VALUE — an empty range — and treating
+     * them as different is what let the FIRST blur on an untouched picker write
+     * `[null, null]` over the `null` it was bound to. No date had moved, but
+     * `model()` emitted: a bound `[formField]` went dirty from nothing but tabbing
+     * through, and a consumer's `@if (period())` flipped from empty to truthy with
+     * neither end picked. The write guard in `commitRange` is only as good as this
+     * comparison.
+     */
     private sameRange;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrDateRangePicker, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrDateRangePicker, "wr-date-range-picker", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "startPlaceholder": { "alias": "startPlaceholder"; "required": false; "isSignal": true; }; "endPlaceholder": { "alias": "endPlaceholder"; "required": false; "isSignal": true; }; "separator": { "alias": "separator"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "dateFilter": { "alias": "dateFilter"; "required": false; "isSignal": true; }; "timeFormat": { "alias": "timeFormat"; "required": false; "isSignal": true; }; "showSeconds": { "alias": "showSeconds"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrDateRangePicker, "wr-date-range-picker", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "startPlaceholder": { "alias": "startPlaceholder"; "required": false; "isSignal": true; }; "endPlaceholder": { "alias": "endPlaceholder"; "required": false; "isSignal": true; }; "separator": { "alias": "separator"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "dateFilter": { "alias": "dateFilter"; "required": false; "isSignal": true; }; "timeFormat": { "alias": "timeFormat"; "required": false; "isSignal": true; }; "showSeconds": { "alias": "showSeconds"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "panelAriaLabel": { "alias": "panelAriaLabel"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; }, never, never, true, never>;
 }
 
 export { WrDatePicker, WrDateRangePicker };

package/types/ngwr-dialog.d.ts

@@ -140,6 +140,19 @@ declare class WrDialog {
     private readonly responsiveConfig;
     private readonly i18n;
     open<C, R = unknown, D = unknown>(component: ComponentType<C>, options?: WrDialogOptions<D>): WrDialogRef<C, R>;
+    /**
+     * The dismiss button's accessible name.
+     *
+     * Two failure modes, and resolving PER OPEN is what covers both. `t()` hands
+     * back the KEY on a miss, and `WrI18n` is root-provided with an empty catalog
+     * by default, so an app that never configured i18n named its dismiss button
+     * "dialog.close" — a name axe cannot fault, because a name is present, and a
+     * screen reader reads out verbatim. Resolving once at injection time fixed
+     * that but froze the answer: this is a root service, constructed before an
+     * async catalog has loaded, so a localized app got the English fallback on
+     * every dialog it ever opened.
+     */
+    private closeLabel;
     static ɵfac: i0.ɵɵFactoryDeclaration<WrDialog, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<WrDialog>;
 }

package/types/ngwr-drawer.d.ts

@@ -254,6 +254,21 @@ declare class WrDrawerManager {
     private readonly isBrowser;
     private readonly i18n;
     open<C, R = unknown, D = unknown>(component: ComponentType<C>, options?: WrDrawerOptions<D>): WrDrawerRef<C, R>;
+    /**
+     * The dismiss button's accessible name.
+     *
+     * Resolved per open, not once at injection: this is a root service, so a
+     * `readI18nText` field — which is what `WrDialog` uses — would be evaluated
+     * before an async catalog had loaded and then freeze that answer for the life
+     * of the app.
+     *
+     * The miss check is the point. `t()` hands back the KEY when the catalog has
+     * no entry, and `WrI18n` is root-provided with an empty catalog by default —
+     * so an app that never configured i18n got a button announced as
+     * "drawer.close, button". A name WAS present, which is exactly why the axe
+     * gate could not see it.
+     */
+    private closeLabel;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrDrawerManager, never>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<WrDrawerManager>;
 }

package/types/ngwr-hotkey.d.ts

@@ -68,9 +68,11 @@ declare class WrHotkey {
     private readonly doc;
     private readonly zone;
     private readonly platform;
+    private readonly destroyRef;
     private readonly isMac;
     /** Bindings grouped by listener target. */
     private readonly registries;
+    constructor();
     /** Register a binding. */
     bind(spec: WrHotkeySpec, handler: (event: KeyboardEvent) => void, options?: WrHotkeyOptions): WrHotkeyHandle;
     private readonly listeners;

package/types/ngwr-list.d.ts

@@ -43,8 +43,13 @@ declare class WrList {
  *  - default — main label / body
  *  - `[wrListItemTrailing]` — meta value, action button, chevron
  *
- * Set `interactive` to get hover, cursor, keyboard activation, and the
- * appropriate ARIA role for click handling.
+ * Set `interactive` to get hover and cursor styles, a tab stop, and Enter /
+ * Space activation. The role stays `listitem`: the row lives inside a
+ * `<ul role="list">`, where a `button` or `option` child role would break the
+ * structure the container promises. That means an interactive row ANNOUNCES as
+ * a list item rather than as a control — deliberate, but worth knowing when the
+ * whole row is the only way to reach an action. Where the action needs to be
+ * announced as one, project a real button into `[wrListItemTrailing]`.
  *
  * @example
  * ```html

package/types/ngwr-loading-bar.d.ts

@@ -4,13 +4,6 @@ import { Signal } from '@angular/core';
 /** Public state of the loading bar. */
 type WrLoadingState = 'idle' | 'running' | 'completing';
 
-/**
- * @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
- */
-
 /**
  * Singleton state machine for a top-of-page progress indicator. Driven
  * by router events out of the box, plus a manual `start()` / `complete()`
@@ -30,6 +23,8 @@ type WrLoadingState = 'idle' | 'running' | 'completing';
  */
 declare class WrLoadingBar {
     private readonly router;
+    private readonly destroyRef;
+    private readonly isBrowser;
     /** Live count of pending "tasks" (manual + router). */
     private readonly count;
     /** Tween value `[0, 1]` — the bar's actual width. */
@@ -37,6 +32,7 @@ declare class WrLoadingBar {
     readonly progress: Signal<number>;
     readonly state: Signal<WrLoadingState>;
     private timer;
+    private holdTimer;
     constructor();
     /** Reserve a slot. The bar starts trickling as long as `count > 0`. */
     start(): void;
@@ -46,6 +42,7 @@ declare class WrLoadingBar {
     reset(): void;
     private beginTrickle;
     private stopTrickle;
+    private clearHold;
     private finish;
     static ɵfac: i0.ɵɵFactoryDeclaration<WrLoadingBar, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<WrLoadingBar>;

package/types/ngwr-pagination.d.ts

@@ -123,7 +123,12 @@ declare class WrPagination {
     protected readonly classes: _angular_core.Signal<string>;
     protected isCurrent(page: number): boolean;
     protected goTo(page: number | typeof ELLIPSIS): void;
-    protected onSizeChange(size: number): void;
+    /**
+     * `wr-select` carries an `unknown` value by design, so the size arrives
+     * untyped and is narrowed here. It used to arrive as `any` through
+     * `[ngModel]`, which hid the coercion rather than removing the need for it.
+     */
+    protected onSizeChange(size: unknown): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrPagination, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrPagination, "wr-pagination", never, { "currentPage": { "alias": "currentPage"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "total": { "alias": "total"; "required": false; "isSignal": true; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; "isSignal": true; }; "showSizeChanger": { "alias": "showSizeChanger"; "required": false; "isSignal": true; }; "showTotal": { "alias": "showTotal"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "responsive": { "alias": "responsive"; "required": false; "isSignal": true; }; "ofLabel": { "alias": "ofLabel"; "required": false; "isSignal": true; }; "prevLabel": { "alias": "prevLabel"; "required": false; "isSignal": true; }; "nextLabel": { "alias": "nextLabel"; "required": false; "isSignal": true; }; "itemsPerPageLabel": { "alias": "itemsPerPageLabel"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, { "currentPage": "currentPageChange"; "pageSize": "pageSizeChange"; }, never, never, true, never>;
 }

package/types/ngwr-popover.d.ts

@@ -26,7 +26,7 @@ declare class WrPopover {
      * - `'tooltip'` — text content, hover+focus trigger, `role="tooltip"`,
      *   `aria-describedby` on the host.
      */
-    readonly mode: _angular_core.InputSignal<"tooltip" | "popover">;
+    readonly mode: _angular_core.InputSignal<"popover" | "tooltip">;
     /**
      * How the popover opens. Ignored in tooltip mode — tooltips are always
      * hover+focus. @default 'click'
@@ -45,6 +45,13 @@ declare class WrPopover {
      * overrides it. Tooltips never become sheets. @default undefined
      */
     readonly responsive: _angular_core.InputSignalWithTransform<boolean | undefined, BooleanInput>;
+    /**
+     * Popover mode only — accessible name of the panel. `role="dialog"` with no
+     * name announces as a bare "dialog", so the catalog's `popover.label` is used
+     * when nothing is given. A popover has no universal name; whenever the panel
+     * has a heading or a purpose, pass it.
+     */
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
     /** Fires after the panel opens. */
     readonly opened: _angular_core.OutputEmitterRef<void>;
     /** Fires after the panel closes. */
@@ -62,6 +69,7 @@ declare class WrPopover {
     protected readonly isTooltip: _angular_core.Signal<boolean>;
     /** Auto-generated id for `aria-controls` / `aria-describedby`. */
     protected readonly panelId: string;
+    private readonly resolvedAriaLabel;
     private readonly resolvedPosition;
     private overlayRef;
     private hoverCloseTimer;
@@ -93,7 +101,7 @@ declare class WrPopover {
     private scheduleHoverClose;
     private clearHoverClose;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrPopover, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<WrPopover, "[wrPopover]", never, { "content": { "alias": "wrPopover"; "required": true; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "trigger": { "alias": "trigger"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "showDelay": { "alias": "showDelay"; "required": false; "isSignal": true; }; "hideDelay": { "alias": "hideDelay"; "required": false; "isSignal": true; }; "responsive": { "alias": "responsive"; "required": false; "isSignal": true; }; }, { "opened": "opened"; "closed": "closed"; }, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<WrPopover, "[wrPopover]", never, { "content": { "alias": "wrPopover"; "required": true; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "trigger": { "alias": "trigger"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "showDelay": { "alias": "showDelay"; "required": false; "isSignal": true; }; "hideDelay": { "alias": "hideDelay"; "required": false; "isSignal": true; }; "responsive": { "alias": "responsive"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "opened": "opened"; "closed": "closed"; }, never, never, true, never>;
 }
 
 export { WrPopover };

package/types/ngwr-storage.d.ts

@@ -37,7 +37,16 @@ declare class WrStorage {
     private readonly engine;
     private readonly config;
     private readonly isBrowser;
-    /** Per-key watchers. Shared so multiple `watch(k)` calls reuse one signal. */
+    /**
+     * Per-key watchers. Shared so multiple `watch(k)` calls reuse one signal.
+     *
+     * The fallback is kept alongside the signal because every refresh has to read
+     * the key the same way `watch` first did. Refreshing without it made `get` and
+     * `watch` disagree about what an ABSENT key means: after a `remove()` the
+     * signal went to `null` while `get(key, fallback)` still answered with the
+     * default, so a consumer watching `'theme'` with a `'light'` fallback got no
+     * theme at all rather than the light one.
+     */
     private readonly watchers;
     private listenerInstalled;
     /** Is `key` present (regardless of value / expiry)? */

package/types/ngwr-toast.d.ts

@@ -39,7 +39,11 @@ interface WrToastOptions {
     readonly duration?: number;
     /** Show a close (×) button. @default true */
     readonly dismissible?: boolean;
-    /** Override the corner for this toast only. */
+    /**
+     * Corner this toast opens in. The whole stack shares one host, so this is
+     * not per-toast: passing a different corner relocates the toasts already on
+     * screen along with this one.
+     */
     readonly position?: WrToastPosition;
     /** Override the progress bar visibility for this toast only. */
     readonly showProgress?: boolean;
@@ -90,7 +94,16 @@ interface WrToastConfig {
     readonly showCloseAll: boolean;
     /** Minimum number of stacked toasts before "Close all" appears. @default 2 */
     readonly closeAllThreshold: number;
-    /** Maximum toasts visible at once. Oldest is dismissed when exceeded. `0` = unlimited. @default 5 */
+    /**
+     * Maximum toasts visible at once. `0` = unlimited.
+     *
+     * Nothing on screen is taken away to make room: once the cap is reached the
+     * *newest* toast waits in a queue, and queued toasts are promoted FIFO as
+     * visible ones dismiss. A queued toast's auto-dismiss countdown only starts
+     * when it becomes visible, so it can never expire unseen.
+     *
+     * @default 5
+     */
     readonly maxStack: number;
     /** Labels rendered in the UI. Keep short — meant to be overridden for i18n. */
     readonly labels: {
@@ -195,13 +208,15 @@ declare class WrToast {
  *       position: 'bottom-end',
  *       showCopy: true,
  *       maxStack: 3,
- *       labels: { close: 'Закрыть', copy: 'Копировать', copied: 'Скопировано', closeAll: 'Закрыть все' },
+ *       labels: { close: 'Закрыть' },
  *     }),
  *   ],
  * });
  * ```
  */
-declare function provideWrToastConfig(config: Partial<WrToastConfig>): EnvironmentProviders;
+declare function provideWrToastConfig(config: Partial<Omit<WrToastConfig, 'labels'>> & {
+    readonly labels?: Partial<WrToastConfig['labels']>;
+}): EnvironmentProviders;
 
 /**
  * @license

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 = "10.2.0";
+declare const NGWR_VERSION = "10.2.1";
 
 /**
  * @license

package/types/ngwr-window.d.ts

@@ -1,7 +1,7 @@
 import * as i0 from '@angular/core';
 import { ComponentRef, WritableSignal, Signal, InjectionToken } from '@angular/core';
 import { OverlayRef } from '@angular/cdk/overlay';
-import { Subject } from 'rxjs';
+import { ReplaySubject, Subject } from 'rxjs';
 import { ComponentType } from '@angular/cdk/portal';
 
 /**
@@ -193,7 +193,15 @@ declare class WrWindowRef<C, R = unknown> {
     /** Stable id — used by the taskbar, workspace save, and DI. */
     readonly id: string;
     /** @internal — emits the close result once and completes. */
-    readonly _closed: Subject<R | undefined>;
+    /**
+     * A `ReplaySubject`, not a plain `Subject`, so the result survives a late
+     * subscriber — the same reasoning `WrDialogRef` already carries. A caller
+     * that holds the ref and awaits `afterClosed()` after any intervening
+     * `await` subscribes to an already-completed stream, and a plain Subject
+     * hands it nothing but `complete`: the promise resolved `undefined` and a
+     * saved result was indistinguishable from a dismissal.
+     */
+    readonly _closed: ReplaySubject<R | undefined>;
     /** @internal — emits whenever the visual state changes. */
     readonly _stateChanged: Subject<WrWindowState>;
     /** @internal — set by the container right after attach. */
@@ -212,6 +220,19 @@ declare class WrWindowRef<C, R = unknown> {
     /** @internal */ readonly _width: WritableSignal<number>;
     /** @internal */ readonly _height: WritableSignal<number>;
     /** @internal */ readonly _z: WritableSignal<number>;
+    /**
+     * The geometry the USER chose, as opposed to the one the current state
+     * imposes. `_x` and friends mirror the window's EFFECTIVE values — a
+     * maximized window reports the viewport, a minimized one reports its
+     * collapsed header height — which is right for anything drawing the window
+     * and wrong for anything persisting it.
+     *
+     * @internal
+     */
+    readonly _rawX: WritableSignal<number>;
+    /** @internal */ readonly _rawY: WritableSignal<number>;
+    /** @internal */ readonly _rawWidth: WritableSignal<number>;
+    /** @internal */ readonly _rawHeight: WritableSignal<number>;
     /** @internal */ readonly _title: WritableSignal<string>;
     /** Window state. */
     readonly state: Signal<WrWindowState>;