ngwr 14.3.1 → 14.5.0

package/types/ngwr-media.d.ts

@@ -46,7 +46,7 @@ declare class WrMedia {
     private resolveQuery;
     private createSignal;
     static ɵfac: i0.ɵɵFactoryDeclaration<WrMedia, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<WrMedia>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
 
 /**

package/types/ngwr-mention.d.ts

@@ -60,8 +60,15 @@ declare class WrMention<T extends WrMentionItem = WrMentionItem> {
     readonly wrMentionSelected: _angular_core.OutputEmitterRef<WrMentionCommit<T>>;
     private readonly host;
     private readonly overlay;
+    /**
+     * 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
+     * directive that works, and defaulting to LTR is the honest fallback.
+     */
+    private readonly dir;
     private readonly scrollStrategies;
     private readonly destroyRef;
+    private readonly injector;
     private readonly isBrowser;
     private overlayRef;
     private panelRef;

package/types/ngwr-meta.d.ts

@@ -123,7 +123,7 @@ declare class WrMeta {
     private updateProp;
     private diffLink;
     static ɵfac: i0.ɵɵFactoryDeclaration<WrMeta, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<WrMeta>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
 
 /**

package/types/ngwr-overlay.d.ts

@@ -1,7 +1,8 @@
-import { ConnectedPosition, OverlayRef, OverlayContainer, Overlay } from '@angular/cdk/overlay';
-import { Observable } from 'rxjs';
+import { Directionality, Direction } from '@angular/cdk/bidi';
+import { OverlayRef, ConnectedPosition, OverlayContainer, Overlay } from '@angular/cdk/overlay';
 import * as i0 from '@angular/core';
-import { EnvironmentProviders, InjectionToken } from '@angular/core';
+import { Injector, EnvironmentProviders, InjectionToken } from '@angular/core';
+import { Observable } from 'rxjs';
 
 /**
  * @license
@@ -28,6 +29,63 @@ import { EnvironmentProviders, InjectionToken } from '@angular/core';
  */
 declare function wrAppendOverlayClose(host: HTMLElement, className: string, label: string, onClose: () => void): HTMLButtonElement;
 
+/**
+ * @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
+ */
+
+/**
+ * Keep an OPEN overlay on the application's reading direction.
+ *
+ * The CDK reads the direction ONCE, as a string, when the overlay is created
+ * (`overlayConfig.direction ||= directionality.value`), writes it as the host's
+ * `dir` on attach, and never looks at it again — `updatePosition()` does not
+ * touch it and `setDirection()` is the only thing that does. So an application
+ * that flips direction while a panel is open mirrors the page and leaves the
+ * panel behind, still `ltr`, still resolving `start` to the left. This site's
+ * own LTR/RTL switch is the demonstration: it lives inside a `wr-dropdown`, and
+ * the `wr-segmented` it is built from reads `Directionality` live — so the thumb
+ * slides to the other slot while the pane around it still renders `ltr`, and
+ * parks under the wrong label.
+ *
+ * Call it once per `OverlayRef`, right after `overlay.create(...)`. The follower
+ * ends itself when that overlay detaches or is disposed, so a reopen — which is
+ * always a NEW ref in this library — needs a new call, and the returned teardown
+ * is only for stopping early.
+ *
+ * `onDirectionChange` is for the sites whose position LIST is itself
+ * direction-dependent (the four that pass their table through
+ * {@link wrMirrorOffsets}): it runs with the new direction already on the ref
+ * and before the overlay repositions, so the strategy is carrying the mirrored
+ * offsets by the time the CDK re-resolves them.
+ *
+ * SSR-safe: it touches no browser global of its own, and the CDK's position
+ * strategies no-op off the browser, so a flip on the server only rewrites the
+ * attribute.
+ *
+ * @param overlayRef The overlay to keep in step, freshly created.
+ * @param dir The `Directionality` the caller injected. `null` — an optional
+ *   inject with no provider, i.e. a bare `TestBed` — means there is nothing
+ *   ambient to follow and this does nothing at all.
+ * @param injector Owns the `valueSignal` watch; the caller's own is right.
+ * @param onDirectionChange Re-applies direction-dependent state, e.g.
+ *   `strategy.withPositions(wrMirrorOffsets(TABLE, direction === 'rtl'))`.
+ * @returns Stops following. Idempotent, and unnecessary in the normal case.
+ *
+ * @example
+ * ```ts
+ * this.overlayRef = this.overlay.create({ positionStrategy, ... });
+ * wrFollowDirection(this.overlayRef, this.dir, this.injector, direction =>
+ *   positionStrategy.withPositions(
+ *     wrMirrorOffsets(WR_POPCONFIRM_POSITIONS[this.position()], direction === 'rtl')
+ *   )
+ * );
+ * ```
+ */
+declare function wrFollowDirection(overlayRef: OverlayRef, dir: Directionality | null, injector: Injector, onDirectionChange?: (direction: Direction) => void): () => void;
+
 /**
  * @license
  *
@@ -126,7 +184,7 @@ declare class WrOutsideClick {
     private listen;
     private unlisten;
     static ɵfac: i0.ɵɵFactoryDeclaration<WrOutsideClick, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<WrOutsideClick>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
 
 /**
@@ -155,7 +213,7 @@ declare class WrOutsideClick {
 declare class WrOverlayContainer extends OverlayContainer {
     protected _createContainer(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<WrOverlayContainer, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<WrOverlayContainer>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
 
 /**
@@ -302,5 +360,5 @@ 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 { WR_OVERLAY, WR_OVERLAY_CONTAINER, WR_RESPONSIVE_OVERLAYS, WrOutsideClick, WrOverlayContainer, provideWrOverlay, provideWrResponsiveOverlays, wrAppendOverlayClose, wrFollowDirection, wrMirrorOffsets, wrPresentAsSheet };
 export type { WrResponsiveOverlaysConfig };

package/types/ngwr-pagination.d.ts

@@ -115,6 +115,22 @@ declare class WrPagination {
     /** The nav landmark's own accessible name — was a hardcoded English literal. */
     protected readonly navLabel: _angular_core.Signal<string>;
     /** Internal: total page count. */
+    /**
+     * A page size that is not a positive number yields ONE page, not `Infinity`.
+     *
+     * `pageSize` is a `model()`, so Angular offers no `transform` to coerce it and
+     * whatever the host writes arrives raw. At 0 the division is `Infinity`,
+     * `Math.max(1, …)` keeps it, and the item list below pushes `total` as the
+     * last page — so the strip rendered a clickable cell reading "Infinity", and
+     * clicking it locked the tab. `NaN` (a `pageSize` bound to an emptied number
+     * field) came through untouched for the same reason.
+     *
+     * One page is the honest answer: a size of zero describes no paging at all.
+     * Note this is about `pageSize` and does NOT touch the recorded contract
+     * about `total` — pagination still refuses to pull the page DOWN while
+     * `total` is at or below zero, because 0 is ambiguous with "still loading".
+     */
+    private readonly usablePageSize;
     protected readonly totalPages: _angular_core.Signal<number>;
     /**
      * Internal: where the previous arrow goes. Clamped to the end of the valid

package/types/ngwr-platform.d.ts

@@ -32,7 +32,7 @@ declare class WrPlatform {
     readonly prefersReducedMotion: Signal<boolean>;
     private mediaSignal;
     static ɵfac: i0.ɵɵFactoryDeclaration<WrPlatform, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<WrPlatform>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
 
 /**
@@ -63,7 +63,7 @@ declare class WrVisualViewport {
     readonly offsetTop: Signal<number>;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<WrVisualViewport, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<WrVisualViewport>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
 
 /** Impact weight for {@link WrHaptics.impact}. */
@@ -122,7 +122,7 @@ declare class WrHaptics {
     /** Cancel any in-progress vibration. */
     stop(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<WrHaptics, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<WrHaptics>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
 
 export { WrHaptics, WrPlatform, WrVisualViewport };

package/types/ngwr-popconfirm.d.ts

@@ -40,6 +40,7 @@ declare class WrPopconfirm {
     private readonly outsideClick;
     private readonly vcr;
     private readonly scrollStrategies;
+    private readonly injector;
     private readonly destroyRef;
     /** @internal Public so the host bindings can read it. */
     readonly isOpen: _angular_core.WritableSignal<boolean>;

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

@@ -34,9 +34,9 @@ interface WrPopoverHarnessFilters extends BaseHarnessFilters {
  *
  * - **popover** — template content, opens on click (or hover), announces
  *   `role="dialog"` and is what the trigger's `aria-expanded` describes;
- * - **tooltip** — string content, opens on hover AND focus after a delay,
- *   announces `role="tooltip"` and DESCRIBES its trigger instead of being
- *   owned by it.
+ * - **tooltip** — string content, opens after a delay on hover or on KEYBOARD
+ *   focus (never on a `.focus()` call — see {@link focus}), announces
+ *   `role="tooltip"` and DESCRIBES its trigger instead of being owned by it.
  *
  * The panel is never inside the trigger: it is a portal in the overlay
  * container, a sibling of the whole app. It is reached through the document
@@ -112,7 +112,9 @@ declare class WrPopoverHarness extends ContentContainerComponentHarness {
      * Hover leads because a click is an outside pointer event for every OTHER open
      * panel, so leading with it would dismiss someone else's popover on the way to
      * opening this one; a click-driven popover ignores the hover outright. A
-     * tooltip is never clicked at all — hover and focus are its only gestures.
+     * tooltip is never clicked at all, and hover is the only one of its two
+     * gestures a harness can perform — the other is a keyboard focus, which is
+     * `FocusMonitor`'s to grant (see {@link focus}).
      *
      * Throws when nothing appears: a tooltip with an empty string never opens, and
      * a spec on fake timers has to advance the clock itself.
@@ -133,7 +135,22 @@ declare class WrPopoverHarness extends ContentContainerComponentHarness {
     hover(): Promise<void>;
     /** Move the pointer off the trigger. The panel goes after the grace period, not instantly. */
     mouseAway(): Promise<void>;
-    /** Focus the trigger — a tooltip's other opening gesture, so keyboard users get the hint too. */
+    /**
+     * Focus the trigger PROGRAMMATICALLY — and note that this does not open a
+     * tooltip.
+     *
+     * `TestElement.focus()` is a `.focus()` call, which is the one kind of focus a
+     * tooltip deliberately ignores: it shows for a KEYBOARD focus only, because
+     * every overlay in the catalog hands focus back to the trigger it was opened
+     * from, and a tooltip that answered those appeared with no pointer to leave and
+     * no focus to lose. So this method is the way to assert that NOTHING happens.
+     *
+     * There is no keyboard-origin twin, and it cannot be written honestly here:
+     * origin is `FocusMonitor`'s answer, this class has no injector, and the Tab
+     * that would earn it moves focus in a browser and not in jsdom. A spec that
+     * needs the opening gesture drives `FocusMonitor.focusVia(el, 'keyboard')`
+     * itself, the way `popover.spec.ts` does — or uses `hover()`.
+     */
     focus(): Promise<void>;
     /** Blur the trigger, which hides a tooltip after `hideDelay`. */
     blur(): Promise<void>;

package/types/ngwr-popover.d.ts

@@ -23,13 +23,13 @@ declare class WrPopover {
      *
      * - `'popover'` (default) — template content, click trigger, dialog
      *   semantics.
-     * - `'tooltip'` — text content, hover+focus trigger, `role="tooltip"`,
-     *   `aria-describedby` on the host.
+     * - `'tooltip'` — text content, hover / keyboard-focus trigger,
+     *   `role="tooltip"`, `aria-describedby` on the host.
      */
     readonly mode: _angular_core.InputSignal<"popover" | "tooltip">;
     /**
-     * How the popover opens. Ignored in tooltip mode — tooltips are always
-     * hover+focus. @default 'click'
+     * How the popover opens. Ignored in tooltip mode — a tooltip is always hover
+     * plus keyboard focus. @default 'click'
      */
     readonly trigger: _angular_core.InputSignal<"click" | "hover">;
     /** Anchor side. @default 'bottom' for popover, 'top' for tooltip */
@@ -57,6 +57,8 @@ declare class WrPopover {
     /** Fires after the panel closes. */
     readonly closed: _angular_core.OutputEmitterRef<void>;
     private readonly host;
+    private readonly focusMonitor;
+    private readonly keystroke;
     private readonly overlay;
     private readonly dir;
     private readonly outsideClick;
@@ -64,6 +66,7 @@ declare class WrPopover {
     private readonly vcr;
     private readonly scrollStrategies;
     private readonly destroyRef;
+    private readonly injector;
     /** @internal */
     readonly isOpen: _angular_core.WritableSignal<boolean>;
     /** @internal */
@@ -74,6 +77,8 @@ declare class WrPopover {
     private readonly resolvedPosition;
     private overlayRef;
     private textPanelRef;
+    /** Whether the HOST itself holds focus — not a descendant of it. */
+    private hostFocused;
     private hoverCloseTimer;
     private showTimer;
     private hideTimer;
@@ -88,15 +93,46 @@ declare class WrPopover {
     /** @internal */
     protected onMouseLeave(event: MouseEvent): void;
     /** @internal */
-    protected onFocus(): void;
-    /** @internal */
-    protected onBlur(): void;
-    /** @internal */
     protected onEscape(): void;
+    /**
+     * Whether the keystroke in flight is one the user moves focus with.
+     *
+     * Asked only of a `keyboard` origin, which the CDK grants to any focus landing
+     * within a millisecond of a keydown — including the hand-back a drawer
+     * performs while Escape is still being handled. That is the reported bug's
+     * keyboard half, and the origin cannot see it.
+     *
+     * NO key on record answers `true`, and that polarity is chosen rather than
+     * inherited: a keyboard modality with no keystroke behind it is a screen
+     * reader's virtual cursor (the CDK reads its synthetic mousedown as
+     * `keyboard`) or a deliberate `focusVia(el, 'keyboard')`, and both are the
+     * user. Refusing wants positive evidence of a key that does something other
+     * than navigate — silence must not cost an AT user the hint. The two windows
+     * are aligned so that "keyboard origin, no key" cannot mean "the key just
+     * expired"; what it does still admit is a `FocusMonitorDetectionMode.EVENTUAL`
+     * app, where the CDK never expires an origin at all.
+     */
+    private fromNavigationKey;
     private scheduleShow;
     private scheduleHide;
     private clearTimers;
     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;
     private readonly onOverlayLeave;
     private readonly onOverlayEnter;

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

@@ -225,10 +225,19 @@ declare class WrRatingHarness extends ComponentHarness {
     /** Whether the rating refuses interaction — `aria-disabled`, for the same reason. */
     isDisabled(): Promise<boolean>;
     /**
-     * Whether the rating is in the tab order.
+     * Whether the rating is a tab stop.
      *
-     * A rating that takes no input takes itself out of it (`tabindex="-1"`), so this
-     * is `false` while readonly or disabled.
+     * `disabled` only, never `readonly` — and the distinction is deliberate, not
+     * incidental. A disabled control leaves the tab order; a READ-ONLY one stays
+     * in it, keeps announcing its value, and still submits, which is the whole
+     * difference between "you may not" and "there is nothing here". The component
+     * records that driving this off an `interactive()` that folded the two
+     * together made `readonly` unreachable, with an `aria-describedby` pointing
+     * at an element nobody could focus.
+     *
+     * This docblock used to describe exactly that fixed bug — "false while
+     * readonly or disabled" — so a reader trusting it would have asserted the
+     * behaviour the component was changed to stop having.
      */
     isFocusable(): Promise<boolean>;
     /**

package/types/ngwr-rating.d.ts

@@ -105,6 +105,19 @@ declare class WrRating implements FormValueControl<number | null> {
     private readonly directionality;
     /** The surrounding `<wr-form-field>`'s error state. @internal */
     protected readonly fieldAria: ngwr_form.WrFormFieldAria;
+    /**
+     * The field's label wins over the built-in default, and an explicit
+     * `ariaLabel` wins over both.
+     *
+     * `<wr-form-field label="…">` renders a `<label for>` that cannot reach this
+     * control — `for` binds only to a LABELABLE element and the focusable part
+     * here carries a role instead — so the field's label named nothing and this
+     * announced its own generic default. A consumer who wrote
+     * `<wr-form-field label="Overall satisfaction">` heard "Rating".
+     */
+    protected readonly labelledBy: _angular_core.Signal<string | null>;
+    /** `null` once `aria-labelledby` is carrying the name, or the two are announced together. */
+    protected readonly nameLabel: _angular_core.Signal<string | null>;
     protected readonly classes: _angular_core.Signal<string>;
     /** Fill ratio for slot `i` in `[0, 1]` — drives the CSS clip width. */
     protected fillFor(i: number): number;

package/types/ngwr-scroll.d.ts

@@ -58,7 +58,7 @@ declare class WrScroll {
     private behavior;
     private scroll;
     static ɵfac: i0.ɵɵFactoryDeclaration<WrScroll, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<WrScroll>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
 
 export { WrScroll };

package/types/ngwr-segmented.d.ts

@@ -148,6 +148,22 @@ declare class WrSegmented<T = unknown> implements FormValueControl<T | null> {
     protected readonly selectedIndex: _angular_core.Signal<number>;
     /** Flips true after the first paint so the thumb only animates user-driven changes, not the initial snap. */
     private readonly mounted;
+    /**
+     * True for the tick in which the reading direction changed.
+     *
+     * Mirroring moves the thumb's SLOT by the whole width of the strip (see
+     * `thumbStyle`), and animating that is a quarter-second of the pill travelling
+     * across options it does not mark — caught under the wrong label every time the
+     * docs site's LTR / RTL switch was used, which is a strip inside an overlay that
+     * mirrors underneath it. The selection did not move, so neither should the pill:
+     * the stylesheet drops its transition while this is set, and the new slot lands
+     * in the same pass that removes it.
+     *
+     * Cleared from a task rather than `afterNextRender`, which runs inside the very
+     * change detection that set this and would put the transition back before the
+     * new position is painted.
+     */
+    private readonly flipping;
     constructor();
     protected readonly classes: _angular_core.Signal<string>;
     private readonly dir;

package/types/ngwr-select.d.ts

@@ -710,6 +710,13 @@ declare class WrSelect implements FormValueControl<unknown>, WrSelectContext {
     private readonly destroyRef;
     private readonly platformId;
     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();
     isSelected(value: unknown): boolean;

package/types/ngwr-squircle.d.ts

@@ -41,6 +41,20 @@ type WrSquircleCornerMask = 'all' | 'left' | 'right' | 'top' | 'bottom' | 'none'
  * Apply a Figma-style smooth-corner ("squircle") `clip-path` to the host
  * element. Re-computes the path whenever the element resizes.
  *
+ * @deprecated Use the native route instead — `@use 'ngwr/theme'` and the
+ * `smooth-br` mixin, which 31 entry points already ride by default. This
+ * directive exists because `corner-shape` was Chromium-only, and that reason
+ * has an expiry date: WebKit has it in Technology Preview. It will be removed
+ * in the major after Safari stable ships the property.
+ *
+ * It is deprecated rather than removed today because it is still the only
+ * DETERMINISTIC squircle — the native property reaches roughly two thirds of
+ * users and the rest see a rounded corner. If that difference matters to a
+ * design, this is still the way to get it, with the costs stated: a hand-ported
+ * superellipse, a `ResizeObserver` and a `getBoundingClientRect` per host on
+ * every resize, square corners until hydration under SSR, no test harness, and
+ * a clip that `box-shadow`, `border-image` and the focus ring do not follow.
+ *
  * Borders: pass `[borderWidth]` (px) + `[borderColor]` and the directive
  * paints a `::before` pseudo with an *inset* squircle path on top of the
  * host. The visible border is the host's own background colour, so set
@@ -92,9 +106,11 @@ declare class WrSquircle {
      * only the two corners on the named side and leave the other two at
      * 90°. `'none'` is equivalent to disabling the directive.
      *
-     * Modelled so parent components composing the directive can flip the
-     * value imperatively — used by `WrButtonGroup` to squircle only the
-     * outer corners of the first / last child.
+     * A `model()` rather than an `input()` so a parent composing the directive
+     * can flip it imperatively. Nothing in the library does today: this line
+     * used to name `WrButtonGroup` as the consumer, and that component has
+     * carried no squircle reference for several releases — `wr-btn--squircle`
+     * is plain CSS now.
      *
      * @default 'all'
      */
@@ -122,6 +138,9 @@ declare class WrSquircle {
  * ```
  *
  * @see https://ngwr.dev/reference/components/squircle
+ *
+ * @deprecated Follows `[wrSquircle]`, which it wraps — see that directive
+ * for why, and for the native route to use instead.
  */
 declare class WrSquircleHost {
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrSquircleHost, never>;

package/types/ngwr-statistic.d.ts

@@ -128,7 +128,6 @@ declare class WrStatisticCountdown {
     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;
     /**

package/types/ngwr-storage.d.ts

@@ -94,7 +94,7 @@ declare class WrStorage {
     private rawKeys;
     private installCrossTabListener;
     static ɵfac: i0.ɵɵFactoryDeclaration<WrStorage, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<WrStorage>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
 
 /**

package/types/ngwr-theme.d.ts

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

package/types/ngwr-toast.d.ts

@@ -164,6 +164,8 @@ declare class WrToastRef {
 declare class WrToast {
     private readonly overlay;
     private readonly config;
+    private readonly injector;
+    private readonly dir;
     private overlayRef;
     private hostRef;
     /** Watches the overlay container for overlays opened after the host. */
@@ -238,7 +240,7 @@ declare class WrToast {
     private pushToHost;
     private disposeHost;
     static ɵfac: i0.ɵɵFactoryDeclaration<WrToast, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<WrToast>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
 
 /**

package/types/ngwr-tour.d.ts

@@ -115,6 +115,12 @@ declare class WrTour {
     private anyResolvableBefore;
     private resolve;
     private openStep;
+    /**
+     * The card's fallback table for one placement, with its inline offsets already
+     * mirrored. Built per call rather than per step: the direction can change while
+     * the step is on screen, and a table is what has to be rebuilt when it does.
+     */
+    private stepPositions;
     private placeSpotlight;
     private teardownStep;
     /**
@@ -126,7 +132,7 @@ declare class WrTour {
      */
     private isRtl;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrTour, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<WrTour>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
 }
 
 /** What the popup needs from the running tour, without importing the service (cycle). */

package/types/ngwr-transfer.d.ts

@@ -114,6 +114,17 @@ declare class WrTransfer implements FormValueControl<readonly unknown[]> {
     protected readonly resolvedSearch: _angular_core.Signal<string>;
     protected readonly resolvedEmpty: _angular_core.Signal<string>;
     protected readonly resolvedSelectAll: _angular_core.Signal<string>;
+    /**
+     * The select-all checkbox's accessible name, composed IN THE CATALOG.
+     *
+     * It used to be a template literal — `` `${title} — ${selectAll}` `` — which
+     * froze both the separator and the operand order into English. A translator
+     * could change each half and not the sentence they make, which is the exact
+     * defect the calendar and event-calendar catalogs were rewritten to remove.
+     * The key ships as `{{pane}} — {{action}}` in every locale, so nothing reads
+     * differently today and every locale can now reorder it without a code change.
+     */
+    protected readonly selectAllAria: (params?: ngwr_i18n.WrI18nParams) => string;
     protected readonly resolvedToTarget: _angular_core.Signal<string>;
     protected readonly resolvedToSource: _angular_core.Signal<string>;
     /** `{{checked}} / {{total}}` under each heading. @internal */
@@ -129,6 +140,23 @@ declare class WrTransfer implements FormValueControl<readonly unknown[]> {
     private readonly valueSet;
     protected readonly source: _angular_core.Signal<PaneState>;
     protected readonly target: _angular_core.Signal<PaneState>;
+    /**
+     * Say something when `value` holds a value no `items` entry matches.
+     *
+     * Such a value is in NEITHER pane — the left one filters out anything already
+     * selected and the right one can only render rows it found — and the header
+     * counts the rows it shows, so nothing on screen contradicts anything. The
+     * result is a value the user can neither see nor remove, and no sign that it
+     * is there.
+     *
+     * A warning rather than an invented row, which matches how the library treats
+     * the same question elsewhere: `wr-select` renders a value outside its option
+     * list only under an explicit `freeText`, so an unmatched value is a mode a
+     * consumer opts into, not a shape a component guesses at. It also stays quiet
+     * about the common transient case — `items` arriving after `value` — because
+     * the message names the values and a developer can see them settle.
+     */
+    private warnAboutOrphans;
     protected readonly canMoveRight: _angular_core.Signal<boolean>;
     protected readonly canMoveLeft: _angular_core.Signal<boolean>;
     protected readonly classes: _angular_core.Signal<string>;
@@ -137,6 +165,30 @@ declare class WrTransfer implements FormValueControl<readonly unknown[]> {
     /** Header checkbox — stages or clears every enabled row the filter shows. */
     protected toggleAll(pane: 'source' | 'target', checked: boolean): void;
     protected onSearch(pane: 'source' | 'target', event: Event): void;
+    private readonly host;
+    private readonly injector;
+    /**
+     * Keep focus in the widget after a move.
+     *
+     * A move empties the pane's staging set, which is exactly what disables the
+     * button that was just pressed — so the element holding DOM focus went
+     * `disabled` as a RESULT of its own activation and the browser dropped focus
+     * to `<body>`. From there the next Tab restarts at the top of the document,
+     * which for a keyboard user is being thrown out of a control they were in the
+     * middle of using.
+     *
+     * The landing is the FIRST ROW OF THE PANE THE ROWS ARRIVED IN, and the
+     * obvious alternative does not work: after a move BOTH buttons are disabled,
+     * because each needs something ticked and the move cleared the tick on one
+     * side and arrived unticked on the other. The rows that just moved are where
+     * the user's attention is and where the next action lives, so that is where
+     * focus goes.
+     *
+     * `afterNextRender`, not `queueMicrotask`: under zoneless CD the microtask
+     * runs before the moved rows are in the DOM, so the focus call would land on
+     * the pane as it was before the move.
+     */
+    private restoreFocusAfterMove;
     protected moveRight(): void;
     protected moveLeft(): void;
     /** Filter, then derive the header state from what survived. */

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

@@ -358,6 +358,26 @@ declare class WrTreeHarness extends ContentContainerComponentHarness {
     removeChip(label: string): Promise<void>;
     /** Click the clear (×) control on the trigger. */
     clear(): Promise<void>;
+    /**
+     * Backspace on the closed overlay trigger — the keyboard route to the ×.
+     *
+     * In single mode it clears (only while `clearable` is on); in multi mode it
+     * drops the LAST chip, one per call, whatever `clearable` says. Both ×
+     * controls are `tabindex="-1"` spans inside the trigger, so a key can never
+     * reach them directly. In single mode this is the ONLY keyboard route back to
+     * no selection; in multi mode a keyboard user can also toggle a row off in the
+     * panel ({@link selectNode} with `additive`). {@link clear} / {@link removeChip}
+     * prove the pointer path and nothing more.
+     *
+     * The key is honoured only on the CLOSED trigger, so an open panel is closed
+     * first with Escape — the step a keyboard user takes too, since focus sits in
+     * the panel while it is up.
+     *
+     * Does nothing, rather than throwing, where the component does nothing —
+     * nothing selected, disabled or read-only — so a spec asserts the outcome on
+     * the value.
+     */
+    clearByKeyboard(): Promise<void>;
     /**
      * The nodes currently rendered, in the order they are shown.
      *