ngwr 6.1.1 → 7.1.0

package/types/ngwr-gauge.d.ts

@@ -0,0 +1,39 @@
+import * as _angular_core from '@angular/core';
+
+/**
+ * Semicircle progress gauge. Display-only — for interactive use see the
+ * {@link WrKnob} from `ngwr/knob`.
+ *
+ * @example
+ * ```html
+ * <wr-gauge [value]="72" />
+ * <wr-gauge [value]="9.5" [min]="0" [max]="10" suffix="/10" valueColor="var(--wr-color-warning)" />
+ * ```
+ *
+ * @see https://ngwr.dev/components/gauge
+ */
+declare class WrGauge {
+    readonly value: _angular_core.InputSignal<number>;
+    readonly min: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly max: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Diameter in CSS pixels. @default 160 */
+    readonly size: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Arc stroke thickness in viewBox units (out of 100). @default 10 */
+    readonly strokeWidth: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly trackColor: _angular_core.InputSignal<string>;
+    readonly valueColor: _angular_core.InputSignal<string>;
+    /** Show the value text in the center. @default true */
+    readonly showValue: _angular_core.InputSignalWithTransform<boolean, any>;
+    readonly suffix: _angular_core.InputSignal<string>;
+    protected readonly cx = 50;
+    protected readonly cy = 50;
+    protected readonly radius: _angular_core.Signal<number>;
+    protected readonly ratio: _angular_core.Signal<number>;
+    protected readonly trackPath: _angular_core.Signal<string>;
+    protected readonly valuePath: _angular_core.Signal<string>;
+    protected readonly viewBox = "0 0 100 56";
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrGauge, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrGauge, "wr-gauge", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; "isSignal": true; }; "trackColor": { "alias": "trackColor"; "required": false; "isSignal": true; }; "valueColor": { "alias": "valueColor"; "required": false; "isSignal": true; }; "showValue": { "alias": "showValue"; "required": false; "isSignal": true; }; "suffix": { "alias": "suffix"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { WrGauge };

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

@@ -0,0 +1,31 @@
+import * as _angular_core from '@angular/core';
+
+/**
+ * Glitchy text effect — colour-split horizontal-tear glitch on the
+ * provided text. Defaults to playing constantly; toggle `[enableOnHover]`
+ * to make it idle until the user hovers.
+ *
+ * @example
+ * ```html
+ * <wr-glitch-text text="404" />
+ * <wr-glitch-text text="ERROR" [speed]="0.5" [enableOnHover]="true" />
+ * ```
+ *
+ * @see https://www.reactbits.dev/text-animations/glitch-text
+ */
+declare class WrGlitchText {
+    /** Text to glitch. Required — the value populates `data-text` for the pseudo clones. */
+    readonly text: _angular_core.InputSignal<string>;
+    /** Time multiplier — higher = slower glitching. @default 1 */
+    readonly speed: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Show the red / cyan colour-split shadows. @default true */
+    readonly enableShadows: _angular_core.InputSignalWithTransform<boolean, any>;
+    /** Only glitch on hover (idle until then). @default true */
+    readonly enableOnHover: _angular_core.InputSignalWithTransform<boolean, any>;
+    protected readonly beforeShadow: _angular_core.Signal<"5px 0 cyan" | "none">;
+    protected readonly afterShadow: _angular_core.Signal<"none" | "-5px 0 red">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrGlitchText, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrGlitchText, "wr-glitch-text", never, { "text": { "alias": "text"; "required": true; "isSignal": true; }; "speed": { "alias": "speed"; "required": false; "isSignal": true; }; "enableShadows": { "alias": "enableShadows"; "required": false; "isSignal": true; }; "enableOnHover": { "alias": "enableOnHover"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { WrGlitchText };

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

@@ -0,0 +1,46 @@
+import * as _angular_core from '@angular/core';
+
+type WrGradientTextDirection = 'horizontal' | 'vertical' | 'diagonal';
+
+/**
+ * Animated multi-stop gradient text. The gradient slides across the text
+ * via `background-clip: text`. Optional `[showBorder]` wraps the text in
+ * a dark pill with the same animated gradient as a border ring.
+ *
+ * @example
+ * ```html
+ * <wr-gradient-text>Hello, ngwr!</wr-gradient-text>
+ * <wr-gradient-text
+ *   [colors]="['#5227FF', '#FF9FFC', '#B497CF']"
+ *   direction="diagonal"
+ *   [animationSpeed]="6"
+ *   [showBorder]="true"
+ * >
+ *   Premium feature
+ * </wr-gradient-text>
+ * ```
+ *
+ * @see https://www.reactbits.dev/text-animations/gradient-text
+ */
+declare class WrGradientText {
+    /** Gradient stops. @default ['#5227FF', '#FF9FFC', '#B497CF'] */
+    readonly colors: _angular_core.InputSignal<readonly string[]>;
+    /** Seconds per full sweep (or per half if `[yoyo]` is on). @default 8 */
+    readonly animationSpeed: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Wrap the text in a dark pill with the gradient as a border. @default false */
+    readonly showBorder: _angular_core.InputSignalWithTransform<boolean, any>;
+    /** Gradient slide direction. @default 'horizontal' */
+    readonly direction: _angular_core.InputSignal<WrGradientTextDirection>;
+    /** Pause the animation while hovered. @default false */
+    readonly pauseOnHover: _angular_core.InputSignalWithTransform<boolean, any>;
+    /** Bounce back-and-forth instead of restarting. @default true */
+    readonly yoyo: _angular_core.InputSignalWithTransform<boolean, any>;
+    protected readonly gradient: _angular_core.Signal<string>;
+    protected readonly size: _angular_core.Signal<"100% 300%" | "300% 300%" | "300% 100%">;
+    private directionAngle;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrGradientText, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrGradientText, "wr-gradient-text", never, { "colors": { "alias": "colors"; "required": false; "isSignal": true; }; "animationSpeed": { "alias": "animationSpeed"; "required": false; "isSignal": true; }; "showBorder": { "alias": "showBorder"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "pauseOnHover": { "alias": "pauseOnHover"; "required": false; "isSignal": true; }; "yoyo": { "alias": "yoyo"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { WrGradientText };
+export type { WrGradientTextDirection };

package/types/ngwr-hotkey.d.ts

@@ -0,0 +1,142 @@
+import * as _angular_core from '@angular/core';
+
+/**
+ * @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
+ */
+/**
+ * A keybinding specification — `'+'` separated tokens, case-insensitive.
+ * Modifiers: `ctrl`, `alt`, `shift`, `meta`, `cmd` (alias for `meta`),
+ * `mod` (auto: `cmd` on macOS, `ctrl` elsewhere). Last token is the key.
+ *
+ * Examples: `'ctrl+k'`, `'cmd+shift+p'`, `'escape'`, `'mod+/'`, `'ArrowDown'`.
+ */
+type WrHotkeySpec = string;
+/** Returned by {@link WrHotkey.bind} — call `.unbind()` to remove. */
+interface WrHotkeyHandle {
+    readonly unbind: () => void;
+}
+/** Options accepted by {@link WrHotkey.bind}. */
+interface WrHotkeyOptions {
+    /**
+     * Scope the listener to a specific element instead of `document`. The
+     * element must be focusable (or contain the focus) for the binding to
+     * fire — usually combined with `tabindex="0"` on the host.
+     */
+    readonly element?: HTMLElement;
+    /** Call `event.preventDefault()` when the binding matches. @default true */
+    readonly preventDefault?: boolean;
+    /**
+     * Fire even when an input / textarea / contenteditable element has
+     * focus. By default these are skipped so the user can type normally.
+     * @default false
+     */
+    readonly allowInInput?: boolean;
+    /**
+     * Higher priority bindings fire first. Bindings sharing a key dispatch
+     * in priority order; the lower-priority ones are skipped when the
+     * handler calls `event.preventDefault()`. @default 0
+     */
+    readonly priority?: number;
+}
+
+/**
+ * Global keybinding registry.
+ *
+ * Bindings are keyed off `KeyboardEvent.key` + modifier state. Multiple
+ * handlers per chord fire in priority order; a handler that calls
+ * `event.preventDefault()` stops lower-priority bindings on that key.
+ *
+ * The listener runs outside Angular — only matched bindings re-enter
+ * the zone, so an idle page doesn't trigger CD on every keystroke.
+ *
+ * Use `[wrHotkey]` for declarative element-scoped bindings.
+ *
+ * @example
+ * ```ts
+ * const hotkeys = inject(WrHotkey);
+ * const handle = hotkeys.bind('mod+k', () => openCommandPalette());
+ * // ...later
+ * handle.unbind();
+ * ```
+ *
+ * @see https://ngwr.dev/services/hotkey
+ */
+declare class WrHotkey {
+    private readonly doc;
+    private readonly zone;
+    private readonly platform;
+    private readonly isMac;
+    /** Bindings grouped by listener target. */
+    private readonly registries;
+    /** Register a binding. */
+    bind(spec: WrHotkeySpec, handler: (event: KeyboardEvent) => void, options?: WrHotkeyOptions): WrHotkeyHandle;
+    private readonly listeners;
+    private attach;
+    private detach;
+    private dispatch;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrHotkey, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<WrHotkey>;
+}
+
+/**
+ * Declarative wrapper around {@link WrHotkey}.
+ *
+ * Binds on init (and re-binds when the spec changes), unbinds on destroy.
+ * Defaults to global scope so the binding works regardless of focus —
+ * pass `[scoped]="true"` to limit it to the host element.
+ *
+ * @example
+ * ```html
+ * <button (wrHotkeyMatch)="open()" [wrHotkey]="'mod+k'">Open palette</button>
+ * <div tabindex="0" [wrHotkey]="'escape'" [scoped]="true" (wrHotkeyMatch)="close()">…</div>
+ * ```
+ */
+declare class WrHotkeyBinding {
+    readonly wrHotkey: _angular_core.InputSignal<string>;
+    /** Scope the binding to the host element instead of `document`. @default false */
+    readonly scoped: _angular_core.InputSignalWithTransform<boolean, any>;
+    /** Fire even when an input / textarea has focus. @default false */
+    readonly allowInInput: _angular_core.InputSignalWithTransform<boolean, any>;
+    /** Suppress the default action when the binding fires. @default true */
+    readonly preventDefault: _angular_core.InputSignalWithTransform<boolean, any>;
+    /** Emits the original KeyboardEvent on match. */
+    readonly wrHotkeyMatch: _angular_core.OutputEmitterRef<KeyboardEvent>;
+    private readonly hotkeys;
+    private readonly host;
+    private handle;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrHotkeyBinding, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<WrHotkeyBinding, "[wrHotkey]", never, { "wrHotkey": { "alias": "wrHotkey"; "required": true; "isSignal": true; }; "scoped": { "alias": "scoped"; "required": false; "isSignal": true; }; "allowInInput": { "alias": "allowInInput"; "required": false; "isSignal": true; }; "preventDefault": { "alias": "preventDefault"; "required": false; "isSignal": true; }; }, { "wrHotkeyMatch": "wrHotkeyMatch"; }, never, 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
+ */
+
+/** Normalised representation of a hotkey spec — easy to match against an event. */
+interface WrParsedHotkey {
+    readonly ctrl: boolean;
+    readonly alt: boolean;
+    readonly shift: boolean;
+    readonly meta: boolean;
+    /** Lowercased `KeyboardEvent.key` value the spec matches. */
+    readonly key: string;
+}
+/**
+ * Parse a hotkey spec like `'mod+shift+k'` into a normalised structure.
+ *
+ * @param spec - the spec to parse
+ * @param isMac - when true, `mod` resolves to `meta` (Cmd); otherwise `ctrl`
+ */
+declare function parseHotkeySpec(spec: WrHotkeySpec, isMac?: boolean): WrParsedHotkey;
+/** Does `event` satisfy the parsed hotkey? */
+declare function matchesHotkey(event: KeyboardEvent, parsed: WrParsedHotkey): boolean;
+
+export { WrHotkey, WrHotkeyBinding, matchesHotkey, parseHotkeySpec };
+export type { WrHotkeyHandle, WrHotkeyOptions, WrHotkeySpec, WrParsedHotkey };

package/types/ngwr-i18n-en.d.ts

@@ -0,0 +1,18 @@
+import { WrI18nCatalog } from 'ngwr/i18n';
+
+/**
+ * Base English catalog for ngwr built-in component strings. Spread this
+ * into your root catalog or pass it to `provideWrI18nStaticLoader`.
+ *
+ * @example
+ * ```ts
+ * import { wrEn } from 'ngwr/i18n/en';
+ *
+ * provideWrI18nStaticLoader({
+ *   en: { ...wrEn, app: { title: 'My app' } },
+ * });
+ * ```
+ */
+declare const wrEn: WrI18nCatalog;
+
+export { wrEn };

package/types/ngwr-i18n-ru.d.ts

@@ -0,0 +1,6 @@
+import { WrI18nCatalog } from 'ngwr/i18n';
+
+/** Base Russian catalog for ngwr built-in component strings. */
+declare const wrRu: WrI18nCatalog;
+
+export { wrRu };

package/types/ngwr-i18n.d.ts

@@ -0,0 +1,336 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, Signal, PipeTransform, EnvironmentProviders, Provider } from '@angular/core';
+import { Observable } from 'rxjs';
+
+/**
+ * @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
+ */
+
+/** Translation catalog — flat or nested record of strings. */
+interface WrI18nCatalog {
+    readonly [key: string]: string | WrI18nCatalog;
+}
+/** Parameters passed to interpolation — coerced to strings via `String(v)`. */
+type WrI18nParams = Readonly<Record<string, unknown>>;
+/** Hook called once on every key that resolves to nothing. */
+type WrI18nMissingHandler = (key: string, locale: string) => string;
+/** User-facing config for {@link provideWrI18n}. */
+interface WrI18nConfig {
+    /** BCP-47 tag used until the user calls `setLocale`. @default 'en' */
+    readonly defaultLocale?: string;
+    /** Whitelisted locales — `setLocale` ignores anything outside this list. */
+    readonly availableLocales?: readonly string[];
+    /**
+     * Storage key for persisting the active locale (via `WrStorage`).
+     * Set to `null` to disable persistence. @default 'wr:i18n:locale'
+     */
+    readonly storageKey?: string | null;
+    /** Called when a key is missing. Default returns the key itself. */
+    readonly missingHandler?: WrI18nMissingHandler;
+}
+/** Resolved config — every field non-optional. @internal */
+interface WrI18nConfigResolved {
+    readonly defaultLocale: string;
+    readonly availableLocales: readonly string[];
+    readonly storageKey: string | null;
+    readonly missingHandler: WrI18nMissingHandler;
+}
+declare const DEFAULT_WR_I18N_CONFIG: WrI18nConfigResolved;
+declare const WR_I18N_CONFIG: InjectionToken<WrI18nConfigResolved>;
+
+/**
+ * @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
+ */
+
+/**
+ * Reactive i18n service. Holds:
+ *
+ * - the active locale as a `Signal<string>`
+ * - per-`(locale, scope)` catalogs in a `Map` (loaded once, then cached)
+ * - a per-locale signal counter so every `translate()` reading the signal
+ *   re-evaluates the moment a new catalog finishes loading
+ *
+ * Translations are looked up scope-first, then root. `t('forms.save', { ... })`
+ * with `scope: 'forms'` will try the scoped catalog before falling back to
+ * `forms.save` in the root catalog — useful for per-feature overrides.
+ *
+ * @example
+ * ```ts
+ * const i18n = inject(WrI18n);
+ * i18n.use('ru');                                  // switch locale
+ * i18n.t('cart.checkout');                         // → 'Оформить заказ'
+ * i18n.t('greeting', { name: 'Ada' });             // → 'Hello, Ada!'
+ *
+ * effect(() => console.log(i18n.translate('hi')())); // re-runs on locale change
+ * ```
+ *
+ * @see https://ngwr.dev/services/i18n
+ */
+declare class WrI18n {
+    private readonly config;
+    private readonly loader;
+    private readonly storage;
+    /** Per-(locale,scope) catalogs, populated by `loadCatalog`. @internal */
+    private readonly catalogs;
+    /** Bumped after each catalog write so reactive translates recompute. @internal */
+    private readonly revision;
+    /** In-flight load promises — dedupes parallel `t()` callers. @internal */
+    private readonly inflight;
+    /** Registered scopes — auto-loaded whenever the locale changes. @internal */
+    private readonly scopes;
+    /** Active locale. Writes go through `use()` so storage stays in sync. */
+    private readonly _locale;
+    readonly locale: Signal<string>;
+    constructor();
+    /** Switch active locale. Ignored when not whitelisted. */
+    use(locale: string): void;
+    /** Available locales — pass-through from config. */
+    available(): readonly string[];
+    /**
+     * Register a scope so its catalog loads alongside the root one. Idempotent.
+     * Returns a promise resolving once the current locale's scope catalog is in
+     * the cache — handy for feature `canActivate` guards.
+     */
+    registerScope(scope: string): Promise<WrI18nCatalog>;
+    /**
+     * Eager translate — returns the current value or the missing-handler
+     * fallback. Does NOT auto-load missing catalogs; combine with the
+     * reactive `translate(...)` if you want load-on-demand.
+     */
+    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>;
+    private initialLocale;
+    private loadCatalog;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WrI18n, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WrI18n>;
+}
+
+/**
+ * @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
+ */
+
+/**
+ * Translate a key. Impure — re-evaluates on every CD so locale switches
+ * and catalog loads propagate without a manual refresh.
+ *
+ * @example
+ * ```html
+ * <h1>{{ 'home.title' | wrT }}</h1>
+ * <p>{{ 'greeting' | wrT: { name: user().name } }}</p>
+ * <button>{{ 'forms.save' | wrT: null : 'checkout' }}</button>
+ * ```
+ */
+declare class WrTPipe implements PipeTransform {
+    private readonly i18n;
+    transform(key: string, params?: WrI18nParams | null, scope?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WrTPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<WrTPipe, "wrT", true>;
+}
+
+/**
+ * Attribute directive that sets `textContent` of its host to the translation
+ * of the bound key. Reactive — re-renders on locale + catalog changes.
+ *
+ * @example
+ * ```html
+ * <span [wrT]="'home.title'"></span>
+ * <span [wrT]="'greeting'" [wrTParams]="{ name: user().name }"></span>
+ * <span [wrT]="'forms.save'" wrTScope="checkout"></span>
+ * ```
+ */
+declare class WrTDirective {
+    /** Translation key. Required. */
+    readonly wrT: i0.InputSignal<string>;
+    /** Interpolation params for `{{name}}` tokens. */
+    readonly wrTParams: i0.InputSignal<Readonly<Record<string, unknown>> | null>;
+    /** Optional scope — scoped lookup first, then root fallback. */
+    readonly wrTScope: i0.InputSignal<string | null>;
+    private readonly host;
+    private readonly i18n;
+    private readonly text;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<WrTDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<WrTDirective, "[wrT]", never, { "wrT": { "alias": "wrT"; "required": true; "isSignal": true; }; "wrTParams": { "alias": "wrTParams"; "required": false; "isSignal": true; }; "wrTScope": { "alias": "wrTScope"; "required": false; "isSignal": true; }; }, {}, never, 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
+ */
+
+/**
+ * Loads a catalog for a `(locale, scope)` pair. `scope` is `null` for the
+ * root catalog. Implementations may return the catalog synchronously
+ * (via `of(...)`) for static catalogs or asynchronously (via HTTP) for
+ * lazy fetches.
+ */
+interface WrI18nLoader {
+    load(locale: string, scope: string | null): Observable<WrI18nCatalog>;
+}
+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
+ */
+
+/** Root catalogs keyed by locale: `{ en: catalog, ru: catalog, … }`. */
+type WrI18nStaticCatalogs = Readonly<Record<string, WrI18nCatalog>>;
+/** Per-scope catalogs: `{ checkout: { en: catalog, ru: catalog }, … }`. */
+type WrI18nStaticScopedCatalogs = Readonly<Record<string, WrI18nStaticCatalogs>>;
+/**
+ * Loader for catalogs already in memory (imported from JSON or generated).
+ *
+ * - Pass `catalogs` for the root catalog of every locale.
+ * - Pass `scopes` if you ship per-feature catalogs the loader should serve
+ *   to `WrI18n.registerScope(name)` calls.
+ *
+ * Missing locale or scope resolves to `{}` — the missing-key handler then
+ * decides what to render.
+ */
+declare class WrI18nStaticLoader implements WrI18nLoader {
+    private readonly catalogs;
+    private readonly scopes;
+    constructor(catalogs: WrI18nStaticCatalogs, scopes?: WrI18nStaticScopedCatalogs);
+    load(locale: string, scope: string | null): Observable<WrI18nCatalog>;
+}
+
+/**
+ * @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
+ */
+
+/** Configuration for {@link WrI18nHttpLoader}. */
+interface WrI18nHttpLoaderConfig {
+    /**
+     * URL template. Tokens:
+     * - `{locale}` — required, BCP-47 tag (e.g. `en`).
+     * - `{scope}` — optional, scope name. Use the `rootPath` if you need a
+     *   different path entirely for the root catalog.
+     *
+     * @example
+     * ```ts
+     * { path: '/assets/i18n/{locale}.json' }                  // root only
+     * { path: '/assets/i18n/{scope}/{locale}.json',
+     *   rootPath: '/assets/i18n/{locale}.json' }              // root + scopes
+     * ```
+     */
+    readonly path: string;
+    /** Path template for the root catalog. Defaults to `path`. */
+    readonly rootPath?: string;
+}
+/**
+ * Loader that fetches catalogs via `HttpClient`. Failures resolve to `{}`
+ * (logged once at the service layer) so a missing file never throws into
+ * user code.
+ */
+declare class WrI18nHttpLoader implements WrI18nLoader {
+    private readonly config;
+    private readonly http;
+    constructor(config: WrI18nHttpLoaderConfig);
+    load(locale: string, scope: string | null): Observable<WrI18nCatalog>;
+}
+
+/**
+ * @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
+ */
+
+/**
+ * Configure {@link WrI18n}. Either pass a `loader` directly, or use the
+ * `provideWrI18nHttpLoader` / `provideWrI18nStaticLoader` helpers in the
+ * same providers array.
+ */
+interface ProvideWrI18nOptions extends WrI18nConfig {
+    readonly loader?: WrI18nLoader;
+}
+declare function provideWrI18n(options?: ProvideWrI18nOptions): EnvironmentProviders;
+/**
+ * Provide a static loader — catalogs already in memory.
+ *
+ * @param catalogs Root catalogs keyed by locale.
+ * @param scopes Optional per-scope catalogs served to `registerScope(name)`.
+ */
+declare function provideWrI18nStaticLoader(catalogs: WrI18nStaticCatalogs, scopes?: WrI18nStaticScopedCatalogs): Provider;
+/** Provide an HTTP loader — catalogs fetched from URLs. Requires `provideHttpClient`. */
+declare function provideWrI18nHttpLoader(config: WrI18nHttpLoaderConfig): Provider;
+
+/**
+ * @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
+ */
+
+/**
+ * Helper for component default text. Returns a reactive string that:
+ *
+ * 1. Prefers the consumer's override (an `input<string | null>()` value).
+ * 2. Falls back to the i18n catalog under `key` — re-renders on locale
+ *    change so a switcher updates the DOM live.
+ * 3. Falls back to `fallback` when no `WrI18n` is provided OR the catalog
+ *    is missing the key.
+ *
+ * Components don't need a hard dependency on `provideWrI18n` — without it,
+ * the fallback is returned and everything still works.
+ *
+ * @example
+ * ```ts
+ * readonly emptyText = input<string | null>(null);
+ * protected readonly empty = useI18nText(this.emptyText, 'table.empty', 'No data');
+ *
+ * // In template:  <div>{{ empty() }}</div>
+ * ```
+ */
+declare function useI18nText(binding: Signal<string | null | undefined>, key: string, fallback: string): Signal<string>;
+/**
+ * Like {@link useI18nText} but takes a literal value (not a Signal) — for
+ * computed `aria-label`s that already mix a static piece with a dynamic
+ * value. Returns the resolved string once, at injection time.
+ */
+declare function readI18nText(key: string, fallback: string): string;
+/**
+ * Build a per-call formatter for parametrized labels (e.g. ARIA labels
+ * that interpolate a per-row value: `"Remove {{label}}"`). Returns a
+ * function the template calls with the params for the current item.
+ *
+ * The returned function:
+ * - Re-resolves the i18n catalog on every call (live locale switches just
+ *   work — re-rendered templates pick up new strings).
+ * - Falls back to the literal `fallback` template with the same
+ *   `{{name}}` syntax when no `WrI18n` provider is present, or when the
+ *   key is missing.
+ *
+ * Use this for labels that vary per row. For static labels, prefer
+ * {@link useI18nText} or {@link readI18nText}.
+ *
+ * @example
+ * ```ts
+ * protected readonly removeChipLabel = useI18nFormatter('select.removeItem', 'Remove {{label}}');
+ *
+ * // In template:
+ * // [attr.aria-label]="removeChipLabel({ label: chip.label })"
+ * ```
+ */
+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 };

package/types/ngwr-icon-adapters-feather.d.ts

@@ -0,0 +1,44 @@
+import { WrIconDef } from 'ngwr/icon';
+
+/**
+ * @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
+ */
+
+/**
+ * Wrap a single Feather icon (inner SVG markup) in a {@link WrIconDef}
+ * envelope. Pair with the upstream `icons.json` map.
+ *
+ * @example
+ * ```ts
+ * import { feather } from 'ngwr/icon/adapters/feather';
+ * // feather-icons ships an inner-SVG-only map under dist/icons.json:
+ * //   { "plus": "<line .../><line .../>", "trash": "...", ... }
+ * import featherIcons from 'feather-icons/dist/icons.json';
+ *
+ * provideWrIcons([feather('plus', featherIcons.plus)]);
+ * ```
+ */
+declare function feather(name: string, innerSvg: string): WrIconDef;
+/**
+ * Bulk variant — pass a `{ alias: innerSvg }` object. Aliases (the
+ * keys) become the registry names so you can use shorter or
+ * project-specific names.
+ *
+ * @example
+ * ```ts
+ * import { featherIcons } from 'ngwr/icon/adapters/feather';
+ * import featherSource from 'feather-icons/dist/icons.json';
+ *
+ * provideWrIcons(featherIcons({
+ *   plus: featherSource.plus,
+ *   trash: featherSource.trash,
+ *   x: featherSource.x,
+ * }));
+ * ```
+ */
+declare function featherIcons(icons: Record<string, string>): WrIconDef[];
+
+export { feather, featherIcons };