ngwr 10.2.0 → 11.0.0

package/types/ngwr-sidebar.d.ts

@@ -55,6 +55,13 @@ declare function isGroup(entry: WrSidebarEntry): entry is WrSidebarGroup;
  */
 declare class WrSidebar {
     readonly entries: _angular_core.InputSignal<readonly WrSidebarEntry[]>;
+    /**
+     * Accessible name for the navigation landmark. Falls back to `sidebar.label`,
+     * then `'Sidebar'` — a page with a sidebar AND a table of contents has two
+     * navigation landmarks, and an unnamed one is announced as just "navigation".
+     */
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    protected readonly resolvedAriaLabel: _angular_core.Signal<string>;
     /** Default icon for entries without one. @default 'folder' */
     readonly defaultGroupIcon: _angular_core.InputSignal<string>;
     /** Default icon for items without one. @default 'caret-forward' */
@@ -63,20 +70,28 @@ declare class WrSidebar {
     readonly autoExpand: _angular_core.InputSignalWithTransform<boolean, any>;
     protected readonly isGroup: typeof isGroup;
     private readonly opened;
+    /** Group titles already seeded from `defaultOpen`, so it seeds once and not again. */
+    private readonly seeded;
+    private readonly uid;
     private readonly router;
     private readonly currentUrl;
     /** Last URL we auto-expanded — prevents re-opening a group the user collapsed. */
     private lastAutoUrl;
     constructor();
     protected isOpen(title: string): boolean;
-    /** Stable id for the group body, referenced by the toggle's `aria-controls`. */
+    /**
+     * Stable id for the group body, referenced by the toggle's `aria-controls`.
+     * Scoped to this sidebar and stripped of anything that is not id-safe: a title
+     * like `Data & charts` used to produce `wr-sidebar-group-data-&-charts`, which
+     * no selector can address.
+     */
     protected groupBodyId(title: string): string;
     protected toggleGroup(title: string): void;
     protected asItem(entry: WrSidebarEntry): WrSidebarItem;
     protected asGroup(entry: WrSidebarEntry): WrSidebarGroup;
     private findGroupForUrl;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrSidebar, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrSidebar, "wr-sidebar", never, { "entries": { "alias": "entries"; "required": false; "isSignal": true; }; "defaultGroupIcon": { "alias": "defaultGroupIcon"; "required": false; "isSignal": true; }; "defaultItemIcon": { "alias": "defaultItemIcon"; "required": false; "isSignal": true; }; "autoExpand": { "alias": "autoExpand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrSidebar, "wr-sidebar", never, { "entries": { "alias": "entries"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "defaultGroupIcon": { "alias": "defaultGroupIcon"; "required": false; "isSignal": true; }; "defaultItemIcon": { "alias": "defaultItemIcon"; "required": false; "isSignal": true; }; "autoExpand": { "alias": "autoExpand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 export { WrSidebar };

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

@@ -0,0 +1,329 @@
+import { BaseHarnessFilters, ComponentHarness, HarnessPredicate } from '@angular/cdk/testing';
+import { WrSliderValue } from 'ngwr/slider';
+
+/**
+ * @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
+ */
+
+/** Which end of a range slider a thumb is — the `--low` / `--high` modifier it carries. */
+type WrSliderThumbPosition = 'low' | 'high';
+/** Narrows which `<wr-slider>` a harness query matches. */
+interface WrSliderHarnessFilters extends BaseHarnessFilters {
+    /**
+     * Match the current value, in the shape the model uses: a plain number for a
+     * single-thumb slider, `[low, high]` for a range one. Compared element-wise,
+     * so a tuple never matches a single-thumb slider and a number never matches a
+     * range one.
+     */
+    readonly value?: WrSliderValue;
+    /** Match only dual-thumb (`true`) or only single-thumb (`false`) sliders. */
+    readonly range?: boolean;
+    /** Match only disabled (`true`) or only enabled (`false`) sliders. */
+    readonly disabled?: boolean;
+    /**
+     * Match the text the slider prints under its track — a string is an exact
+     * match, a RegExp is tested. A slider with `showLabel="false"` prints none and
+     * never matches.
+     */
+    readonly labelText?: string | RegExp;
+}
+/** Narrows which thumb of a `<wr-slider>` a harness query matches. */
+interface WrSliderThumbHarnessFilters extends BaseHarnessFilters {
+    /** Match one end of a range slider. A single-thumb slider only has a `'low'`. */
+    readonly position?: WrSliderThumbPosition;
+    /** Match a thumb standing on exactly this value (`aria-valuenow`). */
+    readonly value?: number;
+    /**
+     * Match the thumb's accessible name — `'Value'` on a single-thumb slider,
+     * `'Lower value'` / `'Upper value'` on a range one. A string is an exact
+     * match, a RegExp is tested.
+     */
+    readonly label?: string | RegExp;
+}
+
+/**
+ * @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
+ */
+
+/**
+ * Test harness for one thumb of a `<wr-slider>`.
+ *
+ * A single-thumb slider has exactly one; a `range` one has two, and each thumb
+ * is the other's limit — the lower thumb's `aria-valuemax` is wherever the upper
+ * thumb is standing, and vice versa. So {@link getMin} / {@link getMax} answer
+ * the room THIS thumb has, not the slider's bounds, which is exactly what a
+ * screen reader announces and exactly the window {@link setValue} can reach.
+ *
+ * Every write here is a KEY PRESS, because a drag is not something a unit test
+ * can perform — see {@link setValue}.
+ *
+ * Every press is on the BLOCK axis — `ArrowUp` / `ArrowDown`, `PageUp` /
+ * `PageDown`, `Home` / `End` — so the harness means the same thing in both
+ * reading directions. That is not a detail: the component's ← / → follow the
+ * VISUAL track, so under `dir="rtl"` a right-arrow LOWERS the value, and a
+ * harness that pressed it would have `stepUp()` stepping down while every LTR
+ * spec stayed green. It cannot detect the direction to compensate either —
+ * `Directionality` is injected, not published to the DOM — so it stays on the
+ * axis `dir` does not govern.
+ *
+ * @example
+ * ```ts
+ * const upper = await slider.getHighThumb();
+ *
+ * await upper.setValue(90);
+ * expect(await upper.getValue()).toBe(90);
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrSliderThumbHarness extends ComponentHarness {
+    /**
+     * The thumb is a real `<button role="slider">`, so it is focusable without a
+     * `tabindex` and leaves the tab order by itself when disabled. Anchored on the
+     * BEM class rather than on `[role="slider"]`: the class also carries the
+     * `--low` / `--high` modifier this harness reads.
+     */
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options?: WrSliderThumbHarnessFilters): HarnessPredicate<WrSliderThumbHarness>;
+    /** Which end this thumb is. A single-thumb slider's thumb is the `'low'` one. */
+    getPosition(): Promise<WrSliderThumbPosition>;
+    /** Where the thumb is standing, from `aria-valuenow` — the number a screen reader reads out. */
+    getValue(): Promise<number>;
+    /**
+     * The lowest value THIS thumb can reach (`aria-valuemin`).
+     *
+     * On a range slider's upper thumb that is the lower thumb, not the slider's
+     * `min` — the two cannot cross, so the neighbour is the real floor.
+     */
+    getMin(): Promise<number>;
+    /**
+     * The highest value THIS thumb can reach (`aria-valuemax`).
+     *
+     * On a range slider's lower thumb that is the upper thumb, not the slider's
+     * `max`.
+     */
+    getMax(): Promise<number>;
+    /** The thumb's accessible name — `'Value'`, or `'Lower value'` / `'Upper value'` in range mode. */
+    getLabel(): Promise<string | null>;
+    /** What a screen reader is told this control is. The role is why the arrows mean anything here. */
+    getRole(): Promise<string | null>;
+    /** Whether the thumb refuses the keyboard. Read from the button's native `disabled`. */
+    isDisabled(): Promise<boolean>;
+    focus(): Promise<void>;
+    isFocused(): Promise<boolean>;
+    /**
+     * One step up (`ArrowUp`). A disabled thumb does not move.
+     *
+     * `ArrowRight` is the same key press in an LTR slider and the OPPOSITE one in
+     * an RTL slider, so the vertical arrow is the one that means "up" everywhere.
+     */
+    stepUp(): Promise<void>;
+    /** One step down (`ArrowDown`; `ArrowLeft` only agrees in LTR — see {@link stepUp}). */
+    stepDown(): Promise<void>;
+    /** Ten steps up (`PageUp`; `Shift`+arrow is the same stride). */
+    largeStepUp(): Promise<void>;
+    /** Ten steps down (`PageDown`; `Shift`+arrow is the same stride). */
+    largeStepDown(): Promise<void>;
+    /**
+     * `Home` — jump to the lowest value this thumb can reach.
+     *
+     * On a range slider's UPPER thumb that lands on the lower thumb, not on the
+     * slider's `min`: the component asks for `min` and then refuses to let the
+     * ends cross, so the range collapses instead of inverting.
+     */
+    toMin(): Promise<void>;
+    /**
+     * `End` — jump to the highest value this thumb can reach.
+     *
+     * On a range slider's LOWER thumb that lands on the upper thumb, not on the
+     * slider's `max`, for the same reason as {@link toMin}.
+     */
+    toMax(): Promise<void>;
+    /**
+     * Walk the thumb to `value` FROM THE KEYBOARD — `PageUp` / `PageDown` for the
+     * distance, arrows for the last stretch, `Home` / `End` for the bounds. That
+     * is the accessible path, and the only one a unit test can trust.
+     *
+     * There is deliberately no drag. jsdom has no layout: the track measures 0×0
+     * and `getBoundingClientRect()` answers all zeros, while the component turns a
+     * pointer into a value by dividing the offset by the track width. Every
+     * positive offset therefore divides by zero, clamps to a ratio of 1 and writes
+     * the slider's MAX — quietly, with no error to notice. A coordinate cannot
+     * mean anything here.
+     *
+     * It costs one press per stride, so the walk is not free: crossing most of a
+     * 0–100 range costs ~19 presses at `step="1"` and ~109 at `step="0.1"`.
+     * Landing exactly on a bound is one press, whatever the step. The walk gives
+     * up after 1000 presses — a 0–100 range reaches that at `step="0.01"` or finer
+     * — and throws rather than spin.
+     *
+     * A bound the step grid misses is announced but not reachable: `aria-valuemax`
+     * is the `max` input, while the component snaps every key press onto whole
+     * steps from `min`, so `max="100" step="3"` stops at 99. That is the off-grid
+     * throw, arriving for `setValue(100)`.
+     *
+     * Either the thumb ends up exactly on `value` or this throws: when `value` is
+     * outside the thumb's window (the other thumb is one end of it in range mode),
+     * when the thumb is disabled, and when `value` is not on the step grid — on
+     * the last one the thumb is left at the nearest value it could reach.
+     */
+    setValue(value: number): Promise<void>;
+    /**
+     * The landing check every path through {@link setValue} ends on: exactly the
+     * value asked for, or an error naming where the thumb stopped instead.
+     */
+    private assertSettled;
+    /** The key that moves the thumb one stride in `direction`. */
+    private strideKey;
+    /**
+     * Press a key on the thumb.
+     *
+     * `sendKeys` focuses the element first, so this is the whole gesture a user
+     * makes — the component listens for `keydown` on the thumb itself.
+     */
+    private press;
+    /**
+     * One of the ARIA range attributes as a number.
+     *
+     * Throws instead of handing back `NaN`: a slider whose `aria-valuenow` is not
+     * a number is broken in a way every later assertion would describe badly.
+     */
+    private numeric;
+}
+
+/**
+ * @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
+ */
+
+/**
+ * Test harness for `<wr-slider>` — single-thumb and `range`.
+ *
+ * Every NUMBER it reads comes off the thumbs' ARIA range trio (`aria-valuenow`,
+ * `aria-valuemin`, `aria-valuemax`), which is what a screen reader is told and
+ * the only place the slider publishes its value. The mode comes off the host's
+ * `wr-slider--range` class and {@link getLabelText} off the rendered text.
+ *
+ * Everything it WRITES is a key press. A slider is a pointer control, but a
+ * pointer control cannot be driven by coordinates in jsdom — there is no layout,
+ * so the track measures 0×0 and the component divides every offset by that
+ * width: a positive one writes the slider's MAX and `clientX: 0` writes `NaN`,
+ * neither of them the value asked for. The keyboard is both the accessible path
+ * and the only honest one here; {@link WrSliderThumbHarness.setValue} spells out
+ * what the walk costs, and {@link WrSliderThumbHarness} why every one of those
+ * presses is on the block axis, which `dir` does not turn around.
+ *
+ * The `step` is deliberately not readable: the component publishes it nowhere in
+ * the DOM (ARIA has no attribute for it), so a spec that needs the number should
+ * measure it — `stepUp()` moves by exactly one step.
+ *
+ * @example
+ * ```ts
+ * const volume = await loader.getHarness(WrSliderHarness);
+ *
+ * await volume.setValue(70);
+ * expect(await volume.getValue()).toBe(70);
+ *
+ * const span = await loader.getHarness(WrSliderHarness.with({ range: true }));
+ * await span.setRange(30, 60);
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrSliderHarness extends ComponentHarness {
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options?: WrSliderHarnessFilters): HarnessPredicate<WrSliderHarness>;
+    /** Whether the slider has two thumbs and answers with a `[low, high]` tuple. */
+    isRange(): Promise<boolean>;
+    /**
+     * Whether the slider refuses interaction.
+     *
+     * Read from the thumb's native `disabled` rather than from the
+     * `wr-slider--disabled` class: the class is paint, while `disabled` on the
+     * button is what takes the thumb out of the tab order and what assistive tech
+     * reports.
+     */
+    isDisabled(): Promise<boolean>;
+    /**
+     * The current value, in the shape the model uses: a plain number for one
+     * thumb, `[low, high]` for two.
+     */
+    getValue(): Promise<WrSliderValue>;
+    /** The slider's lower bound. */
+    getMin(): Promise<number>;
+    /**
+     * The slider's upper bound.
+     *
+     * Taken from the LAST thumb, because in range mode the thumbs bound each
+     * other: the lower one's `aria-valuemax` is wherever the upper one is
+     * standing, so only the upper thumb knows the real ceiling.
+     */
+    getMax(): Promise<number>;
+    /**
+     * The text the slider prints under the track, or `null` when `showLabel` is
+     * off.
+     *
+     * A range slider joins its ends with an EN DASH — `'20 – 80'`, U+2013 — so an
+     * assertion typed with a hyphen will not match.
+     */
+    getLabelText(): Promise<string | null>;
+    /** The slider's thumbs in DOM order: the lower one first. */
+    getThumbs(filters?: WrSliderThumbHarnessFilters): Promise<WrSliderThumbHarness[]>;
+    /** The only thumb of a single-thumb slider, or the lower one of a range slider. */
+    getLowThumb(): Promise<WrSliderThumbHarness>;
+    /** The upper thumb. Throws on a single-thumb slider, which has no such part. */
+    getHighThumb(): Promise<WrSliderThumbHarness>;
+    /**
+     * Walk the slider to `value` from the keyboard.
+     *
+     * Single-thumb only — {@link setRange} moves both ends. See
+     * {@link WrSliderThumbHarness.setValue} for what the walk costs and when it
+     * throws.
+     */
+    setValue(value: number): Promise<void>;
+    /**
+     * Walk both ends of a range slider to `[low, high]`.
+     *
+     * The far end moves FIRST. The thumbs bound each other, so writing `[90, 95]`
+     * over `[20, 80]` lower-end-first would be refused outright — 90 is outside
+     * the `[0, 80]` window the upper thumb leaves the lower one.
+     */
+    setRange(low: number, high: number): Promise<void>;
+    /** One step up (`ArrowUp`). Single-thumb only. A disabled slider does not move. */
+    stepUp(): Promise<void>;
+    /** One step down (`ArrowDown`). Single-thumb only. A disabled slider does not move. */
+    stepDown(): Promise<void>;
+    /** `Home` — jump to the slider's `min`. Single-thumb only. */
+    toMin(): Promise<void>;
+    /** `End` — jump to the slider's `max`. Single-thumb only. */
+    toMax(): Promise<void>;
+    /**
+     * Move keyboard focus to the slider's first thumb. A range slider's thumbs are
+     * two separate tab stops (both are plain buttons — there is no roving
+     * `tabindex`), so reach the other one through {@link getHighThumb}.
+     */
+    focus(): Promise<void>;
+    /** Whether any of the slider's thumbs holds focus. */
+    isFocused(): Promise<boolean>;
+    /**
+     * The one thumb a single-thumb convenience call means.
+     *
+     * Range mode gets an error rather than a guess: "step this slider up" has two
+     * possible answers there, and picking one silently is how a spec ends up
+     * asserting against the end it did not move.
+     */
+    private single;
+}
+
+export { WrSliderHarness, WrSliderThumbHarness };
+export type { WrSliderHarnessFilters, WrSliderThumbHarnessFilters, WrSliderThumbPosition };

package/types/ngwr-slider.d.ts

@@ -31,6 +31,11 @@ type WrSliderValue = number | readonly [number, number];
  * Keyboard: ← / → adjust by `step`; ↑ / ↓ same; Shift+arrow by `step × 10`;
  * Home / End jump to min / max; PageUp / PageDown by `step × 10`.
  *
+ * Reading direction: the arrows follow the VISUAL track, so under `dir="rtl"`
+ * → moves toward the lower end and ← toward the higher one, and a drag reads
+ * its ratio from the right edge. ↑ / ↓, PageUp / PageDown and Home / End are
+ * unchanged — they name a value, not a side of the screen.
+ *
  * @example
  * ```html
  * <!-- signal forms -->
@@ -74,17 +79,46 @@ declare class WrSlider implements FormValueControl<WrSliderValue> {
     protected readonly low: _angular_core.WritableSignal<number>;
     protected readonly high: _angular_core.WritableSignal<number>;
     protected readonly track: _angular_core.Signal<ElementRef<HTMLElement>>;
+    /**
+     * Ambient reading direction. Optional so a bare `TestBed` — or any consumer
+     * that never set a direction — needs no provider; `Directionality` is
+     * root-provided, so `null` only ever means "nobody asked", which is LTR.
+     *
+     * Nothing caches a direction-derived value: the thumbs are painted with
+     * `inset-inline-start`, so the track mirrors from CSS alone, and `isRtl()` is
+     * read inside the event handlers. A runtime flip therefore needs no
+     * subscription to `Directionality.change`.
+     */
+    private readonly dir;
     protected readonly classes: _angular_core.Signal<string>;
     protected readonly lowPercent: _angular_core.Signal<number>;
     protected readonly highPercent: _angular_core.Signal<number>;
-    protected readonly fillLeft: _angular_core.Signal<number>;
+    /** Offset of the fill from the track's START edge — the left one in LTR, the right one in RTL. */
+    protected readonly fillStart: _angular_core.Signal<number>;
     protected readonly fillWidth: _angular_core.Signal<number>;
     protected readonly label: _angular_core.Signal<string>;
     constructor();
     protected onPointerDown(event: PointerEvent, thumb: 'low' | 'high'): void;
     protected onTrackPointerDown(event: PointerEvent): void;
     protected onKey(event: KeyboardEvent, thumb: 'low' | 'high'): void;
+    private isRtl;
+    /**
+     * The value under a pointer, measured along the track's INLINE axis.
+     *
+     * The offset is taken from whichever edge the track starts at — the left one
+     * in LTR, the right one in RTL — so the whole component needs the direction
+     * in exactly one place. Measuring from `rect.left` regardless would read 0 at
+     * the visual maximum of a mirrored track.
+     */
+    private valueAt;
     private updateFromEvent;
+    /**
+     * Which thumb a track click grabs: the one nearest the pointer ON SCREEN.
+     *
+     * Value distance is the same thing as visual distance once {@link valueAt}
+     * has mirrored the ratio — in RTL the low thumb is the RIGHT one, and a click
+     * near the right edge lands close to `low` in value space too.
+     */
     private nearestThumb;
     private focusThumb;
     private setThumb;

package/types/ngwr-sparkline.d.ts

@@ -14,9 +14,19 @@ import * as _angular_core from '@angular/core';
  */
 declare class WrSparkline {
     readonly data: _angular_core.InputSignal<readonly number[]>;
+    /**
+     * Accessible name. A sparkline usually sits beside the number it summarises, where
+     * announcing it again is noise — so it is `aria-hidden` by default and becomes a
+     * named `role="img"` only when a consumer says what it shows.
+     */
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
     /** Stroke colour. @default `var(--wr-color-primary)` */
     readonly color: _angular_core.InputSignal<string>;
-    /** Stroke width in viewBox units. @default 1.5 */
+    /**
+     * Line thickness in CSS pixels — `vector-effect="non-scaling-stroke"` keeps it at
+     * that width whatever the box is stretched to, so it is NOT in viewBox units.
+     * @default 1.5
+     */
     readonly strokeWidth: _angular_core.InputSignalWithTransform<number, unknown>;
     /** Fill the area below the line. @default false */
     readonly showArea: _angular_core.InputSignalWithTransform<boolean, any>;
@@ -42,7 +52,7 @@ declare class WrSparkline {
     } | null>;
     protected readonly viewBox: string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrSparkline, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrSparkline, "wr-sparkline", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; "isSignal": true; }; "showArea": { "alias": "showArea"; "required": false; "isSignal": true; }; "showTip": { "alias": "showTip"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrSparkline, "wr-sparkline", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; "isSignal": true; }; "showArea": { "alias": "showArea"; "required": false; "isSignal": true; }; "showTip": { "alias": "showTip"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 export { WrSparkline };

package/types/ngwr-speed-dial.d.ts

@@ -1,4 +1,5 @@
 import * as _angular_core from '@angular/core';
+import { ElementRef } from '@angular/core';
 import { WrIconName } from 'ngwr/icon';
 
 /** Per-button action shown when the dial expands. */
@@ -10,24 +11,6 @@ interface WrSpeedDialAction {
 /** Direction the action buttons fan out. */
 type WrSpeedDialDirection = 'up' | 'down' | 'left' | 'right';
 
-/**
- * Floating action button that expands into a fan of secondary actions on
- * click / hover. Place inside a positioned container or near `position: fixed`
- * — the component itself doesn't pin to the viewport.
- *
- * @example
- * ```html
- * <wr-speed-dial
- *   [actions]="[
- *     { id: 'new', label: 'New', icon: 'add' },
- *     { id: 'edit', label: 'Edit', icon: 'cog' }
- *   ]"
- *   (pick)="onPick($event)"
- * />
- * ```
- *
- * @see https://ngwr.dev/reference/components/speed-dial
- */
 declare class WrSpeedDial {
     readonly actions: _angular_core.InputSignal<readonly WrSpeedDialAction[]>;
     /**
@@ -52,9 +35,25 @@ declare class WrSpeedDial {
     readonly safeArea: _angular_core.InputSignalWithTransform<boolean, any>;
     /** Fires when the user picks one of the actions. */
     readonly pick: _angular_core.OutputEmitterRef<WrSpeedDialAction>;
+    /** Id the trigger's `aria-controls` points at. */
+    protected readonly menuId: string;
+    protected readonly triggerEl: _angular_core.Signal<ElementRef<HTMLButtonElement> | undefined>;
+    constructor();
     protected readonly classes: _angular_core.Signal<string>;
     protected onTrigger(): void;
     protected onPick(action: WrSpeedDialAction): void;
+    /**
+     * `role="menu"` promises a way out, and the actions are ordinary buttons in the tab
+     * order — without this a keyboard user who opened the dial had to tab through every
+     * action to leave it.
+     */
+    protected onKeydown(event: KeyboardEvent): void;
+    /**
+     * First GLYPH of the label, for an action with no icon. `charAt(0)` returns one
+     * UTF-16 code unit, which cuts an astral character (an emoji) in half and renders a
+     * replacement character.
+     */
+    protected initial(label: string): string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrSpeedDial, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrSpeedDial, "wr-speed-dial", never, { "actions": { "alias": "actions"; "required": false; "isSignal": true; }; "triggerLabel": { "alias": "triggerLabel"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "safeArea": { "alias": "safeArea"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "pick": "pick"; }, never, never, true, never>;
 }

package/types/ngwr-spinner.d.ts

@@ -32,9 +32,16 @@ declare class WrSpinner {
      * @default 'md'
      */
     readonly size: _angular_core.InputSignal<WrSpinnerSize>;
+    /**
+     * Accessible name for the live region. Falls back to `spinner.label`, then
+     * `'Loading'` — which the host used to carry as a hard-coded attribute, while
+     * the catalog had the translated key for it all along.
+     */
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    protected readonly resolvedAriaLabel: _angular_core.Signal<string>;
     protected readonly classes: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrSpinner, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrSpinner, "wr-spinner", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrSpinner, "wr-spinner", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 export { WrSpinner };

package/types/ngwr-splitter.d.ts

@@ -36,8 +36,18 @@ declare class WrSplitter {
     readonly maxPosition: _angular_core.InputSignalWithTransform<number, unknown>;
     /** Disable dragging. @default false */
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, any>;
+    /**
+     * Accessible name of the divider. A focusable `role="separator"` is an
+     * interactive widget, so it needs one — without it a screen reader reaching the
+     * divider announces nothing but "separator" and its number. Falls back to
+     * `splitter.divider`.
+     */
+    readonly dividerLabel: _angular_core.InputSignal<string | null>;
+    protected readonly resolvedDividerLabel: _angular_core.Signal<string>;
     private readonly host;
+    private readonly dir;
     private dragging;
+    constructor();
     protected readonly classes: _angular_core.Signal<string>;
     protected readonly startStyle: _angular_core.Signal<string>;
     protected readonly endStyle: _angular_core.Signal<string>;
@@ -45,8 +55,21 @@ declare class WrSplitter {
     protected onPointerMove(event: PointerEvent): void;
     protected onPointerUp(event: PointerEvent): void;
     protected onKeydown(event: KeyboardEvent): void;
+    /**
+     * Fraction of the host's width measured from the INLINE-START edge — the left edge in
+     * LTR, the right edge in RTL, which is where `flex-direction: row` puts the start pane
+     * whose size `position` is. Counted from `rect.left` in both, a drag under `dir="rtl"`
+     * read 0 where the start pane was widest and inverted the whole gesture.
+     */
+    private inlineFraction;
+    /**
+     * Read per event rather than cached: nothing this component renders is derived from the
+     * direction — `flex-direction: row` mirrors the panes on its own — so there is no stale
+     * value for `Directionality.change` to invalidate.
+     */
+    private isRtl;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrSplitter, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrSplitter, "wr-splitter", never, { "position": { "alias": "position"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "minPosition": { "alias": "minPosition"; "required": false; "isSignal": true; }; "maxPosition": { "alias": "maxPosition"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "position": "positionChange"; }, never, ["[wrSplitterStart]", "[wrSplitterEnd]"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrSplitter, "wr-splitter", never, { "position": { "alias": "position"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "minPosition": { "alias": "minPosition"; "required": false; "isSignal": true; }; "maxPosition": { "alias": "maxPosition"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "dividerLabel": { "alias": "dividerLabel"; "required": false; "isSignal": true; }; }, { "position": "positionChange"; }, never, ["[wrSplitterStart]", "[wrSplitterEnd]"], true, never>;
 }
 
 export { WrSplitter };

package/types/ngwr-statistic.d.ts

@@ -100,15 +100,25 @@ declare class WrStatisticCountdown {
     /** Optional text shown once the countdown reaches zero. */
     readonly endText: _angular_core.InputSignal<string | null>;
     /**
-     * Tick interval in ms. Drop to ~16 for `SSS` (millisecond display).
+     * Tick interval in ms. Drop to ~16 for `SSS` (millisecond display). Floored
+     * at one frame — `0` (or an unparseable value) asked `setInterval` to run as
+     * fast as the browser would allow, which is a busy loop, not a countdown.
      * @default 1000
      */
-    readonly tickMs: _angular_core.InputSignal<number>;
+    readonly tickMs: _angular_core.InputSignalWithTransform<number, unknown>;
     /** Fires once when the countdown crosses zero. */
     readonly countdownEnd: _angular_core.OutputEmitterRef<void>;
     private readonly destroyRef;
     private readonly isBrowser;
     private readonly targetMs;
+    /**
+     * Milliseconds left, or `null` when `target` does not parse to a date at all.
+     * `new Date('nope').getTime()` is `NaN`, and `NaN` propagated all the way to
+     * the screen as `NaN:NaN:NaN` — and, worse, `tick` compared it to `0` and so
+     * never fired `countdownEnd`, while a guard that only clamped the text would
+     * have fired it immediately for a target that was never reached.
+     */
+    private remainingMs;
     /** Remaining milliseconds (live signal). */
     protected readonly remaining: _angular_core.WritableSignal<number>;
     protected readonly finished: _angular_core.WritableSignal<boolean>;