ngx-atomic-i18n 0.1.0

package/esm2022/lib/translation.service.mjs

@@ -0,0 +1,165 @@
+import { computed, effect, Inject, inject, Injectable } from "@angular/core";
+import { BUILD_VERSION, PAGE_TRANSLATION_ROOT, TRANSLATION_CONFIG, TRANSLATION_LOADER, TRANSLATION_NAMESPACE } from "./translate.token";
+import { detectBuildVersion, toObservable } from "./translate.util";
+import { TranslationCoreService } from "./translation-core.service";
+import * as i0 from "@angular/core";
+export 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]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"translation.service.js","sourceRoot":"","sources":["../../../../projects/ngx-atomic-i18n/src/lib/translation.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { computed, effect, Inject, inject, Injectable, Signal } from \"@angular/core\";\nimport { BUILD_VERSION, PAGE_TRANSLATION_ROOT, TRANSLATION_CONFIG, TRANSLATION_LOADER, TRANSLATION_NAMESPACE } from \"./translate.token\";\nimport { Params } from \"./translate.type\";\nimport { detectBuildVersion, toObservable } from \"./translate.util\";\nimport { TranslationCoreService } from \"./translation-core.service\";\n\n@Injectable()\nexport class TranslationService {\n  /** Shared translation configuration resolved from the host application. */\n  private readonly config = inject(TRANSLATION_CONFIG);\n  private readonly parent = inject(TranslationService, { skipSelf: true, optional: true });\n  private readonly isPageRoot = inject(PAGE_TRANSLATION_ROOT, { self: true, optional: true }) ?? false;\n  /** Core translation engine that handles lookups and formatter lifecycle. */\n  private readonly core = inject(TranslationCoreService);\n  /** Loader implementation responsible for fetching translation payloads. */\n  private readonly loader = inject(TRANSLATION_LOADER);\n  /** Optional build fingerprint for cache busting injected at runtime. */\n  private readonly injectedVersion = inject(BUILD_VERSION, { optional: true }) as string | null | undefined;\n  /** Flag used to guard debug logging output. */\n  private readonly debugEnabled = !!this.config.debug;\n\n  /** Observable mirror of the language signal for consumers outside of signals. */\n  readonly onLangChange = toObservable(this.lang);\n  /** Namespace currently owned by this service instance. */\n  private namespace = '';\n\n  get lang(): Signal<string> {\n    return computed(() => this.core.lang());\n  }\n\n  get currentLang(): string {\n    return this.core.currentLang;\n  }\n  get supportedLangs(): string[] {\n    return this.config.supportedLangs;\n  }\n\n  /** Build version identifier used to scope namespace caches. */\n  private readonly buildVersion: string | null = this.injectedVersion ?? detectBuildVersion();\n\n  /** Composes the unique key used to store namespace resources per lang and build. */\n  get getNskey(): string {\n    const version = this.buildVersion;\n    return version ? `${this.lang()}:${this.namespace}:${version}` : `${this.lang()}:${this.namespace}`;\n  }\n\n  /** Signal that flips to true when the namespace resources are available. */\n  get readySignal(): Signal<boolean> {\n    return this.core.readySignal(this.namespace, this.buildVersion ?? undefined);\n  }\n\n  /** Convenience boolean wrapper around the readiness signal. */\n  get ready(): boolean {\n    return this.core.readySignal(this.namespace, this.buildVersion ?? undefined)();\n  }\n\n  constructor(\n    @Inject(TRANSLATION_NAMESPACE) public readonly namespaceInput: string,\n  ) {\n    this.namespace = namespaceInput;\n    effect(() => {\n      const nsKey = this.getNskey;\n      if (!this.ready) {\n        this.info(`Namespace \"${this.namespace}\" is not ready. Loading for \"${this.lang()}\" using key \"${nsKey}\".`);\n        this.core.load(nsKey, () => this.loader.load(this.config.i18nRoots, this.namespace, this.lang()));\n      }\n    })\n  }\n\n  /** Switches the active language and triggers downstream refresh logic. */\n  setLang(lang: string): void {\n    this.info(`setLang called with \"${lang}\".`);\n    this.core.setLang(lang);\n  }\n\n  /**\n   * Resolves the translation for `key`, formatting with the provided params\n   * and falling back to configured behaviors when a translation is missing.\n   */\n  t(key: string, params: Params = {}): string {\n    const nsKey = this.getNskey;\n    const missingResult = this.getMissingTranslation(key);\n    if (!this.ready) {\n      this.warn(`Namespace \"${this.namespace}\" is not ready.`);\n      return '';\n    }\n    const formatResult = this.core.getAndCreateFormatter(nsKey, key);\n    if (formatResult) return formatResult.format(params);\n\n    if (this.config.enablePageFallback && !this.isPageRoot && this.parent) {\n      return this.parent.t(key, params);\n    }\n    const fallback = this.core.findFallbackFormatter(key, [], this.buildVersion ?? undefined);\n    if (fallback) {\n      this.info(`Resolved key \"${key}\" via fallback namespace while rendering \"${this.namespace}\".`);\n      return fallback.format(params);\n    }\n    this.warn(`Missing translation for key \"${key}\" in namespace \"${this.namespace}\". Returning fallback value.`);\n    return missingResult;\n  }\n\n  /** Determines the fallback string or error when a translation entry is missing. */\n  private getMissingTranslation(key?: string): string | never {\n    const forceMode = this.config.missingTranslationBehavior ?? 'show-key';\n    switch (forceMode) {\n      case 'throw-error':\n        throw new Error(`[i18n] Missing translation: ${key} in ${this.namespace}`);\n      case 'empty':\n        this.warn(`Missing translation returned an empty string for key \"${key}\" in namespace \"${this.namespace}\".`);\n        return '';\n      case 'show-key':\n        if (key) {\n          this.warn(`Showing key \"${key}\" because no translation was found in namespace \"${this.namespace}\".`);\n        }\n        return key ?? '';\n      default: return forceMode;\n    }\n  }\n\n  /** Pass-through helpers that delegate resource management to the core service. */\n  addResourceBundle(...p: Parameters<TranslationCoreService['addResourceBundle']>) {\n    return this.core.addResourceBundle(...p);\n  }\n  addResources(...p: Parameters<TranslationCoreService['addResources']>) {\n    return this.core.addResources(...p);\n  }\n  addResource(...p: Parameters<TranslationCoreService['addResource']>) {\n    return this.core.addResource(...p);\n  }\n  hasResourceBundle(...p: Parameters<TranslationCoreService['hasResourceBundle']>) {\n    return this.core.hasResourceBundle(...p);\n  }\n  getResource(...p: Parameters<TranslationCoreService['getResource']>) {\n    return this.core.getResource(...p);\n  }\n  getResourceBundle(...p: Parameters<TranslationCoreService['getResourceBundle']>) {\n    return this.core.getResourceBundle(...p);\n  }\n  getAllBundle() {\n    return this.core.getAllBundle();\n  }\n  removeResourceBundle(...p: Parameters<TranslationCoreService['removeResourceBundle']>) {\n    return this.core.removeResourceBundle(...p);\n  }\n  preloadNamespaces(...p: Parameters<TranslationCoreService['preloadNamespaces']>) {\n    return this.core.preloadNamespaces(...p);\n  }\n\n  /** Emits debug info when verbose logging is enabled. */\n  private info(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  /** Emits debug warnings when verbose logging is enabled. */\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/ngx-atomic-i18n.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmd4LWF0b21pYy1pMThuLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vcHJvamVjdHMvbmd4LWF0b21pYy1pMThuL3NyYy9uZ3gtYXRvbWljLWkxOG4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2022/public-api.mjs

@@ -0,0 +1,15 @@
+/*
+ * Public API Surface of ngx-atomic-i18n
+ */
+export * from './lib/translation.service';
+export * from './lib/translation-core.service';
+export * from './lib/translate.pipe';
+export * from './lib/translation.directive';
+export * from './lib/translate.provider';
+export * from './lib/translation.loader.csr';
+export * from './lib/translation.loader.ssr';
+export * from './lib/translate.token';
+export * from './lib/translate.type';
+export * from './lib/translate.util';
+export * from './lib/FIFO.model';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL25neC1hdG9taWMtaTE4bi9zcmMvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyxnQ0FBZ0MsQ0FBQztBQUMvQyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMsOEJBQThCLENBQUM7QUFDN0MsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyxrQkFBa0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBQdWJsaWMgQVBJIFN1cmZhY2Ugb2Ygbmd4LWF0b21pYy1pMThuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9saWIvdHJhbnNsYXRpb24uc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi90cmFuc2xhdGlvbi1jb3JlLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvdHJhbnNsYXRlLnBpcGUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvdHJhbnNsYXRpb24uZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3RyYW5zbGF0ZS5wcm92aWRlcic7XG5leHBvcnQgKiBmcm9tICcuL2xpYi90cmFuc2xhdGlvbi5sb2FkZXIuY3NyJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3RyYW5zbGF0aW9uLmxvYWRlci5zc3InO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvdHJhbnNsYXRlLnRva2VuJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3RyYW5zbGF0ZS50eXBlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3RyYW5zbGF0ZS51dGlsJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL0ZJRk8ubW9kZWwnO1xuIl19