ngwr 11.2.0 → 12.0.0

package/types/ngwr-mention.d.ts

@@ -65,6 +65,12 @@ declare class WrMention<T extends WrMentionItem = WrMentionItem> {
     private readonly isBrowser;
     private overlayRef;
     private panelRef;
+    /**
+     * Where the caret sits INSIDE the field — its offset from the field's
+     * top-left corner, plus the height of the line it is on. Mutated in place by
+     * `open()`, never replaced: `caretAnchor()` closes over this object.
+     */
+    private readonly caretOffset;
     private state;
     private readonly activeIndex;
     private readonly filteredItems;
@@ -113,6 +119,27 @@ declare class WrMention<T extends WrMentionItem = WrMentionItem> {
     private activate;
     private filter;
     private setActive;
+    /**
+     * The overlay's anchor: the caret's line box, grown by the gap the panel
+     * keeps from the text, as a zero-WIDTH virtual origin in viewport
+     * coordinates. Inflating the rect rather than passing `offsetY` is what keeps
+     * `withPush` honest — CDK applies a position offset as a `transform` AFTER it
+     * has clamped, so a pushed panel would land the offset off the screen edge.
+     *
+     * Live getters, not a snapshot, and that is the whole of the scroll fix.
+     * `getCaretCoordinates` answers in viewport coordinates, which a
+     * `GlobalPositionStrategy` froze at the instant of the keystroke: the panel
+     * then stayed pinned to the screen while the page scrolled out from under it
+     * (150px of scroll, 150px of drift, ending up over unrelated content). CDK
+     * re-reads a virtual origin on every `apply()`, so pinning it to the FIELD's
+     * live rect is what turns `reposition()` into a real re-anchor.
+     *
+     * Only the caret's offset inside the field is captured up front. Measuring it
+     * runs the mirror-div pass in `caret.ts` — a full layout read, far too
+     * expensive to repeat per scroll event — and it cannot change without a
+     * keystroke, which re-enters `open()` anyway.
+     */
+    private caretAnchor;
     private open;
     private close;
     private commit;
@@ -123,6 +150,11 @@ declare class WrMention<T extends WrMentionItem = WrMentionItem> {
 /**
  * Overlay panel rendered by {@link WrMention}. Not intended for
  * direct use — the directive instantiates it via a ComponentPortal.
+ *
+ * @internal — the same tag its twin `WrPopconfirmPanel` already carried. It says
+ * the intent; it does not by itself keep the class out of the generated API
+ * tables, because `WrTableFilter` and `WrTableSort` are tagged AND documented —
+ * see `EXPORTED_BUT_INTERNAL` in `scripts/lib/extract-api.ts`.
  */
 declare class WrMentionPanel {
     readonly items: _angular_core.InputSignal<readonly WrMentionItem[]>;

package/types/ngwr-meter-group-testing.d.ts

@@ -35,8 +35,16 @@ interface WrMeterGroupSlice {
  * **The bar is a single `progressbar`, and its value is the TOTAL.** The bands
  * themselves announce nothing: they carry a `title` for a mouse and their share as an
  * inline width, and the legend is where their labels and values are readable. So a
- * spec that wants "how much of each" reads {@link getLegend} or {@link getSlices},
- * and one that wants "how full" reads {@link getValue}.
+ * spec that wants "how much of each" reads {@link getSlices} for the shares or
+ * {@link getLegendLabels} / {@link getLegendValues} for what is printed, and one that
+ * wants "how full" reads {@link getValue}.
+ *
+ * **A band's share is read off the `style` ATTRIBUTE, not through `getCssValue()`**,
+ * and the difference is not cosmetic: `getCssValue()` is `getComputedStyle()`, and
+ * `width` resolves to the USED value — so the declared `30%` comes straight back in
+ * jsdom and arrives as `180px` on a 600px bar in a real browser, and the same harness
+ * answered 30 here and 180 under a browser runner with nothing to say which one you
+ * got.
  *
  * @see https://ngwr.dev/guides/testing
  */
@@ -55,6 +63,8 @@ declare class WrMeterGroupHarness extends ComponentHarness {
     getMax(): Promise<number>;
     /** The bands, in order, with the share of the bar each takes. */
     getSlices(): Promise<WrMeterGroupSlice[]>;
+    /** Parse one band's declared share. See the class note on why this is not `getCssValue()`. */
+    private static percentOf;
     /** Whether the legend is rendered (`showLegend`, and at least one band). */
     hasLegend(): Promise<boolean>;
     /** The legend's labels, in order. */

package/types/ngwr-overlay.d.ts

@@ -303,3 +303,4 @@ declare const WR_OVERLAY: InjectionToken<Overlay>;
 declare const WR_OVERLAY_CONTAINER: InjectionToken<OverlayContainer>;
 
 export { WR_OVERLAY, WR_OVERLAY_CONTAINER, WR_RESPONSIVE_OVERLAYS, WrOutsideClick, WrOverlayContainer, provideWrOverlay, provideWrResponsiveOverlays, wrAppendOverlayClose, wrMirrorOffsets, wrPresentAsSheet };
+export type { WrResponsiveOverlaysConfig };

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

@@ -179,10 +179,10 @@ declare class WrPaginationHarness extends ComponentHarness {
      * The page the pager announces as current, from `aria-current="page"`.
      *
      * Throws when no cell claims it. The window always keeps the current page on the
-     * strip, so getting here means `currentPage` is not one of the pages at all — it
-     * is below 1, or not a whole number. The component clamps a page ABOVE the last
-     * one and nothing else, and either survivor leaves every cell looking equally
-     * inactive to an assistive tech user.
+     * strip, so getting here means `currentPage` is not one of the pages at all. The
+     * component clamps a host write into `1..totalPages`, which leaves one survivor:
+     * a fractional page, which is in range and matches no cell — and which leaves
+     * every cell looking equally inactive to an assistive tech user.
      */
     getCurrentPage(): Promise<number>;
     /**

package/types/ngwr-pipes.d.ts

@@ -1,6 +1,6 @@
 import * as i0 from '@angular/core';
 import { PipeTransform } from '@angular/core';
-import { WrDateFormat } from 'ngwr/date-adapter';
+import { WrDateFormat } from 'ngwr/date';
 import { SafeHtml } from '@angular/platform-browser';
 
 /**

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

@@ -181,8 +181,13 @@ declare class WrPopoverHarness extends ContentContainerComponentHarness {
      * Where the panel sits relative to the trigger, or `null` when it is presented
      * as a sheet and has no anchor.
      *
-     * The resolved position — the directive defaults it per mode (`bottom` for a
-     * popover, `top` for a tooltip) — read off the pane's public modifier class.
+     * The APPLIED position, not the requested one: CDK flips a placement that does
+     * not fit to the next in its fallback chain and swaps the modifier class with
+     * it. Under a unit test that is always the requested placement — jsdom measures
+     * every box as 0×0, so the first candidate always "fits" — but in a browser the
+     * two can differ, and this answers what is on screen. The directive defaults
+     * the request per mode (`bottom` for a popover, `top` for a tooltip).
+     *
      * The arrow itself is a `::after` pseudo-element, so it exists for no DOM query
      * at all; this class is the placement, and it is what the arrow's own CSS keys
      * off.

package/types/ngwr-popover.d.ts

@@ -73,6 +73,7 @@ declare class WrPopover {
     private readonly resolvedAriaLabel;
     private readonly resolvedPosition;
     private overlayRef;
+    private textPanelRef;
     private hoverCloseTimer;
     private showTimer;
     private hideTimer;

package/types/ngwr-result.d.ts

@@ -40,6 +40,8 @@ declare class WrResult {
  * ```
  */
 declare class WrResult404 {
+    /** Bound by the shared template; not an input — a preset IS its status. */
+    protected readonly status: WrResultStatus;
     readonly title: _angular_core.InputSignal<string>;
     /** Body text. Falls back to `result.notFound` from WrI18n. */
     readonly description: _angular_core.InputSignal<string | null>;
@@ -49,6 +51,8 @@ declare class WrResult404 {
 }
 /** Pre-set 403 result — forbidden / no access. */
 declare class WrResult403 {
+    /** Bound by the shared template; not an input — a preset IS its status. */
+    protected readonly status: WrResultStatus;
     readonly title: _angular_core.InputSignal<string>;
     /** Body text. Falls back to `result.forbidden` from WrI18n. */
     readonly description: _angular_core.InputSignal<string | null>;
@@ -58,6 +62,8 @@ declare class WrResult403 {
 }
 /** Pre-set 500 result — internal server error. */
 declare class WrResult500 {
+    /** Bound by the shared template; not an input — a preset IS its status. */
+    protected readonly status: WrResultStatus;
     readonly title: _angular_core.InputSignal<string>;
     /** Body text. Falls back to `result.serverError` from WrI18n. */
     readonly description: _angular_core.InputSignal<string | null>;

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

@@ -393,6 +393,15 @@ declare class WrSegmentedHarness extends ComponentHarness {
     /** Segment names for an error message, which must not throw on its way out. */
     private describeOptions;
     private describe;
+    /**
+     * One custom property off the host's `style` ATTRIBUTE.
+     *
+     * Not `getCssValue()`, which is `getComputedStyle`: with the entry point's own
+     * stylesheet loaded that resolves the sheet's declaration, so the method
+     * answers plausibly at exactly the moment the host binding — the thing under
+     * test — is what broke. The attribute holds only what the component wrote.
+     */
+    private inlineVar;
     /** One of the thumb's inline custom properties, as a number. */
     private thumbVar;
 }

package/types/ngwr-segmented.d.ts

@@ -61,7 +61,27 @@ declare class WrSegmented<T = unknown> {
     private readonly mounted;
     constructor();
     protected readonly classes: _angular_core.Signal<string>;
-    /** Inline CSS vars driving the sliding thumb position. */
+    private readonly dir;
+    /**
+     * Reading direction of the strip. `Directionality` is root-provided, so this
+     * always resolves — `optional` only guards a consumer who has deliberately
+     * torn the provider out. A subtree that overrides the direction does it with
+     * the CDK's `Dir` directive, which writes `valueSignal`, so `thumbStyle`
+     * re-renders instead of leaving the thumb parked on the old segment.
+     */
+    private readonly isRtl;
+    /**
+     * Inline CSS vars driving the sliding thumb position.
+     *
+     * `--wr-segmented-thumb-index` is the SLOT the thumb parks in, counted from the
+     * physical left, which is the selected index only in LTR. The stylesheet anchors
+     * the thumb with a physical `left` and slides it with `translateX` — neither has
+     * a logical form — while the options are a grid that mirrors, so under `dir="rtl"`
+     * the segment at logical index `i` occupies slot `count - 1 - i`. Left unsigned,
+     * the pill sat under a different label than the one it marks (the whole strip's
+     * worth of offset at the far end), which is the carousel's `trackStyle` problem
+     * one component over.
+     */
     protected readonly thumbStyle: _angular_core.Signal<Record<string, string>>;
     protected isSelected(option: WrSegmentedOption<T>): boolean;
     protected select(option: WrSegmentedOption<T>): void;

package/types/ngwr-select.d.ts

@@ -194,6 +194,48 @@ declare class WrSelect implements FormValueControl<unknown>, WrSelectContext {
     protected readonly resolvedAriaLabel: _angular_core.Signal<string>;
     /** Per-chip ARIA label — interpolates `{{label}}`. @internal */
     protected readonly chipRemoveLabel: (params?: ngwr_i18n.WrI18nParams) => string;
+    /**
+     * The overflow chip past `maxTagCount` — interpolates `{{count}}`. Through the
+     * catalog, like every other string here: printed as a bare `+{{ extra }} more`
+     * it stayed English in a fully localized app, beside an event-calendar cell
+     * reading "ещё 3" from the same string. @internal
+     */
+    protected readonly moreLabel: (params?: ngwr_i18n.WrI18nParams) => string;
+    private readonly field;
+    /**
+     * Id the surrounding `<wr-form-field>`'s `<label for>` points at.
+     *
+     * The field renders its label before it can see what was projected into it, so
+     * the id travels the other way and the control adopts it, exactly as `[wrInput]`
+     * and `wr-slider` do. Without this the `for` named an element that was nowhere in
+     * the document: clicking the label did nothing, and the field's own text reached
+     * the control through no path at all.
+     *
+     * It lands on the ONE focusable element each trigger shape has — the button, the
+     * search input, or the tag input — never on the host, because only a labelable
+     * element can be a label's target and `<wr-select>` is not one.
+     *
+     * What this does NOT change is that element's NAME: `aria-label` outranks a
+     * `<label>` in the accname order, and the trigger keeps `resolvedAriaLabel()`
+     * because the field cannot promise it has a name to give — `<wr-form-field>`
+     * renders a label only when its `label` input is set, and a combobox that traded
+     * a generic name for no name would be the worse bug. `WrFormFieldContext`
+     * publishes no "do I have a visible label" signal to key that on. Until it does,
+     * set `[ariaLabel]` to the field's label where the two should read alike.
+     */
+    protected readonly controlId: _angular_core.Signal<string | null>;
+    /**
+     * The field's error message, wired to the same element.
+     *
+     * Without it the messages `<wr-form-field>` renders are visible and nothing else:
+     * a screen reader on the trigger never learns the field is invalid, nor what the
+     * message says. `aria-invalid` is keyed on the message EXISTING rather than on
+     * `errorKeys()`, because the field only publishes an id once it is showing
+     * something — announcing "invalid" while pointing at nothing is worse than
+     * staying quiet.
+     */
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    protected readonly ariaInvalid: _angular_core.Signal<"true" | null>;
     /**
      * Disable the select. Bound automatically from the field's disabled state
      * when used with `[formField]`.
@@ -465,7 +507,17 @@ declare class WrSelect implements FormValueControl<unknown>, WrSelectContext {
     protected readonly dynamicOptions: _angular_core.Signal<readonly unknown[]>;
     private static readonly FALLBACK_ROW_PX;
     private static readonly FALLBACK_VIEWPORT_PX;
-    /** Consumer-projected `<wr-option>` children only (NOT the `@for`-rendered ones). */
+    /**
+     * Consumer-projected `<wr-option>` children only (NOT the `@for`-rendered ones
+     * — those live in the panel's own view, which a content query never sees).
+     *
+     * `descendants: true` because a projected option is as often wrapped in a
+     * `<wr-option-group>` as it is a direct child, and the signal default is
+     * `false`. A grouped list therefore read as NO projected options: `virtualActive`
+     * engaged over the (empty) data array, so the panel rendered the group's rows
+     * with a virtual window beside them that owned the keyboard — no
+     * `aria-activedescendant`, no active row, and Enter committing nothing.
+     */
     private readonly projectedOptions;
     /**
      * `dynamicOptions()` narrowed to the current search query. `dynamicOptions()`
@@ -475,9 +527,9 @@ declare class WrSelect implements FormValueControl<unknown>, WrSelectContext {
      */
     protected readonly filteredDynamicOptions: _angular_core.Signal<readonly unknown[]>;
     /**
-     * Virtualization engaged: opt-in, search mode, a non-empty filtered array, and
-     * NO projected `<wr-option>` children (those keep the full-render registry path
-     * so their DOM-derived labels / selection still work).
+     * Virtualization engaged: opt-in, search mode, and NO projected `<wr-option>`
+     * children — grouped ones included (those keep the full-render registry path so
+     * their DOM-derived labels / selection still work).
      *
      * NOT gated on there being matches. It used to also require
      * `filteredDynamicOptions().length > 0`, which meant a query matching nothing
@@ -576,8 +628,18 @@ declare class WrSelect implements FormValueControl<unknown>, WrSelectContext {
     isSelected(value: unknown): boolean;
     selectOption(value: unknown): void;
     registerOption(reg: WrSelectOptionRegistration): () => void;
-    /** Remove one selection (chip × button). Works for multi and tag modes. */
-    protected removeChip(value: unknown, event: Event): void;
+    /**
+     * Remove one selection (chip × button) BY POSITION. Works for multi and tag
+     * modes.
+     *
+     * Positional, not by value: under `allowDuplicates` two chips carry the same
+     * string, and a filter on equality deleted every copy at once — one click on
+     * the second "red" took both reds with it. `visibleChips()` slices the HEAD
+     * of `selectedChips()`, which maps the value array one for one, so the
+     * `$index` a chip was rendered with indexes the value array directly. The
+     * multi-mode toggle in `selectOption` was already positional.
+     */
+    protected removeChip(index: number, event: Event): void;
     /** Clear every selection (× button). Multi/tag → empty array; search → null. */
     protected clearAll(event: Event): void;
     /** Capacity check used by tag mode to refuse the next add. */

package/types/ngwr-shiny-text.d.ts

@@ -52,8 +52,10 @@ declare class WrShinyText {
  * Gradient sweep over text. Applies a `background-clip: text` gradient
  * with a moving highlight — gives any text a subtle shimmer.
  *
- * The directive only adds the `wr-shimmer` host class. Pair with the
- * styles in `ngwr/animations` (which include the `wr-shimmer` keyframes).
+ * The directive only adds the `wr-shimmer` host class. Pair with the styles
+ * in `ngwr/shiny-text` (`@use 'ngwr/shiny-text'`), which carry the
+ * `.wr-shimmer` rule and its keyframes; the umbrella `@use 'ngwr'` forwards
+ * the same sheet.
  *
  * @example
  * ```html

package/types/ngwr-sidebar.d.ts

@@ -75,17 +75,26 @@ declare class WrSidebar {
     private readonly uid;
     private readonly router;
     private readonly currentUrl;
-    /** Last URL we auto-expanded — prevents re-opening a group the user collapsed. */
+    /**
+     * Last URL we resolved to a group — prevents re-opening one the user collapsed.
+     * A URL no entry claims is deliberately NOT recorded: see the effect below.
+     */
     private lastAutoUrl;
     constructor();
     protected isOpen(title: string): boolean;
     /**
      * 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.
+     *
+     * Keyed by POSITION, not by the title. Slugging the title kept the id readable
+     * but was not injective: it lowercases and collapses every non-`[a-z0-9]` run,
+     * so `Data & charts` and `Data / charts` produced the same string, and a title
+     * with no ASCII alphanumerics at all — `Компоненты`, `数据` — produced the empty
+     * one. A whole Russian or Chinese sidebar therefore emitted N identical ids and
+     * every toggle's `aria-controls` resolved to the FIRST group's body. The toggle
+     * and its body read `$index` from the same `@for` iteration, so the two always
+     * name each other — reordering `entries` renumbers both together.
      */
-    protected groupBodyId(title: string): string;
+    protected groupBodyId(index: number): string;
     protected toggleGroup(title: string): void;
     protected asItem(entry: WrSidebarEntry): WrSidebarItem;
     protected asGroup(entry: WrSidebarEntry): WrSidebarGroup;

package/types/ngwr-slider.d.ts

@@ -69,6 +69,63 @@ declare class WrSlider implements FormValueControl<WrSliderValue> {
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, any>;
     /** Render the current value below the track. @default true */
     readonly showLabel: _angular_core.InputSignalWithTransform<boolean, any>;
+    /**
+     * Accessible name of the thumb — the single one, or the LOWER one in range
+     * mode. Falls back to `slider.label` / `slider.lower`.
+     */
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    /** Accessible name of the upper thumb in range mode. Falls back to `slider.upper`. */
+    readonly upperLabel: _angular_core.InputSignal<string | null>;
+    /**
+     * A thumb projects no text, so these ARE the accessible names — and they were
+     * hard-coded English with no key behind them, so every slider on a page
+     * announced the same untranslated "Value" whatever it controlled.
+     *
+     * Range mode reads `ariaLabel` as the LOWER end rather than as the whole
+     * control: a name given once must land on something, and naming both thumbs
+     * the same thing would read two different values under one name.
+     */
+    private readonly singleLabel;
+    private readonly lowerLabel;
+    protected readonly resolvedUpperLabel: _angular_core.Signal<string>;
+    protected readonly resolvedLowLabel: _angular_core.Signal<string>;
+    private readonly field;
+    /**
+     * Id the surrounding `<wr-form-field>`'s `<label for>` points at, put on the
+     * single thumb — the LOWER one in range mode, the same end `ariaLabel` names.
+     *
+     * The field renders its label before it can see what was projected into it, so
+     * the id travels the other way and the control adopts it, exactly as
+     * `[wrInput]` does. Without this the `for` named an element that was nowhere
+     * in the document: clicking the label did nothing, and the field's own text
+     * reached the thumb through no path at all.
+     *
+     * It lands on the THUMB rather than on the host because only a labelable
+     * element can be a label's target, and `<wr-slider>` is not one — a `for`
+     * pointing at the host would resolve and still name nothing. The thumb is a
+     * real `<button>`, so it is.
+     *
+     * What this does NOT change is the thumb's name: an `aria-label` outranks a
+     * `<label>` in the accname order, and the thumb keeps its own because the
+     * field cannot promise it has one to give — `<wr-form-field>` renders a label
+     * only when `label` is set, and a slider that traded a generic name for no
+     * name would be the worse bug. Set `[ariaLabel]` to the field's label where
+     * the two should read alike.
+     */
+    protected readonly thumbId: _angular_core.Signal<string | null>;
+    /**
+     * The field's error message, wired to the thumb the same way `wrInput` wires it
+     * to its native element.
+     *
+     * Without this the messages `<wr-form-field>` renders are visible and nothing
+     * else: a screen reader on the thumb never learns the field is invalid, nor
+     * what the message says. `aria-invalid` is keyed on the message EXISTING rather
+     * than on `errorKeys()`, because the field only publishes an id once it is
+     * showing something — announcing "invalid" while pointing at nothing is worse
+     * than staying quiet.
+     */
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    protected readonly ariaInvalid: _angular_core.Signal<"true" | null>;
     /**
      * Current value. Bound by `[formField]`, or two-way via `[(value)]`. Shape
      * follows `range`: a plain `number`, or `[low, high]` in range mode.
@@ -116,6 +173,17 @@ declare class WrSlider implements FormValueControl<WrSliderValue> {
     protected onPointerDown(event: PointerEvent, thumb: 'low' | 'high'): void;
     protected onTrackPointerDown(event: PointerEvent): void;
     protected onKey(event: KeyboardEvent, thumb: 'low' | 'high'): void;
+    /**
+     * A bound field learns it may show its validation copy from `touch`, and
+     * pointer-up plus a value-changing keypress cannot be the only sources: a
+     * slider tabbed into and out of without an arrow press left the field
+     * untouched forever — which is exactly the case `touched` exists for, and
+     * what this output has always documented itself as doing. `wr-knob` and
+     * `wr-rating` bind `(blur)` on the one element they own; this component has
+     * two thumbs, so it listens for the bubbling `focusout` on its host instead
+     * — and ignores the one that only moves focus from one thumb to the other.
+     */
+    protected onFocusOut(event: FocusEvent): void;
     private isRtl;
     /**
      * The value under a pointer, measured along the track's INLINE axis.
@@ -142,7 +210,7 @@ declare class WrSlider implements FormValueControl<WrSliderValue> {
     private percentOf;
     private emitChange;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrSlider, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrSlider, "wr-slider", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "range": { "alias": "range"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "showLabel": { "alias": "showLabel"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrSlider, "wr-slider", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "range": { "alias": "range"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "showLabel": { "alias": "showLabel"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "upperLabel": { "alias": "upperLabel"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; }, never, never, true, never>;
 }
 
 export { WrSlider };

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

@@ -46,14 +46,12 @@ interface WrSpeedDialActionHarnessFilters extends BaseHarnessFilters {
  * @see https://ngwr.dev/guides/testing
  */
 declare class WrSpeedDialActionHarness extends ComponentHarness {
-    /** The action button. `role="menuitem"` sits on this element too. */
+    /** The action button. */
     static hostSelector: string;
     /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
     static with(options?: WrSpeedDialActionHarnessFilters): HarnessPredicate<WrSpeedDialActionHarness>;
     /** The action's accessible name — what a screen reader reads, and what `title` shows. */
     getLabel(): Promise<string | null>;
-    /** The role the action announces — `menuitem`. */
-    getRole(): Promise<string | null>;
     /** Whether the action draws an icon rather than a letter. */
     hasIcon(): Promise<boolean>;
     /** The icon's registered name, from `wr-icon`'s reflected `data-icon`, or `null`. */
@@ -136,15 +134,22 @@ declare class WrSpeedDialHarness extends ComponentHarness {
     isDisabled(): Promise<boolean>;
     /** Whether the host is padded for the device's safe area (`safeArea`). */
     hasSafeArea(): Promise<boolean>;
-    /** The role the action list announces — `menu`. */
+    /**
+     * The role the action list announces — `list`.
+     *
+     * Worth asking despite being a plain `<ul>`: the list is styled `list-style: none`,
+     * which drops the implicit list semantics in Safari, so the role is written out. It
+     * is deliberately NOT `menu` — that role promises arrows, Home/End and a single tab
+     * stop, none of which this component has.
+     */
     getMenuRole(): Promise<string | null>;
     /**
-     * Whether the trigger's `aria-controls` names THIS dial's menu, and nothing else on
-     * the page.
+     * Whether the trigger's `aria-controls` names THIS dial's action list, and nothing
+     * else on the page.
      *
      * Both halves matter. The id is resolved inside the host first, so a trigger
-     * pointing at a SIBLING dial's menu — which resolves perfectly well from the
-     * document — fails here. Then it is counted across the document, because two menus
+     * pointing at a SIBLING dial's list — which resolves perfectly well from the
+     * document — fails here. Then it is counted across the document, because two lists
      * answering to one id hand every reference to whichever comes first.
      */
     isMenuBound(): Promise<boolean>;
@@ -179,9 +184,8 @@ declare class WrSpeedDialHarness extends ComponentHarness {
      * Press Escape — closing the dial and putting focus back on the trigger.
      *
      * Sent to the host, which is where the component listens. The focus return is the
-     * half worth asserting: `role="menu"` promises a way out, and the actions are
-     * ordinary tab stops, so without it a keyboard user has to walk through every
-     * action to leave.
+     * half worth asserting: the actions are ordinary tab stops, so without it a keyboard
+     * user has to walk through every action to leave.
      */
     sendEscape(): Promise<void>;
     /** Move keyboard focus to the trigger. */

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

@@ -11,6 +11,24 @@ 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.
+ * 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[]>;
     /**
@@ -38,14 +56,15 @@ declare class WrSpeedDial {
     /** Id the trigger's `aria-controls` points at. */
     protected readonly menuId: string;
     protected readonly triggerEl: _angular_core.Signal<ElementRef<HTMLButtonElement> | undefined>;
+    private readonly host;
     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.
+     * Escape closes the dial and hands the caret back. The actions are ordinary buttons
+     * in the tab order, so without this a keyboard user who opened the dial had to tab
+     * through every action to leave it.
      */
     protected onKeydown(event: KeyboardEvent): void;
     /**

package/types/ngwr-split-text.d.ts

@@ -84,6 +84,15 @@ declare class WrSplitText {
      * watching the same host and all of them able to fire `animate()`.
      */
     private observer;
+    /**
+     * `startObserver()` builds its observer inside a `document.fonts.ready`
+     * continuation, so the component can be destroyed while it is awaiting. At
+     * that moment `observer` is still null, so the destroy hook below disconnects
+     * nothing — and the continuation then starts an observer on a host Angular
+     * has already detached, which nothing is left to disconnect. Same hazard, and
+     * same flag, as `wr-fuzzy-text`.
+     */
+    private destroyed;
     constructor();
     private startObserver;
     private animate;

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

@@ -248,11 +248,11 @@ declare class WrStepperHarness extends ComponentHarness {
      * The index of the step the wizard is showing, from the header announcing
      * `aria-current="step"`.
      *
-     * Throws when no header does, which is a state a stepper can genuinely be in: the
-     * `active` model is two-way, `WrStepper.goTo()` clamps an out-of-range index but a
-     * host writing `active` directly does not, and an index past the last step leaves
-     * every header un-current and every step body hidden. A `-1` here would be read as
-     * "the first step" by the next line of a spec.
+     * Throws when no header does, which is a state a stepper can genuinely be in: one
+     * with no `<wr-step>` children renders its (empty) header strip and no body. A `-1`
+     * here would be read as "the first step" by the next line of a spec. An
+     * out-of-range `active` is NOT such a state — `WrStepper` clamps the two-way model
+     * back into the step list, not only inside `goTo()`.
      */
     getActiveIndex(): Promise<number>;
     /** The label of the step the wizard is showing. Throws when there is no current step. */

package/types/ngwr-stepper.d.ts

@@ -88,6 +88,14 @@ declare class WrStepper implements WrStepperContext {
      */
     readonly responsive: _angular_core.InputSignalWithTransform<boolean, any>;
     protected readonly steps: _angular_core.Signal<readonly WrStep[]>;
+    /**
+     * The "optional" badge sits INSIDE the header button's label span, so the word
+     * is part of the step's accessible name — a hard-coded literal announced English
+     * to every locale, not just showed it. Catalog-only rather than an input: the
+     * badge is one word shared by every step, and an app that wants other wording
+     * overrides `stepper.optional` once instead of on every `<wr-step>`.
+     */
+    protected readonly optionalLabel: _angular_core.Signal<string>;
     protected readonly classes: _angular_core.Signal<string>;
     constructor();
     /** Is the step at `index` considered completed? */

package/types/ngwr-storage.d.ts

@@ -36,6 +36,7 @@ import * as ngwr_storage from 'ngwr/storage';
 declare class WrStorage {
     private readonly engine;
     private readonly config;
+    private readonly destroyRef;
     private readonly isBrowser;
     /**
      * Per-key watchers. Shared so multiple `watch(k)` calls reuse one signal.