@seliseblocks/blocks-angular-localization 0.0.1

package/dist/fesm2022/seliseblocks-blocks-angular-localization.mjs

@@ -0,0 +1,1430 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, Injectable, inject, DestroyRef, signal, computed, makeEnvironmentProviders, provideEnvironmentInitializer, effect, TemplateRef, ViewContainerRef, input, Directive, Pipe, ChangeDetectionStrategy, Component } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { Subject, of, shareReplay, from, forkJoin } from 'rxjs';
+import { HttpClient, HttpHeaders } from '@angular/common/http';
+import { map, catchError, switchMap, tap } from 'rxjs/operators';
+import { NgTemplateOutlet } from '@angular/common';
+
+/**
+ * Injection token for the blocks-localization configuration.
+ * Provided by `provideBlocksLocalization()` at the application root.
+ */
+const BLOCKS_LOCALIZATION_CONFIG = new InjectionToken('BlocksLocalizationConfig');
+
+const DB_NAME = 'uilm-translations';
+const DB_VERSION = 1;
+const STORE_NAME = 'translations';
+/**
+ * IndexedDB persistence layer for UILM translation cache.
+ *
+ * Stores translation maps keyed by `{prefix}::{lang}` with timestamps
+ * for TTL-based invalidation. Falls back gracefully to `null` when
+ * IndexedDB is unavailable (SSR, restrictive incognito, etc.).
+ *
+ * All public methods are **fire-and-forget safe** — they never throw
+ * and resolve to `null` / `void` on any failure.
+ *
+ * @publicApi
+ */
+class UilmIndexedDbCache {
+    dbReady;
+    constructor() {
+        this.dbReady = this.openDb();
+    }
+    /** Re-open the database connection (used after unexpected close). */
+    reconnect() {
+        this.dbReady = this.openDb();
+    }
+    /**
+     * Retrieve a cached entry if it exists and hasn't exceeded the TTL.
+     *
+     * @param key   Cache key (`{prefix}::{lang}`)
+     * @param ttl   Time-to-live in ms. `0` disables expiry (entry is always valid).
+     * @returns The translation map, or `null` on miss / expiry / error.
+     */
+    async get(key, ttl) {
+        const db = await this.dbReady;
+        if (!db)
+            return null;
+        try {
+            const entry = await this.txGet(db, key);
+            if (!entry)
+                return null;
+            if (ttl > 0 && Date.now() - entry.timestamp >= ttl) {
+                return null;
+            }
+            return entry.data;
+        }
+        catch {
+            this.reconnect();
+            return null;
+        }
+    }
+    /**
+     * Retrieve a stale entry (ignoring TTL) for fallback purposes.
+     *
+     * @param key Cache key
+     * @returns The translation map regardless of age, or `null` if absent.
+     */
+    async getStale(key) {
+        const db = await this.dbReady;
+        if (!db)
+            return null;
+        try {
+            const entry = await this.txGet(db, key);
+            return entry?.data ?? null;
+        }
+        catch {
+            this.reconnect();
+            return null;
+        }
+    }
+    /**
+     * Persist a translation map.
+     *
+     * @param key  Cache key
+     * @param data Flat key→value translation map
+     */
+    async set(key, data) {
+        const db = await this.dbReady;
+        if (!db)
+            return;
+        try {
+            await this.txPut(db, { key, data, timestamp: Date.now() });
+        }
+        catch {
+            this.reconnect();
+        }
+    }
+    /** Remove all cached translations from IndexedDB. */
+    async clear() {
+        const db = await this.dbReady;
+        if (!db)
+            return;
+        try {
+            await this.txClear(db);
+        }
+        catch {
+            this.reconnect();
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Private — IndexedDB primitives
+    // ---------------------------------------------------------------------------
+    openDb() {
+        return new Promise((resolve) => {
+            try {
+                if (typeof indexedDB === 'undefined') {
+                    resolve(null);
+                    return;
+                }
+                const request = indexedDB.open(DB_NAME, DB_VERSION);
+                request.onupgradeneeded = () => {
+                    const db = request.result;
+                    if (!db.objectStoreNames.contains(STORE_NAME)) {
+                        db.createObjectStore(STORE_NAME, { keyPath: 'key' });
+                    }
+                };
+                request.onsuccess = () => {
+                    const db = request.result;
+                    // Allow other tabs to upgrade the DB by closing our connection on demand
+                    db.onversionchange = () => {
+                        db.close();
+                        this.reconnect();
+                    };
+                    // Reconnect if the browser unexpectedly closes the connection
+                    db.onclose = () => {
+                        this.reconnect();
+                    };
+                    resolve(db);
+                };
+                request.onerror = () => resolve(null);
+            }
+            catch {
+                resolve(null);
+            }
+        });
+    }
+    txGet(db, key) {
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(STORE_NAME, 'readonly');
+            const request = tx.objectStore(STORE_NAME).get(key);
+            request.onsuccess = () => resolve(request.result);
+            request.onerror = () => reject(request.error);
+        });
+    }
+    txPut(db, entry) {
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(STORE_NAME, 'readwrite');
+            const request = tx.objectStore(STORE_NAME).put(entry);
+            request.onsuccess = () => resolve();
+            request.onerror = () => reject(request.error);
+        });
+    }
+    txClear(db) {
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(STORE_NAME, 'readwrite');
+            const request = tx.objectStore(STORE_NAME).clear();
+            request.onsuccess = () => resolve();
+            request.onerror = () => reject(request.error);
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: UilmIndexedDbCache, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: UilmIndexedDbCache, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: UilmIndexedDbCache, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+
+/**
+ * Flattens a nested object into dot-notation keys.
+ *
+ * @example
+ * ```typescript
+ * flattenJson({ LABEL: { HELLO: 'Hello', WORLD: 'World' }, BTN: { SAVE: 'Save' } })
+ * // → { 'LABEL.HELLO': 'Hello', 'LABEL.WORLD': 'World', 'BTN.SAVE': 'Save' }
+ * ```
+ */
+function flattenJson(obj, parentKey = '', separator = '.', _visited = new Set()) {
+    _visited.add(obj);
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        const newKey = parentKey ? `${parentKey}${separator}${key}` : key;
+        if (value != null && typeof value === 'object' && !Array.isArray(value)) {
+            if (_visited.has(value))
+                continue; // skip circular refs
+            _visited.add(value);
+            Object.assign(result, flattenJson(value, newKey, separator, _visited));
+        }
+        else if (Array.isArray(value)) {
+            if (_visited.has(value))
+                continue; // skip circular refs
+            _visited.add(value);
+            value.forEach((item, i) => {
+                const arrKey = `${newKey}${separator}${i}`;
+                if (item != null && typeof item === 'object' && !Array.isArray(item)) {
+                    if (_visited.has(item))
+                        return;
+                    _visited.add(item);
+                    Object.assign(result, flattenJson(item, arrKey, separator, _visited));
+                }
+                else {
+                    result[arrKey] = String(item ?? '');
+                }
+            });
+        }
+        else {
+            result[newKey] = String(value ?? '');
+        }
+    }
+    return result;
+}
+
+/**
+ * Convert a short language code to a full locale code using the provided mapping.
+ * Returns the original code if no mapping is found or if it's already a full code.
+ */
+function toFullLangCode(lang, mapping) {
+    if (lang.includes('-')) {
+        return lang;
+    }
+    return mapping[lang] || lang;
+}
+/**
+ * Convert a full locale code (e.g. 'en-US') to a short code (e.g. 'en').
+ */
+function toShortLangCode(fullCode) {
+    return fullCode.split('-')[0];
+}
+/**
+ * Build a reverse mapping from full locale codes to short codes.
+ */
+function buildReverseMapping(localeMapping) {
+    return Object.fromEntries(Object.entries(localeMapping).map(([short, full]) => [full, short]));
+}
+
+/**
+ * Low-level HTTP client for fetching translations from the UILM API.
+ *
+ * ## Caching architecture (two-tier)
+ *
+ * | Layer | Storage         | Lifetime        | When enabled              |
+ * |-------|-----------------|-----------------|---------------------------|
+ * | L1    | In-memory `Map` | Current session | Always                    |
+ * | L2    | IndexedDB       | Cross-session   | `cacheStorage: 'indexeddb'`|
+ *
+ * ### Lookup order
+ * 1. **L1 hit** (valid TTL) → return immediately
+ * 2. **In-flight dedup** → share existing Observable
+ * 3. **L2 hit** (valid TTL, if enabled) → populate L1, return
+ * 4. **HTTP fetch** → populate L1 + L2, return
+ * 5. **Error fallback chain**: stale L1 → stale L2 → local JSON → empty `{}`
+ *
+ * @publicApi
+ */
+class UilmLoader {
+    http = inject(HttpClient);
+    config = inject(BLOCKS_LOCALIZATION_CONFIG);
+    idbCache = inject(UilmIndexedDbCache);
+    destroyRef = inject(DestroyRef);
+    /** L1 in-memory cache. */
+    memCache = new Map();
+    /** Tracks in-flight HTTP observables for request deduplication. */
+    inflight = new Map();
+    /** Emits when a background revalidation produces updated translations. */
+    revalidated$ = new Subject();
+    availableModules = [];
+    availableLanguages = [];
+    shortToFullMapping = {};
+    modulesLoaded = false;
+    languagesLoaded = false;
+    metadataInflight$ = null;
+    constructor() {
+        if (this.config.localeMapping) {
+            this.shortToFullMapping = { ...this.config.localeMapping };
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Derived config helpers
+    // ---------------------------------------------------------------------------
+    get cacheTimeout() {
+        return this.config.cacheTimeout ?? 0;
+    }
+    get shouldPrefixKeys() {
+        return !!this.config.prefixKeysWithModule;
+    }
+    get useIndexedDb() {
+        return this.config.cacheStorage === 'indexeddb';
+    }
+    get shouldRevalidate() {
+        return this.useIndexedDb && !!this.config.revalidateInBackground;
+    }
+    get shouldFallbackToLocal() {
+        return this.config.fallbackToLocal !== false;
+    }
+    get localAssetsPath() {
+        return this.config.localAssetsPath ?? 'assets/i18n';
+    }
+    // ---------------------------------------------------------------------------
+    // Public API
+    // ---------------------------------------------------------------------------
+    /**
+     * Fetch a single UILM module's translations.
+     *
+     * @param lang       Short language code (e.g. `'en'`)
+     * @param moduleName UILM module name as registered in the API
+     * @param alias      Optional alias used as the key prefix instead of the module name
+     * @returns Observable emitting the (optionally prefixed) key→value map
+     */
+    fetchModuleTranslations(lang, moduleName, alias) {
+        const prefix = alias ?? moduleName;
+        const cacheKey = this.buildCacheKey(prefix, lang);
+        // 1. L1 hit
+        const l1Entry = this.memCache.get(cacheKey);
+        if (l1Entry && this.isL1Valid(cacheKey)) {
+            // Still fire background revalidation so stale cached data gets updated
+            if (this.shouldRevalidate) {
+                this.revalidateFromApi(lang, moduleName, prefix, cacheKey, l1Entry.data);
+            }
+            return of(l1Entry.data);
+        }
+        // 2. In-flight dedup
+        const existing = this.inflight.get(cacheKey);
+        if (existing)
+            return existing;
+        // 3. Build the fetch pipeline: L2 → HTTP → fallback
+        const request$ = this.resolveTranslation(lang, moduleName, prefix, cacheKey).pipe(shareReplay(1));
+        this.inflight.set(cacheKey, request$);
+        return request$;
+    }
+    /**
+     * Attempt to load translations from IndexedDB cache only (no API, no metadata).
+     * Returns `null` if IndexedDB is disabled or the entry is missing.
+     * Used for instant store hydration before metadata is available.
+     */
+    loadFromCacheOnly(lang, moduleName, alias) {
+        if (!this.useIndexedDb)
+            return of(null);
+        const prefix = alias ?? moduleName;
+        const cacheKey = this.buildCacheKey(prefix, lang);
+        // L1 hit
+        const l1Entry = this.memCache.get(cacheKey);
+        if (l1Entry && this.isL1Valid(cacheKey)) {
+            return of(l1Entry.data);
+        }
+        return from(this.idbCache.get(cacheKey, this.cacheTimeout)).pipe(map((data) => {
+            if (data) {
+                this.memCache.set(cacheKey, { data, timestamp: Date.now() });
+            }
+            return data;
+        }), catchError(() => of(null)));
+    }
+    /** Ensure modules and languages metadata are loaded (fetches once, then no-ops). */
+    ensureMetadataLoaded() {
+        if (this.modulesLoaded && this.languagesLoaded) {
+            return of(undefined);
+        }
+        if (this.metadataInflight$)
+            return this.metadataInflight$;
+        this.metadataInflight$ = this.getAvailableModules().pipe(switchMap(() => this.getAvailableLanguages()), map(() => undefined), tap(() => {
+            this.metadataInflight$ = null;
+        }), catchError((err) => {
+            this.metadataInflight$ = null;
+            throw err;
+        }), shareReplay(1));
+        return this.metadataInflight$;
+    }
+    /** Clear all translation caches (L1 in-memory, in-flight, and L2 IndexedDB if enabled). */
+    clearCache() {
+        this.memCache.clear();
+        this.inflight.clear();
+        if (this.useIndexedDb) {
+            this.idbCache.clear();
+        }
+    }
+    /** Fetch available languages from the UILM API. */
+    getAvailableLanguages() {
+        if (this.languagesLoaded && this.availableLanguages.length > 0) {
+            return of(this.availableLanguages);
+        }
+        const url = `${this.config.uilmApiBaseUrl}/Language/Gets?ProjectKey=${encodeURIComponent(this.config.projectKey)}`;
+        return this.http.get(url, { headers: this.buildHeaders() }).pipe(tap((languages) => {
+            this.availableLanguages = languages ?? [];
+            for (const lang of this.availableLanguages) {
+                const shortCode = lang.languageCode.split('-')[0];
+                // Only populate mapping if user config didn't already define this short code
+                if (!this.shortToFullMapping[shortCode]) {
+                    this.shortToFullMapping[shortCode] = lang.languageCode;
+                }
+            }
+            this.languagesLoaded = true;
+        }), catchError(() => {
+            this.languagesLoaded = true;
+            return of([]);
+        }));
+    }
+    /** Fetch available modules from the UILM API. */
+    getAvailableModules() {
+        if (this.modulesLoaded && this.availableModules.length > 0) {
+            return of(this.availableModules);
+        }
+        const url = `${this.config.uilmApiBaseUrl}/Module/Gets?ProjectKey=${encodeURIComponent(this.config.projectKey)}`;
+        return this.http.get(url, { headers: this.buildHeaders() }).pipe(tap((modules) => {
+            this.availableModules = modules ?? [];
+            this.modulesLoaded = true;
+        }), catchError(() => {
+            this.modulesLoaded = true;
+            return of([]);
+        }));
+    }
+    /** Get cached languages (empty until `ensureMetadataLoaded()` resolves). */
+    getLanguages() {
+        return this.availableLanguages;
+    }
+    /** Get cached modules (empty until `ensureMetadataLoaded()` resolves). */
+    getModules() {
+        return this.availableModules;
+    }
+    // ---------------------------------------------------------------------------
+    // Private — cache helpers
+    // ---------------------------------------------------------------------------
+    buildCacheKey(prefix, lang) {
+        return `${prefix}::${lang}`;
+    }
+    /** Check whether the L1 entry is present and within TTL. `cacheTimeout=0` means no expiry. */
+    isL1Valid(key) {
+        const entry = this.memCache.get(key);
+        if (!entry)
+            return false;
+        if (this.cacheTimeout <= 0)
+            return true; // 0 = no expiry, entry is always valid
+        return Date.now() - entry.timestamp < this.cacheTimeout;
+    }
+    /** Write data to L1 (always) and L2 (when enabled). */
+    populateCache(key, data) {
+        this.memCache.set(key, { data, timestamp: Date.now() });
+        if (this.useIndexedDb) {
+            // Fire-and-forget — IndexedDB write is best-effort
+            this.idbCache.set(key, data);
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Private — fetch pipeline
+    // ---------------------------------------------------------------------------
+    /**
+     * Resolve translations through the full L2 → HTTP → fallback chain.
+     * Called only when L1 misses and no in-flight request exists.
+     */
+    resolveTranslation(lang, moduleName, prefix, cacheKey) {
+        if (this.useIndexedDb) {
+            return from(this.idbCache.get(cacheKey, this.cacheTimeout)).pipe(switchMap((idbData) => {
+                if (idbData) {
+                    this.memCache.set(cacheKey, { data: idbData, timestamp: Date.now() });
+                    this.inflight.delete(cacheKey);
+                    if (this.shouldRevalidate) {
+                        this.revalidateFromApi(lang, moduleName, prefix, cacheKey, idbData);
+                    }
+                    return of(idbData);
+                }
+                return this.fetchFromApi(lang, moduleName, prefix, cacheKey);
+            }));
+        }
+        return this.fetchFromApi(lang, moduleName, prefix, cacheKey);
+    }
+    /** Issue the HTTP request and handle success / error with full fallback chain. */
+    fetchFromApi(lang, moduleName, prefix, cacheKey) {
+        const fullLangCode = toFullLangCode(lang, this.shortToFullMapping);
+        const url = `${this.config.uilmApiBaseUrl}/Key/GetUilmFile` +
+            `?ProjectKey=${this.config.projectKey}` +
+            `&ModuleName=${encodeURIComponent(moduleName)}` +
+            `&Language=${encodeURIComponent(fullLangCode)}`;
+        return this.http.get(url, { headers: this.buildHeaders() }).pipe(map((data) => this.sanitizeApiResponse(data)), map((data) => (this.shouldPrefixKeys ? this.prefixKeys(data, prefix) : data)), tap((data) => {
+            this.populateCache(cacheKey, data);
+            this.inflight.delete(cacheKey);
+        }), catchError(() => {
+            this.inflight.delete(cacheKey);
+            return this.resolveFromFallbacks(lang, moduleName, prefix, cacheKey);
+        }));
+    }
+    /**
+     * Fallback chain on HTTP failure:
+     * 1. Stale L1 (in-memory)
+     * 2. Stale L2 (IndexedDB, if enabled)
+     * 3. Local JSON file (if enabled)
+     * 4. Empty map
+     */
+    resolveFromFallbacks(lang, moduleName, prefix, cacheKey) {
+        // 1. Stale L1
+        const staleL1 = this.memCache.get(cacheKey);
+        if (staleL1)
+            return of(staleL1.data);
+        // 2. Stale L2
+        if (this.useIndexedDb) {
+            return from(this.idbCache.getStale(cacheKey)).pipe(switchMap((staleIdb) => {
+                if (staleIdb)
+                    return of(staleIdb);
+                return this.localFallbackOrEmpty(lang, moduleName, prefix);
+            }));
+        }
+        // 3 + 4. Local JSON or empty
+        return this.localFallbackOrEmpty(lang, moduleName, prefix);
+    }
+    /** Attempt local JSON fallback, or return empty map. */
+    localFallbackOrEmpty(lang, moduleName, prefix) {
+        if (this.shouldFallbackToLocal) {
+            return this.fetchLocalFallback(lang, moduleName, prefix);
+        }
+        return of({});
+    }
+    // ---------------------------------------------------------------------------
+    // Private — local fallback
+    // ---------------------------------------------------------------------------
+    /**
+     * Fetch translations from a local JSON file.
+     * Nested JSON is automatically flattened to dot-notation keys.
+     *
+     * Path convention:
+     * - Module with content: `{localAssetsPath}/{moduleName}/{lang}.json`
+     * - Root/common module (empty alias): `{localAssetsPath}/{lang}.json`
+     */
+    fetchLocalFallback(lang, moduleName, prefix) {
+        const path = prefix === ''
+            ? `${this.localAssetsPath}/${lang}.json`
+            : `${this.localAssetsPath}/${moduleName}/${lang}.json`;
+        return this.http.get(path).pipe(map((nested) => {
+            const flat = flattenJson(nested);
+            return this.shouldPrefixKeys ? this.prefixKeys(flat, prefix) : flat;
+        }), tap((data) => this.populateCache(this.buildCacheKey(prefix, lang), data)), catchError(() => of({})));
+    }
+    // ---------------------------------------------------------------------------
+    // Private — background revalidation
+    // ---------------------------------------------------------------------------
+    /**
+     * Fire-and-forget API fetch that silently updates caches and emits on
+     * `revalidated$` when the response differs from the currently cached data.
+     */
+    revalidateFromApi(lang, moduleName, prefix, cacheKey, cachedData) {
+        const fullLangCode = toFullLangCode(lang, this.shortToFullMapping);
+        const url = `${this.config.uilmApiBaseUrl}/Key/GetUilmFile` +
+            `?ProjectKey=${this.config.projectKey}` +
+            `&ModuleName=${encodeURIComponent(moduleName)}` +
+            `&Language=${encodeURIComponent(fullLangCode)}`;
+        this.http
+            .get(url, { headers: this.buildHeaders() })
+            .pipe(map((data) => this.sanitizeApiResponse(data)), map((data) => (this.shouldPrefixKeys ? this.prefixKeys(data, prefix) : data)), takeUntilDestroyed(this.destroyRef))
+            .subscribe({
+            next: (freshData) => {
+                if (!this.shallowEqual(freshData, cachedData)) {
+                    this.populateCache(cacheKey, freshData);
+                    this.revalidated$.next({ lang, data: freshData });
+                }
+            },
+            error: () => {
+                /* silent — cached data is already served */
+            },
+        });
+    }
+    // ---------------------------------------------------------------------------
+    // Private — utilities
+    // ---------------------------------------------------------------------------
+    buildHeaders() {
+        const headers = {
+            'x-blocks-key': this.config.projectKey,
+            'Content-Type': 'application/json',
+            Accept: 'application/json',
+        };
+        if (this.config.accessToken) {
+            headers['Authorization'] = `Bearer ${this.config.accessToken}`;
+        }
+        return new HttpHeaders(headers);
+    }
+    /** Ensure API response is a valid flat object. Returns empty map for malformed responses. */
+    sanitizeApiResponse(data) {
+        if (!data || typeof data !== 'object' || Array.isArray(data)) {
+            return {};
+        }
+        return data;
+    }
+    /** Shallow key-by-key equality check for flat TranslationMaps. */
+    shallowEqual(a, b) {
+        const aKeys = Object.keys(a);
+        const bKeys = Object.keys(b);
+        if (aKeys.length !== bKeys.length)
+            return false;
+        return aKeys.every((key) => a[key] === b[key]);
+    }
+    prefixKeys(data, prefix) {
+        if (!prefix)
+            return data;
+        const prefixed = {};
+        const lowerPrefix = prefix.toLowerCase();
+        for (const [key, value] of Object.entries(data)) {
+            prefixed[`${lowerPrefix}.${key}`] = value;
+        }
+        return prefixed;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: UilmLoader, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: UilmLoader, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: UilmLoader, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+
+/**
+ * Core reactive translation store.
+ *
+ * Holds translations per language, tracks the active language via signals,
+ * and persists language preference to `localStorage`.
+ *
+ * @publicApi
+ */
+class UilmStore {
+    config = inject(BLOCKS_LOCALIZATION_CONFIG);
+    destroyRef = inject(DestroyRef);
+    storageKey = this.config.langStorageKey ?? 'uilmLang';
+    /** Internal translation maps: `lang → flat key-value pairs` */
+    store = new Map();
+    /** Toggled on every `setTranslation` call to trigger signal reactivity. */
+    _version = signal(0, ...(ngDevMode ? [{ debugName: "_version" }] : []));
+    versionCounter = 0;
+    /** Active language short code. */
+    activeLang = signal(this.loadPersistedLang(), ...(ngDevMode ? [{ debugName: "activeLang" }] : []));
+    /**
+     * When `true`, `translate()` returns the raw key instead of the translated value.
+     * Toggled via `window.postMessage({ action: 'keymode', keymode: true/false })`.
+     * Useful for testing with a browser extension.
+     */
+    keyMode = signal(false, ...(ngDevMode ? [{ debugName: "keyMode" }] : []));
+    /** Read-only version signal — depend on this to react to translation changes. */
+    version = this._version.asReadonly();
+    /** `true` when translations have been loaded for the active language. */
+    ready = computed(() => {
+        this._version();
+        return this.store.has(this.activeLang());
+    }, ...(ngDevMode ? [{ debugName: "ready" }] : []));
+    constructor() {
+        this.listenForKeyModeToggle();
+    }
+    /**
+     * Translate a key for the active language.
+     * Supports interpolation: `{{ name }}` in values is replaced by `params.name`.
+     *
+     * Returns the raw key if no translation is found.
+     */
+    translate(key, params) {
+        this._version(); // touch so computed signals re-evaluate
+        // In key mode, always return the raw key for debugging/testing
+        if (this.keyMode())
+            return key;
+        const translations = this.store.get(this.activeLang());
+        let value = translations?.[key];
+        if (value == null)
+            return key;
+        if (params) {
+            value = value.replace(/\{\{\s*([\w.]+)\s*\}\}/g, (match, paramKey) => {
+                const val = paramKey.split('.').reduce((obj, k) => {
+                    if (obj != null && typeof obj === 'object' && !Array.isArray(obj)) {
+                        return obj[k];
+                    }
+                    return undefined;
+                }, params);
+                return val != null ? String(val) : match;
+            });
+        }
+        return value;
+    }
+    /** Check if a translation key exists for the active language. */
+    has(key) {
+        this._version();
+        return this.store.get(this.activeLang())?.[key] != null;
+    }
+    /** Merge translations into the store for a given language. */
+    setTranslation(data, lang) {
+        const existing = this.store.get(lang) ?? {};
+        this.store.set(lang, { ...existing, ...data });
+        this.versionCounter = (this.versionCounter + 1) % 0x7fffffff;
+        this._version.set(this.versionCounter);
+    }
+    /** Set active language and persist to `localStorage`. Ignores invalid language codes. */
+    setActiveLang(lang) {
+        if (!this.config.availableLangs.includes(lang)) {
+            console.warn(`[blocks-localization] "${lang}" is not in availableLangs [${this.config.availableLangs.join(', ')}]. Ignoring.`);
+            return;
+        }
+        this.activeLang.set(lang);
+        this.persistLang(lang);
+    }
+    /** Get configured available languages. */
+    getAvailableLangs() {
+        return [...this.config.availableLangs];
+    }
+    // ---------------------------------------------------------------------------
+    // Private
+    // ---------------------------------------------------------------------------
+    getStorage() {
+        try {
+            const type = this.config.langStorage ?? 'localStorage';
+            if (type === 'none')
+                return null;
+            return type === 'sessionStorage' ? sessionStorage : localStorage;
+        }
+        catch {
+            return null;
+        }
+    }
+    loadPersistedLang() {
+        try {
+            const storage = this.getStorage();
+            const stored = storage?.getItem(this.storageKey) ?? null;
+            if (stored) {
+                const reverse = this.config.localeMapping
+                    ? buildReverseMapping(this.config.localeMapping)
+                    : {};
+                const shortCode = reverse[stored] ?? stored;
+                if (this.config.availableLangs.includes(shortCode)) {
+                    return shortCode;
+                }
+            }
+        }
+        catch {
+            // Storage unavailable (SSR, incognito restrictions, etc.)
+        }
+        return this.config.defaultLang;
+    }
+    persistLang(lang) {
+        try {
+            const storage = this.getStorage();
+            if (!storage)
+                return;
+            const fullCode = this.config.localeMapping?.[lang] ?? lang;
+            storage.setItem(this.storageKey, fullCode);
+        }
+        catch {
+            // Storage unavailable
+        }
+    }
+    /**
+     * Listen for `window.postMessage` events to toggle key mode.
+     *
+     * Expected payload: `{ action: 'keymode', keymode: boolean }`
+     *
+     * Only messages from the same window and origin are accepted.
+     * Toggling key mode bumps the version signal so all translated
+     * values reactively update across the UI.
+     */
+    listenForKeyModeToggle() {
+        if (typeof window === 'undefined')
+            return;
+        const handler = (event) => {
+            if (event.source !== window)
+                return;
+            if (event.origin !== window.location.origin)
+                return;
+            const { data } = event;
+            if (!data || typeof data !== 'object')
+                return;
+            const { action, keymode } = data;
+            if (action === 'keymode' && typeof keymode === 'boolean') {
+                const previous = this.keyMode();
+                this.keyMode.set(keymode);
+                if (previous !== keymode) {
+                    this.versionCounter = (this.versionCounter + 1) % 0x7fffffff;
+                    this._version.set(this.versionCounter);
+                }
+            }
+        };
+        window.addEventListener('message', handler);
+        this.destroyRef.onDestroy(() => window.removeEventListener('message', handler));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: UilmStore, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: UilmStore, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: UilmStore, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+
+/**
+ * Build an array of `fetchModuleTranslations` observables from module entries.
+ * @internal
+ */
+function buildRequests(loader, modules, lang) {
+    return modules.map((m) => typeof m === 'string'
+        ? loader.fetchModuleTranslations(lang, m)
+        : loader.fetchModuleTranslations(lang, m.module, m.alias));
+}
+/**
+ * Build an array of cache-only read observables from module entries.
+ * @internal
+ */
+function buildCacheRequests(loader, modules, lang) {
+    return modules.map((m) => typeof m === 'string'
+        ? loader.loadFromCacheOnly(lang, m)
+        : loader.loadFromCacheOnly(lang, m.module, m.alias));
+}
+/**
+ * Provides all UILM translation infrastructure for an Angular application.
+ *
+ * ## Strategies
+ *
+ * ### `'modular'` (default)
+ * Preloads only the modules listed in `preloadModules` at startup.
+ * Additional modules are lazily loaded per route via `provideUilmScope()`.
+ * Shows empty placeholders while translations are loading.
+ *
+ * ### `'eager'`
+ * All modules in `preloadModules` are fetched at startup (non-blocking).
+ * Use `UilmLoadingScreenComponent` with `UilmStore.ready` to gate the UI
+ * until translations are available. Route-level `provideUilmScope()` calls
+ * become cache hits.
+ *
+ * @example
+ * ```typescript
+ * // Eager — all modules upfront with loading screen
+ * provideBlocksLocalization({
+ *   strategy: 'eager',
+ *   preloadModules: [
+ *     { module: 'common', alias: '' },
+ *     'dashboard',
+ *     { module: 'opportunity', alias: 'op' },
+ *   ],
+ *   // ...
+ * })
+ *
+ * // app.component.html
+ * // @if (!store.ready()) {
+ * //   <uilm-loading-screen />
+ * // } @else {
+ * //   <router-outlet />
+ * // }
+ * ```
+ *
+ * @publicApi
+ */
+function provideBlocksLocalization(config) {
+    const modules = config.preloadModules ?? [];
+    return makeEnvironmentProviders([
+        { provide: BLOCKS_LOCALIZATION_CONFIG, useValue: config },
+        // -------------------------------------------------------------------------
+        // Preload modules + language-change watcher
+        // -------------------------------------------------------------------------
+        ...(modules.length
+            ? [
+                provideEnvironmentInitializer(() => {
+                    const loader = inject(UilmLoader);
+                    const store = inject(UilmStore);
+                    const destroyRef = inject(DestroyRef);
+                    const loadForLang = (lang) => {
+                        forkJoin(buildRequests(loader, modules, lang))
+                            .pipe(takeUntilDestroyed(destroyRef))
+                            .subscribe((results) => {
+                            const merged = Object.assign({}, ...results);
+                            store.setTranslation(merged, lang);
+                        });
+                    };
+                    // Merge background revalidation updates into the store
+                    loader.revalidated$
+                        .pipe(takeUntilDestroyed(destroyRef))
+                        .subscribe(({ lang, data }) => store.setTranslation(data, lang));
+                    // Hydrate from IndexedDB cache immediately (no metadata needed),
+                    // then let the normal metadata + API flow handle revalidation.
+                    if (config.revalidateInBackground && config.cacheStorage === 'indexeddb') {
+                        const lang = store.activeLang();
+                        forkJoin(buildCacheRequests(loader, modules, lang))
+                            .pipe(takeUntilDestroyed(destroyRef))
+                            .subscribe((results) => {
+                            // Only hydrate if the store hasn't been populated yet
+                            // (avoids overwriting fresher API data that arrived first)
+                            if (store.ready())
+                                return;
+                            const cached = results.filter((r) => r != null);
+                            if (cached.length > 0) {
+                                store.setTranslation(Object.assign({}, ...cached), lang);
+                            }
+                        });
+                    }
+                    // Load for current language (metadata + API)
+                    loader
+                        .ensureMetadataLoaded()
+                        .pipe(takeUntilDestroyed(destroyRef))
+                        .subscribe(() => loadForLang(store.activeLang()));
+                    // Re-load when language changes
+                    let previousLang = store.activeLang();
+                    effect(() => {
+                        const newLang = store.activeLang();
+                        if (newLang !== previousLang) {
+                            previousLang = newLang;
+                            loader
+                                .ensureMetadataLoaded()
+                                .pipe(takeUntilDestroyed(destroyRef))
+                                .subscribe(() => loadForLang(newLang));
+                        }
+                    });
+                }),
+            ]
+            : []),
+    ]);
+}
+
+function normalizeEntries(modules) {
+    return modules.map((m) => (typeof m === 'string' ? { module: m } : m));
+}
+/**
+ * Route-level provider that lazily loads specific UILM modules on navigation.
+ *
+ * In `'eager'` strategy mode, translations are typically already cached
+ * from the initial `APP_INITIALIZER` load. The loader's cache deduplication
+ * ensures no redundant HTTP calls are made.
+ *
+ * Re-fetches automatically when the active language changes.
+ * Subscriptions are auto-cleaned via `DestroyRef`.
+ *
+ * @publicApi
+ */
+function provideUilmScope(config) {
+    const entries = normalizeEntries(config.modules);
+    return makeEnvironmentProviders([
+        provideEnvironmentInitializer(() => {
+            const loader = inject(UilmLoader);
+            const store = inject(UilmStore);
+            const destroyRef = inject(DestroyRef);
+            const globalConfig = inject(BLOCKS_LOCALIZATION_CONFIG);
+            const loadForLang = (lang) => {
+                if (entries.length === 0)
+                    return;
+                const requests = entries.map((e) => loader.fetchModuleTranslations(lang, e.module, e.alias));
+                forkJoin(requests)
+                    .pipe(takeUntilDestroyed(destroyRef))
+                    .subscribe((results) => {
+                    const merged = Object.assign({}, ...results);
+                    store.setTranslation(merged, lang);
+                });
+            };
+            // Merge background revalidation updates into the store
+            loader.revalidated$
+                .pipe(takeUntilDestroyed(destroyRef))
+                .subscribe(({ lang, data }) => store.setTranslation(data, lang));
+            // Hydrate from IndexedDB cache immediately for instant rendering
+            if (globalConfig.revalidateInBackground &&
+                globalConfig.cacheStorage === 'indexeddb' &&
+                entries.length > 0) {
+                const lang = store.activeLang();
+                const cacheRequests = entries.map((e) => loader.loadFromCacheOnly(lang, e.module, e.alias));
+                forkJoin(cacheRequests)
+                    .pipe(takeUntilDestroyed(destroyRef))
+                    .subscribe((results) => {
+                    // Only hydrate if the store hasn't been populated yet
+                    // (avoids overwriting fresher API data that arrived first)
+                    if (store.ready())
+                        return;
+                    const cached = results.filter((r) => r != null);
+                    if (cached.length > 0) {
+                        store.setTranslation(Object.assign({}, ...cached), lang);
+                    }
+                });
+            }
+            // In eager mode, skip the initial fetch — APP_INITIALIZER already loaded everything.
+            // The loader cache will short-circuit anyway, but this avoids unnecessary forkJoin overhead.
+            if (globalConfig.strategy !== 'eager') {
+                loader
+                    .ensureMetadataLoaded()
+                    .pipe(takeUntilDestroyed(destroyRef))
+                    .subscribe(() => loadForLang(store.activeLang()));
+            }
+            // Re-load when language changes (always needed — even in eager mode)
+            let previousLang = store.activeLang();
+            effect(() => {
+                const newLang = store.activeLang();
+                if (newLang !== previousLang) {
+                    previousLang = newLang;
+                    loader
+                        .ensureMetadataLoaded()
+                        .pipe(takeUntilDestroyed(destroyRef))
+                        .subscribe(() => loadForLang(newLang));
+                }
+            });
+        }),
+    ]);
+}
+
+/**
+ * Headless language switching service.
+ * Provides programmatic control over the active language.
+ */
+class BlocksLangSwitcher {
+    store = inject(UilmStore);
+    loader = inject(UilmLoader);
+    /** Active language as a signal. */
+    activeLang = this.store.activeLang;
+    /** Get the currently active short language code. */
+    getActiveLang() {
+        return this.store.activeLang();
+    }
+    /** Get the list of configured available language codes. */
+    getAvailableLangs() {
+        return this.store.getAvailableLangs();
+    }
+    /**
+     * Switch the active language.
+     * @param lang Short language code (e.g. 'en', 'de')
+     * @param reload Whether to reload the page after switching. Default: false
+     */
+    setActiveLang(lang, reload = false) {
+        this.store.setActiveLang(lang);
+        if (reload && typeof window !== 'undefined') {
+            window.location.reload();
+        }
+    }
+    /** Fetch available languages from the UILM API. */
+    getAvailableLanguagesFromApi() {
+        return this.loader.getAvailableLanguages();
+    }
+    /** Clear the translation cache. */
+    clearCache() {
+        this.loader.clearCache();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: BlocksLangSwitcher, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: BlocksLangSwitcher, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: BlocksLangSwitcher, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/**
+ * Structural directive that provides a translation function to the template.
+ * Re-renders when the active language or translations change.
+ *
+ * @example
+ * ```html
+ * <section *uilmTranslate="let t">
+ *   <p>{{ t('dashboard.LABEL.TITLE') }}</p>
+ * </section>
+ * ```
+ *
+ * With scope (auto-prefixes keys):
+ * ```html
+ * <section *uilmTranslate="let t; scope: 'dashboard'">
+ *   <p>{{ t('LABEL.TITLE') }}</p>  <!-- resolves to dashboard.LABEL.TITLE -->
+ * </section>
+ * ```
+ */
+class UilmTranslateDirective {
+    store = inject(UilmStore);
+    templateRef = inject((TemplateRef));
+    vcr = inject(ViewContainerRef);
+    viewRef = null;
+    /** Optional scope prefix */
+    uilmTranslateScope = input('', ...(ngDevMode ? [{ debugName: "uilmTranslateScope" }] : []));
+    constructor() {
+        effect(() => {
+            this.store.activeLang();
+            this.store.version();
+            const isReady = this.store.ready();
+            if (isReady) {
+                this.ensureView();
+            }
+            else {
+                this.vcr.clear();
+                this.viewRef = null;
+            }
+        });
+    }
+    ensureView() {
+        const scope = this.uilmTranslateScope();
+        const translateFn = (key, params) => {
+            const resolve = (k) => this.store.has(k) ? this.store.translate(k, params) : null;
+            const result = scope ? (resolve(`${scope}.${key}`) ?? resolve(key)) : resolve(key);
+            return result ?? key;
+        };
+        if (this.viewRef) {
+            // Update context in-place — preserves DOM, focus, scroll, animation state
+            this.viewRef.context.$implicit = translateFn;
+            this.viewRef.context.uilmTranslate = translateFn;
+            this.viewRef.markForCheck();
+        }
+        else {
+            this.viewRef = this.vcr.createEmbeddedView(this.templateRef, {
+                $implicit: translateFn,
+                uilmTranslate: translateFn,
+            });
+        }
+    }
+    static ngTemplateContextGuard(_dir, _ctx) {
+        return true;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: UilmTranslateDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "20.3.19", type: UilmTranslateDirective, isStandalone: true, selector: "[uilmTranslate]", inputs: { uilmTranslateScope: { classPropertyName: "uilmTranslateScope", publicName: "uilmTranslateScope", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: UilmTranslateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[uilmTranslate]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [], propDecorators: { uilmTranslateScope: [{ type: i0.Input, args: [{ isSignal: true, alias: "uilmTranslateScope", required: false }] }] } });
+
+/**
+ * Resolves a multilingual object to the value matching the current active language.
+ *
+ * @example
+ * ```html
+ * <!-- Given: { en: 'Hello', de: 'Hallo', fr: 'Bonjour' } -->
+ * {{ item.name | multiLang }}  <!-- outputs 'Hello' when lang is 'en' -->
+ * ```
+ */
+class MultiLangPipe {
+    store = inject(UilmStore);
+    transform(value) {
+        if (!value || typeof value === 'string') {
+            return value ?? '';
+        }
+        const lang = this.store.activeLang();
+        const defaultLang = this.store.getAvailableLangs()[0];
+        return value[lang] ?? (defaultLang ? value[defaultLang] : '') ?? '';
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: MultiLangPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "20.3.19", ngImport: i0, type: MultiLangPipe, isStandalone: true, name: "multiLang", pure: false });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: MultiLangPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'multiLang',
+                    standalone: true,
+                    pure: false,
+                }]
+        }] });
+
+/**
+ * Impure pipe that translates a key using the UILM store.
+ * Re-evaluates when the active language or translations change.
+ *
+ * @example
+ * ```html
+ * <p>{{ 'dashboard.LABEL.TITLE' | uilmTranslate }}</p>
+ * <p>{{ 'LABEL.HELLO' | uilmTranslate: { name: userName } }}</p>
+ * ```
+ */
+class UilmTranslatePipe {
+    store = inject(UilmStore);
+    lastKey = '';
+    lastLang = '';
+    lastVersion = -1;
+    lastParamsJson = '';
+    lastValue = '';
+    transform(key, params) {
+        const lang = this.store.activeLang();
+        const version = this.store.version();
+        if (!this.store.ready()) {
+            return '';
+        }
+        const paramsJson = params ? JSON.stringify(params) : '';
+        if (key === this.lastKey &&
+            lang === this.lastLang &&
+            version === this.lastVersion &&
+            paramsJson === this.lastParamsJson) {
+            return this.lastValue;
+        }
+        this.lastKey = key;
+        this.lastLang = lang;
+        this.lastVersion = version;
+        this.lastParamsJson = paramsJson;
+        this.lastValue = this.store.has(key)
+            ? this.store.translate(key, params)
+            : key;
+        return this.lastValue;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: UilmTranslatePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "20.3.19", ngImport: i0, type: UilmTranslatePipe, isStandalone: true, name: "uilmTranslate", pure: false });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: UilmTranslatePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'uilmTranslate',
+                    standalone: true,
+                    pure: false,
+                }]
+        }] });
+
+/**
+ * Translation service for component classes.
+ * Fully signal-based with sync helpers.
+ *
+ * @example
+ * ```typescript
+ * private readonly uilm = inject(UilmTranslateService);
+ *
+ * // Signal-based (reactive, updates on lang change + translation load)
+ * title = this.uilm.t('dashboard.LABEL.TITLE');
+ * // In template: {{ title() }}
+ *
+ * // Sync snapshot (does NOT react)
+ * label = this.uilm.translate('dashboard.LABEL.TITLE');
+ * ```
+ */
+class UilmTranslateService {
+    store = inject(UilmStore);
+    /** Active language as a signal. */
+    activeLang = this.store.activeLang;
+    /**
+     * Signal-based translation. Auto-updates on language change
+     * and when new translations are loaded.
+     */
+    t(key, params) {
+        return computed(() => this.store.translate(key, params));
+    }
+    /** Synchronous translation snapshot. Does NOT react to changes. */
+    translate(key, params) {
+        return this.store.translate(key, params);
+    }
+    /** Current active language code. */
+    getActiveLang() {
+        return this.store.activeLang();
+    }
+    /** Set active language. */
+    setActiveLang(lang) {
+        this.store.setActiveLang(lang);
+    }
+    /**
+     * Signal-based batch translation. Reactive to lang and translation changes.
+     */
+    tMany(keys, params) {
+        return computed(() => {
+            const result = {};
+            for (const key of keys) {
+                result[key] = this.store.translate(key, params);
+            }
+            return result;
+        });
+    }
+    /** Synchronous batch translation snapshot. */
+    translateMany(keys, params) {
+        const result = {};
+        for (const key of keys) {
+            result[key] = this.store.translate(key, params);
+        }
+        return result;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: UilmTranslateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: UilmTranslateService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: UilmTranslateService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class UilmLoadingScreenComponent {
+    title = input('Loading', ...(ngDevMode ? [{ debugName: "title" }] : []));
+    description = input('Loading translations...', ...(ngDevMode ? [{ debugName: "description" }] : []));
+    /**
+     * Optional custom template to replace the entire default loading UI.
+     *
+     * @example
+     * ```html
+     * <ng-template #customLoading>
+     *   <div class="my-loading">
+     *     <img src="assets/logo.svg" />
+     *     <p>Please wait...</p>
+     *   </div>
+     * </ng-template>
+     *
+     * <uilm-loading-screen [customTemplate]="customLoading" />
+     * ```
+     */
+    customTemplate = input(...(ngDevMode ? [undefined, { debugName: "customTemplate" }] : []));
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: UilmLoadingScreenComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.3.19", type: UilmLoadingScreenComponent, isStandalone: true, selector: "uilm-loading-screen", inputs: { title: { classPropertyName: "title", publicName: "title", isSignal: true, isRequired: false, transformFunction: null }, description: { classPropertyName: "description", publicName: "description", isSignal: true, isRequired: false, transformFunction: null }, customTemplate: { classPropertyName: "customTemplate", publicName: "customTemplate", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: `
+    <div class="uilm-loading-screen">
+      @if (customTemplate()) {
+        <ng-container *ngTemplateOutlet="customTemplate()!" />
+      } @else {
+        <div class="uilm-loading-content">
+          <div class="uilm-loading-logo">
+            <svg
+              width="44"
+              height="44"
+              viewBox="0 0 24 24"
+              fill="none"
+              xmlns="http://www.w3.org/2000/svg"
+            >
+              <path d="M12 2L2 7l10 5 10-5-10-5z" fill="#6366f1" />
+              <path
+                d="M2 17l10 5 10-5"
+                stroke="#6366f1"
+                stroke-opacity="0.35"
+                stroke-width="1.5"
+                stroke-linecap="round"
+                stroke-linejoin="round"
+              />
+              <path
+                d="M2 12l10 5 10-5"
+                stroke="#6366f1"
+                stroke-opacity="0.6"
+                stroke-width="1.5"
+                stroke-linecap="round"
+                stroke-linejoin="round"
+              />
+            </svg>
+          </div>
+          <h2 class="uilm-loading-title">{{ title() }}</h2>
+          <p class="uilm-loading-description">{{ description() }}</p>
+          <div class="uilm-loading-bar">
+            <div class="uilm-loading-bar-fill"></div>
+          </div>
+        </div>
+      }
+    </div>
+  `, isInline: true, styles: [".uilm-loading-screen{position:fixed;inset:0;display:flex;align-items:center;justify-content:center;background:#fff;z-index:9999;animation:uilm-fade-in .3s ease-out}.uilm-loading-content{display:flex;flex-direction:column;align-items:center;gap:16px;text-align:center;padding:32px}.uilm-loading-logo{display:flex;align-items:center;justify-content:center;animation:uilm-pulse 2s ease-in-out infinite}.uilm-loading-title{margin:0;font-size:1.5rem;font-weight:600;color:#374151;letter-spacing:-.01em;font-family:system-ui,-apple-system,sans-serif}.uilm-loading-description{margin:0;font-size:1rem;color:#9ca3af;font-family:system-ui,-apple-system,sans-serif}.uilm-loading-bar{width:180px;height:3px;background:#0000000f;border-radius:3px;overflow:hidden;margin-top:4px}.uilm-loading-bar-fill{height:100%;width:40%;background:#6366f1;border-radius:3px;animation:uilm-slide 1.4s ease-in-out infinite}@keyframes uilm-fade-in{0%{opacity:0}to{opacity:1}}@keyframes uilm-pulse{0%,to{transform:scale(1);opacity:1}50%{transform:scale(1.04);opacity:.85}}@keyframes uilm-slide{0%{transform:translate(-100%)}50%{transform:translate(350%)}to{transform:translate(-100%)}}\n"], dependencies: [{ kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: UilmLoadingScreenComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'uilm-loading-screen', standalone: true, imports: [NgTemplateOutlet], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div class="uilm-loading-screen">
+      @if (customTemplate()) {
+        <ng-container *ngTemplateOutlet="customTemplate()!" />
+      } @else {
+        <div class="uilm-loading-content">
+          <div class="uilm-loading-logo">
+            <svg
+              width="44"
+              height="44"
+              viewBox="0 0 24 24"
+              fill="none"
+              xmlns="http://www.w3.org/2000/svg"
+            >
+              <path d="M12 2L2 7l10 5 10-5-10-5z" fill="#6366f1" />
+              <path
+                d="M2 17l10 5 10-5"
+                stroke="#6366f1"
+                stroke-opacity="0.35"
+                stroke-width="1.5"
+                stroke-linecap="round"
+                stroke-linejoin="round"
+              />
+              <path
+                d="M2 12l10 5 10-5"
+                stroke="#6366f1"
+                stroke-opacity="0.6"
+                stroke-width="1.5"
+                stroke-linecap="round"
+                stroke-linejoin="round"
+              />
+            </svg>
+          </div>
+          <h2 class="uilm-loading-title">{{ title() }}</h2>
+          <p class="uilm-loading-description">{{ description() }}</p>
+          <div class="uilm-loading-bar">
+            <div class="uilm-loading-bar-fill"></div>
+          </div>
+        </div>
+      }
+    </div>
+  `, styles: [".uilm-loading-screen{position:fixed;inset:0;display:flex;align-items:center;justify-content:center;background:#fff;z-index:9999;animation:uilm-fade-in .3s ease-out}.uilm-loading-content{display:flex;flex-direction:column;align-items:center;gap:16px;text-align:center;padding:32px}.uilm-loading-logo{display:flex;align-items:center;justify-content:center;animation:uilm-pulse 2s ease-in-out infinite}.uilm-loading-title{margin:0;font-size:1.5rem;font-weight:600;color:#374151;letter-spacing:-.01em;font-family:system-ui,-apple-system,sans-serif}.uilm-loading-description{margin:0;font-size:1rem;color:#9ca3af;font-family:system-ui,-apple-system,sans-serif}.uilm-loading-bar{width:180px;height:3px;background:#0000000f;border-radius:3px;overflow:hidden;margin-top:4px}.uilm-loading-bar-fill{height:100%;width:40%;background:#6366f1;border-radius:3px;animation:uilm-slide 1.4s ease-in-out infinite}@keyframes uilm-fade-in{0%{opacity:0}to{opacity:1}}@keyframes uilm-pulse{0%,to{transform:scale(1);opacity:1}50%{transform:scale(1.04);opacity:.85}}@keyframes uilm-slide{0%{transform:translate(-100%)}50%{transform:translate(350%)}to{transform:translate(-100%)}}\n"] }]
+        }], propDecorators: { title: [{ type: i0.Input, args: [{ isSignal: true, alias: "title", required: false }] }], description: [{ type: i0.Input, args: [{ isSignal: true, alias: "description", required: false }] }], customTemplate: [{ type: i0.Input, args: [{ isSignal: true, alias: "customTemplate", required: false }] }] } });
+
+/**
+ * Creates an empty record with keys for each provided language.
+ * Useful for initializing multilingual form models.
+ *
+ * @example
+ * createI18nRecord(['en', 'de', 'fr']) // { en: '', de: '', fr: '' }
+ */
+function createI18nRecord(langs) {
+    return langs.reduce((acc, lang) => {
+        acc[lang] = '';
+        return acc;
+    }, {});
+}
+
+/**
+ * Provides a test-friendly translation setup with in-memory translations.
+ * No HTTP calls are made.
+ *
+ * @example
+ * ```typescript
+ * TestBed.configureTestingModule({
+ *   providers: [
+ *     provideBlocksLocalizationTesting({
+ *       en: { 'dashboard.LABEL.HELLO': 'Hello', 'dashboard.LABEL.WORLD': 'World' },
+ *       de: { 'dashboard.LABEL.HELLO': 'Hallo', 'dashboard.LABEL.WORLD': 'Welt' },
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+function provideBlocksLocalizationTesting(translations = { en: {} }, config) {
+    const langs = Object.keys(translations);
+    const defaultLang = config?.defaultLang ?? langs[0] ?? 'en';
+    const fullConfig = {
+        uilmApiBaseUrl: '',
+        projectKey: '',
+        availableLangs: langs,
+        defaultLang,
+        ...config,
+    };
+    return makeEnvironmentProviders([
+        { provide: BLOCKS_LOCALIZATION_CONFIG, useValue: fullConfig },
+        provideEnvironmentInitializer(() => {
+            const store = inject(UilmStore);
+            for (const [lang, data] of Object.entries(translations)) {
+                store.setTranslation(data, lang);
+            }
+            // Ensure deterministic active language regardless of leftover localStorage
+            store.setActiveLang(defaultLang);
+        }),
+    ]);
+}
+
+// ---------------------------------------------------------------------------
+// Core configuration
+// ---------------------------------------------------------------------------
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { BLOCKS_LOCALIZATION_CONFIG, BlocksLangSwitcher, MultiLangPipe, UilmIndexedDbCache, UilmLoader, UilmLoadingScreenComponent, UilmStore, UilmTranslateDirective, UilmTranslatePipe, UilmTranslateService, buildReverseMapping, createI18nRecord, flattenJson, provideBlocksLocalization, provideBlocksLocalizationTesting, provideUilmScope, toFullLangCode, toShortLangCode };
+//# sourceMappingURL=seliseblocks-blocks-angular-localization.mjs.map