ngx-atomic-i18n 0.1.0

package/fesm2022/ngx-atomic-i18n.mjs

@@ -0,0 +1,1099 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, inject, Injector, runInInjectionContext, effect, signal, computed, Injectable, Inject, Pipe, ElementRef, input, Directive, makeStateKey, isDevMode, PLATFORM_ID, Optional, TransferState, APP_INITIALIZER } from '@angular/core';
+import { Observable, firstValueFrom } from 'rxjs';
+import { HttpClient } from '@angular/common/http';
+import { isPlatformServer } from '@angular/common';
+
+/** Scoped namespace for translating a component tree (string or array). */
+const TRANSLATION_NAMESPACE = new InjectionToken('TRANSLATION_NAMESPACE');
+/** Root configuration describing language support and loader behavior. */
+const TRANSLATION_CONFIG = new InjectionToken('TRANSLATION_CONFIG');
+/** Factory used to retrieve translation JSON for a namespace/language tuple. */
+const TRANSLATION_LOADER = new InjectionToken('TRANSLATION_LOADER');
+/** Optional build fingerprint appended to namespace cache keys. */
+const BUILD_VERSION = new InjectionToken('BUILD_VERSION');
+/** Custom ICU formatter constructor injected by the host app when available. */
+const ICU_FORMATTER_TOKEN = new InjectionToken('ICU_FORMATTER_TOKEN');
+const PAGE_TRANSLATION_ROOT = new InjectionToken('PAGE_TRANSLATION_ROOT');
+/** Per-request language captured during SSR and replayed on CSR. */
+const CLIENT_REQUEST_LANG = new InjectionToken('CLIENT_REQUEST_LANG');
+
+/** Normalizes a language code against the configured supported languages. */
+function normalizeLangCode(lang, supportedLangs) {
+    if (!lang)
+        return null;
+    const variants = new Set();
+    variants.add(lang);
+    variants.add(lang.replace(/_/g, '-'));
+    variants.add(lang.replace(/-/g, '_'));
+    variants.add(lang.toLowerCase());
+    variants.add(lang.replace(/_/g, '-').toLowerCase());
+    for (const candidate of variants) {
+        const match = supportedLangs.find(supported => supported.toLowerCase() === candidate.toLowerCase());
+        if (match)
+            return match;
+    }
+    return null;
+}
+/** Determines the most appropriate language using the configured detection order. */
+function detectPreferredLang(config) {
+    const { supportedLangs, fallbackLang, langDetectionOrder } = config;
+    for (const source of langDetectionOrder) {
+        let lang;
+        switch (source) {
+            case 'url':
+                lang = typeof window !== 'undefined' ? window.location.pathname.split('/')[1] : null;
+                break;
+            case 'clientRequest':
+                lang = config.clientRequestLang ?? null;
+                break;
+            case 'localStorage':
+                lang = typeof window !== 'undefined' ? localStorage.getItem('lang') : null;
+                break;
+            case 'browser':
+                const langTag = globalThis?.navigator?.language ?? '';
+                lang = supportedLangs.find(s => langTag.startsWith(s)) ?? null;
+                break;
+            case 'customLang':
+                lang = typeof config.customLang === 'function' ? config.customLang() : config.customLang ?? null;
+                break;
+            case 'fallback':
+                lang = fallbackLang;
+                break;
+        }
+        const normalized = normalizeLangCode(lang, supportedLangs);
+        if (normalized) {
+            return normalized;
+        }
+        ;
+    }
+    return normalizeLangCode(fallbackLang, supportedLangs) ?? fallbackLang;
+}
+/** Lightweight ICU parser that supports nested select/plural structures. */
+function parseICU(templateText, params) {
+    if (typeof params === 'object' ? !Object.keys(params).length : true)
+        return templateText;
+    const paramMap = {};
+    for (const [key, val] of Object.entries(params)) {
+        paramMap[key] = String(val);
+    }
+    function extractBlock(text, startIndex) {
+        let depth = 0;
+        let i = startIndex;
+        while (i < text.length) {
+            if (text[i] === '{') {
+                if (depth === 0)
+                    startIndex = i;
+                depth++;
+            }
+            else if (text[i] === '}') {
+                depth--;
+                if (depth === 0)
+                    return [text.slice(startIndex, i + 1), i + 1];
+            }
+            i++;
+        }
+        return [text.slice(startIndex), text.length];
+    }
+    function extractOptions(body) {
+        const options = {};
+        let i = 0;
+        while (i < body.length) {
+            while (body[i] === ' ')
+                i++;
+            let key = '';
+            while (i < body.length && body[i] !== '{' && body[i] !== ' ') {
+                key += body[i++];
+            }
+            while (i < body.length && body[i] === ' ')
+                i++;
+            if (body[i] !== '{') {
+                // Option must have a nested block; otherwise skip it.
+                i++;
+                continue;
+            }
+            const [block, next] = extractBlock(body, i);
+            options[key] = block.slice(1, -1);
+            i = next;
+        }
+        return options;
+    }
+    function resolveICU(text) {
+        text = text.replace(/\{\{(\w+)\}\}/g, (_, key) => paramMap[key] ?? '');
+        let result = '';
+        let cursor = 0;
+        while (cursor < text.length) {
+            const start = text.indexOf('{', cursor);
+            if (start === -1) {
+                result += text.slice(cursor);
+                break;
+            }
+            result += text.slice(cursor, start);
+            const [block, nextIndex] = extractBlock(text, start);
+            if (!block || block === '' || block === '{}') {
+                cursor = nextIndex;
+                continue;
+            }
+            const match = block.match(/^\{(\w+),\s*(plural|select),/);
+            if (!match) {
+                result += block;
+                cursor = nextIndex;
+                continue;
+            }
+            const [, varName, type] = match;
+            const rawVal = paramMap[varName] ?? '';
+            const numVal = Number(rawVal);
+            const body = block.slice(match[0].length, -1);
+            const options = extractOptions(body);
+            const selected = options[`=${rawVal}`] ||
+                (type === 'plural' && numVal === 1 && options['one']) ||
+                options[rawVal] ||
+                options['other'] ||
+                '';
+            if (!selected) {
+                result += block;
+                cursor = nextIndex;
+                continue;
+            }
+            let resolved = resolveICU(selected);
+            if (type === 'plural') {
+                resolved = resolved.replace(/#/g, rawVal);
+            }
+            resolved = resolved.replace(/{{(\w+)}}|\{(\w+)\}/g, (_, k1, k2) => {
+                const k = k1 || k2;
+                return paramMap[k] ?? '';
+            });
+            result += resolved;
+            cursor = nextIndex;
+        }
+        return result;
+    }
+    return resolveICU(templateText);
+}
+/** Flattens a nested translation object using dot notation keys. */
+function flattenTranslations(obj, prefix = '') {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        const newKey = prefix ? `${prefix}.${key}` : key;
+        if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            Object.assign(result, flattenTranslations(value, newKey));
+        }
+        else {
+            result[newKey] = String(value);
+        }
+    }
+    return result;
+}
+/** Converts a signal to an observable while preserving injection context. */
+function toObservable(signal) {
+    const injector = inject(Injector);
+    return new Observable(subscribe => {
+        subscribe.next(signal());
+        const stop = runInInjectionContext(injector, () => effect(() => subscribe.next(signal()), { allowSignalWrites: true }));
+        return () => stop.destroy();
+    });
+}
+/** Deeply merges plain objects, replacing non-object values by assignment. */
+function deepMerge(target, source) {
+    const output = { ...target };
+    for (const key in source) {
+        const targetValue = target[key];
+        if (source.hasOwnProperty(key) &&
+            typeof source[key] === 'object' &&
+            source[key] !== null &&
+            !Array.isArray(source[key]) &&
+            typeof targetValue === 'object' &&
+            targetValue !== null &&
+            !Array.isArray(targetValue)) {
+            output[key] = deepMerge(targetValue, source[key]);
+        }
+        else {
+            output[key] = source[key];
+        }
+    }
+    return output;
+}
+/** Recursively retains only keys that are not already present in the existing object. */
+function filterNewKeysDeep(bundle, existing) {
+    const result = {};
+    for (const key in bundle) {
+        const existValue = existing[key];
+        if (typeof bundle[key] === 'object' &&
+            bundle[key] !== null &&
+            !Array.isArray(bundle[key]) &&
+            typeof existValue === 'object' &&
+            existValue !== null &&
+            !Array.isArray(existValue)) {
+            result[key] = filterNewKeysDeep(bundle[key], existValue);
+        }
+        else if (!(key in existing)) {
+            result[key] = bundle[key];
+        }
+    }
+    return result;
+}
+/** Safely reads a dotted path from a nested object. */
+function getNested(obj, path) {
+    return path.split('.').reduce((res, key) => res?.[key], obj);
+}
+/** Removes any leading slashes from path-like strings. */
+const stripLeadingSep = (s) => s.replace(/^[\\/]+/, '');
+/** Normalises the path template configuration to an array form. */
+const tempToArray = (template) => Array.isArray(template) ? template : (template ? [template] : undefined);
+/**
+ * Detect current build version from injected script names (CSR only).
+ * Matches filenames like: main.<hash>.js, runtime.<hash>.js, polyfills.<hash>.js
+ */
+function detectBuildVersion() {
+    try {
+        if (typeof document === 'undefined' || !document?.scripts)
+            return null;
+        const regex = /\/(?:main|runtime|polyfills)\.([a-f0-9]{8,})\.[^\/]*\.js(?:\?|$)/i;
+        for (const s of Array.from(document.scripts)) {
+            const version = regex.exec(s.src);
+            if (version?.[1])
+                return version[1];
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+
+/** Combined FIFO/LRU cache used to store compiled formatters. */
+class FIFOCache {
+    max;
+    map = new Map();
+    get size() {
+        return this.map.size;
+    }
+    constructor(max) {
+        this.max = max;
+    }
+    set(key, value) {
+        if (this.map.has(key)) {
+            this.map.delete(key);
+        }
+        this.map.set(key, value);
+        if (this.map.size > this.max) {
+            const first = this.map.keys().next().value;
+            if (first) {
+                this.map.delete(first);
+            }
+        }
+    }
+    get(key) {
+        const val = this.map.get(key);
+        // Refresh recency on hit so frequently used entries stay resident.
+        if (val !== undefined) {
+            this.map.delete(key);
+            this.map.set(key, val);
+        }
+        return val;
+    }
+    has(key) {
+        return this.map.has(key);
+    }
+    delete(k) {
+        this.map.delete(k);
+    }
+    clear() {
+        this.map.clear();
+    }
+    /** Utility helper for controlled external iteration/manipulation. */
+    keys() {
+        return this.map.keys();
+    }
+    /** Iterates cached values without exposing the backing Map. */
+    forEach(cb) {
+        this.map.forEach((v, k) => cb(v, k));
+    }
+    /**
+     * Delete all entries that match the predicate.
+     * Returns the number of deleted entries.
+     */
+    deleteWhere(predicate) {
+        let count = 0;
+        for (const [k, v] of this.map) {
+            if (predicate(k, v)) {
+                this.map.delete(k);
+                count++;
+            }
+        }
+        return count;
+    }
+}
+
+/** Maximum compiled formatter entries retained before evicting older ones. */
+const MAX_CACHE_SIZE = 30;
+/**
+ * Central cache and orchestration layer for loading translation namespaces,
+ * compiling ICU messages, and serving formatted strings to the higher-level API.
+ */
+class TranslationCoreService {
+    /** Immutable runtime configuration injected from the library bootstrap. */
+    _config = inject(TRANSLATION_CONFIG);
+    /** Active loader used to fetch namespace JSON payloads. */
+    _loader = inject(TRANSLATION_LOADER);
+    /** Optional custom ICU formatter constructor supplied by the host application. */
+    _ICU = inject(ICU_FORMATTER_TOKEN, { optional: true });
+    debugEnabled = !!this._config.debug;
+    /** Reactive language state tracking the current locale. */
+    _lang = signal(detectPreferredLang(this._config));
+    lang = this._lang.asReadonly();
+    /** Translation documents keyed by language then namespace. */
+    _jsonCache = signal(new Map()); // lang => namespace => key
+    /** Version fingerprints captured alongside each namespace entry. */
+    _versionMap = signal(new Map()); // lang => namespace => version
+    /** Least-recently-used cache of compiled ICU formatters. */
+    _formatterCache = new FIFOCache(MAX_CACHE_SIZE);
+    _missingKeyCache = new Set();
+    _inflight = new Map();
+    /** Caches compiled ICU expressions (with or without custom formatters). */
+    _icuCompiledCache = new Map();
+    onLangChange = toObservable(this._lang);
+    fallbackLang = this._config.fallbackLang ?? 'en';
+    get currentLang() {
+        return this._lang.asReadonly()();
+    }
+    readySignal(namespace, version) {
+        return computed(() => this.hasJsonCacheValue(this.lang(), namespace, version));
+    }
+    setLang(lang) {
+        const attempted = lang ?? detectPreferredLang(this._config);
+        const currentLang = normalizeLangCode(attempted, this._config.supportedLangs);
+        if (!currentLang) {
+            this.warn(`Unsupported language requested: ${attempted}`);
+            return;
+        }
+        if (this._lang() !== currentLang) {
+            this._lang.set(currentLang);
+            this.log(`Switched active language to "${currentLang}".`);
+            this._icuCompiledCache.clear();
+            const isBroswer = typeof window !== 'undefined';
+            if (isBroswer) {
+                try {
+                    localStorage.setItem('lang', this._lang());
+                }
+                catch (err) {
+                    this.warn('Failed to persist language to localStorage.', err);
+                }
+            }
+        }
+    }
+    async load(nsKey, fetchFn) {
+        const parts = nsKey.split(':');
+        const lang = parts[0];
+        const namespace = parts[1];
+        const version = parts[2];
+        if (this.hasJsonCacheValue(lang, namespace, version)) {
+            this.log(`Namespace "${namespace}" for "${lang}" is already cached. Skip loader.`);
+            return;
+        }
+        // coalesce concurrent loads for the same nsKey
+        if (this._inflight.has(nsKey)) {
+            this.log(`Namespace "${namespace}" for "${lang}" is already loading. Reusing in-flight request.`);
+            await this._inflight.get(nsKey);
+            return;
+        }
+        this.log(`Loading namespace "${namespace}" for "${lang}"${version ? ` (version ${version})` : ''}.`);
+        const p = (async () => {
+            try {
+                const json = await fetchFn();
+                this.handleNewTranslations(json, lang, namespace, version);
+                this.log(`Namespace "${namespace}" for "${lang}" loaded successfully.`);
+            }
+            catch (error) {
+                this.error(`Failed to load namespace "${namespace}" for "${lang}".`, error);
+                throw error;
+            }
+            finally {
+                this._inflight.delete(nsKey);
+            }
+        })();
+        this._inflight.set(nsKey, p);
+        await p;
+    }
+    getAndCreateFormatter(nsKey, key) {
+        const cacheKey = `${nsKey}:${key}`;
+        if (this._formatterCache.has(cacheKey))
+            return this._formatterCache.get(cacheKey);
+        const [lang, namespace] = nsKey.split(':');
+        const raw = getNested(this._jsonCache().get(lang)?.get(namespace), key);
+        if (raw === undefined)
+            return;
+        let result;
+        if (this._ICU) {
+            const k = `${raw}|${this.lang()}`;
+            const exist = this._icuCompiledCache.get(k);
+            if (exist) {
+                result = exist;
+            }
+            else {
+                result = new this._ICU(raw, this.lang());
+                this._icuCompiledCache.set(k, result);
+            }
+        }
+        else {
+            const k = raw;
+            const exist = this._icuCompiledCache.get(k);
+            if (exist) {
+                result = exist;
+            }
+            else {
+                result = { format: (p) => parseICU(raw, p) };
+                this._icuCompiledCache.set(k, result);
+            }
+        }
+        this._formatterCache.set(cacheKey, result);
+        return result;
+    }
+    findFallbackFormatter(key, exclude, version) {
+        const namespaces = Array.isArray(this._config.fallbackNamespace)
+            ? this._config.fallbackNamespace
+            : [this._config.fallbackNamespace ?? ''];
+        for (const namespace of namespaces) {
+            const nsKey = version ? `${this.currentLang}:${namespace}:${version}` : `${this.currentLang}:${namespace}`;
+            if (exclude.includes(nsKey))
+                continue;
+            const missKey = version
+                ? `${this.currentLang}:${namespace}:${version}:${key}`
+                : `${this.currentLang}:${namespace}:${key}`;
+            if (this._missingKeyCache.has(missKey))
+                continue;
+            const result = this.getAndCreateFormatter(nsKey, key);
+            if (result)
+                return result;
+            this._missingKeyCache.add(missKey);
+        }
+        return undefined;
+    }
+    async preloadNamespaces(namespaces, lang) {
+        const roots = Array.isArray(this._config.i18nRoots) ? this._config.i18nRoots : [this._config.i18nRoots];
+        const loadList = namespaces.filter(namespace => !this.hasJsonCacheValue(lang, namespace));
+        const jsonArray = await Promise.all(loadList.map(namespace => this._loader.load(roots, namespace, lang)));
+        jsonArray.forEach((json, index) => this.handleNewTranslations(json, lang, loadList[index], undefined));
+    }
+    handleNewTranslations(json, lang, namespace, version) {
+        const map = new Map(this._jsonCache());
+        const langMap = new Map(this._jsonCache().get(lang));
+        langMap.set(namespace, json);
+        map.set(lang, langMap);
+        this._jsonCache.set(map);
+        const vMap = new Map(this._versionMap());
+        const vLangMap = new Map(this._versionMap().get(lang));
+        vLangMap.set(namespace, version);
+        vMap.set(lang, vLangMap);
+        this._versionMap.set(vMap);
+        // Invalidate formatter cache for this namespace (covers with/without version)
+        const nsKey = `${lang}:${namespace}:`;
+        this._formatterCache.deleteWhere((k) => k.startsWith(nsKey));
+        this._missingKeyCache.clear();
+        if (this.debugEnabled) {
+            const keyCount = json && typeof json === 'object' ? Object.keys(json).length : 0;
+            this.log(`Cached namespace "${namespace}" for "${lang}" (${keyCount} top-level keys).`);
+        }
+    }
+    hasJsonCacheValue(lang, namespace, version) {
+        const exists = this._jsonCache().get(lang)?.get(namespace) !== undefined;
+        if (!exists)
+            return false;
+        if (version !== undefined) {
+            const stored = this._versionMap().get(lang)?.get(namespace);
+            return stored === version;
+        }
+        return true;
+    }
+    addResourceBundle(lang, namespace, bundle, deep = true, overwrite = true) {
+        const map = new Map(this._jsonCache());
+        const oldLangMap = map.get(lang);
+        const langMap = oldLangMap ? new Map(map.get(lang)) : new Map();
+        const existTranslations = langMap.get(namespace) ?? {};
+        let merged;
+        if (deep) {
+            merged = overwrite
+                ? deepMerge(existTranslations, bundle)
+                : deepMerge(existTranslations, filterNewKeysDeep(bundle, existTranslations));
+        }
+        else {
+            merged = overwrite
+                ? { ...existTranslations, ...bundle }
+                : { ...bundle };
+            if (!overwrite) {
+                for (const key in existTranslations) {
+                    if (!(key in merged)) {
+                        merged[key] = existTranslations[key];
+                    }
+                }
+            }
+        }
+        langMap.set(namespace, merged);
+        map.set(lang, langMap);
+        this._jsonCache.set(map);
+    }
+    addResources(lang, namespace, obj, overwrite = true) {
+        this.addResourceBundle(lang, namespace, obj, false, overwrite);
+    }
+    addResource(lang, namespace, key, val, overwrite = true) {
+        this.addResources(lang, namespace, { [key]: val }, overwrite);
+    }
+    getAllBundle() {
+        return this._jsonCache();
+    }
+    hasResourceBundle(lang, namespace) {
+        return !!this._jsonCache().get(lang)?.has(namespace);
+    }
+    getResourceBundle(lang, namespace) {
+        return this._jsonCache().get(lang)?.get(namespace);
+    }
+    removeResourceBundle(lang, namespace) {
+        const map = new Map(this._jsonCache());
+        const langMap = new Map(map.get(lang));
+        langMap.delete(namespace);
+        map.set(lang, langMap);
+        this._jsonCache.set(map);
+        // Evict all formatter cache entries that belong to this lang:namespace (with or without version)
+        // Keys are in form `${nsKey}:${key}` where nsKey may include version
+        const prefix = `${lang}:${namespace}:`;
+        this._formatterCache.deleteWhere((k) => k.startsWith(prefix));
+        // also clear missing-key entries for this namespace
+        for (const k of Array.from(this._missingKeyCache)) {
+            if (k.startsWith(prefix))
+                this._missingKeyCache.delete(k);
+        }
+    }
+    /** Clear everything: data, versions, formatters, missing keys, inflight */
+    clearAll() {
+        this._jsonCache.set(new Map());
+        this._versionMap.set(new Map());
+        this._formatterCache.clear();
+        this._missingKeyCache.clear();
+        this._inflight.clear();
+        this._icuCompiledCache.clear();
+    }
+    /** Clear all resources for a language */
+    clearLang(lang) {
+        const map = new Map(this._jsonCache());
+        map.delete(lang);
+        this._jsonCache.set(map);
+        const vmap = new Map(this._versionMap());
+        vmap.delete(lang);
+        this._versionMap.set(vmap);
+        this._formatterCache.deleteWhere((k) => k.startsWith(`${lang}:`));
+        for (const k of Array.from(this._missingKeyCache)) {
+            if (k.startsWith(`${lang}:`))
+                this._missingKeyCache.delete(k);
+        }
+        for (const k of Array.from(this._icuCompiledCache.keys())) {
+            if (k.endsWith(`|${lang}`))
+                this._icuCompiledCache.delete(k);
+        }
+    }
+    /** Clear a specific namespace for a language */
+    clearNamespace(lang, namespace) {
+        this.removeResourceBundle(lang, namespace);
+    }
+    getResource(lang, namespace, key) {
+        return getNested(this._jsonCache().get(lang)?.get(namespace), key);
+    }
+    log(message, ...details) {
+        if (!this.debugEnabled)
+            return;
+        if (details.length) {
+            console.info(`[ngx-atomic-i18n] ${message}`, ...details);
+        }
+        else {
+            console.info(`[ngx-atomic-i18n] ${message}`);
+        }
+    }
+    error(message, error) {
+        if (!this.debugEnabled)
+            return;
+        console.error(`[ngx-atomic-i18n] ${message}`, error);
+    }
+    warn(message, ...details) {
+        if (!this.debugEnabled)
+            return;
+        if (details.length) {
+            console.warn(`[ngx-atomic-i18n] ${message}`, ...details);
+        }
+        else {
+            console.warn(`[ngx-atomic-i18n] ${message}`);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TranslationCoreService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TranslationCoreService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TranslationCoreService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class TranslationService {
+    namespaceInput;
+    /** Shared translation configuration resolved from the host application. */
+    config = inject(TRANSLATION_CONFIG);
+    parent = inject(TranslationService, { skipSelf: true, optional: true });
+    isPageRoot = inject(PAGE_TRANSLATION_ROOT, { self: true, optional: true }) ?? false;
+    /** Core translation engine that handles lookups and formatter lifecycle. */
+    core = inject(TranslationCoreService);
+    /** Loader implementation responsible for fetching translation payloads. */
+    loader = inject(TRANSLATION_LOADER);
+    /** Optional build fingerprint for cache busting injected at runtime. */
+    injectedVersion = inject(BUILD_VERSION, { optional: true });
+    /** Flag used to guard debug logging output. */
+    debugEnabled = !!this.config.debug;
+    /** Observable mirror of the language signal for consumers outside of signals. */
+    onLangChange = toObservable(this.lang);
+    /** Namespace currently owned by this service instance. */
+    namespace = '';
+    get lang() {
+        return computed(() => this.core.lang());
+    }
+    get currentLang() {
+        return this.core.currentLang;
+    }
+    get supportedLangs() {
+        return this.config.supportedLangs;
+    }
+    /** Build version identifier used to scope namespace caches. */
+    buildVersion = this.injectedVersion ?? detectBuildVersion();
+    /** Composes the unique key used to store namespace resources per lang and build. */
+    get getNskey() {
+        const version = this.buildVersion;
+        return version ? `${this.lang()}:${this.namespace}:${version}` : `${this.lang()}:${this.namespace}`;
+    }
+    /** Signal that flips to true when the namespace resources are available. */
+    get readySignal() {
+        return this.core.readySignal(this.namespace, this.buildVersion ?? undefined);
+    }
+    /** Convenience boolean wrapper around the readiness signal. */
+    get ready() {
+        return this.core.readySignal(this.namespace, this.buildVersion ?? undefined)();
+    }
+    constructor(namespaceInput) {
+        this.namespaceInput = namespaceInput;
+        this.namespace = namespaceInput;
+        effect(() => {
+            const nsKey = this.getNskey;
+            if (!this.ready) {
+                this.info(`Namespace "${this.namespace}" is not ready. Loading for "${this.lang()}" using key "${nsKey}".`);
+                this.core.load(nsKey, () => this.loader.load(this.config.i18nRoots, this.namespace, this.lang()));
+            }
+        });
+    }
+    /** Switches the active language and triggers downstream refresh logic. */
+    setLang(lang) {
+        this.info(`setLang called with "${lang}".`);
+        this.core.setLang(lang);
+    }
+    /**
+     * Resolves the translation for `key`, formatting with the provided params
+     * and falling back to configured behaviors when a translation is missing.
+     */
+    t(key, params = {}) {
+        const nsKey = this.getNskey;
+        const missingResult = this.getMissingTranslation(key);
+        if (!this.ready) {
+            this.warn(`Namespace "${this.namespace}" is not ready.`);
+            return '';
+        }
+        const formatResult = this.core.getAndCreateFormatter(nsKey, key);
+        if (formatResult)
+            return formatResult.format(params);
+        if (this.config.enablePageFallback && !this.isPageRoot && this.parent) {
+            return this.parent.t(key, params);
+        }
+        const fallback = this.core.findFallbackFormatter(key, [], this.buildVersion ?? undefined);
+        if (fallback) {
+            this.info(`Resolved key "${key}" via fallback namespace while rendering "${this.namespace}".`);
+            return fallback.format(params);
+        }
+        this.warn(`Missing translation for key "${key}" in namespace "${this.namespace}". Returning fallback value.`);
+        return missingResult;
+    }
+    /** Determines the fallback string or error when a translation entry is missing. */
+    getMissingTranslation(key) {
+        const forceMode = this.config.missingTranslationBehavior ?? 'show-key';
+        switch (forceMode) {
+            case 'throw-error':
+                throw new Error(`[i18n] Missing translation: ${key} in ${this.namespace}`);
+            case 'empty':
+                this.warn(`Missing translation returned an empty string for key "${key}" in namespace "${this.namespace}".`);
+                return '';
+            case 'show-key':
+                if (key) {
+                    this.warn(`Showing key "${key}" because no translation was found in namespace "${this.namespace}".`);
+                }
+                return key ?? '';
+            default: return forceMode;
+        }
+    }
+    /** Pass-through helpers that delegate resource management to the core service. */
+    addResourceBundle(...p) {
+        return this.core.addResourceBundle(...p);
+    }
+    addResources(...p) {
+        return this.core.addResources(...p);
+    }
+    addResource(...p) {
+        return this.core.addResource(...p);
+    }
+    hasResourceBundle(...p) {
+        return this.core.hasResourceBundle(...p);
+    }
+    getResource(...p) {
+        return this.core.getResource(...p);
+    }
+    getResourceBundle(...p) {
+        return this.core.getResourceBundle(...p);
+    }
+    getAllBundle() {
+        return this.core.getAllBundle();
+    }
+    removeResourceBundle(...p) {
+        return this.core.removeResourceBundle(...p);
+    }
+    preloadNamespaces(...p) {
+        return this.core.preloadNamespaces(...p);
+    }
+    /** Emits debug info when verbose logging is enabled. */
+    info(message, ...details) {
+        if (!this.debugEnabled)
+            return;
+        if (details.length) {
+            console.info(`[ngx-atomic-i18n] ${message}`, ...details);
+        }
+        else {
+            console.info(`[ngx-atomic-i18n] ${message}`);
+        }
+    }
+    /** Emits debug warnings when verbose logging is enabled. */
+    warn(message, ...details) {
+        if (!this.debugEnabled)
+            return;
+        if (details.length) {
+            console.warn(`[ngx-atomic-i18n] ${message}`, ...details);
+        }
+        else {
+            console.warn(`[ngx-atomic-i18n] ${message}`);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TranslationService, deps: [{ token: TRANSLATION_NAMESPACE }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TranslationService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TranslationService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TRANSLATION_NAMESPACE]
+                }] }] });
+
+/** Template helper that proxies lookups to `TranslationService.t`. */
+class TranslationPipe {
+    service = inject(TranslationService);
+    /** Formats the translation identified by `key` using the optional params. */
+    transform(key, params) {
+        return this.service.t(key, params);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TranslationPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: TranslationPipe, isStandalone: true, name: "t", pure: false });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TranslationPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 't', standalone: true, pure: false }]
+        }] });
+
+/** Binds translation keys to an element, updating text or attributes reactively. */
+class TranslationDirective {
+    selfElm = inject(ElementRef).nativeElement;
+    service = inject(TranslationService);
+    /** Translation key resolved for the host element. */
+    t = input('');
+    /** Optional interpolation parameters passed to the translation formatter. */
+    tParams = input(undefined);
+    /** Attribute name to receive the translated value instead of textContent. */
+    tAttr = input('');
+    constructor() {
+        effect(() => {
+            const value = this.service.t(this.t(), this.tParams());
+            if (this.tAttr()) {
+                this.selfElm.setAttribute(this.tAttr(), value);
+            }
+            else {
+                this.selfElm.textContent = value;
+            }
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TranslationDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.13", type: TranslationDirective, isStandalone: true, selector: "[t]", inputs: { t: { classPropertyName: "t", publicName: "t", isSignal: true, isRequired: false, transformFunction: null }, tParams: { classPropertyName: "tParams", publicName: "tParams", isSignal: true, isRequired: false, transformFunction: null }, tAttr: { classPropertyName: "tAttr", publicName: "tAttr", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TranslationDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[t]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [] });
+
+var TempToken;
+(function (TempToken) {
+    /** Placeholder for the language code inside loader path templates. */
+    TempToken["Lang"] = "{{lang}}";
+    /** Placeholder for the namespace inside loader path templates. */
+    TempToken["Namespace"] = "{{namespace}}";
+    /** Placeholder for the root folder inside loader path templates. */
+    TempToken["Root"] = "{{root}}";
+})(TempToken || (TempToken = {}));
+
+class HttpTranslationLoader {
+    http;
+    option;
+    pathTemplates;
+    pathTemplateCache;
+    constructor(http, option = {}, pathTemplates) {
+        this.http = http;
+        this.option = option;
+        this.pathTemplates = pathTemplates;
+    }
+    async load(i18nRoots, namespace, lang) {
+        const roots = tempToArray(i18nRoots) ?? [];
+        const baseUrl = this.option.baseUrl ?? '/assets';
+        const safeBaseUrl = (/^https?:\/\//i.test(baseUrl)
+            ? baseUrl
+            : (baseUrl.startsWith('/') ? baseUrl : '/' + baseUrl)).replace(/[\\/]+$/, '');
+        const tempArray = tempToArray(this.pathTemplates);
+        const pathTemps = this.pathTemplateCache ? [this.pathTemplateCache, ...(tempArray ?? []).filter(t => t !== this.pathTemplateCache)] : (tempArray ?? defaultConfig.pathTemplates);
+        for (const root of roots) {
+            for (const temp of pathTemps) {
+                let url = `${safeBaseUrl}/${temp.replace(TempToken.Root, root).replace(TempToken.Lang, lang).replace(TempToken.Namespace, namespace)}`;
+                const v = detectBuildVersion();
+                if (v) {
+                    url += (url.includes('?') ? '&' : '?') + `v=${encodeURIComponent(v)}`;
+                }
+                try {
+                    const json = await firstValueFrom(this.http.get(url));
+                    if (!this.pathTemplateCache)
+                        this.pathTemplateCache = temp;
+                    return json;
+                }
+                catch {
+                    /* ignore  */
+                }
+            }
+        }
+        throw new Error(`[i18n] ${namespace}.json for ${lang} not found in any i18nRoot`);
+    }
+}
+
+/** File-system backed loader used during SSR to read translation JSON from disk. */
+class FsTranslationLoader {
+    fsOptions;
+    pathTemplates;
+    customFs;
+    cache = new Map();
+    /**
+     * @param customFs  Optional fs-like abstraction injected explicitly (tests or adapters).
+     */
+    constructor(fsOptions = {}, pathTemplates, customFs) {
+        this.fsOptions = fsOptions;
+        this.pathTemplates = pathTemplates;
+        this.customFs = customFs;
+    }
+    async load(i18nRoots, namespace, lang) {
+        const roots = (Array.isArray(i18nRoots) ? i18nRoots : [i18nRoots]).map(stripLeadingSep);
+        const pathMod = await this.importSafely('node:path');
+        const fsImported = await this.importSafely('node:fs');
+        const fsLike = this.pickFs(this.customFs) ?? this.pickFs(this.fsOptions.fsModule) ?? this.pickFs(fsImported);
+        const nodeProcess = globalThis.process;
+        const baseDir = this.fsOptions.baseDir ?? (nodeProcess?.cwd?.() ?? '/');
+        const assetPathRaw = this.fsOptions.assetPath ?? 'dist/browser/assets';
+        const assetPath = stripLeadingSep(assetPathRaw);
+        const templates = tempToArray(this.pathTemplates) ??
+            tempToArray(defaultConfig.pathTemplates);
+        for (const root of roots) {
+            const candidatePaths = this.fsOptions.resolvePaths?.({
+                baseDir,
+                assetPath,
+                root,
+                lang,
+                namespace,
+            }) ??
+                templates.map((temp) => this.safeJoin(pathMod, baseDir, assetPath, temp.replace(TempToken.Root, root).replace(TempToken.Lang, lang).replace(TempToken.Namespace, namespace)));
+            for (const absolutePath of candidatePaths) {
+                try {
+                    if (!fsLike?.statSync || !fsLike?.readFileSync)
+                        continue;
+                    const stat = fsLike.statSync(absolutePath);
+                    const mtimeMs = typeof stat.mtimeMs === 'number'
+                        ? stat.mtimeMs
+                        : stat.mtime?.getTime?.() ?? 0;
+                    const size = typeof stat.size === 'number' ? stat.size : 0;
+                    const sign = (mtimeMs | 0) * 1000003 + (size | 0);
+                    const cached = this.cache.get(absolutePath);
+                    if (cached && cached.mtimeMs === sign) {
+                        return cached.data;
+                    }
+                    const raw = fsLike.readFileSync(absolutePath, 'utf8');
+                    const json = JSON.parse(raw);
+                    this.cache.set(absolutePath, { mtimeMs: sign, data: json });
+                    return json;
+                }
+                catch {
+                    // Continue probing other candidate files until a match is found.
+                }
+            }
+        }
+        throw new Error(`[SSR i18n] ${namespace}.json for ${lang} not found in any i18nRoot`);
+    }
+    /** Attempts to import a Node built-in without throwing when unavailable (e.g. CSR). */
+    async importSafely(specifier) {
+        const nodeProcess = globalThis.process;
+        const isNode = !!nodeProcess?.versions?.node;
+        if (!isNode)
+            return undefined;
+        try {
+            const importer = new Function('s', 'return import(s)');
+            return await importer(specifier);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    pickFs(x) {
+        return x && typeof x.readFileSync === 'function' && typeof x.statSync === 'function'
+            ? x
+            : undefined;
+    }
+    safeJoin(pathMod, ...parts) {
+        return (pathMod?.join ??
+            pathMod?.default?.join ??
+            ((...parts) => parts.join('/')))(...parts);
+    }
+}
+
+const defaultConfig = {
+    supportedLangs: ['en'],
+    fallbackNamespace: 'common',
+    fallbackLang: '',
+    i18nRoots: ['i18n'],
+    pathTemplates: [`${TempToken.Root}/${TempToken.Namespace}/${TempToken.Lang}.json`],
+    enablePageFallback: false,
+    missingTranslationBehavior: 'show-key',
+    langDetectionOrder: ['url', 'clientRequest', 'localStorage', 'browser', 'customLang', 'fallback'],
+    clientRequestLang: null,
+};
+const CLIENT_REQUEST_LANG_STATE_KEY = makeStateKey('NGX_I18N_CLIENT_REQUEST_LANG');
+function resolveClientRequestLang(platformId, transferState, providedLang) {
+    const stored = transferState?.get(CLIENT_REQUEST_LANG_STATE_KEY, null);
+    if (stored)
+        return stored;
+    const resolved = providedLang ?? null;
+    if (resolved && transferState && isPlatformServer(platformId)) {
+        transferState.set(CLIENT_REQUEST_LANG_STATE_KEY, resolved);
+    }
+    return resolved;
+}
+/** Bootstraps the entire translation infrastructure for an application. */
+function provideTranslationInit(userConfig) {
+    const debugEnabled = userConfig?.debug ?? isDevMode();
+    const baseConfig = { ...defaultConfig, ...(userConfig ?? {}), fallbackLang: defaultConfig.supportedLangs[0], debug: debugEnabled };
+    if (debugEnabled) {
+        console.info('[ngx-atomic-i18n] Debug logging is enabled.');
+    }
+    return [
+        {
+            provide: TRANSLATION_CONFIG,
+            useFactory: (platformId, transferState, clientRequestLang) => {
+                const requestLang = resolveClientRequestLang(platformId, transferState, clientRequestLang ?? baseConfig.clientRequestLang ?? null);
+                const finalConfig = { ...baseConfig, clientRequestLang: requestLang };
+                const preferredLang = detectPreferredLang(finalConfig);
+                return { ...finalConfig, customLang: preferredLang };
+            },
+            deps: [PLATFORM_ID, [new Optional(), TransferState], [new Optional(), CLIENT_REQUEST_LANG]],
+        },
+        {
+            provide: BUILD_VERSION,
+            useValue: userConfig?.buildVersion ?? null,
+        },
+        ...provideTranslationLoader(baseConfig),
+        ...provideTranslation(baseConfig.fallbackNamespace),
+        {
+            provide: APP_INITIALIZER,
+            useFactory: (ts) => {
+                return async () => {
+                    const preload = baseConfig.preloadNamespaces;
+                    if (preload?.length) {
+                        await ts.preloadNamespaces(preload, ts.currentLang);
+                    }
+                    ts.setLang(ts.currentLang);
+                };
+            },
+            deps: [TranslationService],
+            multi: true,
+        },
+    ];
+}
+/** Provides the component-scoped namespace injection for component-registered service.
+ * @param namespace The namespace owned by the component.
+ * @param isPage Whether the component is a top-level page (defaults to false).
+*/
+function provideTranslation(namespace, isPage = false) {
+    return [
+        {
+            provide: TRANSLATION_NAMESPACE,
+            useValue: namespace,
+        },
+        TranslationService,
+        ...(isPage ? [{
+                provide: PAGE_TRANSLATION_ROOT,
+                useValue: true,
+            }] : []),
+    ];
+}
+/** Configures the runtime translation loader for CSR or SSR environments. */
+function provideTranslationLoader(config) {
+    return [
+        {
+            provide: TRANSLATION_LOADER,
+            useFactory: (platformId) => {
+                const options = config.loader ?? {};
+                const finalPathTemplates = config.pathTemplates ?? defaultConfig.pathTemplates;
+                const isSSR = options.forceMode === 'ssr' || (options.forceMode !== 'csr' && isPlatformServer(platformId));
+                if (isSSR) {
+                    const nodeProcess = globalThis.process;
+                    const baseDir = options.fsOptions?.baseDir ??
+                        (typeof nodeProcess?.cwd === 'function' ? nodeProcess.cwd() : '');
+                    const assetPath = options.fsOptions?.assetPath ?? (isDevMode() ? 'src/assets' : 'dist/browser/assets');
+                    return options.ssrLoader?.()
+                        ?? new FsTranslationLoader({
+                            baseDir,
+                            assetPath,
+                            resolvePaths: options.fsOptions?.resolvePaths,
+                            fsModule: options.fsOptions?.fsModule
+                        }, finalPathTemplates);
+                }
+                const http = inject(HttpClient);
+                return options.csrLoader?.(http)
+                    ?? new HttpTranslationLoader(http, {
+                        baseUrl: options.httpOptions?.baseUrl ?? '/assets',
+                    }, finalPathTemplates);
+            },
+            deps: [PLATFORM_ID],
+        }
+    ];
+}
+
+/*
+ * Public API Surface of ngx-atomic-i18n
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { BUILD_VERSION, CLIENT_REQUEST_LANG, FIFOCache, FsTranslationLoader, HttpTranslationLoader, ICU_FORMATTER_TOKEN, PAGE_TRANSLATION_ROOT, TRANSLATION_CONFIG, TRANSLATION_LOADER, TRANSLATION_NAMESPACE, TempToken, TranslationCoreService, TranslationDirective, TranslationPipe, TranslationService, deepMerge, defaultConfig, detectBuildVersion, detectPreferredLang, filterNewKeysDeep, flattenTranslations, getNested, normalizeLangCode, parseICU, provideTranslation, provideTranslationInit, provideTranslationLoader, stripLeadingSep, tempToArray, toObservable };
+//# sourceMappingURL=ngx-atomic-i18n.mjs.map