ngwr 10.1.0 → 10.2.1

package/theme/styles/_colors.scss

@@ -28,7 +28,15 @@ $base-colors: (
 $contrast-threshold: 150 !default;
 
 // Dark text used on light backgrounds.
-$contrast-dark: #171616 !default;
+//
+// Pure black, not a near-black. `_contrast()` does not blend — it picks
+// whichever of these two candidates scores higher against the fill — so this
+// value IS the ceiling for every intent whose label comes out dark, and a
+// softer black spends contrast that cannot be recovered anywhere else.
+// Measured: #171616 cost between 0.74 and 1.95 across the ramp, and left
+// `secondary` clearing AA by 0.02 when 5.26:1 was available. On a saturated
+// chip the two are hard to tell apart; the ratio is not.
+$contrast-dark: #000000 !default;
 
 // Light text used on dark backgrounds.
 $contrast-light: #ffffff !default;
@@ -236,14 +244,27 @@ $contrast-light: #ffffff !default;
   // intent to warning's share would drag primary to near-navy for no reason.
   // Each is the measured minimum that clears 4.5:1 in BOTH themes on the surface
   // and on the tag's 6% / 10% tints, with 3pp of headroom.
+  // Calibrated against the `-soft` TINT, not the plain surface — it is the
+  // darker of the two backgrounds `-ink` is documented for, in both themes, so
+  // it is the binding one.
+  //
+  // Each share is the LARGEST (most saturated) value that still reaches 5.0:1
+  // there. Targeting AA's 4.5 exactly is what the first pass did, and it left
+  // every intent between 4.59 and 4.83 — inside rounding distance of the line.
+  // Anything that shifted the background a little then pushed it under:
+  // `wr-typography--code` measured 4.24 with `success-ink`, `wr-tag--primary`
+  // 4.42. Half a point of headroom absorbs that, for 2–7 points of share.
+  //
+  // Going further is not free: 5.25 costs 7–11 points and 5.5 up to 14, which
+  // on `primary` means 93% -> 79% and a visibly muddier blue.
   $ink-mix: (
-    primary: 93%,
-    secondary: 80%,
-    success: 72%,
-    warning: 50%,
-    danger: 77%,
-    info: 76%,
-    medium: 69%,
+    primary: 86%,
+    secondary: 75%,
+    success: 67%,
+    warning: 48%,
+    danger: 72%,
+    info: 71%,
+    medium: 65%,
   );
 
   @each $name, $share in $ink-mix {

package/types/ngwr-button.d.ts

@@ -113,7 +113,39 @@ declare class WrButton {
      * used, falling back to `rounded`.
      */
     protected readonly effectiveShape: _angular_core.Signal<WrButtonShape>;
+    private readonly hostEl;
+    /**
+     * Whether this instance is the `<wr-btn>` ELEMENT rather than the attribute
+     * form on a native `<button>` / `<a>`.
+     *
+     * The element form is documented as first-class and is what the pagination,
+     * event-calendar and popconfirm chrome use — but a custom element has no
+     * button semantics of its own. It was rendering with no `role`, no
+     * `tabindex` and no keyboard activation, so it was invisible to assistive
+     * tech and unreachable by Tab. Measured in Chromium against the built site:
+     * the whole `wr-pagination` subtree, 26 elements, contained ZERO focusable
+     * nodes and sixty Tab presses never entered it. axe cannot see this — an
+     * unknown element with no role simply is not an interactive control to it,
+     * which is the same blind spot that lets `disabled` pass unnoticed on a
+     * custom element.
+     */
+    private readonly isCustomHost;
+    private readonly isOff;
     protected readonly nativeDisabled: _angular_core.Signal<"" | null>;
+    protected readonly hostRole: _angular_core.Signal<"button" | null>;
+    /** Out of the tab order while off — `disabled` is inert on a custom element. */
+    protected readonly hostTabIndex: _angular_core.Signal<"0" | null>;
+    protected readonly hostAriaDisabled: _angular_core.Signal<"true" | null>;
+    /**
+     * Enter and Space activate a button. A native one does this for free; a
+     * custom element does not, so without this the element form could be focused
+     * (once it had a tabindex) and still not be operable.
+     *
+     * `preventDefault` on Space is not optional — it scrolls the page otherwise.
+     * The pointer path needs no guard here: `.wr-btn[disabled]` already sets
+     * `pointer-events: none`.
+     */
+    protected onHostKeydown(event: KeyboardEvent): void;
     protected readonly classes: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrButton, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrButton, "wr-btn, button[wr-btn], a[wr-btn]", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconPosition": { "alias": "iconPosition"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "outlined": { "alias": "outlined"; "required": false; "isSignal": true; }; "block": { "alias": "block"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "isDisabledWhenLoading": { "alias": "isDisabledWhenLoading"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;

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)? */