ngx-atomic-i18n 0.1.0

package/esm2022/lib/translation-core.service.mjs

@@ -0,0 +1,312 @@
+import { computed, inject, Injectable, signal } from '@angular/core';
+import { deepMerge, detectPreferredLang, filterNewKeysDeep, getNested, normalizeLangCode, parseICU, toObservable } from './translate.util';
+import { FIFOCache } from './FIFO.model';
+import { ICU_FORMATTER_TOKEN, TRANSLATION_CONFIG, TRANSLATION_LOADER } from './translate.token';
+import * as i0 from "@angular/core";
+/** 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.
+ */
+export 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'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"translation-core.service.js","sourceRoot":"","sources":["../../../../projects/ngx-atomic-i18n/src/lib/translation-core.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { computed, inject, Injectable, Signal, signal } from '@angular/core';\nimport { deepMerge, detectPreferredLang, filterNewKeysDeep, getNested, normalizeLangCode, parseICU, toObservable } from './translate.util';\n\nimport { FIFOCache } from './FIFO.model';\nimport { ICU_FORMATTER_TOKEN, TRANSLATION_CONFIG, TRANSLATION_LOADER } from './translate.token';\nimport { FormatResult, nsKey, Translations } from './translate.type';\n\n/** Maximum compiled formatter entries retained before evicting older ones. */\nconst MAX_CACHE_SIZE = 30;\n@Injectable({\n  providedIn: 'root'\n})\n/**\n * Central cache and orchestration layer for loading translation namespaces,\n * compiling ICU messages, and serving formatted strings to the higher-level API.\n */\nexport class TranslationCoreService {\n  /** Immutable runtime configuration injected from the library bootstrap. */\n  private readonly _config = inject(TRANSLATION_CONFIG);\n  /** Active loader used to fetch namespace JSON payloads. */\n  private readonly _loader = inject(TRANSLATION_LOADER);\n  /** Optional custom ICU formatter constructor supplied by the host application. */\n  private readonly _ICU = inject(ICU_FORMATTER_TOKEN, { optional: true }) as unknown as (new (raw: string, lang: string) => FormatResult) | null\n  private readonly debugEnabled = !!this._config.debug;\n\n  /** Reactive language state tracking the current locale. */\n  private readonly _lang = signal(detectPreferredLang(this._config));\n  readonly lang = this._lang.asReadonly();\n\n  /** Translation documents keyed by language then namespace. */\n  private readonly _jsonCache = signal(new Map<string, Map<string, Record<string, any>>>()); // lang => namespace => key\n  /** Version fingerprints captured alongside each namespace entry. */\n  private readonly _versionMap = signal(new Map<string, Map<string, string | undefined>>()); // lang => namespace => version\n  /** Least-recently-used cache of compiled ICU formatters. */\n  private readonly _formatterCache = new FIFOCache<nsKey, FormatResult>(MAX_CACHE_SIZE);\n  private _missingKeyCache = new Set<nsKey>();\n  private _inflight = new Map<string, Promise<void>>();\n  /** Caches compiled ICU expressions (with or without custom formatters). */\n  private readonly _icuCompiledCache = new Map<string, FormatResult>();\n\n  readonly onLangChange = toObservable(this._lang);\n  readonly fallbackLang = this._config.fallbackLang ?? 'en';\n\n  get currentLang(): string {\n    return this._lang.asReadonly()();\n  }\n\n  readySignal(namespace: string, version?: string): Signal<boolean> {\n    return computed(() => this.hasJsonCacheValue(this.lang(), namespace, version));\n  }\n\n  setLang(lang?: string): void {\n    const attempted = lang ?? detectPreferredLang(this._config);\n    const currentLang = normalizeLangCode(attempted, this._config.supportedLangs);\n\n    if (!currentLang) {\n      this.warn(`Unsupported language requested: ${attempted}`);\n      return;\n    }\n    if (this._lang() !== currentLang) {\n      this._lang.set(currentLang);\n      this.log(`Switched active language to \"${currentLang}\".`);\n      this._icuCompiledCache.clear();\n      const isBroswer = typeof window !== 'undefined';\n      if (isBroswer) {\n        try {\n          localStorage.setItem('lang', this._lang());\n        } catch (err) {\n          this.warn('Failed to persist language to localStorage.', err);\n        }\n      }\n    }\n  }\n\n  async load(nsKey: string, fetchFn: () => Promise<Translations>): Promise<void> {\n    const parts = nsKey.split(':');\n    const lang = parts[0];\n    const namespace = parts[1];\n    const version = parts[2];\n    if (this.hasJsonCacheValue(lang, namespace, version)) {\n      this.log(`Namespace \"${namespace}\" for \"${lang}\" is already cached. Skip loader.`);\n      return;\n    }\n\n    // coalesce concurrent loads for the same nsKey\n    if (this._inflight.has(nsKey)) {\n      this.log(`Namespace \"${namespace}\" for \"${lang}\" is already loading. Reusing in-flight request.`);\n      await this._inflight.get(nsKey);\n      return;\n    }\n\n    this.log(`Loading namespace \"${namespace}\" for \"${lang}\"${version ? ` (version ${version})` : ''}.`);\n    const p = (async () => {\n      try {\n        const json = await fetchFn();\n        this.handleNewTranslations(json, lang, namespace, version);\n        this.log(`Namespace \"${namespace}\" for \"${lang}\" loaded successfully.`);\n      } catch (error) {\n        this.error(`Failed to load namespace \"${namespace}\" for \"${lang}\".`, error);\n        throw error;\n      } finally {\n        this._inflight.delete(nsKey);\n      }\n    })();\n    this._inflight.set(nsKey, p);\n    await p;\n  }\n\n  getAndCreateFormatter(nsKey: string, key: string): FormatResult | undefined {\n    const cacheKey = `${nsKey}:${key}`;\n    if (this._formatterCache.has(cacheKey)) return this._formatterCache.get(cacheKey);\n    const [lang, namespace] = nsKey.split(':');\n    const raw = getNested(this._jsonCache().get(lang)?.get(namespace), key);\n    if (raw === undefined) return;\n    let result: FormatResult;\n    if (this._ICU) {\n      const k = `${raw}|${this.lang()}`;\n      const exist = this._icuCompiledCache.get(k);\n      if (exist) {\n        result = exist;\n      } else {\n        result = new this._ICU(raw, this.lang());\n        this._icuCompiledCache.set(k, result);\n      }\n    } else {\n      const k = raw;\n      const exist = this._icuCompiledCache.get(k);\n      if (exist) {\n        result = exist;\n      } else {\n        result = { format: (p) => parseICU(raw, p) };\n        this._icuCompiledCache.set(k, result);\n      }\n    }\n    this._formatterCache.set(cacheKey, result);\n    return result;\n  }\n\n  findFallbackFormatter(key: string, exclude: string[], version?: string): FormatResult | undefined {\n    const namespaces = Array.isArray(this._config.fallbackNamespace)\n      ? this._config.fallbackNamespace\n      : [this._config.fallbackNamespace ?? '']\n    for (const namespace of namespaces) {\n      const nsKey = version ? `${this.currentLang}:${namespace}:${version}` : `${this.currentLang}:${namespace}`;\n      if (exclude.includes(nsKey)) continue;\n      const missKey = version\n        ? `${this.currentLang}:${namespace}:${version}:${key}`\n        : `${this.currentLang}:${namespace}:${key}`;\n      if (this._missingKeyCache.has(missKey)) continue;\n      const result = this.getAndCreateFormatter(nsKey, key);\n      if (result) return result;\n      this._missingKeyCache.add(missKey);\n    }\n    return undefined;\n  }\n\n  async preloadNamespaces(namespaces: string[], lang: string): Promise<void> {\n    const roots = Array.isArray(this._config.i18nRoots) ? this._config.i18nRoots : [this._config.i18nRoots];\n    const loadList = namespaces.filter(namespace => !this.hasJsonCacheValue(lang, namespace));\n    const jsonArray = await Promise.all(loadList.map(namespace => this._loader.load(roots, namespace, lang)));\n    jsonArray.forEach((json, index) => this.handleNewTranslations(json, lang, loadList[index], undefined))\n  }\n\n  private handleNewTranslations(json: Translations, lang: string, namespace: string, version?: string): void {\n    const map = new Map(this._jsonCache());\n    const langMap = new Map(this._jsonCache().get(lang));\n    langMap.set(namespace, json);\n    map.set(lang, langMap);\n    this._jsonCache.set(map);\n\n    const vMap = new Map(this._versionMap());\n    const vLangMap = new Map(this._versionMap().get(lang));\n    vLangMap.set(namespace, version);\n    vMap.set(lang, vLangMap);\n    this._versionMap.set(vMap);\n\n    // Invalidate formatter cache for this namespace (covers with/without version)\n    const nsKey = `${lang}:${namespace}:`;\n    this._formatterCache.deleteWhere((k) => (k as unknown as string).startsWith(nsKey));\n\n    this._missingKeyCache.clear();\n    if (this.debugEnabled) {\n      const keyCount = json && typeof json === 'object' ? Object.keys(json).length : 0;\n      this.log(`Cached namespace \"${namespace}\" for \"${lang}\" (${keyCount} top-level keys).`);\n    }\n  }\n\n  private hasJsonCacheValue(lang: string, namespace: string, version?: string): boolean {\n    const exists = this._jsonCache().get(lang)?.get(namespace) !== undefined;\n    if (!exists) return false;\n    if (version !== undefined) {\n      const stored = this._versionMap().get(lang)?.get(namespace);\n      return stored === version;\n    }\n    return true;\n  }\n\n  addResourceBundle(lang: string, namespace: string, bundle: Translations, deep = true, overwrite = true) {\n    const map = new Map(this._jsonCache());\n    const oldLangMap = map.get(lang);\n    const langMap = oldLangMap ? new Map(map.get(lang)) : new Map<string, Translations>();\n    const existTranslations = langMap.get(namespace) ?? {};\n    let merged: Translations;\n    if (deep) {\n      merged = overwrite\n        ? deepMerge(existTranslations, bundle)\n        : deepMerge(existTranslations, filterNewKeysDeep(bundle, existTranslations))\n    } else {\n      merged = overwrite\n        ? { ...existTranslations, ...bundle }\n        : { ...bundle }\n      if (!overwrite) {\n        for (const key in existTranslations) {\n          if (!(key in merged)) {\n            merged[key] = existTranslations[key];\n          }\n        }\n      }\n    }\n    langMap.set(namespace, merged);\n    map.set(lang, langMap);\n    this._jsonCache.set(map);\n  }\n\n  addResources(lang: string, namespace: string, obj: Translations, overwrite = true) {\n    this.addResourceBundle(lang, namespace, obj, false, overwrite);\n  }\n\n  addResource(lang: string, namespace: string, key: string, val: string, overwrite = true) {\n    this.addResources(lang, namespace, { [key]: val }, overwrite);\n  }\n\n  getAllBundle(): Map<string, Map<string, Record<string, any>>> {\n    return this._jsonCache()\n  }\n\n  hasResourceBundle(lang: string, namespace: string): boolean {\n    return !!this._jsonCache().get(lang)?.has(namespace);\n  }\n\n  getResourceBundle(lang: string, namespace: string): Translations | undefined {\n    return this._jsonCache().get(lang)?.get(namespace);\n  }\n\n  removeResourceBundle(lang: string, namespace: string): void {\n    const map = new Map(this._jsonCache());\n    const langMap = new Map(map.get(lang));\n    langMap.delete(namespace)\n    map.set(lang, langMap);\n    this._jsonCache.set(map);\n    // Evict all formatter cache entries that belong to this lang:namespace (with or without version)\n    // Keys are in form `${nsKey}:${key}` where nsKey may include version\n    const prefix = `${lang}:${namespace}:`;\n    this._formatterCache.deleteWhere((k) => (k as unknown as string).startsWith(prefix));\n    // also clear missing-key entries for this namespace\n    for (const k of Array.from(this._missingKeyCache)) {\n      if (k.startsWith(prefix)) this._missingKeyCache.delete(k);\n    }\n  }\n\n  /** Clear everything: data, versions, formatters, missing keys, inflight */\n  clearAll(): void {\n    this._jsonCache.set(new Map());\n    this._versionMap.set(new Map());\n    this._formatterCache.clear();\n    this._missingKeyCache.clear();\n    this._inflight.clear();\n    this._icuCompiledCache.clear();\n  }\n\n  /** Clear all resources for a language */\n  clearLang(lang: string): void {\n    const map = new Map(this._jsonCache());\n    map.delete(lang);\n    this._jsonCache.set(map);\n    const vmap = new Map(this._versionMap());\n    vmap.delete(lang);\n    this._versionMap.set(vmap);\n    this._formatterCache.deleteWhere((k) => (k as unknown as string).startsWith(`${lang}:`));\n    for (const k of Array.from(this._missingKeyCache)) {\n      if (k.startsWith(`${lang}:`)) this._missingKeyCache.delete(k);\n    }\n    for (const k of Array.from(this._icuCompiledCache.keys())) {\n      if (k.endsWith(`|${lang}`)) this._icuCompiledCache.delete(k);\n    }\n  }\n\n  /** Clear a specific namespace for a language */\n  clearNamespace(lang: string, namespace: string): void {\n    this.removeResourceBundle(lang, namespace);\n  }\n\n  getResource(lang: string, namespace: string, key: string): string | undefined {\n    return getNested(this._jsonCache().get(lang)?.get(namespace), key);\n  }\n\n  private log(message: string, ...details: unknown[]): void {\n    if (!this.debugEnabled) return;\n    if (details.length) {\n      console.info(`[ngx-atomic-i18n] ${message}`, ...details);\n    } else {\n      console.info(`[ngx-atomic-i18n] ${message}`);\n    }\n  }\n\n  private error(message: string, error: unknown): void {\n    if (!this.debugEnabled) return;\n    console.error(`[ngx-atomic-i18n] ${message}`, error);\n  }\n\n  private warn(message: string, ...details: unknown[]): void {\n    if (!this.debugEnabled) return;\n    if (details.length) {\n      console.warn(`[ngx-atomic-i18n] ${message}`, ...details);\n    } else {\n      console.warn(`[ngx-atomic-i18n] ${message}`);\n    }\n  }\n}\n"]}

package/esm2022/lib/translation.directive.mjs

@@ -0,0 +1,35 @@
+import { Directive, effect, ElementRef, inject, input } from '@angular/core';
+import { TranslationService } from './translation.service';
+import * as i0 from "@angular/core";
+/** Binds translation keys to an element, updating text or attributes reactively. */
+export 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: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/translation.loader.csr.mjs

@@ -0,0 +1,44 @@
+import { defaultConfig } from './translate.provider';
+import { TempToken } from "./translate.type";
+import { firstValueFrom } from "rxjs";
+import { detectBuildVersion, tempToArray } from "./translate.util";
+export 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`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/translation.loader.ssr.mjs

@@ -0,0 +1,89 @@
+import { defaultConfig } from './translate.provider';
+import { TempToken as t, } from './translate.type';
+import { stripLeadingSep, tempToArray } from './translate.util';
+/** File-system backed loader used during SSR to read translation JSON from disk. */
+export 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(t.Root, root).replace(t.Lang, lang).replace(t.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);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"translation.loader.ssr.js","sourceRoot":"","sources":["../../../../projects/ngx-atomic-i18n/src/lib/translation.loader.ssr.ts"],"names":[],"mappings":"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","sourcesContent":["import { defaultConfig } from './translate.provider';\nimport {\n  FsModuleLike,\n  TempToken as t,\n  type CacheEntry,\n  type FsLoaderOptions,\n  type TranslationLoader,\n  type Translations,\n} from './translate.type';\nimport { stripLeadingSep, tempToArray } from './translate.util';\n\n/** File-system backed loader used during SSR to read translation JSON from disk. */\nexport class FsTranslationLoader implements TranslationLoader {\n  private cache = new Map<string, CacheEntry>();\n\n  /**\n   * @param customFs  Optional fs-like abstraction injected explicitly (tests or adapters).\n   */\n  constructor(private fsOptions: FsLoaderOptions = {}, private pathTemplates: string[] | string, private customFs?: FsModuleLike) { }\n\n  async load(i18nRoots: string[] | string, namespace: string, lang: string): Promise<Translations> {\n    const roots = (Array.isArray(i18nRoots) ? i18nRoots : [i18nRoots]).map(stripLeadingSep);\n\n    const pathMod = await this.importSafely('node:path');\n    const fsImported = await this.importSafely('node:fs');\n    const fsLike: FsModuleLike | undefined =\n      this.pickFs(this.customFs) ?? this.pickFs(this.fsOptions.fsModule) ?? this.pickFs(fsImported);\n\n    const nodeProcess = (globalThis as any).process as { cwd?: () => string } | undefined;\n    const baseDir = this.fsOptions.baseDir ?? (nodeProcess?.cwd?.() ?? '/');\n    const assetPathRaw = this.fsOptions.assetPath ?? 'dist/browser/assets';\n    const assetPath = stripLeadingSep(assetPathRaw);\n\n    const templates =\n      tempToArray(this.pathTemplates) ??\n      tempToArray(defaultConfig.pathTemplates) as string[];\n\n    for (const root of roots) {\n      const candidatePaths =\n        this.fsOptions.resolvePaths?.({\n          baseDir,\n          assetPath,\n          root,\n          lang,\n          namespace,\n        }) ??\n        templates.map((temp) =>\n          this.safeJoin(\n            pathMod,\n            baseDir,\n            assetPath,\n            temp.replace(t.Root, root).replace(t.Lang, lang).replace(t.Namespace, namespace),\n          ),\n        );\n\n      for (const absolutePath of candidatePaths) {\n        try {\n          if (!fsLike?.statSync || !fsLike?.readFileSync) continue;\n\n          const stat = fsLike.statSync(absolutePath);\n          const mtimeMs =\n            typeof stat.mtimeMs === 'number'\n              ? stat.mtimeMs\n              : stat.mtime?.getTime?.() ?? 0;\n          const size = typeof stat.size === 'number' ? stat.size : 0;\n          const sign = (mtimeMs | 0) * 1000003 + (size | 0);\n\n          const cached = this.cache.get(absolutePath);\n          if (cached && cached.mtimeMs === sign) {\n            return cached.data;\n          }\n\n          const raw = fsLike.readFileSync(absolutePath, 'utf8');\n          const json = JSON.parse(raw) as Translations;\n\n          this.cache.set(absolutePath, { mtimeMs: sign, data: json });\n          return json;\n        } catch {\n          // Continue probing other candidate files until a match is found.\n        }\n      }\n    }\n\n    throw new Error(`[SSR i18n] ${namespace}.json for ${lang} not found in any i18nRoot`);\n  }\n\n  /** Attempts to import a Node built-in without throwing when unavailable (e.g. CSR). */\n  private async importSafely(specifier: string): Promise<any | undefined> {\n    const nodeProcess = (globalThis as any).process as { versions?: { node?: string } } | undefined;\n    const isNode = !!nodeProcess?.versions?.node;\n    if (!isNode) return undefined;\n    try {\n      const importer = new Function('s', 'return import(s)');\n      return await importer(specifier);\n    } catch {\n      return undefined;\n    }\n  }\n\n  private pickFs(x: any): FsModuleLike | undefined {\n    return x && typeof x.readFileSync === 'function' && typeof x.statSync === 'function'\n      ? (x as FsModuleLike)\n      : undefined;\n  }\n\n  private safeJoin(pathMod: any, ...parts: any[]): string {\n    return (pathMod?.join ??\n      pathMod?.default?.join ??\n      ((...parts: any[]) => parts.join('/')))(...parts);\n  }\n}\n"]}