ngwr 14.3.1 → 14.5.0

package/types/ngwr-calendar-heatmap.d.ts

@@ -8,6 +8,8 @@ interface WrHeatmapDatum {
 
 interface Cell {
     readonly iso: string;
+    /** The day as the reader's locale writes it — see `cellTitle`. */
+    readonly date: Date;
     readonly value: number;
     readonly intensity: number;
     readonly week: number;
@@ -34,6 +36,26 @@ declare class WrCalendarHeatmap {
      */
     readonly ariaLabel: _angular_core.InputSignal<string | null>;
     protected readonly resolvedAriaLabel: _angular_core.Signal<string>;
+    private readonly cellText;
+    /**
+     * A cell's tooltip, with both halves formatted and the sentence in the catalog.
+     *
+     * It used to be `` `${cell.iso}: ${cell.value}` `` — a raw ISO date beside an
+     * unformatted number, joined by a hard-coded `': '`. Three things were wrong
+     * at once and none of them are visible from the template: `2026-09-10` is not
+     * how most of the world writes a date, `1234` is not how every locale groups
+     * digits (`ar-SA` does not even use these ones), and the separator and order
+     * were frozen into a shape a translator could not reach.
+     *
+     * Both halves go through `Intl` on the SAME locale the rest of the component
+     * resolves — `WR_DATE_LOCALE`, which since v14 follows Angular's `LOCALE_ID`.
+     * The key ships as `{{date}}: {{count}}` everywhere, so nothing reorders today
+     * and every locale can.
+     */
+    protected cellTitle(cell: {
+        readonly date: Date;
+        readonly value: number;
+    }): string;
     /** Last day to render. @default today */
     readonly endDate: _angular_core.InputSignal<string | Date | null>;
     /** Number of weeks (columns) to render. @default 53 */

package/types/ngwr-calendar.d.ts

@@ -170,7 +170,28 @@ declare class WrCalendar {
     protected next(): void;
     /** Header label click — zooms out (`day → month → year`). No-op at year view. */
     protected onLabelClick(): void;
+    /**
+     * Picking a month drops to the day grid — and takes real focus with it.
+     *
+     * The `@switch (viewMode())` in the template destroys the chip that holds DOM
+     * focus, so without the two lines below `document.activeElement` became
+     * `<body>`: the ring appeared on the new view and focus did not, the arrow
+     * keys went dead (the keydown handler is a HOST binding, so nothing reaches
+     * the component from `<body>`), and the next Tab restarted from the top of the
+     * document — out of the calendar entirely. It is the same trap the two
+     * keyboard paths in this file already fix, and for the same reason
+     * `afterNextRender` rather than `queueMicrotask`: under zoneless CD the
+     * microtask runs before the new view is in the DOM.
+     *
+     * `focusedDate` has to move too, and that half is easy to miss. The grid marks
+     * its focusable cell by comparing against `focusedDate`, not `viewDate`, so
+     * choosing a DIFFERENT month rendered a grid with no `--focused` cell and no
+     * `tabindex="0"` at all — unreachable by keyboard from either direction. The
+     * day is preserved when the month already holds it and otherwise falls to the
+     * first, which is where `viewDate` lands anyway.
+     */
     protected onMonthSelect(monthIdx: number): void;
+    /** Year → month view, with the same focus restoration; the landing view is chips. */
     protected onYearSelect(year: number): void;
     /**
      * Switch views and drop the chip ring with them.

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

@@ -56,21 +56,25 @@ interface WrCascaderOptionHarnessFilters extends BaseHarnessFilters {
  *
  * An option is either a BRANCH (it has children, so clicking it opens the next
  * column) or a LEAF (clicking it commits the whole path and closes the panel).
- * {@link hasChildren} is the only way to tell them apart, and it reads the
- * chevron the template draws for branches — the option carries no
- * `aria-haspopup` / `aria-expanded`, so a screen-reader user is told nothing
- * about a branch either. Reported here rather than papered over.
+ * {@link hasChildren} reads the chevron the template draws for branches;
+ * {@link isExpanded} reads the state that same branch announces. The two are
+ * not one question — a branch always HAS children and is expanded only while
+ * the column to its right is showing them.
+ *
+ * The panel is a `role="tree"` and an option is a `treeitem`. It was a `menu`
+ * of `menuitem`s until the roles were corrected, and this class documented that
+ * a branch announced nothing at all; both are historical now.
  *
  * @see https://ngwr.dev/guides/testing
  */
 declare class WrCascaderOptionHarness extends ComponentHarness {
-    /** The `<li role="menuitem">` a column renders per option. */
+    /** The `<li role="treeitem">` a column renders per option. */
     static hostSelector: string;
     /** Build a predicate that narrows the query. */
     static with(options?: WrCascaderOptionHarnessFilters): HarnessPredicate<WrCascaderOptionHarness>;
     /** The option's label, trimmed. The branch chevron contributes no text. */
     getText(): Promise<string>;
-    /** The role the option announces — `menuitem`. */
+    /** The role the option announces — `treeitem`. */
     getRole(): Promise<string | null>;
     /** Whether the option refuses selection, from the state a screen reader is given. */
     isDisabled(): Promise<boolean>;
@@ -79,11 +83,40 @@ declare class WrCascaderOptionHarness extends ComponentHarness {
      * whose children the column to the right is showing, or the committed segment
      * at this level.
      *
-     * Read from the `--active` modifier because nothing else says it: the option
-     * has no `aria-selected` and no `aria-expanded`, so the class is both the
-     * whole visual answer and the only one available.
+     * Read from the `--active` modifier, and NOT the same question as
+     * {@link isSelected}: this one tracks where the user has navigated, that one
+     * tracks what they committed. They agree only once a leaf is picked, and a
+     * harness that collapsed them would hide exactly the divergence it exists to
+     * catch.
      */
     isActive(): Promise<boolean>;
+    /**
+     * Whether this option is the committed choice, or `null` when it is not a
+     * choice at all.
+     *
+     * `null` — the attribute absent — for a branch while `changeOnSelect` is off,
+     * because such a branch genuinely cannot be chosen. Answering a plausible
+     * `false` there would report an unselectable row as merely unselected, which
+     * is the distinction the attribute exists to carry.
+     */
+    isSelected(): Promise<boolean | null>;
+    /**
+     * Whether this branch's children are the column to its right, or `null` for a
+     * leaf.
+     *
+     * `null` rather than `false`, and the difference is the whole point: a leaf
+     * does not have a collapsed subtree, it has none. `aria-expanded="false"` on
+     * one would state that a subtree exists and is shut.
+     */
+    isExpanded(): Promise<boolean | null>;
+    /**
+     * The option's depth, 1-based — its `aria-level`.
+     *
+     * Worth reading in a spec rather than trusting: the columns are DOM SIBLINGS,
+     * so nothing about the markup's shape carries depth. Every option would be
+     * level 1 if this attribute were dropped, and no gate would say so.
+     */
+    getLevel(): Promise<number | null>;
     /** Whether the option opens a deeper level rather than ending the path. */
     hasChildren(): Promise<boolean>;
     /**
@@ -117,10 +150,10 @@ declare class WrCascaderOptionHarness extends ComponentHarness {
      * This is the component's entire keyboard model — the columns bind
      * `keydown.enter` / `keydown.space` per option and nothing else, so there are
      * no arrow keys to walk levels with. A keyboard user reaches the option they
-     * want with Tab and presses Enter — and Tab is a long way round: the panel is a
-     * portal in the overlay container at the end of the document, and nothing moves
-     * focus into it on open, so the first option is not the next stop after the
-     * trigger.
+     * want with Tab and presses Enter. Opening the panel does move focus into it —
+     * `focusPanelOption()` lands on the active option, or the first enabled one —
+     * so the walk starts there rather than from the trigger; this JSDoc claimed
+     * the opposite for a while and was simply wrong.
      */
     selectByKeyboard(): Promise<void>;
     /**
@@ -165,11 +198,11 @@ declare class WrCascaderOptionHarness extends ComponentHarness {
  * @see https://ngwr.dev/guides/testing
  */
 declare class WrCascaderColumnHarness extends ComponentHarness {
-    /** The `<ul role="menu">` the panel renders per level. */
+    /** The `<ul role="group">` the panel renders per level, inside the `tree`. */
     static hostSelector: string;
     /** Build a predicate that narrows the query. */
     static with(options?: WrCascaderColumnHarnessFilters): HarnessPredicate<WrCascaderColumnHarness>;
-    /** The role the column announces — `menu`. */
+    /** The role the column announces — `group`, inside the panel's `tree`. */
     getRole(): Promise<string | null>;
     /** The options this level offers, in order. */
     getOptions(filters?: WrCascaderOptionHarnessFilters): Promise<WrCascaderOptionHarness[]>;
@@ -269,9 +302,16 @@ declare class WrCascaderHarness extends ComponentHarness {
      * nothing selected and no placeholder would otherwise have no name at all.
      */
     getAccessibleName(): Promise<string | null>;
-    /** The kind of popup the trigger promises via `aria-haspopup` — `menu`. */
+    /**
+     * The kind of popup the trigger promises via `aria-haspopup` — `tree`.
+     *
+     * Worth pinning rather than assuming: a combobox's popup may be a listbox, a
+     * tree, a grid or a dialog and nothing else, and this one said `menu` for a
+     * long time. `menu` is a valid token for the global `aria-haspopup`, so axe
+     * reports nothing either way — an assertion here is the only guard there is.
+     */
     getPopupRole(): Promise<string | null>;
-    /** The role the panel announces — `menu`, matching what the trigger promised. */
+    /** The role the panel announces — `tree`, matching what the trigger promised. */
     getPanelRole(): Promise<string | null>;
     /**
      * The id the trigger publishes as `aria-controls`.
@@ -368,6 +408,23 @@ declare class WrCascaderHarness extends ComponentHarness {
      * rendered at all in either case (nor while disabled).
      */
     clear(): Promise<void>;
+    /**
+     * Clear from the keyboard — Backspace on the closed trigger.
+     *
+     * The × {@link clear} clicks is a `tabindex="-1"` span inside the trigger, so no
+     * key can ever reach it; Backspace on the trigger is its keyboard twin, and the
+     * route a keyboard-only user actually has. Prefer this one in a spec that cares
+     * about that user — {@link clear} proves the pointer path and nothing more.
+     *
+     * The component honours the key only on the CLOSED trigger, so an open panel
+     * is closed first with Escape — the step a keyboard user takes too. Sending
+     * Backspace into an open panel and returning would be a plausible nothing.
+     *
+     * Does nothing, rather than throwing, when there is nothing to clear, `clearable`
+     * is off, or the cascader is disabled or read-only: that silence IS the
+     * component's contract, so a spec asserts it on the value.
+     */
+    clearByKeyboard(): Promise<void>;
     /** Move keyboard focus to the trigger. */
     focus(): Promise<void>;
     /** Take focus off the trigger, which is what makes a bound form field touched. */

package/types/ngwr-cascader.d.ts

@@ -133,6 +133,13 @@ declare class WrCascader<T = string> implements FormValueControl<unknown> {
     private readonly scrollStrategies;
     private readonly destroyRef;
     private readonly injector;
+    /**
+     * Ambient reading direction, for the open panel alone — nothing in this
+     * component reads it directly. Optional so a bare `TestBed` needs no
+     * provider; `Directionality` is root-provided anyway, and a missing one
+     * simply reads as `ltr`.
+     */
+    private readonly dir;
     private overlayRef;
     constructor();
     protected onTriggerClick(): void;
@@ -148,6 +155,34 @@ declare class WrCascader<T = string> implements FormValueControl<unknown> {
     protected onOptionClick(colIndex: number, opt: WrCascaderOption<T>, event: Event): void;
     protected clearSelection(event: Event): void;
     protected isActiveAt(colIndex: number, value: T): boolean;
+    /**
+     * Whether this option is the committed choice — `null` when it is not a
+     * choice at all.
+     *
+     * Two questions the panel has to keep apart, and `--active` answers only the
+     * first: `activePath()` is where the user has NAVIGATED to, `path()` is what
+     * they have COMMITTED. They agree once a leaf is picked and diverge for the
+     * whole walk down.
+     *
+     * `null` — the attribute absent — on a branch while `changeOnSelect` is off,
+     * because such a branch genuinely cannot be chosen; ARIA reads a missing
+     * `aria-selected` as "not selectable", which is exactly true here. That makes
+     * this binding the first expression the `changeOnSelect` contract has ever had
+     * in ARIA, in both directions.
+     */
+    protected isSelectedAt(colIndex: number, opt: WrCascaderOption<T>): boolean | null;
+    /** Stable id for one option — what a column's `aria-labelledby` points at. */
+    protected optionId(colIndex: number, optIndex: number): string;
+    /** Stable id for one column — what an expanded branch's `aria-controls` points at. */
+    protected columnId(colIndex: number): string;
+    /**
+     * The option whose children a column holds, by id — its accessible name.
+     *
+     * The columns are DOM SIBLINGS, so nothing in the markup says the second one
+     * belongs to "Europe". Column 0 has no parent and stays unnamed; the tree
+     * itself already carries the control's name.
+     */
+    protected parentOptionId(colIndex: number): string | null;
     private pathsEqual;
     private openOverlay;
     /**

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

@@ -61,7 +61,18 @@ declare class WrCheckboxHarness extends ComponentHarness {
      */
     isIndeterminate(): Promise<boolean>;
     isDisabled(): Promise<boolean>;
-    /** The group identity — `checkboxValue`, not the form value. */
+    /**
+     * The group identity — `checkboxValue`, not the form value.
+     *
+     * Read off the host's `data-checkbox-value`, which the component reflects for
+     * exactly this. It used to read `value` from the inner `<input>`, an attribute
+     * nothing writes, so it answered `null` for every checkbox whatever its
+     * identity — the shape these harnesses are not allowed to have.
+     *
+     * `null` still means one honest thing: no identity, or an identity that is not
+     * a primitive. An object or an array has no attribute form, and a harness
+     * cannot reach a TypeScript value the DOM never carried.
+     */
     getCheckboxValue(): Promise<string | null>;
     /** Flip the box. A disabled checkbox does not move; assert rather than assume. */
     toggle(): Promise<void>;

package/types/ngwr-checkbox.d.ts

@@ -49,6 +49,16 @@ declare class WrCheckbox implements FormCheckboxControl {
      * `value`.)
      */
     readonly checkboxValue: _angular_core.InputSignal<unknown>;
+    /**
+     * `checkboxValue` as an attribute, when it can be one.
+     *
+     * A primitive round-trips through the DOM and is what a group identity is in
+     * practice. Anything else — an object, an array — has no honest attribute
+     * form, so the attribute is ABSENT rather than `[object Object]`: a harness
+     * reading it then gets `null`, which is true, instead of a string that looks
+     * like data and identifies nothing.
+     */
+    protected readonly reflectedValue: _angular_core.Signal<string | null>;
     /**
      * Accessible name for a checkbox used WITHOUT projected text — a selection
      * cell in a table, say. The wrapping `<label>` names the control whenever

package/types/ngwr-clipboard.d.ts

@@ -64,7 +64,7 @@ declare class WrClipboard {
      */
     private legacyWrite;
     static ɵfac: i0.ɵɵFactoryDeclaration<WrClipboard, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<WrClipboard>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
 
 export { WrClipboard };

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

@@ -415,6 +415,14 @@ declare class WrColorPickerTrigger {
     private readonly vcr;
     private readonly scrollStrategies;
     private readonly destroyRef;
+    private readonly injector;
+    /**
+     * Ambient reading direction, for the open panel alone — nothing in this
+     * directive reads it directly. Optional so a bare `TestBed` needs no
+     * provider; `Directionality` is root-provided anyway, and a missing one
+     * simply reads as `ltr`.
+     */
+    private readonly dir;
     protected readonly isOpen: _angular_core.WritableSignal<boolean>;
     private overlayRef;
     /** @internal Public so the host binding can read it. */

package/types/ngwr-confetti.d.ts

@@ -71,7 +71,7 @@ declare class WrConfetti {
     private spawn;
     private tick;
     static ɵfac: i0.ɵɵFactoryDeclaration<WrConfetti, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<WrConfetti>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
 
 export { WrConfetti };

package/types/ngwr-context-menu.d.ts

@@ -44,9 +44,18 @@ declare class WrContextMenu {
     readonly menu: _angular_core.InputSignal<WrContextMenuPanel>;
     private readonly host;
     private readonly overlay;
+    /**
+     * The reading direction the open menu has to keep up with.
+     *
+     * Optional inject, as on every other overlay here: `Directionality` is
+     * root-provided and so never null in an app, but a bare `TestBed` that
+     * provides nothing should still get a menu that opens.
+     */
+    private readonly dir;
     private readonly outsideClick;
     private readonly vcr;
     private readonly scrollStrategies;
+    private readonly injector;
     private readonly destroyRef;
     /**
      * Id of the menu element while this trigger's menu is open, published on the
@@ -219,6 +228,7 @@ declare class WrContextMenuItem {
     private readonly dir;
     private readonly vcr;
     private readonly scrollStrategies;
+    private readonly injector;
     private readonly destroyRef;
     private submenuRef;
     private submenuKeys;

package/types/ngwr-cookie.d.ts

@@ -59,7 +59,7 @@ declare class WrCookie {
     /** Remove every cookie visible to this document. Uses `path: '/'`. */
     clear(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<WrCookie, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<WrCookie>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
 
 export { WrCookie };

package/types/ngwr-date-adapters-fns.d.ts

@@ -67,7 +67,7 @@ declare class WrDateFnsAdapter extends WrDateAdapter<Date> {
     getDayOfWeekNames(style: 'narrow' | 'short' | 'long'): readonly string[];
     getMonthNames(style: 'narrow' | 'short' | 'long'): readonly string[];
     static ɵfac: i0.ɵɵFactoryDeclaration<WrDateFnsAdapter, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<WrDateFnsAdapter>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
 
 /**

package/types/ngwr-date-adapters-luxon.d.ts

@@ -70,7 +70,7 @@ declare class WrLuxonAdapter extends WrDateAdapter<DateTime> {
     getDayOfWeekNames(style: 'narrow' | 'short' | 'long'): readonly string[];
     getMonthNames(style: 'narrow' | 'short' | 'long'): readonly string[];
     static ɵfac: i0.ɵɵFactoryDeclaration<WrLuxonAdapter, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<WrLuxonAdapter>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
 
 /**

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

@@ -83,6 +83,14 @@ declare class WrDatePicker implements FormValueControl<Date | null> {
     private readonly scrollStrategies;
     private readonly host;
     private readonly destroyRef;
+    private readonly injector;
+    /**
+     * Ambient reading direction, for the open panel alone — nothing in this
+     * component reads it directly. Optional so a bare `TestBed` needs no
+     * provider; `Directionality` is root-provided anyway, and a missing one
+     * simply reads as `ltr`.
+     */
+    private readonly dir;
     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)]`. */
@@ -306,6 +314,14 @@ declare class WrDateRangePicker implements FormValueControl<WrDateRange | null>
     private readonly scrollStrategies;
     private readonly host;
     private readonly destroyRef;
+    private readonly injector;
+    /**
+     * Ambient reading direction, for the open panel alone — nothing in this
+     * component reads it directly. Optional so a bare `TestBed` needs no
+     * provider; `Directionality` is root-provided anyway, and a missing one
+     * simply reads as `ltr`.
+     */
+    private readonly dir;
     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>;

package/types/ngwr-date.d.ts

@@ -29,8 +29,14 @@ interface WrDateAdapterOptions {
      */
     readonly adapter?: Type<WrDateAdapter<unknown>>;
     /**
-     * BCP 47 locale tag (`'en-US'`, `'ru-RU'`, …). Default: `navigator.language`
-     * in the browser, `'en-US'` on the server.
+     * BCP 47 locale tag (`'en-US'`, `'ru-RU'`, …).
+     *
+     * Default: Angular's own `LOCALE_ID`, which is what {@link WR_DATE_LOCALE}
+     * resolves to. This line used to say `navigator.language` in the browser and
+     * `'en-US'` on the server, which was true before v14 and has been wrong since
+     * — v14 made `LOCALE_ID` the single locale source precisely so an app that
+     * sets it correctly stops formatting dates in whatever language the visitor's
+     * browser happens to be.
      */
     readonly locale?: string;
 }
@@ -272,7 +278,7 @@ declare class WrNativeDateAdapter extends WrDateAdapter<Date> {
      */
     private compose;
     static ɵfac: i0.ɵɵFactoryDeclaration<WrNativeDateAdapter, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<WrNativeDateAdapter>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
 
 /**

package/types/ngwr-density.d.ts

@@ -57,7 +57,7 @@ declare class WrDensity {
     private readPersisted;
     private persist;
     static ɵfac: i0.ɵɵFactoryDeclaration<WrDensity, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<WrDensity>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
 
 /**

package/types/ngwr-dialog.d.ts

@@ -149,6 +149,7 @@ declare class WrDialog {
     private readonly isBrowser;
     private readonly responsiveConfig;
     private readonly i18n;
+    private readonly dir;
     private readonly location;
     open<C, R = unknown, D = unknown>(component: ComponentType<C>, options?: WrDialogOptions<D>): WrDialogRef<C, R>;
     /**
@@ -181,7 +182,7 @@ declare class WrDialog {
      */
     private closeLabel;
     static ɵfac: i0.ɵɵFactoryDeclaration<WrDialog, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<WrDialog>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
 
 /**

package/types/ngwr-donut-chart-testing.d.ts

@@ -75,7 +75,17 @@ declare class WrDonutChartHarness extends ComponentHarness {
     getCenterValue(): Promise<string | null>;
     /** The caption under the centre value, or `null`. */
     getCenterLabel(): Promise<string | null>;
-    /** The ring's diameter in pixels, as the component writes it inline. */
+    /**
+     * The chart's outer size in pixels, read off the `style` ATTRIBUTE.
+     *
+     * NOT `getCssValue()`, which is `getComputedStyle()` — the same rule this
+     * file's class note already states and this method alone broke. A computed
+     * read answers from the LAID-OUT box, so it agrees with the inline value in
+     * jsdom (which lays nothing out and echoes the declaration) and disagrees in a
+     * browser, where sub-pixel rounding turns a declared 240 into 239.5. A harness
+     * that answers differently in the two places it runs is worse than one that
+     * refuses.
+     */
     getSize(): Promise<number>;
 }
 

package/types/ngwr-drawer.d.ts

@@ -168,8 +168,28 @@ declare class WrDrawer {
     private readonly overlay;
     private readonly vcr;
     private readonly destroyRef;
+    private readonly injector;
     private readonly focusTrapFactory;
     private readonly isBrowser;
+    /**
+     * The reading direction the open drawer has to keep up with, resolved off the
+     * ENVIRONMENT injector rather than this component's.
+     *
+     * That is where the CDK read it: `createOverlayRef` takes `Directionality`
+     * from the `Overlay`'s own injector, which `provideWrOverlay()` parents to
+     * the application's, so a node-level CDK `[dir]` is never in the chain. A
+     * panel is not IN that island either — it is appended to the overlay
+     * container on `<body>` — so following the node injector would not follow the
+     * ref at all: it would rewrite a correctly-stamped panel to the island's
+     * direction one pass after it opened, and `WrDrawerManager`, a root service
+     * with no island to read, could never do the same. Two halves of one
+     * component, same panel classes, same stylesheet, two answers.
+     *
+     * `null` never happens in an app — `Directionality` is root-provided — but a
+     * bare `TestBed` should still get a drawer that opens, with nothing ambient
+     * to follow.
+     */
+    private readonly dir;
     private overlayRef;
     private focusTrap;
     private previouslyFocused;
@@ -297,6 +317,14 @@ declare class WrDrawerManager {
     private readonly isBrowser;
     private readonly i18n;
     private readonly location;
+    /**
+     * The application's reading direction — the instance the CDK itself read when
+     * it stamped the overlay. A root service has no node injector above it, so a
+     * plain `inject()` here already resolves the environment one; `<wr-drawer>`,
+     * which does, spells that out and says why. The two halves of one component
+     * must not answer differently about the same panel.
+     */
+    private readonly dir;
     open<C, R = unknown, D = unknown>(component: ComponentType<C>, options?: WrDrawerOptions<D>): WrDrawerRef<C, R>;
     /**
      * Tie the drawer's lifetime to the URL it was opened on — the same treatment
@@ -333,7 +361,7 @@ declare class WrDrawerManager {
      */
     private closeLabel;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrDrawerManager, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<WrDrawerManager>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
 }
 
 /**

package/types/ngwr-dropdown.d.ts

@@ -73,10 +73,19 @@ declare class WrDropdown {
     readonly closed: _angular_core.OutputEmitterRef<void>;
     private readonly host;
     private readonly overlay;
+    /**
+     * The reading direction the open menu has to keep up with.
+     *
+     * Optional inject: `Directionality` is root-provided, so this is never null in
+     * an app — but a bare `TestBed` that provides nothing should still get a menu
+     * that opens, with simply nothing ambient to follow.
+     */
+    private readonly dir;
     private readonly outsideClick;
     private readonly responsiveConfig;
     private readonly vcr;
     private readonly scrollStrategies;
+    private readonly injector;
     private readonly destroyRef;
     /** @internal Public so host bindings can read it. */
     readonly isOpen: _angular_core.WritableSignal<boolean>;
@@ -128,6 +137,22 @@ declare class WrDropdown {
     /** @internal */
     protected onMouseLeave(event: MouseEvent): void;
     private openOverlay;
+    /**
+     * Tear the overlay down, and tell the host — unless the host is going away
+     * with it.
+     *
+     * `notify: false` is the DESTROY path, and it is not a nicety. An `output()`
+     * belongs to the view that declares it, so emitting from `onDestroy` is
+     * refused: Angular logs `NG0953: Unexpected emit for destroyed OutputRef` and
+     * the listener never runs. Measured — a `(closed)` handler on a dropdown whose
+     * host view is removed while the menu is open fired zero times and left a
+     * console error behind. There is nobody to notify at that point, because the
+     * consumer's own view is being torn down in the same pass; `wr-popconfirm`
+     * already disposes without emitting, and this brings the other two into line.
+     *
+     * The focus hand-back is skipped for the same reason — the host element is on
+     * its way out of the document.
+     */
     private closeOverlay;
     /** @internal Trigger keydown — ArrowDown/Up/Enter/Space open the menu. */
     protected onKeydown(event: KeyboardEvent): void;

package/types/ngwr-file-upload.d.ts

@@ -72,6 +72,17 @@ declare class WrFileUpload implements FormValueControl<File | readonly File[] |
     readonly readonly: _angular_core.InputSignalWithTransform<boolean, any>;
     /** The surrounding `<wr-form-field>`'s error state. @internal */
     protected readonly fieldAria: ngwr_form.WrFormFieldAria;
+    /**
+     * The field's label names the drop zone, when there is one.
+     *
+     * The zone is a `div[role="button"]`, so `<wr-form-field>`'s `<label for>`
+     * cannot reach it and named nothing at all — the zone announced only its own
+     * generic "drop files here" copy. `aria-labelledby` is the direction that
+     * works for a role. The zone copy stays as the label when no field wraps it.
+     */
+    protected readonly labelledBy: _angular_core.Signal<string | null>;
+    /** `null` while the field's label carries the name, or both are announced. */
+    protected readonly zoneName: _angular_core.Signal<string | null>;
     /** Primary call-to-action label. Falls back to `fileUpload.browse`. */
     readonly pickLabel: _angular_core.InputSignal<string | null>;
     /** Secondary instruction below the CTA. Falls back to `fileUpload.dropZone`. */