ngx-atomic-i18n 0.1.0

package/README.md

@@ -0,0 +1,24 @@
+# NgxComponentTranslate
+
+This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 18.2.0.
+
+## Code scaffolding
+
+Run `ng generate component component-name --project ngx-atomic-i18n` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module --project ngx-atomic-i18n`.
+> Note: Don't forget to add `--project ngx-atomic-i18n` or else it will be added to the default project in your `angular.json` file. 
+
+## Build
+
+Run `ng build ngx-atomic-i18n` to build the project. The build artifacts will be stored in the `dist/` directory.
+
+## Publishing
+
+After building your library with `ng build ngx-atomic-i18n`, go to the dist folder `cd dist/ngx-atomic-i18n` and run `npm publish`.
+
+## Running unit tests
+
+Run `ng test ngx-atomic-i18n` to execute the unit tests via [Karma](https://karma-runner.github.io).
+
+## Further help
+
+To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI Overview and Command Reference](https://angular.dev/tools/cli) page.

package/esm2022/lib/FIFO.model.mjs

@@ -0,0 +1,64 @@
+/** Combined FIFO/LRU cache used to store compiled formatters. */
+export 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;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/translate.pipe.mjs

@@ -0,0 +1,18 @@
+import { inject, Pipe } from "@angular/core";
+import { TranslationService } from "./translation.service";
+import * as i0 from "@angular/core";
+/** Template helper that proxies lookups to `TranslationService.t`. */
+export 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 }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNsYXRlLnBpcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtYXRvbWljLWkxOG4vc3JjL2xpYi90cmFuc2xhdGUucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsTUFBTSxFQUFFLElBQUksRUFBaUIsTUFBTSxlQUFlLENBQUM7QUFFNUQsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sdUJBQXVCLENBQUM7O0FBRzNELHNFQUFzRTtBQUN0RSxNQUFNLE9BQU8sZUFBZTtJQUNULE9BQU8sR0FBRyxNQUFNLENBQUMsa0JBQWtCLENBQUMsQ0FBQztJQUN0RCw2RUFBNkU7SUFDN0UsU0FBUyxDQUFDLEdBQVcsRUFBRSxNQUFlO1FBQ3BDLE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsR0FBRyxFQUFFLE1BQU0sQ0FBQyxDQUFDO0lBQ3JDLENBQUM7d0dBTFUsZUFBZTtzR0FBZixlQUFlOzs0RkFBZixlQUFlO2tCQUYzQixJQUFJO21CQUFDLEVBQUUsSUFBSSxFQUFFLEdBQUcsRUFBRSxVQUFVLEVBQUUsSUFBSSxFQUFFLElBQUksRUFBRSxLQUFLLEVBQUUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBpbmplY3QsIFBpcGUsIFBpcGVUcmFuc2Zvcm0gfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xuaW1wb3J0IHsgUGFyYW1zIH0gZnJvbSBcIi4vdHJhbnNsYXRlLnR5cGVcIjtcbmltcG9ydCB7IFRyYW5zbGF0aW9uU2VydmljZSB9IGZyb20gXCIuL3RyYW5zbGF0aW9uLnNlcnZpY2VcIjtcblxuQFBpcGUoeyBuYW1lOiAndCcsIHN0YW5kYWxvbmU6IHRydWUsIHB1cmU6IGZhbHNlIH0pXG4vKiogVGVtcGxhdGUgaGVscGVyIHRoYXQgcHJveGllcyBsb29rdXBzIHRvIGBUcmFuc2xhdGlvblNlcnZpY2UudGAuICovXG5leHBvcnQgY2xhc3MgVHJhbnNsYXRpb25QaXBlIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XG4gIHByaXZhdGUgcmVhZG9ubHkgc2VydmljZSA9IGluamVjdChUcmFuc2xhdGlvblNlcnZpY2UpO1xuICAvKiogRm9ybWF0cyB0aGUgdHJhbnNsYXRpb24gaWRlbnRpZmllZCBieSBga2V5YCB1c2luZyB0aGUgb3B0aW9uYWwgcGFyYW1zLiAqL1xuICB0cmFuc2Zvcm0oa2V5OiBzdHJpbmcsIHBhcmFtcz86IFBhcmFtcyk6IHN0cmluZyB7XG4gICAgcmV0dXJuIHRoaXMuc2VydmljZS50KGtleSwgcGFyYW1zKTtcbiAgfVxufVxuIl19

package/esm2022/lib/translate.provider.mjs

@@ -0,0 +1,121 @@
+import { HttpClient } from "@angular/common/http";
+import { APP_INITIALIZER, inject, isDevMode, PLATFORM_ID, TransferState, makeStateKey, Optional } from "@angular/core";
+import { HttpTranslationLoader } from "./translation.loader.csr";
+import { detectPreferredLang } from "./translate.util";
+import { isPlatformServer } from "@angular/common";
+import { TranslationService } from "./translation.service";
+import { TempToken } from "./translate.type";
+import { BUILD_VERSION, CLIENT_REQUEST_LANG, PAGE_TRANSLATION_ROOT, TRANSLATION_CONFIG, TRANSLATION_LOADER, TRANSLATION_NAMESPACE } from "./translate.token";
+import { FsTranslationLoader } from "./translation.loader.ssr";
+export 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. */
+export 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).
+*/
+export 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. */
+export 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],
+        }
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"translate.provider.js","sourceRoot":"","sources":["../../../../projects/ngx-atomic-i18n/src/lib/translate.provider.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from \"@angular/common/http\";\nimport { APP_INITIALIZER, inject, isDevMode, PLATFORM_ID, Provider, TransferState, makeStateKey, Optional } from \"@angular/core\";\nimport { HttpTranslationLoader } from \"./translation.loader.csr\";\nimport { detectPreferredLang } from \"./translate.util\";\nimport { isPlatformServer } from \"@angular/common\";\nimport { TranslationService } from \"./translation.service\";\nimport { TempToken, TranslationConfig, TranslationLoader, TranslationLoaderOptions } from \"./translate.type\";\nimport { BUILD_VERSION, CLIENT_REQUEST_LANG, PAGE_TRANSLATION_ROOT, TRANSLATION_CONFIG, TRANSLATION_LOADER, TRANSLATION_NAMESPACE } from \"./translate.token\";\nimport { FsTranslationLoader } from \"./translation.loader.ssr\";\n\nexport type ProvideTranslationInitOptions =\n  Partial<TranslationConfig> & {\n    loader?: TranslationLoaderOptions;\n    /** Optional global build version for SSR/CSR to align caches */\n    buildVersion?: string | null;\n  };\n\nexport const defaultConfig: TranslationConfig = {\n  supportedLangs: ['en'],\n  fallbackNamespace: 'common',\n  fallbackLang: '',\n  i18nRoots: ['i18n'],\n  pathTemplates: [`${TempToken.Root}/${TempToken.Namespace}/${TempToken.Lang}.json`],\n  enablePageFallback: false,\n  missingTranslationBehavior: 'show-key',\n  langDetectionOrder: ['url', 'clientRequest', 'localStorage', 'browser', 'customLang', 'fallback'],\n  clientRequestLang: null,\n};\n\nconst CLIENT_REQUEST_LANG_STATE_KEY = makeStateKey<string | null>('NGX_I18N_CLIENT_REQUEST_LANG');\n\nfunction resolveClientRequestLang(\n  platformId: Object,\n  transferState: TransferState | null | undefined,\n  providedLang: string | null\n): string | null {\n  const stored = transferState?.get(CLIENT_REQUEST_LANG_STATE_KEY, null);\n  if (stored) return stored;\n\n  const resolved = providedLang ?? null;\n  if (resolved && transferState && isPlatformServer(platformId)) {\n    transferState.set(CLIENT_REQUEST_LANG_STATE_KEY, resolved);\n  }\n  return resolved;\n}\n/** Bootstraps the entire translation infrastructure for an application. */\nexport function provideTranslationInit(userConfig?: ProvideTranslationInitOptions): Provider[] {\n  const debugEnabled = userConfig?.debug ?? isDevMode();\n  const baseConfig = { ...defaultConfig, ...(userConfig ?? {}), fallbackLang: defaultConfig.supportedLangs[0], debug: debugEnabled } as TranslationConfig;\n  if (debugEnabled) {\n    console.info('[ngx-atomic-i18n] Debug logging is enabled.');\n  }\n  return [\n    {\n      provide: TRANSLATION_CONFIG,\n      useFactory: (platformId: Object, transferState: TransferState | null | undefined, clientRequestLang: string | null) => {\n        const requestLang = resolveClientRequestLang(platformId, transferState, clientRequestLang ?? baseConfig.clientRequestLang ?? null);\n        const finalConfig = { ...baseConfig, clientRequestLang: requestLang } as TranslationConfig;\n        const preferredLang = detectPreferredLang(finalConfig);\n        return { ...finalConfig, customLang: preferredLang };\n      },\n      deps: [PLATFORM_ID, [new Optional(), TransferState], [new Optional(), CLIENT_REQUEST_LANG]],\n    },\n    {\n      provide: BUILD_VERSION,\n      useValue: userConfig?.buildVersion ?? null,\n    },\n    ...provideTranslationLoader(baseConfig),\n    ...provideTranslation(baseConfig.fallbackNamespace),\n    {\n      provide: APP_INITIALIZER,\n      useFactory: (ts: TranslationService) => {\n        return async () => {\n          const preload = baseConfig.preloadNamespaces;\n          if (preload?.length) {\n            await ts.preloadNamespaces(preload, ts.currentLang);\n          }\n          ts.setLang(ts.currentLang);\n        };\n      },\n      deps: [TranslationService],\n      multi: true,\n    },\n  ];\n}\n\n\n/** Provides the component-scoped namespace injection for component-registered service.\n * @param namespace The namespace owned by the component.\n * @param isPage Whether the component is a top-level page (defaults to false).\n*/\nexport function provideTranslation(namespace: string, isPage: boolean = false): Provider[] {\n  return [\n    {\n      provide: TRANSLATION_NAMESPACE,\n      useValue: namespace,\n    },\n    TranslationService,\n    ...(isPage ? [{\n      provide: PAGE_TRANSLATION_ROOT,\n      useValue: true,\n    }] : []),\n  ]\n}\n\n/** Configures the runtime translation loader for CSR or SSR environments. */\nexport function provideTranslationLoader(config: ProvideTranslationInitOptions): Provider[] {\n  return [\n    {\n      provide: TRANSLATION_LOADER,\n      useFactory: (platformId: Object): TranslationLoader => {\n        const options = config.loader ?? {};\n        const finalPathTemplates = config.pathTemplates ?? defaultConfig.pathTemplates;\n        const isSSR = options.forceMode === 'ssr' || (options.forceMode !== 'csr' && isPlatformServer(platformId));\n        if (isSSR) {\n          const nodeProcess = (globalThis as any).process as { cwd?: () => string } | undefined;\n          const baseDir =\n            options.fsOptions?.baseDir ??\n            (typeof nodeProcess?.cwd === 'function' ? nodeProcess.cwd() : '');\n          const assetPath = options.fsOptions?.assetPath ?? (isDevMode() ? 'src/assets' : 'dist/browser/assets');\n          return options.ssrLoader?.()\n            ?? new FsTranslationLoader({\n              baseDir,\n              assetPath,\n              resolvePaths: options.fsOptions?.resolvePaths,\n              fsModule: options.fsOptions?.fsModule\n            }, finalPathTemplates);\n        }\n        const http = inject(HttpClient);\n        return options.csrLoader?.(http)\n          ?? new HttpTranslationLoader(http, {\n            baseUrl: options.httpOptions?.baseUrl ?? '/assets',\n          }, finalPathTemplates);\n      },\n      deps: [PLATFORM_ID],\n    }\n  ];\n}\n"]}

package/esm2022/lib/translate.token.mjs

@@ -0,0 +1,15 @@
+import { InjectionToken } from "@angular/core";
+/** Scoped namespace for translating a component tree (string or array). */
+export const TRANSLATION_NAMESPACE = new InjectionToken('TRANSLATION_NAMESPACE');
+/** Root configuration describing language support and loader behavior. */
+export const TRANSLATION_CONFIG = new InjectionToken('TRANSLATION_CONFIG');
+/** Factory used to retrieve translation JSON for a namespace/language tuple. */
+export const TRANSLATION_LOADER = new InjectionToken('TRANSLATION_LOADER');
+/** Optional build fingerprint appended to namespace cache keys. */
+export const BUILD_VERSION = new InjectionToken('BUILD_VERSION');
+/** Custom ICU formatter constructor injected by the host app when available. */
+export const ICU_FORMATTER_TOKEN = new InjectionToken('ICU_FORMATTER_TOKEN');
+export const PAGE_TRANSLATION_ROOT = new InjectionToken('PAGE_TRANSLATION_ROOT');
+/** Per-request language captured during SSR and replayed on CSR. */
+export const CLIENT_REQUEST_LANG = new InjectionToken('CLIENT_REQUEST_LANG');
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/translate.type.mjs

@@ -0,0 +1,10 @@
+export 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 = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/translate.util.mjs

@@ -0,0 +1,245 @@
+import { effect, inject, Injector, runInInjectionContext } from "@angular/core";
+import { Observable } from "rxjs";
+/** Normalizes a language code against the configured supported languages. */
+export 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. */
+export 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. */
+export 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. */
+export 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. */
+export 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. */
+export 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. */
+export 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. */
+export function getNested(obj, path) {
+    return path.split('.').reduce((res, key) => res?.[key], obj);
+}
+/** Removes any leading slashes from path-like strings. */
+export const stripLeadingSep = (s) => s.replace(/^[\\/]+/, '');
+/** Normalises the path template configuration to an array form. */
+export 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
+ */
+export 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;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"translate.util.js","sourceRoot":"","sources":["../../../../projects/ngx-atomic-i18n/src/lib/translate.util.ts"],"names":[],"mappings":"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","sourcesContent":["import { effect, inject, Injector, runInInjectionContext, Signal } from \"@angular/core\";\nimport { DeepPartial, PathTemplate, TranslationConfig } from \"./translate.type\";\nimport { Observable } from \"rxjs\";\n\n/** Normalizes a language code against the configured supported languages. */\nexport function normalizeLangCode(\n  lang: string | null | undefined,\n  supportedLangs: string[]\n): string | null {\n  if (!lang) return null;\n  const variants = new Set<string>();\n  variants.add(lang);\n  variants.add(lang.replace(/_/g, '-'));\n  variants.add(lang.replace(/-/g, '_'));\n  variants.add(lang.toLowerCase());\n  variants.add(lang.replace(/_/g, '-').toLowerCase());\n  for (const candidate of variants) {\n    const match = supportedLangs.find(\n      supported => supported.toLowerCase() === candidate.toLowerCase()\n    );\n    if (match) return match;\n  }\n  return null;\n}\n\n/** Determines the most appropriate language using the configured detection order. */\nexport function detectPreferredLang(config: TranslationConfig): string {\n  const { supportedLangs, fallbackLang, langDetectionOrder } = config;\n  for (const source of langDetectionOrder) {\n    let lang: string | null;\n    switch (source) {\n      case 'url':\n        lang = typeof window !== 'undefined' ? window.location.pathname.split('/')[1] : null;\n        break;\n      case 'clientRequest':\n        lang = config.clientRequestLang ?? null;\n        break;\n      case 'localStorage':\n        lang = typeof window !== 'undefined' ? localStorage.getItem('lang') : null;\n        break;\n      case 'browser':\n        const langTag = (globalThis as any)?.navigator?.language ?? '';\n        lang = supportedLangs.find(s => langTag.startsWith(s)) ?? null;\n        break;\n      case 'customLang':\n        lang = typeof config.customLang === 'function' ? config.customLang() : config.customLang ?? null;\n        break;\n      case 'fallback':\n        lang = fallbackLang;\n        break;\n    }\n    const normalized = normalizeLangCode(lang, supportedLangs);\n    if (normalized) {\n      return normalized;\n    };\n  }\n  return normalizeLangCode(fallbackLang, supportedLangs) ?? fallbackLang;\n}\n\n/** Lightweight ICU parser that supports nested select/plural structures. */\nexport function parseICU(templateText: string, params?: Record<string, string | number>): string {\n  if (typeof params === 'object' ? !Object.keys(params).length : true) return templateText;\n\n  const paramMap: Record<string, string> = {};\n  for (const [key, val] of Object.entries(params!)) {\n    paramMap[key] = String(val);\n  }\n\n  function extractBlock(text: string, startIndex: number): [string, number] {\n    let depth = 0;\n    let i = startIndex;\n    while (i < text.length) {\n      if (text[i] === '{') {\n        if (depth === 0) startIndex = i;\n        depth++;\n      } else if (text[i] === '}') {\n        depth--;\n        if (depth === 0) return [text.slice(startIndex, i + 1), i + 1];\n      }\n      i++;\n    }\n    return [text.slice(startIndex), text.length];\n  }\n\n  function extractOptions(body: string): Record<string, string> {\n    const options: Record<string, string> = {};\n    let i = 0;\n    while (i < body.length) {\n      while (body[i] === ' ') i++;\n      let key = '';\n      while (i < body.length && body[i] !== '{' && body[i] !== ' ') {\n        key += body[i++];\n      }\n      while (i < body.length && body[i] === ' ') i++;\n      if (body[i] !== '{') {\n        // Option must have a nested block; otherwise skip it.\n        i++;\n        continue;\n      }\n      const [block, next] = extractBlock(body, i);\n      options[key] = block.slice(1, -1);\n      i = next;\n    }\n    return options;\n  }\n\n  function resolveICU(text: string): string {\n    text = text.replace(/\\{\\{(\\w+)\\}\\}/g, (_, key) => paramMap[key] ?? '');\n    let result = '';\n    let cursor = 0;\n\n    while (cursor < text.length) {\n      const start = text.indexOf('{', cursor);\n      if (start === -1) {\n        result += text.slice(cursor);\n        break;\n      }\n\n      result += text.slice(cursor, start);\n\n      const [block, nextIndex] = extractBlock(text, start);\n\n      if (!block || block === '' || block === '{}') {\n        cursor = nextIndex;\n        continue;\n      }\n\n      const match = block.match(/^\\{(\\w+),\\s*(plural|select),/);\n      if (!match) {\n        result += block;\n        cursor = nextIndex;\n        continue;\n      }\n\n      const [, varName, type] = match;\n      const rawVal = paramMap[varName] ?? '';\n      const numVal = Number(rawVal);\n      const body = block.slice(match[0].length, -1);\n      const options = extractOptions(body);\n\n      const selected =\n        options[`=${rawVal}`] ||\n        (type === 'plural' && numVal === 1 && options['one']) ||\n        options[rawVal] ||\n        options['other'] ||\n        '';\n\n      if (!selected) {\n        result += block;\n        cursor = nextIndex;\n        continue;\n      }\n\n      let resolved = resolveICU(selected);\n\n      if (type === 'plural') {\n        resolved = resolved.replace(/#/g, rawVal);\n      }\n\n      resolved = resolved.replace(/{{(\\w+)}}|\\{(\\w+)\\}/g, (_, k1, k2) => {\n        const k = k1 || k2;\n        return paramMap[k] ?? '';\n      });\n\n      result += resolved;\n      cursor = nextIndex;\n    }\n\n    return result;\n  }\n\n  return resolveICU(templateText);\n}\n\n\n\n/** Flattens a nested translation object using dot notation keys. */\nexport function flattenTranslations(obj: any, prefix = ''): Record<string, string> {\n  const result: Record<string, string> = {};\n  for (const [key, value] of Object.entries(obj)) {\n    const newKey = prefix ? `${prefix}.${key}` : key;\n    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {\n      Object.assign(result, flattenTranslations(value, newKey));\n    } else {\n      result[newKey] = String(value);\n    }\n  }\n  return result;\n}\n\n\n/** Converts a signal to an observable while preserving injection context. */\nexport function toObservable<T>(signal: Signal<T>): Observable<T> {\n  const injector = inject(Injector);\n  return new Observable(subscribe => {\n    subscribe.next(signal());\n    const stop = runInInjectionContext(injector, () => effect(() => subscribe.next(signal()), { allowSignalWrites: true }));\n    return () => stop.destroy();\n  });\n}\n\n\n/** Deeply merges plain objects, replacing non-object values by assignment. */\nexport function deepMerge<T extends object, U extends object>(target: T, source: U): T & U {\n  const output = { ...target } as T & U;\n  for (const key in source) {\n    const targetValue = (target as any)[key];\n    if (\n      source.hasOwnProperty(key) &&\n      typeof source[key] === 'object' &&\n      source[key] !== null &&\n      !Array.isArray(source[key]) &&\n      typeof targetValue === 'object' &&\n      targetValue !== null &&\n      !Array.isArray(targetValue)\n    ) {\n      output[key] = deepMerge(targetValue as any, source[key] as any);\n    } else {\n      output[key] = source[key] as any;\n    }\n  }\n  return output;\n}\n\n/** Recursively retains only keys that are not already present in the existing object. */\nexport function filterNewKeysDeep<T extends object, U extends object>(bundle: T, existing: U): DeepPartial<T> {\n  const result = {} as Partial<T>;\n  for (const key in bundle) {\n    const existValue = (existing as any)[key];\n    if (\n      typeof bundle[key] === 'object' &&\n      bundle[key] !== null &&\n      !Array.isArray(bundle[key]) &&\n      typeof existValue === 'object' &&\n      existValue !== null &&\n      !Array.isArray(existValue)\n    ) {\n      result[key] = filterNewKeysDeep(bundle[key], existValue) as any;\n    } else if (!(key in existing)) {\n      result[key] = bundle[key];\n    }\n  }\n  return result;\n}\n\n/** Safely reads a dotted path from a nested object. */\nexport function getNested(obj: any, path: string): string | undefined {\n  return path.split('.').reduce((res, key) => res?.[key], obj);\n}\n\n/** Removes any leading slashes from path-like strings. */\nexport const stripLeadingSep = (s: string) => s.replace(/^[\\\\/]+/, '');\n\n/** Normalises the path template configuration to an array form. */\nexport const tempToArray = (template: PathTemplate) => Array.isArray(template) ? template : (template ? [template] : undefined);\n\n/**\n * Detect current build version from injected script names (CSR only).\n * Matches filenames like: main.<hash>.js, runtime.<hash>.js, polyfills.<hash>.js\n */\nexport function detectBuildVersion(): string | null {\n  try {\n    if (typeof document === 'undefined' || !document?.scripts) return null;\n    const regex = /\\/(?:main|runtime|polyfills)\\.([a-f0-9]{8,})\\.[^\\/]*\\.js(?:\\?|$)/i;\n    for (const s of Array.from(document.scripts)) {\n      const version = regex.exec((s as HTMLScriptElement).src);\n      if (version?.[1]) return version[1];\n    }\n    return null;\n  } catch {\n    return null;\n  }\n}\n"]}