ngx-kit 8.5.0 → 9.0.1

package/fesm2022/ngx-kit-lazy-i18n.mjs

@@ -0,0 +1,612 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, inject, signal, computed, isDevMode, Injectable, Pipe, TemplateRef, ViewContainerRef, Input, Directive, ElementRef, Renderer2, effect, makeEnvironmentProviders, provideAppInitializer, provideEnvironmentInitializer, assertInInjectionContext } from '@angular/core';
+import { DOCUMENT } from '@angular/common';
+import { firstValueFrom, defer, from, retry } from 'rxjs';
+import { HttpClient } from '@angular/common/http';
+
+/** Defaults applied by `provideI18n()`. */
+const I18N_DEFAULTS = { fileExtension: '.json', retries: 1 };
+const I18N_CONFIG = new InjectionToken('I18N_CONFIG');
+const I18N_LOADER = new InjectionToken('I18N_LOADER');
+
+/** Flatten a nested dictionary into `target` (dot-separated keys). Non-string leaves are stringified. */
+function flatten(dict, target = new Map(), onConflict, prefix = '') {
+    for (const k of Object.keys(dict)) {
+        const v = dict[k];
+        const key = prefix ? `${prefix}.${k}` : k;
+        if (v !== null && typeof v === 'object') {
+            flatten(v, target, onConflict, key);
+        }
+        else if (v !== null && v !== undefined) {
+            const s = String(v);
+            if (onConflict) {
+                const prev = target.get(key);
+                if (prev !== undefined && prev !== '' && s !== '' && prev !== s)
+                    onConflict(key);
+            }
+            target.set(key, s);
+        }
+    }
+    return target;
+}
+const RE = /\{\{\s*([\w$.-]+)\s*\}\}/g;
+function getPath(obj, path) {
+    if (path in obj)
+        return obj[path];
+    let cur = obj;
+    for (const part of path.split('.')) {
+        if (cur == null)
+            return undefined;
+        cur = cur[part];
+    }
+    return cur;
+}
+/** `Hello {{ name }}` + `{name:'Ali'}` -> `Hello Ali`. Unknown placeholders are left untouched. */
+function interpolate(text, params) {
+    if (!params || text.indexOf('{{') === -1)
+        return text; // fast path: no regex
+    return text.replace(RE, (m, k) => {
+        const v = getPath(params, k);
+        return v == null ? m : String(v);
+    });
+}
+function shallowEqual(a, b) {
+    if (a === b)
+        return true;
+    if (!a || !b)
+        return false;
+    const ka = Object.keys(a);
+    if (ka.length !== Object.keys(b).length)
+        return false;
+    for (const k of ka)
+        if (a[k] !== b[k])
+            return false;
+    return true;
+}
+const RTL_LANGS = new Set(['ar', 'fa', 'he', 'ur', 'ps', 'sd', 'ug', 'yi', 'ckb', 'dv']);
+/** Identity function the extractor recognises: `const k = marker('orders.title')`. */
+function marker(key) {
+    return key;
+}
+/** Copy only the properties of `patch` that are not `undefined` (so an omitted option never wipes a default). */
+function assignDefined(target, patch) {
+    for (const k of Object.keys(patch)) {
+        if (patch[k] !== undefined)
+            target[k] = patch[k];
+    }
+    return target;
+}
+/**
+ * Build `{base}/{scope}/{lang}{ext}` without ever producing `undefined`, `//` or a trailing slash problem:
+ *   ("/i18n",            undefined, "fa", ".json") -> "/i18n/fa.json"
+ *   ("https://x.com/",   "setting", "fa", "json")  -> "https://x.com/setting/fa.json"
+ *   (undefined | "",     undefined, "fa")          -> "/fa"
+ * The protocol part of `base` ("https://") is left alone.
+ */
+function buildI18nUrl(base, scope, lang, ext = '') {
+    const trim = (s) => s.trim().replace(/^\/+|\/+$/g, '');
+    const e = ext ? (ext.startsWith('.') ? ext : '.' + ext) : '';
+    const path = [scope ? trim(scope) : '', trim(lang) + e]
+        .filter(Boolean)
+        .join('/')
+        .replace(/\/{2,}/g, '/');
+    return `${(base ?? '').trim().replace(/\/+$/, '')}/${path}`;
+}
+
+const TAG = '[lazy-i18n]';
+const EMPTY = [];
+class I18nService {
+    cfg = inject(I18N_CONFIG);
+    loader = inject(I18N_LOADER);
+    doc = inject(DOCUMENT);
+    _lang = signal(this.cfg.defaultLang ?? '', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_lang" }] : /* istanbul ignore next */ []));
+    _rev = signal(0, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_rev" }] : /* istanbul ignore next */ []));
+    _langs = signal(this.cfg.langs ?? EMPTY, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_langs" }] : /* istanbul ignore next */ []));
+    _ready = signal(false, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_ready" }] : /* istanbul ignore next */ []));
+    /** Active language (reactive). */
+    lang = this._lang.asReadonly();
+    /** Bumps whenever the active language or any dictionary changes. */
+    revision = this._rev.asReadonly();
+    dir = computed(() => RTL_LANGS.has(this._lang().split('-')[0]) ? 'rtl' : 'ltr', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "dir" }] : /* istanbul ignore next */ []));
+    /** Supported languages (a signal: they may be supplied after startup via `init()` / `configure()`). */
+    langs = this._langs.asReadonly();
+    /** `true` once the first language has been activated. Handy for a splash screen. */
+    ready = this._ready.asReadonly();
+    // read live, so values supplied later through configure() are honoured
+    get fallbacks() {
+        return this.cfg.fallbackLangs ?? EMPTY;
+    }
+    get warn() {
+        return this.cfg.warnMissing ?? isDevMode();
+    }
+    dicts = new Map(); // lang -> flat map
+    loaded = new Set(); // `${lang}|${scope}`
+    inflight = new Map();
+    scopes = new Set();
+    pending = new Set();
+    warned = new Set();
+    useToken = 0;
+    // ───────────────────────── translate ─────────────────────────
+    /** Translate. Reads signals, so it is reactive inside `computed`, `effect` and templates. */
+    t(key, params) {
+        this._rev();
+        return this.resolve(key, params, this._lang());
+    }
+    /** Same as `t`, but never creates a reactive dependency. */
+    instant(key, params) {
+        return this.resolve(key, params, this._lang());
+    }
+    /** `computed` signal for one key. `params` may be a function reading other signals. */
+    select(key, params) {
+        return computed(() => this.t(key, typeof params === 'function' ? params() : params));
+    }
+    /** True when the key has a non-empty value in the active language or a fallback. */
+    has(key) {
+        this._rev();
+        return this.lookup(key, this._lang()) !== undefined;
+    }
+    /** Returns every key below `prefix` as a nested object (values are raw, not interpolated). */
+    getObject(prefix) {
+        this._rev();
+        const out = {};
+        const p = prefix + '.';
+        for (const lang of [this._lang(), ...this.fallbacks]) {
+            for (const [k, v] of this.dicts.get(lang) ?? []) {
+                if (!k.startsWith(p) || !v)
+                    continue;
+                const parts = k.slice(p.length).split('.');
+                let cur = out;
+                for (let i = 0; i < parts.length - 1; i++)
+                    cur = typeof cur[parts[i]] === 'object' ? cur[parts[i]] : (cur[parts[i]] = {});
+                if (!(parts[parts.length - 1] in cur))
+                    cur[parts[parts.length - 1]] = v;
+            }
+        }
+        return out;
+    }
+    lookup(key, lang) {
+        let raw = this.dicts.get(lang)?.get(key);
+        if (raw)
+            return raw;
+        for (const fb of this.fallbacks) {
+            if (fb === lang)
+                continue;
+            raw = this.dicts.get(fb)?.get(key);
+            if (raw)
+                return raw;
+        }
+        return undefined; // '' (extractor placeholder) counts as missing -> falls back
+    }
+    resolve(key, params, lang) {
+        const raw = this.lookup(key, lang);
+        if (raw === undefined)
+            return this.onMissing(key, lang);
+        return this.cfg.transpile ? this.cfg.transpile(raw, params, lang) : interpolate(raw, params);
+    }
+    onMissing(key, lang) {
+        if (this.warn && this.dicts.has(lang) && !this.warned.has(key)) {
+            this.warned.add(key);
+            console.warn(`${TAG} Missing translation "${key}" (lang: ${lang})`);
+        }
+        const h = this.cfg.missing ?? 'key';
+        return typeof h === 'function' ? h(key, lang) : h === 'empty' ? '' : key;
+    }
+    // ───────────────────────── language ─────────────────────────
+    /**
+     * Load global + all registered scopes (and fallback languages) for `lang`, THEN activate it.
+     * Nothing renders half-translated and no "missing" flash occurs.
+     */
+    use(lang) {
+        const p = this.activate(lang);
+        // tracked so whenReady() / i18nReadyGuard also wait for an in-flight language change
+        const tracked = p
+            .then(() => undefined, () => undefined)
+            .then(() => {
+            this.pending.delete(tracked);
+        });
+        this.pending.add(tracked);
+        return p;
+    }
+    /**
+     * Complete the configuration and activate the first language in one call. Use it from your own
+     * APP_INITIALIZER when the language list is only known at runtime (e.g. from the backend):
+     *
+     * ```ts
+     * await i18n.init({ langs: ['fa', 'en'], defaultLang: 'fa', baseUrl: apiUrl, lang: user.lang });
+     * ```
+     * `lang` is used when it is in `langs`; otherwise stored > browser (opt-in) > `defaultLang`.
+     * Rejects when the files cannot be loaded, so the initializer can show an error page.
+     */
+    init(options = {}) {
+        const { lang, ...patch } = options;
+        this.configure(patch);
+        const wanted = lang && (this.cfg.langs ?? EMPTY).includes(lang) ? lang : this.detectInitialLang();
+        return this.use(wanted);
+    }
+    /**
+     * Update options after startup (languages, baseUrl, fallbacks, ...). Already downloaded files stay cached.
+     * `loader` and `autoInit` can only be set in `provideI18n()`.
+     */
+    configure(patch) {
+        assignDefined(this.cfg, patch);
+        this.syncLangs();
+        if (patch.defaultLang && !this._ready())
+            this._lang.set(patch.defaultLang);
+    }
+    syncLangs() {
+        const l = this.cfg.langs ?? EMPTY;
+        if (l !== this._langs())
+            this._langs.set(l);
+    }
+    async activate(lang) {
+        this.syncLangs();
+        const langs = this.cfg.langs ?? EMPTY;
+        if (!langs.length) {
+            throw new Error(`${TAG} No languages configured. Pass "langs" to provideI18n() or call I18nService.init({ langs, defaultLang }) first.`);
+        }
+        if (!langs.includes(lang))
+            throw new Error(`${TAG} Unsupported language "${lang}"`);
+        const token = ++this.useToken;
+        do {
+            await this.loadLang(lang);
+        } while (!this.isComplete(lang)); // a scope may have been registered meanwhile
+        if (token !== this.useToken)
+            return; // a newer use() won
+        this._lang.set(lang);
+        this._rev.update((v) => v + 1);
+        this._ready.set(true);
+        this.persist(lang);
+        this.applyDocument(lang);
+    }
+    /** Download a language without activating it. */
+    preload(lang) {
+        return this.loadLang(lang);
+    }
+    /** Language to start with: stored > browser (opt-in) > default. */
+    detectInitialLang() {
+        const langs = this.cfg.langs ?? EMPTY;
+        const key = this.storageKey();
+        try {
+            const s = key ? localStorage.getItem(key) : null;
+            if (s && langs.includes(s))
+                return s;
+        }
+        catch {
+            /* storage unavailable (SSR / privacy mode) */
+        }
+        if (this.cfg.detectBrowserLang && typeof navigator !== 'undefined') {
+            for (const n of navigator.languages ?? [navigator.language]) {
+                if (langs.includes(n))
+                    return n;
+                const base = n.split('-')[0];
+                if (langs.includes(base))
+                    return base;
+            }
+        }
+        const def = this.cfg.defaultLang ?? '';
+        return langs.includes(def) ? def : (langs[0] ?? def);
+    }
+    // ───────────────────────── scopes ─────────────────────────
+    /** Register a scope and start loading it for the active language. Idempotent. Used by `provideI18nScope`. */
+    registerScope(scope) {
+        if (!scope)
+            return;
+        this.scopes.add(scope);
+        // before the first activation only remember it: init()/use() loads every registered scope
+        if (!this._ready())
+            return;
+        const lang = this._lang();
+        const p = Promise.all([lang, ...this.fallbacks.filter((f) => f !== lang)].map((l) => this.fetch(l, scope).catch((e) => {
+            console.error(`${TAG} Failed to load scope "${scope}" (${l})`, e);
+        }))).then(() => {
+            this.pending.delete(p);
+        });
+        this.pending.add(p);
+    }
+    /** Resolves once every scope registered so far is available. Never rejects. */
+    async whenReady() {
+        while (this.pending.size)
+            await Promise.all([...this.pending]);
+    }
+    // ───────────────────────── data ─────────────────────────
+    /** Manually set translations (tests, SSR transfer state, ...). */
+    setTranslation(lang, dict, merge = true) {
+        if (!merge)
+            this.dicts.delete(lang);
+        this.merge(lang, dict);
+    }
+    merge(lang, dict) {
+        let m = this.dicts.get(lang);
+        if (!m)
+            this.dicts.set(lang, (m = new Map()));
+        flatten(dict, m, this.warn
+            ? (k) => console.warn(`${TAG} Key "${k}" is defined twice with different values (${lang})`)
+            : undefined);
+        this._rev.update((v) => v + 1);
+    }
+    fetch(lang, scope) {
+        scope = scope || undefined; // never hand '' / null to a loader
+        const id = `${lang}|${scope ?? ''}`;
+        if (this.loaded.has(id))
+            return Promise.resolve();
+        let p = this.inflight.get(id);
+        if (!p) {
+            p = firstValueFrom(defer(() => from(this.loader.load(lang, scope))).pipe(retry({ count: this.cfg.retries ?? 1, delay: 250 })))
+                .then((d) => {
+                this.merge(lang, d);
+                this.loaded.add(id);
+            })
+                .finally(() => this.inflight.delete(id));
+            this.inflight.set(id, p);
+        }
+        return p;
+    }
+    loadLang(lang) {
+        const scopes = [undefined, ...this.scopes];
+        const main = scopes.map((s) => this.fetch(lang, s));
+        const fb = this.fallbacks
+            .filter((f) => f !== lang)
+            .flatMap((f) => scopes.map((s) => this.fetch(f, s).catch((e) => console.error(`${TAG} Fallback "${f}" failed`, e))));
+        return Promise.all([...main, ...fb]).then(() => undefined);
+    }
+    isComplete(lang) {
+        return (this.loaded.has(`${lang}|`) && [...this.scopes].every((s) => this.loaded.has(`${lang}|${s}`)));
+    }
+    storageKey() {
+        return this.cfg.storageKey === undefined ? 'lazy-i18n.lang' : this.cfg.storageKey;
+    }
+    persist(lang) {
+        const key = this.storageKey();
+        try {
+            if (key)
+                localStorage.setItem(key, lang);
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    applyDocument(lang) {
+        if (this.cfg.manageDocument === false)
+            return;
+        const el = this.doc?.documentElement;
+        if (!el)
+            return;
+        el.setAttribute('lang', lang);
+        el.setAttribute('dir', this.dir());
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.4", ngImport: i0, type: I18nService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.4", ngImport: i0, type: I18nService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.4", ngImport: i0, type: I18nService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/**
+ * `{{ 'orders.title' | tr }}`  /  `{{ 'hello' | tr: { name } }}`
+ *
+ * Impure on purpose (it must follow signals), but memoised: when key, params and the
+ * service revision are unchanged it returns the cached string in O(1) with no lookup.
+ */
+class TrPipe {
+    svc = inject(I18nService);
+    k;
+    p;
+    rev = -1;
+    out = '';
+    transform(key, params) {
+        if (!key)
+            return '';
+        const rev = this.svc.revision(); // tracked: marks the view dirty on lang / dictionary change
+        if (rev === this.rev && key === this.k && shallowEqual(params, this.p))
+            return this.out;
+        this.k = key;
+        this.p = params;
+        this.rev = rev;
+        return (this.out = this.svc.t(key, params));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.4", ngImport: i0, type: TrPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "22.0.4", ngImport: i0, type: TrPipe, isStandalone: true, name: "tr", pure: false });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.4", ngImport: i0, type: TrPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'tr', pure: false }]
+        }] });
+
+/**
+ * Structural directive. The view is created ONCE; `t` reads signals, so only the bindings that use it update.
+ *
+ *   <ng-container *tr="let t; prefix: 'orders'">
+ *     <h1>{{ t('title') }}</h1>            <!-- orders.title -->
+ *   </ng-container>
+ */
+class TrDirective {
+    tpl = inject(TemplateRef);
+    vcr = inject(ViewContainerRef);
+    svc = inject(I18nService);
+    prefix = signal(undefined, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "prefix" }] : /* istanbul ignore next */ []));
+    /** `prefix: 'orders'` in the microsyntax. */
+    set trPrefix(v) { this.prefix.set(v); }
+    static ngTemplateContextGuard(_dir, _ctx) {
+        return true;
+    }
+    constructor() {
+        const t = (key, params) => {
+            const p = this.prefix();
+            return this.svc.t(p ? p + '.' + key : key, params);
+        };
+        this.vcr.createEmbeddedView(this.tpl, { $implicit: t, t, lang: this.svc.lang });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.4", ngImport: i0, type: TrDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.4", type: TrDirective, isStandalone: true, selector: "[tr],[translate]", inputs: { trPrefix: "trPrefix" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.4", ngImport: i0, type: TrDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[tr],[translate]' }]
+        }], ctorParameters: () => [], propDecorators: { trPrefix: [{
+                type: Input,
+                args: ['trPrefix']
+            }] } });
+/**
+ * Attribute directive.
+ *   <span trKey="orders.title"></span>
+ *   <input trKey="form.name" trAttr="placeholder" />
+ *   <p trKey="hello" [trParams]="{ name: user.name }"></p>
+ */
+class TrKeyDirective {
+    // @Input setters feeding signals: works with JIT, AOT and every supported Angular version.
+    key = signal(undefined, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "key" }] : /* istanbul ignore next */ []));
+    params = signal(undefined, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "params" }] : /* istanbul ignore next */ []));
+    attr = signal(undefined, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "attr" }] : /* istanbul ignore next */ []));
+    prefix = signal(undefined, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "prefix" }] : /* istanbul ignore next */ []));
+    set trKey(v) { this.key.set(v); }
+    set trParams(v) { this.params.set(v); }
+    set trAttr(v) { this.attr.set(v); }
+    set trPrefix(v) { this.prefix.set(v); }
+    constructor() {
+        const svc = inject(I18nService);
+        const el = inject(ElementRef).nativeElement;
+        const r = inject(Renderer2);
+        effect(() => {
+            const k = this.key();
+            if (!k)
+                return;
+            const p = this.prefix();
+            const text = svc.t(p ? p + '.' + k : k, this.params());
+            const a = this.attr();
+            if (a)
+                r.setAttribute(el, a, text);
+            else if (el.textContent !== text)
+                el.textContent = text;
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.4", ngImport: i0, type: TrKeyDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.4", type: TrKeyDirective, isStandalone: true, selector: "[trKey]", inputs: { trKey: "trKey", trParams: "trParams", trAttr: "trAttr", trPrefix: "trPrefix" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.4", ngImport: i0, type: TrKeyDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[trKey]' }]
+        }], ctorParameters: () => [], propDecorators: { trKey: [{
+                type: Input,
+                args: ['trKey']
+            }], trParams: [{
+                type: Input,
+                args: ['trParams']
+            }], trAttr: [{
+                type: Input,
+                args: ['trAttr']
+            }], trPrefix: [{
+                type: Input,
+                args: ['trPrefix']
+            }] } });
+
+/**
+ * Default loader: GET `{baseUrl}/{lang}{ext}` and `{baseUrl}/{scope}/{lang}{ext}`.
+ * Goes through your HttpClient interceptors.
+ * Config is read on every request, so values supplied later via `I18nService.init()` /
+ * `configure()` (for example `baseUrl`) are picked up.
+ */
+class HttpI18nLoader {
+    http = inject(HttpClient);
+    cfg = inject(I18N_CONFIG);
+    load(lang, scope) {
+        const { url, baseUrl, fileExtension } = this.cfg;
+        const u = url
+            ? url(lang, scope)
+            : buildI18nUrl(baseUrl ?? '/i18n', scope, lang, fileExtension ?? I18N_DEFAULTS.fileExtension);
+        return this.http.get(u);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.4", ngImport: i0, type: HttpI18nLoader, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.4", ngImport: i0, type: HttpI18nLoader, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.4", ngImport: i0, type: HttpI18nLoader, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/**
+ * Static configuration (everything known at build time):
+ * ```ts
+ * provideHttpClient(),
+ * provideI18n({ langs: ['fa', 'en'], defaultLang: 'fa', fallbackLangs: ['en'] })
+ * ```
+ * The global dictionary of the initial language is then loaded before the app starts.
+ *
+ * Deferred configuration (languages come from your backend): omit `langs`/`defaultLang`
+ * and call `await inject(I18nService).init({ langs, defaultLang, baseUrl, lang })`
+ * from your own APP_INITIALIZER once you know them:
+ * ```ts
+ * provideI18n({ fallbackLangs: ['fa'] }),              // no automatic initializer
+ * provideAppInitializer(() => AppInitializer()),       // calls i18n.init(...)
+ * ```
+ * Pass `autoInit: false` to force this mode even when `langs` is given.
+ */
+function provideI18n(config = {}) {
+    const autoInit = config.autoInit ?? (!!config.langs?.length && !!config.defaultLang);
+    return makeEnvironmentProviders([
+        // a fresh, mutable object per injector (the service updates it through configure())
+        { provide: I18N_CONFIG, useFactory: () => assignDefined({ ...I18N_DEFAULTS }, config) },
+        ...(config.loader ? [config.loader] : []),
+        { provide: I18N_LOADER, useFactory: () => inject(config.loader ?? HttpI18nLoader) },
+        ...(autoInit
+            ? [
+                provideAppInitializer(() => {
+                    const svc = inject(I18nService);
+                    return svc.use(svc.detectInitialLang());
+                }),
+            ]
+            : []),
+    ]);
+}
+
+/**
+ * Put in `route.providers`. Runs when the route injector is created (before guards),
+ * so loading starts as early as possible. Child routes need nothing.
+ */
+function provideI18nScope(scope) {
+    const scopes = Array.isArray(scope) ? scope : [scope];
+    return makeEnvironmentProviders([
+        provideEnvironmentInitializer(() => {
+            const svc = inject(I18nService);
+            for (const s of scopes)
+                svc.registerScope(s);
+        }),
+    ]);
+}
+/** Put ONCE on the root path-less route: `canActivateChild: [i18nReadyGuard]`. Waits for every registered scope. */
+const i18nReadyGuard = async () => {
+    await inject(I18nService).whenReady();
+    return true;
+};
+
+/** `readonly title = translateSignal('orders.title')`  (injection context) */
+function translateSignal(key, params) {
+    assertInInjectionContext(translateSignal);
+    return inject(I18nService).select(key, params);
+}
+/** `const t = injectT();  computed(() => t('a.b'))` — reactive translate function. */
+function injectT() {
+    assertInInjectionContext(injectT);
+    const svc = inject(I18nService);
+    return (key, params) => svc.t(key, params);
+}
+
+/** `imports: [TR]` brings the pipe and both directives into a standalone component. */
+const TR = [TrPipe, TrDirective, TrKeyDirective];
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { HttpI18nLoader, I18N_CONFIG, I18N_DEFAULTS, I18N_LOADER, I18nService, TR, TrDirective, TrKeyDirective, TrPipe, buildI18nUrl, flatten, i18nReadyGuard, injectT, interpolate, marker, provideI18n, provideI18nScope, translateSignal };
+//# sourceMappingURL=ngx-kit-lazy-i18n.mjs.map