@reforgium/presentia 1.3.0 → 1.4.0

package/fesm2022/reforgium-presentia.mjs

@@ -1,14 +1,14 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, signal, computed, inject, PLATFORM_ID, afterRenderEffect, Injectable, TemplateRef, ViewContainerRef, effect, Input, Directive, input, ElementRef, Renderer2, Injector, afterNextRender, runInInjectionContext, Optional, Inject, Pipe, makeEnvironmentProviders, LOCALE_ID, DestroyRef } from '@angular/core';
+import { InjectionToken, signal, computed, inject, DestroyRef, PLATFORM_ID, afterRenderEffect, Injectable, TemplateRef, ViewContainerRef, effect, Input, Directive, input, ElementRef, Renderer2, Injector, afterNextRender, runInInjectionContext, Pipe, makeEnvironmentProviders, LOCALE_ID } from '@angular/core';
 import { TRANSLATION, SELECTED_LANG, CHANGE_LANG, SELECTED_THEME, CHANGE_THEME, CURRENT_DEVICE, deepEqual } from '@reforgium/internal';
 import { BreakpointObserver } from '@angular/cdk/layout';
 import { isPlatformBrowser, DOCUMENT } from '@angular/common';
-import { fromEvent, debounceTime, startWith, filter as filter$1, map } from 'rxjs';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { fromEvent, debounceTime, firstValueFrom, tap, filter as filter$1 } from 'rxjs';
 import { HttpClient } from '@angular/common/http';
 import { Title, Meta } from '@angular/platform-browser';
 import { Router, ActivatedRoute, NavigationEnd } from '@angular/router';
 import { filter } from 'rxjs/operators';
-import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
 
 /**
  * Default breakpoints for device type detection.
@@ -108,6 +108,7 @@ class AdaptiveService {
     isPortrait = computed(() => this.#height() > this.#width(), ...(ngDevMode ? [{ debugName: "isPortrait" }] : []));
     deviceBreakpoints = inject(DEVICE_BREAKPOINTS);
     devicePriority = Object.keys(this.deviceBreakpoints);
+    destroyRef = inject(DestroyRef);
     breakpointObserver = inject(BreakpointObserver);
     isBrowser = isPlatformBrowser(inject(PLATFORM_ID));
     constructor() {
@@ -119,15 +120,23 @@ class AdaptiveService {
             this.#width.set(window.innerWidth);
             this.#height.set(window.innerHeight);
         });
-        this.breakpointObserver.observe(Object.values(this.deviceBreakpoints)).subscribe((state) => {
-            const device = this.devicePriority.find((key) => state.breakpoints[this.deviceBreakpoints[key]]);
-            this.#device.set(device ?? 'desktop');
+        this.breakpointObserver
+            .observe(Object.values(this.deviceBreakpoints))
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe((state) => {
+            const device = this.devicePriority.find((key) => state.breakpoints[this.deviceBreakpoints[key]]) ?? 'desktop';
+            if (this.#device() !== device) {
+                this.#device.set(device);
+            }
         });
         fromEvent(window, 'resize')
             .pipe(debounceTime(100))
+            .pipe(takeUntilDestroyed(this.destroyRef))
             .subscribe(() => {
-            this.#width.set(window.innerWidth);
-            this.#height.set(window.innerHeight);
+            const width = window.innerWidth;
+            const height = window.innerHeight;
+            this.#width() !== width && this.#width.set(width);
+            this.#height() !== height && this.#height.set(height);
         });
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: AdaptiveService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
@@ -214,6 +223,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.1", ngImpor
 
 const innerLangVal = Symbol('reInnerLangVal');
 
+const LANG_MISSING_KEY_HANDLER = new InjectionToken('RE_LANG_MISSING_KEY_HANDLER');
+
 /**
  * Injection token for providing locale configuration to the language module.
  *
@@ -241,30 +252,48 @@ const LANG_CONFIG = new InjectionToken('RE_LANG_CONFIG');
  * throughout the application.
  */
 class LangService {
+    static BUILTIN_LANGS = ['ru', 'kg', 'en'];
+    static LANG_CODE_RE = /^[a-z]{2,3}(?:-[a-z0-9]{2,8})?$/;
     config = inject(LANG_CONFIG);
     http = inject(HttpClient);
     isBrowser = isPlatformBrowser(inject(PLATFORM_ID));
+    missingKeyHandler = inject(LANG_MISSING_KEY_HANDLER, { optional: true });
+    supportedLangSet = new Set([
+        ...LangService.BUILTIN_LANGS,
+        ...this.normalizeSupportedLangs(this.config.supportedLangs ?? []),
+    ]);
     #lang = signal(this.getStoredLang(), ...(ngDevMode ? [{ debugName: "#lang" }] : []));
     #cache = signal({}, ...(ngDevMode ? [{ debugName: "#cache" }] : []));
     #loadedNamespaces = new Set();
     #pendingLoads = new Map();
+    #pendingBatchLoads = new Map();
+    #namespaceLoadedAt = new Map();
+    #missingKeyFallbacks = new Map();
     /**
      * Computed property determining the current language setting.
      *
-     * - If private method `#lang` returns 'ru', this property will return 'ru'.
-     * - If `#lang` returns another value, the `config.kgValue` property is checked:
+     * - If private method `#lang` returns 'kg', `config.kgValue` is checked:
      * - If `config.kgValue` is defined, the property will return its value.
      * - If `config.kgValue` is not defined, the property will return the default value 'kg'.
+     * - For other languages (e.g. `ru`, `en`) returns source language as-is.
      */
     currentLang = computed(() => {
         const lang = this.#lang();
-        return lang === 'ru' ? 'ru' : (this.config?.kgValue ?? 'kg');
+        return lang === 'kg' ? (this.config?.kgValue ?? 'kg') : lang;
     }, ...(ngDevMode ? [{ debugName: "currentLang" }] : []));
     /**
      * Extracts readonly value from private property `#lang` and assigns it to `innerLangVal`.
      * Expected that property `#lang` has `asReadonly` method that returns immutable representation.
      */
     [innerLangVal] = this.#lang.asReadonly();
+    constructor() {
+        const preload = this.config.preloadNamespaces ?? [];
+        if (preload.length) {
+            queueMicrotask(() => {
+                void this.loadNamespaces(preload);
+            });
+        }
+    }
     /**
      * Sets the current language for the application.
      *
@@ -273,44 +302,32 @@ class LangService {
      * @return {void} Returns no value.
      */
     setLang(lang) {
-        const langVal = lang === 'ky' ? 'kg' : lang;
+        const langVal = this.normalizeLang(lang);
+        if (!langVal || !this.supportedLangSet.has(langVal)) {
+            return;
+        }
         if (langVal !== this.#lang()) {
             this.#lang.set(langVal);
             if (this.isBrowser) {
                 localStorage.setItem('lang', langVal);
             }
-            const namespaces = Array.from(this.#loadedNamespaces.values()).map((key) => key.split('.')[1]);
+            const namespaces = Array.from(this.#loadedNamespaces.values()).map((key) => this.namespaceFromKey(key));
             this.#loadedNamespaces.clear();
-            namespaces.forEach((ns) => void this.loadNamespace(ns));
+            this.#namespaceLoadedAt.clear();
+            void this.loadNamespaces(namespaces);
         }
     }
-    /**
-     * Gets value based on a provided query and optionally applies specified parameters.
-     *
-     * @param {string} query - Query string used to retrieve desired value.
-     * @param {LangParams} [params] - Optional parameters to apply to retrieved value.
-     * @return {string} Retrieved value after optional parameter application,
-     * or default value if a query is not found.
-     */
     get(query, params) {
         const value = this.getChainedValue(query);
+        const baseValue = value ?? this.resolveMissingValue(query);
         if (params) {
-            return this.applyParams((value ?? query), params);
+            return this.applyParams(baseValue, params);
         }
-        return value ?? this.config.defaultValue ?? query;
+        return baseValue;
     }
-    /**
-     * Observes changes to a specified translation key and dynamically computes its value.
-     *
-     * @param {string} query - Translation key to observe, typically in format "namespace.key".
-     * @param {LangParams} [params] - Optional parameters for interpolation or
-     * dynamic content replacement in translation value.
-     * @return {Signal<string>} Computed value that dynamically updates
-     * with translation matching a provided query and parameters.
-     */
     observe(query, params) {
         const [ns] = query.split('.');
-        if (!this.#loadedNamespaces.has(this.makeNamespaceKey(ns))) {
+        if (!this.isNamespaceLoaded(ns)) {
             void this.loadNamespace(ns);
         }
         return computed(() => this.get(query, params));
@@ -323,33 +340,117 @@ class LangService {
      * or rejects when error occurs during a process.
      */
     async loadNamespace(ns) {
-        const key = this.makeNamespaceKey(ns);
-        if (this.#loadedNamespaces.has(key)) {
+        const requestedLang = this.#lang();
+        const key = this.makeNamespaceKey(ns, requestedLang);
+        if (this.isNamespaceValid(key)) {
             return;
         }
+        this.tryExpireNamespace(key);
         if (this.#pendingLoads.has(key)) {
             return this.#pendingLoads.get(key);
         }
-        const promise = new Promise((resolve, reject) => {
-            this.http.get(this.makeUrl(ns)).subscribe({
-                next: (res) => {
-                    const resolved = Array.isArray(res) ? this.parseModelToRecord(res) : this.parseAssetToRecord(ns, res);
+        const promise = (async () => {
+            try {
+                await firstValueFrom(this.http.request('GET', this.makeUrl(ns, requestedLang), this.makeRequestOptions(ns, requestedLang)).pipe(tap((res) => {
+                    // Ignore stale responses from a previously selected language.
+                    if (this.#lang() !== requestedLang) {
+                        return;
+                    }
+                    const resolved = this.adaptResponse(res, ns, requestedLang);
                     this.#cache.update((existing) => ({ ...existing, ...resolved }));
                     this.#loadedNamespaces.add(key);
-                    resolve();
-                },
-                error: (err) => {
-                    this.#pendingLoads.delete(key);
-                    reject(err);
-                },
-                complete: () => this.#pendingLoads.delete(key),
-            });
-        });
+                    this.#namespaceLoadedAt.set(key, Date.now());
+                    this.enforceNamespaceCacheLimit(requestedLang);
+                })));
+            }
+            finally {
+                this.#pendingLoads.delete(key);
+            }
+        })();
         this.#pendingLoads.set(key, promise);
         return promise;
     }
     isNamespaceLoaded(ns) {
-        return this.#loadedNamespaces.has(this.makeNamespaceKey(ns));
+        const key = this.makeNamespaceKey(ns);
+        const isValid = this.isNamespaceValid(key);
+        if (!isValid) {
+            this.tryExpireNamespace(key);
+        }
+        return isValid;
+    }
+    async loadNamespaces(namespaces) {
+        const uniqueNamespaces = Array.from(new Set(namespaces.map((ns) => ns.trim()).filter(Boolean)));
+        if (!uniqueNamespaces.length) {
+            return;
+        }
+        const requestedLang = this.#lang();
+        const toLoad = uniqueNamespaces.filter((ns) => {
+            const key = this.makeNamespaceKey(ns, requestedLang);
+            const valid = this.isNamespaceValid(key);
+            if (!valid) {
+                this.tryExpireNamespace(key);
+            }
+            return !valid;
+        });
+        if (!toLoad.length) {
+            return;
+        }
+        if (!(this.config.batchRequestBuilder && this.config.batchResponseAdapter) || toLoad.length < 2) {
+            await Promise.all(toLoad.map((ns) => this.loadNamespace(ns)));
+            return;
+        }
+        const batchKey = this.makeBatchKey(requestedLang, toLoad);
+        if (this.#pendingBatchLoads.has(batchKey)) {
+            return this.#pendingBatchLoads.get(batchKey);
+        }
+        const promise = (async () => {
+            try {
+                const context = {
+                    namespaces: toLoad,
+                    lang: requestedLang,
+                    isFromAssets: this.config.isFromAssets,
+                    baseUrl: this.config.url,
+                };
+                const url = this.config.batchRequestBuilder(context);
+                const response = await firstValueFrom(this.http.request('GET', url, this.makeBatchRequestOptions(context)));
+                if (this.#lang() !== requestedLang) {
+                    return;
+                }
+                const payloads = this.config.batchResponseAdapter(response, this.toBatchResponseContext(context));
+                const merged = {};
+                for (const ns of toLoad) {
+                    const nsPayload = payloads[ns];
+                    if (!nsPayload) {
+                        continue;
+                    }
+                    const adapted = this.adaptNamespacePayload(nsPayload, ns, requestedLang);
+                    Object.assign(merged, adapted);
+                    this.#loadedNamespaces.add(this.makeNamespaceKey(ns, requestedLang));
+                    this.#namespaceLoadedAt.set(this.makeNamespaceKey(ns, requestedLang), Date.now());
+                }
+                this.#cache.update((existing) => ({ ...existing, ...merged }));
+                this.enforceNamespaceCacheLimit(requestedLang);
+            }
+            finally {
+                this.#pendingBatchLoads.delete(batchKey);
+            }
+        })();
+        this.#pendingBatchLoads.set(batchKey, promise);
+        return promise;
+    }
+    evictNamespace(ns) {
+        const key = this.makeNamespaceKey(ns);
+        if (!this.#loadedNamespaces.has(key)) {
+            return;
+        }
+        this.#loadedNamespaces.delete(key);
+        this.#namespaceLoadedAt.delete(key);
+        this.removeNamespaceFromCache(ns);
+    }
+    clearNamespaceCache() {
+        this.#loadedNamespaces.clear();
+        this.#namespaceLoadedAt.clear();
+        this.#cache.set({});
     }
     parseModelToRecord(model) {
         const records = {};
@@ -366,7 +467,7 @@ class LangService {
         return records;
     }
     applyParams(text, params) {
-        return text.replace(/\{\{(.*?)}}/g, (_, k) => params[k.trim()] ?? '');
+        return text.replace(/\{\{(.*?)}}/g, (_, k) => String(params[k.trim()] ?? ''));
     }
     getChainedValue(query = '', source = this.#cache()) {
         if (!query || typeof source !== 'object') {
@@ -387,17 +488,163 @@ class LangService {
         return acc;
     }
     getStoredLang() {
+        const normalize = (value) => this.normalizeLang(value);
+        const fallbackLang = normalize(this.config.fallbackLang ?? null);
+        const defaultLang = normalize(this.config.defaultLang ?? null) ?? fallbackLang ?? 'ru';
         if (!this.isBrowser) {
-            return this.config.defaultLang || 'ru';
+            return defaultLang;
         }
-        return localStorage.getItem('lang') || this.config.defaultLang || 'ru';
+        return normalize(localStorage.getItem('lang')) ?? defaultLang;
     }
-    makeUrl(ns) {
-        const suffix = this.config.isFromAssets ? `.${this.#lang()}.json` : `?language=${this.#lang()}`;
+    makeUrl(ns, lang) {
+        if (this.config.requestBuilder) {
+            return this.config.requestBuilder(this.toRequestContext(ns, lang));
+        }
+        const suffix = this.config.isFromAssets ? `.${lang}.json` : `?language=${lang}`;
         return `${this.config.url}/${ns}${suffix}`;
     }
-    makeNamespaceKey(ns) {
-        return `${this.#lang()}.${ns}`;
+    adaptResponse(response, ns, lang) {
+        const context = { ns, lang, isFromAssets: this.config.isFromAssets };
+        const adapted = this.config.responseAdapter ? this.config.responseAdapter(response, context) : response;
+        return this.adaptNamespacePayload(adapted, ns, lang);
+    }
+    adaptNamespacePayload(payload, ns, _lang) {
+        const adapted = payload;
+        if (Array.isArray(adapted)) {
+            return this.parseModelToRecord(adapted);
+        }
+        if (this.isLangModel(adapted)) {
+            if (Object.keys(adapted).some((key) => key.startsWith(`${ns}.`))) {
+                return adapted;
+            }
+            return this.parseAssetToRecord(ns, adapted);
+        }
+        return {};
+    }
+    makeRequestOptions(ns, lang) {
+        if (!this.config.requestOptionsFactory) {
+            return { observe: 'body' };
+        }
+        return { ...this.config.requestOptionsFactory(this.toRequestContext(ns, lang)), observe: 'body' };
+    }
+    makeBatchRequestOptions(context) {
+        if (!this.config.requestOptionsFactory) {
+            return { observe: 'body' };
+        }
+        const options = this.config.requestOptionsFactory({
+            ns: context.namespaces.join(','),
+            lang: context.lang,
+            isFromAssets: context.isFromAssets,
+            baseUrl: context.baseUrl,
+        });
+        return { ...options, observe: 'body' };
+    }
+    toRequestContext(ns, lang) {
+        return { ns, lang, isFromAssets: this.config.isFromAssets, baseUrl: this.config.url };
+    }
+    toBatchResponseContext(context) {
+        return { namespaces: context.namespaces, lang: context.lang, isFromAssets: context.isFromAssets };
+    }
+    isNamespaceValid(key) {
+        if (!this.#loadedNamespaces.has(key)) {
+            return false;
+        }
+        const ttlMs = this.config.namespaceCache?.ttlMs;
+        if (!ttlMs || ttlMs <= 0) {
+            return true;
+        }
+        const loadedAt = this.#namespaceLoadedAt.get(key);
+        if (!loadedAt) {
+            return false;
+        }
+        return Date.now() - loadedAt < ttlMs;
+    }
+    tryExpireNamespace(key) {
+        if (!this.#loadedNamespaces.has(key)) {
+            return;
+        }
+        const ttlMs = this.config.namespaceCache?.ttlMs;
+        if (!ttlMs || ttlMs <= 0) {
+            return;
+        }
+        const loadedAt = this.#namespaceLoadedAt.get(key);
+        if (!loadedAt || Date.now() - loadedAt >= ttlMs) {
+            this.#loadedNamespaces.delete(key);
+            this.#namespaceLoadedAt.delete(key);
+            this.removeNamespaceFromCache(this.namespaceFromKey(key));
+        }
+    }
+    enforceNamespaceCacheLimit(currentLang) {
+        const maxNamespaces = this.config.namespaceCache?.maxNamespaces;
+        if (!maxNamespaces || maxNamespaces <= 0) {
+            return;
+        }
+        const langKeys = Array.from(this.#loadedNamespaces.values()).filter((key) => key.startsWith(`${currentLang}.`));
+        if (langKeys.length <= maxNamespaces) {
+            return;
+        }
+        const sorted = langKeys.sort((a, b) => (this.#namespaceLoadedAt.get(a) ?? 0) - (this.#namespaceLoadedAt.get(b) ?? 0));
+        const overflow = sorted.slice(0, langKeys.length - maxNamespaces);
+        for (const key of overflow) {
+            this.#loadedNamespaces.delete(key);
+            this.#namespaceLoadedAt.delete(key);
+            this.removeNamespaceFromCache(this.namespaceFromKey(key));
+        }
+    }
+    removeNamespaceFromCache(ns) {
+        this.#cache.update((existing) => {
+            const next = {};
+            for (const [key, value] of Object.entries(existing)) {
+                if (key === ns || key.startsWith(`${ns}.`)) {
+                    continue;
+                }
+                next[key] = value;
+            }
+            return next;
+        });
+    }
+    namespaceFromKey(key) {
+        const idx = key.indexOf('.');
+        return idx >= 0 ? key.slice(idx + 1) : key;
+    }
+    makeBatchKey(lang, namespaces) {
+        return `${lang}::${[...namespaces].sort().join('|')}`;
+    }
+    isLangModel(value) {
+        return typeof value === 'object' && value !== null;
+    }
+    makeNamespaceKey(ns, lang = this.#lang()) {
+        return `${lang}.${ns}`;
+    }
+    resolveMissingValue(query) {
+        const fallback = this.config.defaultValue ?? query;
+        if (!this.missingKeyHandler) {
+            return fallback;
+        }
+        const cacheKey = `${this.#lang()}::${query}`;
+        if (!this.#missingKeyFallbacks.has(cacheKey)) {
+            const next = this.missingKeyHandler(query, { lang: this.#lang() });
+            if (typeof next === 'string') {
+                this.#missingKeyFallbacks.set(cacheKey, next);
+            }
+            else {
+                this.#missingKeyFallbacks.set(cacheKey, null);
+            }
+        }
+        return this.#missingKeyFallbacks.get(cacheKey) ?? fallback;
+    }
+    normalizeLang(value) {
+        const normalized = value?.trim().toLowerCase();
+        if (!normalized) {
+            return null;
+        }
+        const resolved = normalized === 'ky' ? 'kg' : normalized;
+        return this.supportedLangSet.has(resolved) ? resolved : null;
+    }
+    normalizeSupportedLangs(langs) {
+        return langs
+            .map((lang) => lang.trim().toLowerCase())
+            .filter((lang) => !!lang && LangService.LANG_CODE_RE.test(lang));
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: LangService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: LangService, providedIn: 'root' });
@@ -405,7 +652,7 @@ class LangService {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: LangService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }] });
+        }], ctorParameters: () => [] });
 
 /**
  * **LangDirective** - directive for automatic localization of attributes and text content.
@@ -434,6 +681,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.1", ngImpor
  * @publicApi
  */
 class LangDirective {
+    static TEXT_NODE_TYPE = 3;
+    warned = new Set();
     /**
      * Localization mode: defines which parts of the element will be translated.
      * @default 'all'
@@ -560,7 +809,7 @@ class LangDirective {
         }
         const keyAttr = 'data-re-lang-text';
         const storedKey = native.getAttribute(keyAttr);
-        let textNode = Array.from(native.childNodes).find((n) => n.nodeType === Node.TEXT_NODE);
+        let textNode = Array.from(native.childNodes).find((n) => n.nodeType === LangDirective.TEXT_NODE_TYPE);
         const key = (keyOverride ?? storedKey ?? textNode?.nodeValue?.trim() ?? '').trim();
         if (!this.looksLikeKey(key)) {
             if (storedKey) {
@@ -575,8 +824,8 @@ class LangDirective {
             native.setAttribute(keyAttr, key);
         }
         if (!textNode) {
-            textNode = document.createTextNode('');
-            native.appendChild(textNode);
+            textNode = this.renderer.createText('');
+            this.renderer.appendChild(native, textNode);
         }
         this.getLangValue(key).then((langed) => this.renderer.setValue(textNode, langed));
     }
@@ -591,6 +840,11 @@ class LangDirective {
     }
     warn(message, value) {
         if (typeof ngDevMode !== 'undefined') {
+            const key = `${message}|${String(value ?? '')}`;
+            if (this.warned.has(key)) {
+                return;
+            }
+            this.warned.add(key);
             // eslint-disable-next-line no-console
             console.warn(message, value);
         }
@@ -636,7 +890,9 @@ class LangDirective {
      */
     async getLangValue(key) {
         const [ns] = key.split('.', 1);
-        await this.service.loadNamespace(ns);
+        if (!this.service.isNamespaceLoaded(ns)) {
+            await this.service.loadNamespace(ns);
+        }
         return this.service.get(key);
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: LangDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
@@ -668,19 +924,18 @@ const LANG_PIPE_CONFIG = new InjectionToken('RE_LANG_PIPE_CONFIG');
  * @implements {PipeTransform}
  */
 class LangPipe {
-    lang;
     cache = new Map();
+    lang = inject(LangService);
+    injector = inject(Injector);
     config;
     ttlMs;
     maxCacheSize;
-    constructor(lang = inject(LangService), config, injector) {
-        this.lang = lang;
-        const resolvedInjector = injector ?? inject(Injector);
-        const resolved = config ?? inject(LANG_PIPE_CONFIG, { optional: true }) ?? {};
+    constructor() {
+        const resolved = inject(LANG_PIPE_CONFIG, { optional: true }) ?? {};
         this.config = resolved;
         this.ttlMs = resolved.ttlMs ?? 5 * 60 * 1000;
         this.maxCacheSize = resolved.maxCacheSize ?? 500;
-        runInInjectionContext(resolvedInjector, () => {
+        runInInjectionContext(this.injector, () => {
             effect(() => {
                 // Clear cache on language change to avoid stale signals and unbounded growth.
                 this.lang.currentLang();
@@ -689,6 +944,9 @@ class LangPipe {
         });
     }
     transform(query, params) {
+        if (!query) {
+            return '';
+        }
         const key = this.makeKey(query, params);
         const now = Date.now();
         const existing = this.cache.get(key);
@@ -699,9 +957,10 @@ class LangPipe {
             this.cache.delete(key);
         }
         if (!this.cache.has(key)) {
-            this.cache.set(key, { value: this.lang.observe(query, params), ts: now });
+            this.cache.set(key, { value: this.lang.observe(query, params ?? undefined), ts: now });
             this.evictIfNeeded();
         }
+        const value = this.cache.get(key).value();
         const ns = query.split('.', 1)[0];
         if (ns && !this.lang.isNamespaceLoaded(ns)) {
             const placeholder = this.config.placeholder;
@@ -712,7 +971,7 @@ class LangPipe {
                 return placeholder;
             }
         }
-        return this.cache.get(key).value();
+        return value;
     }
     makeKey(query, params) {
         if (!params) {
@@ -732,23 +991,13 @@ class LangPipe {
             this.cache.delete(firstKey);
         }
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: LangPipe, deps: [{ token: LangService }, { token: LANG_PIPE_CONFIG, optional: true }, { token: Injector, optional: true }], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: LangPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
     static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.1.1", ngImport: i0, type: LangPipe, isStandalone: true, name: "lang", pure: false });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: LangPipe, decorators: [{
             type: Pipe,
             args: [{ name: 'lang', standalone: true, pure: false }]
-        }], ctorParameters: () => [{ type: LangService }, { type: undefined, decorators: [{
-                    type: Optional
-                }, {
-                    type: Inject,
-                    args: [LANG_PIPE_CONFIG]
-                }] }, { type: i0.Injector, decorators: [{
-                    type: Optional
-                }, {
-                    type: Inject,
-                    args: [Injector]
-                }] }] });
+        }], ctorParameters: () => [] });
 
 /**
  * Type-safe mapping of available theme names.
@@ -846,7 +1095,7 @@ class ThemeService {
      */
     theme = computed(() => this.#theme(), ...(ngDevMode ? [{ debugName: "theme" }] : []));
     /**
-     * Convenient flag returning `true` if light theme is active.
+     * Convenient flag returning `true` if the light theme is active.
      * Suitable for conditional style application or resource selection.
      */
     isLight = computed(() => this.#theme() === themes.light, ...(ngDevMode ? [{ debugName: "isLight" }] : []));
@@ -892,31 +1141,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.1", ngImpor
                 }]
         }], ctorParameters: () => [] });
 
-/**
- * Provides environment-level providers for Presentia application initialization.
- *
- * This function configures essential application services:
- * - Language and localization settings
- * - Theme configuration
- * - Adaptive/responsive breakpoints
- * - Current device detection
- *
- * @param {AppConfig} config - Configuration object containing locale, theme, and breakpoints settings.
- * @returns {EnvironmentProviders} A collection of Angular providers for the application environment.
- *
- * @example
- * ```typescript
- * export const appConfig: ApplicationConfig = {
- *   providers: [
- *     provideReInit({
- *       locale: { defaultLang: 'en', supportedLangs: ['en', 'ru'] },
- *       theme: { defaultTheme: 'dark' },
- *       breakpoints: { mobile: 768, tablet: 1024 }
- *     })
- *   ]
- * };
- * ```
- */
 function provideReInit(config) {
     return makeEnvironmentProviders([
         { provide: TRANSLATION, deps: [LangService], useFactory: (ls) => ls },
@@ -927,8 +1151,9 @@ function provideReInit(config) {
         { provide: CURRENT_DEVICE, deps: [AdaptiveService], useFactory: (ls) => ls.device },
         { provide: DEVICE_BREAKPOINTS, useValue: config.breakpoints || defaultBreakpoints },
         { provide: THEME_CONFIG, useValue: config.theme || defaultThemeConfig },
-        { provide: LANG_CONFIG, useValue: config.locale || { defaultValue: '████████' } },
+        { provide: LANG_CONFIG, useValue: config.locale || { defaultValue: '--------' } },
         { provide: LANG_PIPE_CONFIG, useValue: config.langPipe || {} },
+        { provide: LANG_MISSING_KEY_HANDLER, useValue: config.langMissingKeyHandler ?? null },
         { provide: LOCALE_ID, useValue: config.locale.defaultLang ?? 'ru' },
     ]);
 }
@@ -957,6 +1182,9 @@ class SeoService {
      * @param value title text
      */
     setTitle(value) {
+        if (this.title.getTitle() === value) {
+            return;
+        }
         this.title.setTitle(value);
     }
     /**
@@ -1021,14 +1249,25 @@ class SeoService {
             el.id = id;
             this.document.head.appendChild(el);
         }
-        el.text = JSON.stringify(schema);
+        const next = JSON.stringify(schema);
+        if (el.text !== next) {
+            el.text = next;
+        }
     }
     upsert(tag) {
+        const selector = tag.name ? `name='${tag.name}'` : tag.property ? `property='${tag.property}'` : null;
+        if (!selector) {
+            return;
+        }
+        const current = this.meta.getTag(selector);
+        if (current?.getAttribute('content') === tag.content) {
+            return;
+        }
         if (tag.name) {
-            this.meta.updateTag(tag, `name='${tag.name}'`);
+            this.meta.updateTag(tag, selector);
         }
         else if (tag.property) {
-            this.meta.updateTag(tag, `property='${tag.property}'`);
+            this.meta.updateTag(tag, selector);
         }
     }
     upsertLink(rel, href) {
@@ -1042,7 +1281,9 @@ class SeoService {
             link.rel = rel;
             head.appendChild(link);
         }
-        link.href = href;
+        if (link.getAttribute('href') !== href) {
+            link.href = href;
+        }
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: SeoService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: SeoService });
@@ -1082,7 +1323,7 @@ class SeoRouteListener {
      *                  Trailing slashes will be removed automatically.
      */
     init(baseUrl) {
-        const sub = this.router.events.pipe(filter((e) => e instanceof NavigationEnd)).subscribe(() => {
+        const applyRouteSeo = () => {
             const route = this.deepest(this.ar);
             const data = route.snapshot.data;
             const url = data.canonical ?? baseUrl.replace(/\/+$/, '') + this.router.url;
@@ -1098,8 +1339,11 @@ class SeoRouteListener {
                 url: url,
                 ...data.og,
             });
-        });
-        this.destroyRef.onDestroy(() => sub.unsubscribe());
+        };
+        applyRouteSeo();
+        this.router.events
+            .pipe(filter((e) => e instanceof NavigationEnd), takeUntilDestroyed(this.destroyRef))
+            .subscribe(() => applyRouteSeo());
     }
     /**
      * Recursively finds the deepest (most nested) activated route in the route tree.
@@ -1173,7 +1417,7 @@ class RouteWatcher {
         };
         read();
         this.router.events
-            .pipe(startWith(new NavigationEnd(0, this.router.url, this.router.url)), filter$1((e) => e instanceof NavigationEnd), map(() => true), takeUntilDestroyed(this.destroyRef))
+            .pipe(filter$1((e) => e instanceof NavigationEnd), takeUntilDestroyed(this.destroyRef))
             .subscribe(() => read());
     }
     /** Convenient selector for a data key with type-safe casting */
@@ -1204,5 +1448,5 @@ function joinUrl(segments) {
  * Generated bundle index. Do not edit.
  */
 
-export { AdaptiveService, DEVICE_BREAKPOINTS, IfDeviceDirective, LANG_CONFIG, LANG_PIPE_CONFIG, LangDirective, LangPipe, LangService, RouteWatcher, SeoRouteListener, SeoService, THEME_CONFIG, ThemeService, darkThemePrefix, defaultBreakpoints, defaultThemeConfig, innerLangVal, provideReInit, themes };
+export { AdaptiveService, DEVICE_BREAKPOINTS, IfDeviceDirective, LANG_CONFIG, LANG_MISSING_KEY_HANDLER, LANG_PIPE_CONFIG, LangDirective, LangPipe, LangService, RouteWatcher, SeoRouteListener, SeoService, THEME_CONFIG, ThemeService, darkThemePrefix, defaultBreakpoints, defaultThemeConfig, innerLangVal, provideReInit, themes };
 //# sourceMappingURL=reforgium-presentia.mjs.map