ngwr 9.0.1 → 10.0.0

package/types/ngwr-dialog.d.ts

@@ -3,7 +3,7 @@ import { ConfigurableFocusTrap } from '@angular/cdk/a11y';
 import { OverlayRef } from '@angular/cdk/overlay';
 import * as i0 from '@angular/core';
 import { ComponentRef, InjectionToken, ElementRef } from '@angular/core';
-import { Subject } from 'rxjs';
+import { ReplaySubject } from 'rxjs';
 
 /**
  * @license
@@ -15,18 +15,43 @@ import { Subject } from 'rxjs';
 /**
  * Handle returned by `WrDialog.open()`.
  *
- * Wraps the underlying `OverlayRef` and tracks the close result.
+ * Wraps the underlying `OverlayRef` and tracks the close result. It is also
+ * provided inside the dialog's own injector, so the projected content can
+ * inject it and close itself — the counterpart to `[wrDialogClose]` when the
+ * close is programmatic (after a save succeeds, say) rather than a click.
  *
  * @example
  * ```ts
+ * // Caller side.
  * const ref = dialog.open<ConfirmComponent, boolean>(ConfirmComponent);
  * const result = await ref.awaitClose(); // boolean | undefined
  * ```
+ *
+ * @example
+ * ```ts
+ * // Content side — the dialog closes itself.
+ * @Component({...})
+ * export class ConfirmComponent {
+ *   private readonly ref = inject(WrDialogRef);
+ *
+ *   save(): void {
+ *     this.store.save();
+ *     this.ref.close(true);
+ *   }
+ * }
+ * ```
  */
 declare class WrDialogRef<C, R = unknown> {
     private readonly _overlayRef;
-    /** Emits the close result once and completes. */
-    readonly closed: Subject<R | undefined>;
+    /**
+     * Emits the close result once and completes.
+     *
+     * A `ReplaySubject`, not a plain `Subject`, so the result survives a late
+     * subscriber: content can close itself before `open()` has even returned, and
+     * `awaitClose()` may be called long after the dismissal — both would otherwise
+     * see only `complete` and resolve `undefined`.
+     */
+    readonly closed: ReplaySubject<R | undefined>;
     /** @internal */
     componentRef: ComponentRef<C> | null;
     /** @internal */
@@ -36,8 +61,10 @@ declare class WrDialogRef<C, R = unknown> {
     constructor(_overlayRef: OverlayRef);
     /** The instantiated dialog component. */
     get componentInstance(): C;
+    private isClosed;
     /** Close the dialog, optionally returning a result. */
     close(result?: R): void;
+    private teardown;
     /** Resolves with the close result when the dialog is dismissed. */
     awaitClose(): Promise<R | undefined>;
     /** Underlying overlay ref — escape hatch for advanced cases. */
@@ -60,6 +87,14 @@ interface WrDialogOptions<D = unknown> {
     readonly closeOnBackdropClick?: boolean;
     /** When `true`, the Escape key closes the dialog. @default true */
     readonly closeOnEscape?: boolean;
+    /**
+     * Render a dismiss (×) button in the panel's top-right corner. Set `false`
+     * when the content supplies its own close affordance, or when the dialog must
+     * be resolved through its own actions. @default true
+     */
+    readonly closable?: boolean;
+    /** Accessible name for the dismiss button. Falls back to the `dialog.close` catalog key. */
+    readonly closeLabel?: string;
     /** Width applied to the panel — any valid CSS length. */
     readonly width?: string;
     /** Maximum width applied to the panel. */
@@ -103,6 +138,7 @@ declare class WrDialog {
     private readonly focusTrapFactory;
     private readonly isBrowser;
     private readonly responsiveConfig;
+    private readonly i18n;
     open<C, R = unknown, D = unknown>(component: ComponentType<C>, options?: WrDialogOptions<D>): WrDialogRef<C, R>;
     static ɵfac: i0.ɵɵFactoryDeclaration<WrDialog, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<WrDialog>;
@@ -128,6 +164,42 @@ declare class WrDialog {
  */
 declare const WR_DIALOG_DATA: InjectionToken<unknown>;
 
+/**
+ * @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
+ */
+
+/**
+ * Token exposing the open dialog's `WrDialogRef` to components and
+ * directives rendered inside it (e.g. `[wrDialogClose]`).
+ *
+ * **Prefer `inject(WrDialogRef)`** — the ref is provided under the class token
+ * too, and the class path is the documented one. It already covers both cases
+ * you might reach for a token for: `inject(WrDialogRef, { optional: true })`
+ * works for content that also renders outside a dialog, and
+ * `inject<WrDialogRef<ConfirmComponent, boolean>>(WrDialogRef)` types the
+ * generics without a cast.
+ *
+ * This token is the same object under a second key. It exists for the library's
+ * own directives (`[wrDialogClose]`) and for swapping the provider out — a test
+ * stub, say — without touching the class.
+ *
+ * @example
+ * ```ts
+ * @Component({...})
+ * export class ConfirmComponent {
+ *   private readonly ref = inject<WrDialogRef<ConfirmComponent, boolean>>(WrDialogRef);
+ *
+ *   confirm(): void {
+ *     this.ref.close(true);
+ *   }
+ * }
+ * ```
+ */
+declare const WR_DIALOG_REF: InjectionToken<WrDialogRef<unknown, unknown>>;
+
 /**
  * @license
  *
@@ -203,15 +275,15 @@ declare class WrDialogFooter {
  */
 declare class WrDialogClose<R = unknown> {
     /**
-     * Value to pass to `close()`. When unset, the dialog closes with
-     * `undefined`.
+     * Value to pass to `close()`. When unset — or used as a bare attribute — the
+     * dialog closes with `undefined`.
      */
-    readonly result: i0.InputSignal<R | undefined>;
+    readonly result: i0.InputSignalWithTransform<R | undefined, "" | R | undefined>;
     private readonly ref;
     protected onClick(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<WrDialogClose<any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<WrDialogClose<any>, "[wrDialogClose]", never, { "result": { "alias": "wrDialogClose"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-export { WR_DIALOG_DATA, WrDialog, WrDialogClose, WrDialogContent, WrDialogFooter, WrDialogRef, WrDialogTitle };
+export { WR_DIALOG_DATA, WR_DIALOG_REF, WrDialog, WrDialogClose, WrDialogContent, WrDialogFooter, WrDialogRef, WrDialogTitle };
 export type { WrDialogOptions };

package/types/ngwr-drawer.d.ts

@@ -1,5 +1,9 @@
 import * as _angular_core from '@angular/core';
-import { TemplateRef } from '@angular/core';
+import { TemplateRef, ComponentRef, InjectionToken } from '@angular/core';
+import { ComponentType } from '@angular/cdk/portal';
+import { ConfigurableFocusTrap } from '@angular/cdk/a11y';
+import { OverlayRef } from '@angular/cdk/overlay';
+import { ReplaySubject } from 'rxjs';
 
 /**
  * @license
@@ -10,6 +14,51 @@ import { TemplateRef } from '@angular/core';
 /** Side of the viewport the drawer slides in from. */
 type WrDrawerPosition = 'left' | 'right' | 'top' | 'bottom';
 
+/**
+ * @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
+ */
+
+/**
+ * Options accepted by `WrDrawerManager.open()`.
+ *
+ * Mirrors the `<wr-drawer>` inputs, minus the ones that need the component's
+ * own wrapper markup (`showHandle` / swipe-to-dismiss).
+ */
+interface WrDrawerOptions<D = unknown> {
+    /** Data payload exposed to the drawer content via `WR_DRAWER_DATA`. */
+    readonly data?: D;
+    /** Side the drawer slides in from. @default 'right' */
+    readonly position?: WrDrawerPosition;
+    /** Width when position is left/right. Any CSS length. @default '20rem' */
+    readonly width?: string;
+    /** Height when position is top/bottom. Any CSS length. @default '16rem' */
+    readonly height?: string;
+    /** Upper cap on height (top/bottom positions). Any CSS length. @default null (no cap) */
+    readonly maxHeight?: string | null;
+    /** Round the leading corners — the edge facing the viewport interior. @default false */
+    readonly rounded?: boolean;
+    /** Pad the trailing edge with `env(safe-area-inset-*)`. @default false */
+    readonly safeArea?: boolean;
+    /** Show the dimming backdrop. @default true */
+    readonly hasBackdrop?: boolean;
+    /** When `true`, clicks on the backdrop close the drawer. @default true */
+    readonly closeOnBackdropClick?: boolean;
+    /** When `true`, the Escape key closes the drawer. @default true */
+    readonly closeOnEscape?: boolean;
+    /**
+     * Render a dismiss (×) button in the panel's top-right corner. Set `false`
+     * when the content supplies its own close affordance. @default true
+     */
+    readonly closable?: boolean;
+    /** Accessible name for the dismiss button. Falls back to the `drawer.close` catalog key. */
+    readonly closeLabel?: string;
+    /** Extra CSS class(es) added to the panel. */
+    readonly panelClass?: string | readonly string[];
+}
+
 /**
  * Side panel that slides in from an edge of the viewport. Two-way binds
  * `open` and renders into a CDK overlay so it sits above page content.
@@ -67,14 +116,22 @@ declare class WrDrawer {
     readonly closeOnBackdropClick: _angular_core.InputSignalWithTransform<boolean, any>;
     /** Close on Escape. @default true */
     readonly closeOnEscape: _angular_core.InputSignalWithTransform<boolean, any>;
+    /**
+     * Show a dismiss (×) button in the panel's top-right corner. Set `false` when
+     * the projected content supplies its own close affordance. @default true
+     */
+    readonly closable: _angular_core.InputSignalWithTransform<boolean, any>;
+    /** Accessible name for the dismiss button. Falls back to `drawer.close`. */
+    readonly closeLabel: _angular_core.InputSignal<string | null>;
+    protected readonly resolvedCloseLabel: _angular_core.Signal<string>;
     protected readonly panelTpl: _angular_core.Signal<TemplateRef<any>>;
     protected panelClass(): string;
     private swipeStartX;
     private swipeStartY;
     private swiping;
-    protected onSwipeStart(event: TouchEvent): void;
-    protected onSwipeMove(event: TouchEvent, panel: HTMLElement): void;
-    protected onSwipeEnd(event: TouchEvent, panel: HTMLElement): void;
+    protected onSwipeStart(event: PointerEvent): void;
+    protected onSwipeMove(event: PointerEvent, panel: HTMLElement): void;
+    protected onSwipeEnd(event: PointerEvent, panel: HTMLElement): void;
     /** Axis + sign of the closing direction for the current position. */
     private closeAxis;
     private readonly overlay;
@@ -89,9 +146,174 @@ declare class WrDrawer {
     private openOverlay;
     private closeOverlay;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrDrawer, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrDrawer, "wr-drawer", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; "rounded": { "alias": "rounded"; "required": false; "isSignal": true; }; "showHandle": { "alias": "showHandle"; "required": false; "isSignal": true; }; "safeArea": { "alias": "safeArea"; "required": false; "isSignal": true; }; "hasBackdrop": { "alias": "hasBackdrop"; "required": false; "isSignal": true; }; "closeOnBackdropClick": { "alias": "closeOnBackdropClick"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrDrawer, "wr-drawer", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; "rounded": { "alias": "rounded"; "required": false; "isSignal": true; }; "showHandle": { "alias": "showHandle"; "required": false; "isSignal": true; }; "safeArea": { "alias": "safeArea"; "required": false; "isSignal": true; }; "hasBackdrop": { "alias": "hasBackdrop"; "required": false; "isSignal": true; }; "closeOnBackdropClick": { "alias": "closeOnBackdropClick"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; "closable": { "alias": "closable"; "required": false; "isSignal": true; }; "closeLabel": { "alias": "closeLabel"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, never, ["*"], true, never>;
+}
+
+/**
+ * @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
+ */
+
+/**
+ * Handle returned by `WrDrawerManager.open()`.
+ *
+ * Wraps the underlying `OverlayRef` and tracks the close result. It is also
+ * provided inside the drawer's own injector, so the projected content can
+ * inject it and close itself — the counterpart to `[wrDrawerClose]` when the
+ * close is programmatic (after a save succeeds, say) rather than a click.
+ *
+ * @example
+ * ```ts
+ * // Caller side.
+ * const ref = drawers.open<ChatComponent, boolean>(ChatComponent, { position: 'right' });
+ * const result = await ref.awaitClose(); // boolean | undefined
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Content side — the drawer closes itself.
+ * @Component({...})
+ * export class ChatComponent {
+ *   private readonly ref = inject(WrDrawerRef);
+ *
+ *   send(): void {
+ *     this.store.send(this.draft());
+ *     this.ref.close(true);
+ *   }
+ * }
+ * ```
+ */
+declare class WrDrawerRef<C, R = unknown> {
+    private readonly _overlayRef;
+    /**
+     * Emits the close result once and completes.
+     *
+     * A `ReplaySubject`, not a plain `Subject`, so the result survives a late
+     * subscriber: content can close itself before `open()` has even returned, and
+     * `awaitClose()` may be called long after the dismissal — both would otherwise
+     * see only `complete` and resolve `undefined`.
+     */
+    readonly closed: ReplaySubject<R | undefined>;
+    /** @internal */
+    componentRef: ComponentRef<C> | null;
+    /** @internal */
+    focusTrap: ConfigurableFocusTrap | null;
+    /** @internal */
+    previouslyFocused: HTMLElement | null;
+    constructor(_overlayRef: OverlayRef);
+    /** The instantiated drawer component. */
+    get componentInstance(): C;
+    private isClosed;
+    /** Close the drawer, optionally returning a result. */
+    close(result?: R): void;
+    private teardown;
+    /** Resolves with the close result when the drawer is dismissed. */
+    awaitClose(): Promise<R | undefined>;
+    /** Underlying overlay ref — escape hatch for advanced cases. */
+    get overlayRef(): OverlayRef;
+}
+
+/**
+ * Opens drawer components in an isolated NGWR overlay — the programmatic
+ * counterpart to `<wr-drawer [(open)]="…">`.
+ *
+ * Use the component when the drawer is part of a template and its open state
+ * is a signal you already own; use this service when the caller doesn't own
+ * the markup (opening a chat panel from a toolbar action, from an effect, from
+ * a route guard) or when you need the close result.
+ *
+ * Uses `WR_OVERLAY` so it composes cleanly with `provideWrOverlay()`
+ * — drawers render into NGWR's own overlay container and never collide
+ * with other CDK consumers (Material, NG-ZORRO, etc.).
+ *
+ * `showHandle` / swipe-to-dismiss is component-only: it needs the drawer's own
+ * wrapper markup, which the service path replaces with your component.
+ *
+ * @example
+ * ```ts
+ * const drawers = inject(WrDrawerManager);
+ *
+ * const ref = drawers.open(ChatComponent, {
+ *   data: { threadId },
+ *   position: 'right',
+ *   width: '28rem',
+ * });
+ *
+ * await ref.awaitClose();
+ * ```
+ *
+ * @see https://ngwr.dev/reference/components/drawer
+ */
+declare class WrDrawerManager {
+    private readonly overlay;
+    private readonly scrollStrategies;
+    private readonly parentInjector;
+    private readonly focusTrapFactory;
+    private readonly isBrowser;
+    private readonly i18n;
+    open<C, R = unknown, D = unknown>(component: ComponentType<C>, options?: WrDrawerOptions<D>): WrDrawerRef<C, R>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrDrawerManager, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<WrDrawerManager>;
 }
 
+/**
+ * @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
+ */
+
+/**
+ * Token that exposes the `data` payload passed to `WrDrawerManager.open()`.
+ *
+ * @example
+ * ```ts
+ * @Component({...})
+ * export class ChatComponent {
+ *   readonly data = inject<ChatData>(WR_DRAWER_DATA);
+ * }
+ * ```
+ */
+declare const WR_DRAWER_DATA: InjectionToken<unknown>;
+
+/**
+ * @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
+ */
+
+/**
+ * Token exposing the open drawer's `WrDrawerRef` to components and
+ * directives rendered inside it (e.g. `[wrDrawerClose]`).
+ *
+ * **Prefer `inject(WrDrawerRef)`** — the ref is provided under the class token
+ * too, and the class path is the documented one. It already covers both cases
+ * you might reach for a token for: `inject(WrDrawerRef, { optional: true })`
+ * works for content that also renders outside a drawer, and
+ * `inject<WrDrawerRef<ChatComponent, boolean>>(WrDrawerRef)` types the generics
+ * without a cast.
+ *
+ * This token is the same object under a second key. It exists for the library's
+ * own directives (`[wrDrawerClose]`) and for swapping the provider out — a test
+ * stub, say — without touching the class.
+ *
+ * @example
+ * ```ts
+ * @Component({...})
+ * export class ChatComponent {
+ *   private readonly ref = inject<WrDrawerRef<ChatComponent, boolean>>(WrDrawerRef);
+ *
+ *   dismiss(): void {
+ *     this.ref.close(true);
+ *   }
+ * }
+ * ```
+ */
+declare const WR_DRAWER_REF: InjectionToken<WrDrawerRef<unknown, unknown>>;
+
 /**
  * Marks an element as the drawer's title row. Applies the `wr-drawer__title`
  * class so the drawer's stylesheet can lay it out alongside content and
@@ -147,17 +369,30 @@ declare class WrDrawerFooter {
 /**
  * Closes the parent drawer on click. Attach to any clickable element.
  *
+ * Works for both drawer flavours: inside `<wr-drawer>` it clears the
+ * component's `open` model, and inside a `WrDrawerManager.open()` drawer it
+ * closes the ref — optionally passing a `[wrDrawerClose]` value as the close
+ * result (the component flavour has no result to carry, so the value is
+ * ignored there).
+ *
  * @example
  * ```html
  * <wr-btn wrDrawerClose>Close</wr-btn>
+ * <wr-btn color="primary" [wrDrawerClose]="true">Save</wr-btn>
  * ```
  */
-declare class WrDrawerClose {
+declare class WrDrawerClose<R = unknown> {
+    /**
+     * Value to pass to `close()` for service-opened drawers. When unset — or
+     * used as a bare attribute — the drawer closes with `undefined`.
+     */
+    readonly result: _angular_core.InputSignalWithTransform<R | undefined, "" | R | undefined>;
     private readonly drawer;
+    private readonly ref;
     protected close(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrDrawerClose, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<WrDrawerClose, "[wrDrawerClose]", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrDrawerClose<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<WrDrawerClose<any>, "[wrDrawerClose]", never, { "result": { "alias": "wrDrawerClose"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-export { WrDrawer, WrDrawerClose, WrDrawerContent, WrDrawerFooter, WrDrawerTitle };
-export type { WrDrawerPosition };
+export { WR_DRAWER_DATA, WR_DRAWER_REF, WrDrawer, WrDrawerClose, WrDrawerContent, WrDrawerFooter, WrDrawerManager, WrDrawerRef, WrDrawerTitle };
+export type { WrDrawerOptions, WrDrawerPosition };

package/types/ngwr-dropdown.d.ts

@@ -73,6 +73,7 @@ declare class WrDropdown {
     readonly closed: _angular_core.OutputEmitterRef<void>;
     private readonly host;
     private readonly overlay;
+    private readonly outsideClick;
     private readonly responsiveConfig;
     private readonly vcr;
     private readonly scrollStrategies;

package/types/ngwr-i18n.d.ts

@@ -76,6 +76,12 @@ declare class WrI18n {
     private readonly config;
     private readonly loader;
     private readonly storage;
+    /**
+     * Catalogs registered via `provideWrI18nBaseCatalogs()` — the floor under the
+     * loader's own catalogs, so ngwr's built-in strings survive an app that only
+     * ships its own keys. @internal
+     */
+    private readonly baseCatalogs;
     /** Per-(locale,scope) catalogs, populated by `loadCatalog`. @internal */
     private readonly catalogs;
     /** Bumped after each catalog write so reactive translates recompute. @internal */
@@ -106,6 +112,11 @@ declare class WrI18n {
     t(key: string, params?: WrI18nParams, scope?: string): string;
     /** Reactive translate — re-evaluates on locale or catalog updates. */
     translate(key: string, params?: WrI18nParams, scope?: string): Signal<string>;
+    /**
+     * Look a key up in the registered base catalogs, later contributions first so
+     * a feature can shadow an earlier one.
+     */
+    private walkBase;
     private initialLocale;
     private loadCatalog;
     static ɵfac: i0.ɵɵFactoryDeclaration<WrI18n, never>;
@@ -181,6 +192,35 @@ interface WrI18nLoader {
 }
 declare const WR_I18N_LOADER: InjectionToken<WrI18nLoader>;
 
+/**
+ * @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
+ */
+
+/** Base catalogs keyed by locale, contributed by {@link provideWrI18nBaseCatalogs}. */
+type WrI18nBaseCatalogs = Readonly<Record<string, WrI18nCatalog>>;
+/**
+ * Catalogs consulted *underneath* whatever the loader returned — the place for
+ * ngwr's own built-in strings.
+ *
+ * A loader **replaces** the catalog for a locale rather than extending it, so an
+ * app whose JSON holds only its own keys used to lose every built-in label to
+ * its hardcoded English fallback, silently. Registering `wrRu` / `wrEn` here
+ * puts them back without the app having to merge anything itself.
+ *
+ * `multi`, so several features can each contribute; later contributions win on
+ * a key collision, and anything the loader returned still wins over all of them.
+ *
+ * It has to be handed in by the consumer rather than wired up inside
+ * `provideWrI18n()`: the catalogs are their own entry points (`ngwr/i18n/ru`)
+ * and they already import from `ngwr/i18n`, so importing them back here is a
+ * circular entry-point dependency that ng-packagr rejects outright. Passing
+ * them in also keeps the locales you don't ship out of your bundle.
+ */
+declare const WR_I18N_BASE_CATALOGS: InjectionToken<readonly Readonly<Record<string, WrI18nCatalog>>[]>;
+
 /**
  * @license
  *
@@ -270,6 +310,29 @@ declare function provideWrI18n(options?: ProvideWrI18nOptions): EnvironmentProvi
  * @param scopes Optional per-scope catalogs served to `registerScope(name)`.
  */
 declare function provideWrI18nStaticLoader(catalogs: WrI18nStaticCatalogs, scopes?: WrI18nStaticScopedCatalogs): Provider;
+/**
+ * Register catalogs consulted *underneath* the loader — this is how ngwr's own
+ * built-in strings survive when you supply your own catalogs.
+ *
+ * A loader replaces the catalog for a locale instead of extending it, so a JSON
+ * file holding only your keys leaves every built-in label on its hardcoded
+ * English fallback, with nothing logged. One line fixes it, on either loader:
+ *
+ * @example
+ * ```ts
+ * import { wrRu } from 'ngwr/i18n/ru';
+ *
+ * providers: [
+ *   provideWrI18n({ defaultLocale: 'ru', availableLocales: ['ru'] }),
+ *   provideWrI18nBaseCatalogs({ ru: wrRu }),
+ *   provideWrI18nHttpLoader({ path: '/assets/i18n/{locale}.json' }),
+ * ]
+ * ```
+ *
+ * Pass only the locales you ship — the ones you leave out stay out of the
+ * bundle. Your own keys always win; this is a floor, not an override.
+ */
+declare function provideWrI18nBaseCatalogs(catalogs: WrI18nBaseCatalogs): Provider;
 /** Provide an HTTP loader — catalogs fetched from URLs. Requires `provideHttpClient`. */
 declare function provideWrI18nHttpLoader(config: WrI18nHttpLoaderConfig): Provider;
 
@@ -332,5 +395,5 @@ declare function readI18nText(key: string, fallback: string): string;
  */
 declare function useI18nFormatter(key: string, fallback: string): (params?: WrI18nParams) => string;
 
-export { DEFAULT_WR_I18N_CONFIG, WR_I18N_CONFIG, WR_I18N_LOADER, WrI18n, WrI18nHttpLoader, WrI18nStaticLoader, WrTDirective, WrTPipe, provideWrI18n, provideWrI18nHttpLoader, provideWrI18nStaticLoader, readI18nText, useI18nFormatter, useI18nText };
-export type { ProvideWrI18nOptions, WrI18nCatalog, WrI18nConfig, WrI18nConfigResolved, WrI18nHttpLoaderConfig, WrI18nLoader, WrI18nMissingHandler, WrI18nParams, WrI18nStaticCatalogs, WrI18nStaticScopedCatalogs };
+export { DEFAULT_WR_I18N_CONFIG, WR_I18N_BASE_CATALOGS, WR_I18N_CONFIG, WR_I18N_LOADER, WrI18n, WrI18nHttpLoader, WrI18nStaticLoader, WrTDirective, WrTPipe, provideWrI18n, provideWrI18nBaseCatalogs, provideWrI18nHttpLoader, provideWrI18nStaticLoader, readI18nText, useI18nFormatter, useI18nText };
+export type { ProvideWrI18nOptions, WrI18nBaseCatalogs, WrI18nCatalog, WrI18nConfig, WrI18nConfigResolved, WrI18nHttpLoaderConfig, WrI18nLoader, WrI18nMissingHandler, WrI18nParams, WrI18nStaticCatalogs, WrI18nStaticScopedCatalogs };

package/types/ngwr-icon.d.ts

@@ -18,28 +18,20 @@ declare class WrIcon {
     readonly name: i0.InputSignal<string>;
     private readonly host;
     /**
-     * Merged view of every `WR_ICONS` multi-provider visible from this
-     * injector position — element-level first overlay, environment-level
-     * (app/lazy-route bootstrap) as the base.
+     * Every icon visible from this position, walked up the whole chain of
+     * registering injector levels.
      *
-     * Angular's default `inject(WR_ICONS)` only returns the **closest**
-     * injector's contribution; if a component declares its own
-     * `provideWrIcons(...)`, the root registration is **shadowed**, not
-     * appended. That contradicts the docstring's "each call adds to the
-     * registry" promise and silently breaks any page that overrides while
-     * still relying on root-registered icons.
+     * Angular's `inject(WR_ICONS)` returns only the **closest** injector's
+     * contribution — `multi` providers are not merged across levels — so a
+     * component that registers its own icons used to shadow, not extend, what an
+     * ancestor registered. {@link WrIconRegistry} is provided once per
+     * registering level and links to its parent, so nesting any number of levels
+     * now adds up, with the nearest registration winning a name collision.
      *
-     * We work around it by also asking the environment injector directly
-     * (`envInjector.get(WR_ICONS, null, …)`). When no element-level
-     * provider exists both calls return the same array reference and we
-     * skip the redundant pass. Otherwise we lay element on top of env so
-     * a page's local icons can override a root-registered name.
-     *
-     * One known limitation: multiple element-injector levels in between
-     * still shadow each other — but the showcase doesn't nest providers
-     * that deep, and the env+local merge fixes the dominant case.
+     * Optional: with no `provideWrIcons()` anywhere the map is simply empty and
+     * every name reports as unregistered.
      */
-    private readonly iconSets;
+    private readonly iconRegistry;
     private readonly registry;
     private readonly icon;
     constructor();