@reforgium/presentia 2.0.0 → 2.1.0

package/CHANGELOG.md

@@ -1,3 +1,22 @@
+## [2.1.0]: 05.04.2026
+### Refactor:
+- replaced presentia-specific persistence adapter behavior with storage contracts and strategies backed by `@reforgium/internal`
+- `LangService` and `ThemeService` now persist through storage interface bindings instead of direct localStorage-specific adapter semantics
+
+### Feat:
+- added grouped `storage` / `persistence` options for `providePresentia(...)` theme and lang config
+- kept `persistenceAdapter` as a compatibility alias during the transition to storage-based persistence
+
+### Fix:
+- aligned `persistence: 'none'` with a real no-op storage instead of pseudo-persistent in-memory behavior
+- preserved raw `lang` / `theme` browser storage keys while moving persistence onto shared storage contracts
+
+### Test:
+- updated provider and theme tests for the storage-based persistence contract
+- verified `presentia` typecheck, Vitest suite, and Angular package build after the persistence migration
+
+---
+
 ## [2.0.0]: 04.04.2026
 ### Feat:
 - added grouped `providePresentia(...)` v2 entry point and marked `provideReInit(...)` as legacy in dev mode

package/fesm2022/reforgium-presentia.mjs

@@ -1,6 +1,6 @@
 import * as i0 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, provideAppInitializer, LOCALE_ID } from '@angular/core';
-import { getChainedValue, deepEqual, compareRoutes, TRANSLATION, SELECTED_LANG, CHANGE_LANG, SELECTED_THEME, CHANGE_THEME, CURRENT_DEVICE } from '@reforgium/internal';
+import { InjectionToken, signal, computed, inject, DestroyRef, PLATFORM_ID, afterRenderEffect, Injectable, TemplateRef, ViewContainerRef, effect, Input, Directive, makeEnvironmentProviders, provideAppInitializer, input, ElementRef, Renderer2, Injector, afterNextRender, runInInjectionContext, Pipe, LOCALE_ID } from '@angular/core';
+import { LruCache, MemoryStorage, deepEqual, compareRoutes, getChainedValue, TRANSLATION, SELECTED_LANG, CHANGE_LANG, SELECTED_THEME, CHANGE_THEME, CURRENT_DEVICE } from '@reforgium/internal';
 import { BreakpointObserver } from '@angular/cdk/layout';
 import { isPlatformBrowser, DOCUMENT } from '@angular/common';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
@@ -280,6 +280,61 @@ const innerLangVal = Symbol('reInnerLangVal');
 
 const LANG_MISSING_KEY_HANDLER = new InjectionToken('RE_LANG_MISSING_KEY_HANDLER');
 
+function createPresentiaStorage(strategy, storage) {
+    if (storage) {
+        return storage;
+    }
+    switch (strategy ?? 'persist') {
+        case 'none':
+            return createNoopStorage();
+        case 'memory':
+            return new MemoryStorage();
+        case 'session':
+            return createBrowserStringStorage('session');
+        case 'lru':
+            return new LruCache(1);
+        case 'persist':
+        default:
+            return createBrowserStringStorage('local');
+    }
+}
+function createBrowserStringStorage(kind) {
+    const getStorage = () => {
+        if (typeof globalThis === 'undefined') {
+            return null;
+        }
+        return kind === 'local' ? (globalThis.localStorage ?? null) : (globalThis.sessionStorage ?? null);
+    };
+    return {
+        get length() {
+            return getStorage()?.length ?? 0;
+        },
+        get(key) {
+            return getStorage()?.getItem(key) ?? null;
+        },
+        set(key, value) {
+            getStorage()?.setItem(key, value);
+        },
+        remove(key) {
+            getStorage()?.removeItem(key);
+        },
+        clear() {
+            getStorage()?.clear();
+        },
+    };
+}
+function createNoopStorage() {
+    return {
+        get length() {
+            return 0;
+        },
+        get: () => null,
+        set: () => undefined,
+        remove: () => undefined,
+        clear: () => undefined,
+    };
+}
+
 /**
  * Optional DI token for a custom persistence adapter used by `LangService`
  * to store and retrieve the selected language (default key: `'lang'`).
@@ -291,7 +346,10 @@ const LANG_MISSING_KEY_HANDLER = new InjectionToken('RE_LANG_MISSING_KEY_HANDLER
  * { provide: LANG_PERSISTENCE_ADAPTER, useValue: sessionStorageAdapter }
  * ```
  */
-const LANG_PERSISTENCE_ADAPTER = new InjectionToken('RE_LANG_PERSISTENCE_ADAPTER');
+const defaultLangPersistenceAdapter = createPresentiaStorage('persist');
+const LANG_PERSISTENCE_ADAPTER = new InjectionToken('RE_LANG_PERSISTENCE_ADAPTER', {
+    factory: () => defaultLangPersistenceAdapter,
+});
 
 /**
  * Injection token for providing locale configuration to the language module.
@@ -313,6 +371,160 @@ const LANG_PERSISTENCE_ADAPTER = new InjectionToken('RE_LANG_PERSISTENCE_ADAPTER
  */
 const LANG_CONFIG = new InjectionToken('RE_LANG_CONFIG');
 
+function deepestActivatedRoute(route) {
+    let current = route;
+    while (current.firstChild) {
+        current = current.firstChild;
+    }
+    return current;
+}
+function deepestRouteSnapshot(snapshot) {
+    let current = snapshot;
+    while (current.firstChild) {
+        current = current.firstChild;
+    }
+    return current;
+}
+function joinUrl(segments) {
+    return segments.length ? segments.map((segment) => segment.path).join('/') : '';
+}
+function snapshotFullPath(snapshot) {
+    return snapshot.pathFromRoot
+        .map((route) => joinUrl(route.url))
+        .filter(Boolean)
+        .join('/');
+}
+function snapshotRoutePattern(snapshot) {
+    return snapshot.pathFromRoot
+        .map((route) => route.routeConfig?.path ?? '')
+        .filter(Boolean)
+        .join('/');
+}
+function snapshotMergedParams(snapshot) {
+    return snapshot.pathFromRoot.reduce((acc, route) => ({ ...acc, ...route.params }), {});
+}
+function snapshotDeepestParams(snapshot) {
+    const mergedParams = snapshotMergedParams(snapshot);
+    const keys = extractRouteParamKeys(snapshot.routeConfig?.path ?? '');
+    if (!keys.length) {
+        return {};
+    }
+    return keys.reduce((acc, key) => {
+        const value = mergedParams[key];
+        if (value !== undefined) {
+            acc[key] = value;
+        }
+        return acc;
+    }, {});
+}
+function snapshotMergedData(snapshot) {
+    return snapshot.pathFromRoot.reduce((acc, route) => ({ ...acc, ...route.data }), {});
+}
+function extractRouteParamKeys(path) {
+    return path
+        .split('/')
+        .filter((segment) => segment.startsWith(':'))
+        .map((segment) => segment.slice(1))
+        .filter(Boolean);
+}
+
+/**
+ * Reactive snapshot of the current route (the deepest active route).
+ * Updates on every `NavigationEnd` event.
+ */
+class RouteWatcher {
+    router = inject(Router);
+    destroyRef = inject(DestroyRef);
+    #params = signal({}, ...(ngDevMode ? [{ debugName: "#params" }] : /* istanbul ignore next */ []));
+    #deepestParams = signal({}, ...(ngDevMode ? [{ debugName: "#deepestParams" }] : /* istanbul ignore next */ []));
+    #query = signal({}, ...(ngDevMode ? [{ debugName: "#query" }] : /* istanbul ignore next */ []));
+    #data = signal({}, ...(ngDevMode ? [{ debugName: "#data" }] : /* istanbul ignore next */ []));
+    #mergedData = signal({}, ...(ngDevMode ? [{ debugName: "#mergedData" }] : /* istanbul ignore next */ []));
+    #url = signal('', ...(ngDevMode ? [{ debugName: "#url" }] : /* istanbul ignore next */ []));
+    #routePattern = signal('', ...(ngDevMode ? [{ debugName: "#routePattern" }] : /* istanbul ignore next */ []));
+    #fragment = signal(null, ...(ngDevMode ? [{ debugName: "#fragment" }] : /* istanbul ignore next */ []));
+    /** Params merged from root to deepest route. */
+    params = this.#params.asReadonly();
+    /** Params declared on the deepest route only. */
+    deepestParams = this.#deepestParams.asReadonly();
+    /** Query params from the current navigation. */
+    query = this.#query.asReadonly();
+    /** Deepest route data only. */
+    data = this.#data.asReadonly();
+    /** Route data merged from root to deepest route. */
+    mergedData = this.#mergedData.asReadonly();
+    /** Full current url path assembled from root to deepest route. */
+    url = this.#url.asReadonly();
+    /** Current route config pattern, e.g. `orgs/:orgId/users/:id`. */
+    routePattern = this.#routePattern.asReadonly();
+    /** Current url fragment without `#`. */
+    fragment = this.#fragment.asReadonly();
+    /** Combined computed snapshot. */
+    state = computed(() => ({
+        params: this.#params(),
+        deepestParams: this.#deepestParams(),
+        query: this.#query(),
+        data: this.#data(),
+        mergedData: this.#mergedData(),
+        url: this.#url(),
+        routePattern: this.#routePattern(),
+        fragment: this.#fragment(),
+    }), ...(ngDevMode ? [{ debugName: "state" }] : /* istanbul ignore next */ []));
+    constructor() {
+        const read = () => {
+            const snapshot = this.deepestSnapshot();
+            const nextUrl = snapshotFullPath(snapshot);
+            const nextRoutePattern = snapshotRoutePattern(snapshot);
+            const nextParams = snapshotMergedParams(snapshot);
+            const nextDeepestParams = snapshotDeepestParams(snapshot);
+            const nextMergedData = snapshotMergedData(snapshot);
+            const nextQuery = snapshot.queryParams;
+            const nextData = snapshot.data;
+            const nextFragment = snapshot.fragment ?? null;
+            !deepEqual(nextParams, this.#params()) && this.#params.set(nextParams);
+            !deepEqual(nextDeepestParams, this.#deepestParams()) && this.#deepestParams.set(nextDeepestParams);
+            !deepEqual(nextQuery, this.#query()) && this.#query.set(nextQuery);
+            !deepEqual(nextData, this.#data()) && this.#data.set(nextData);
+            !deepEqual(nextMergedData, this.#mergedData()) && this.#mergedData.set(nextMergedData);
+            this.#url() !== nextUrl && this.#url.set(nextUrl);
+            this.#routePattern() !== nextRoutePattern && this.#routePattern.set(nextRoutePattern);
+            this.#fragment() !== nextFragment && this.#fragment.set(nextFragment);
+        };
+        read();
+        const subscription = this.router.events.subscribe((event) => {
+            if (event instanceof NavigationEnd) {
+                read();
+            }
+        });
+        this.destroyRef.onDestroy(() => subscription.unsubscribe());
+    }
+    selectData(key, strategy = 'deepest') {
+        return computed(() => {
+            const source = strategy === 'merged' ? this.#mergedData() : this.#data();
+            return source[key];
+        });
+    }
+    selectParam(key, strategy = 'merged') {
+        return computed(() => {
+            const source = strategy === 'deepest' ? this.#deepestParams() : this.#params();
+            return source[key];
+        });
+    }
+    matchesPath(path) {
+        const current = this.#url();
+        return typeof path === 'string' ? current === path : path.test(current);
+    }
+    deepestSnapshot() {
+        return deepestRouteSnapshot(this.router.routerState.snapshot.root);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: RouteWatcher, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: RouteWatcher, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: RouteWatcher, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+
 /**
  * @deprecated Diagnostics are usually enabled through route preload config, not by consuming this service directly.
  */
@@ -374,72 +586,193 @@ function normalizeUrlPath$1(url) {
     return normalized === '/' ? normalized : normalized.replace(/\/{2,}/g, '/');
 }
 
-/**
- * LangService provides functionality for managing and tracking language settings
- * and translations in the application. It is designed to handle localization needs,
- * loading language resources, caching translations, and dynamically applying translations
- * 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 });
-    routeNamespaceDiagnostics = inject(RouteNamespaceDiagnosticsService, { optional: true });
-    supportedLangSet = new Set([
-        ...LangService.BUILTIN_LANGS,
-        ...this.normalizeSupportedLangs(this.config.supportedLangs ?? []),
+const PRESENTIA_ROUTE_NAMESPACE_PRELOAD_RESOLVE_KEY = '__rePresentiaRouteNamespacePreload';
+const PRESENTIA_ROUTE_NAMESPACES_DATA_KEY = 'presentiaNamespaces';
+function providePresentiaRouteNamespacePreload() {
+    return makeEnvironmentProviders([
+        provideAppInitializer(() => {
+            const router = inject(Router, { optional: true });
+            const langConfig = inject(LANG_CONFIG);
+            const normalized = normalizeRouteNamespacePreloadConfig(langConfig.routeNamespacePreload);
+            if (!router || !normalized) {
+                return;
+            }
+            if (typeof ngDevMode !== 'undefined' && normalized.manifest && Object.keys(normalized.manifest).length === 0) {
+                // eslint-disable-next-line no-console
+                console.warn('[presentia] routeNamespacePreload.manifest is empty. Route-data preload still works, but manifest mode is effectively disabled.');
+            }
+            router.resetConfig(patchRoutesWithNamespacePreload(router.config, normalized));
+        }),
     ]);
-    #lang = signal(this.getStoredLang(), ...(ngDevMode ? [{ debugName: "#lang" }] : /* istanbul ignore next */ []));
-    #cache = signal({}, ...(ngDevMode ? [{ debugName: "#cache" }] : /* istanbul ignore next */ []));
-    #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 '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 === 'kg' ? (this.config?.kgValue ?? 'kg') : lang;
-    }, ...(ngDevMode ? [{ debugName: "currentLang" }] : /* istanbul ignore next */ []));
-    /**
-     * 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);
-            });
-        }
+}
+function normalizeRouteNamespacePreloadConfig(config) {
+    if (!config) {
+        return null;
     }
-    /**
-     * Sets the current language for the application.
-     *
-     * @param {Langs | 'ky'} lang - The language to set.
-     * Accepts predefined type `Langs` or 'ky' to set Kyrgyz language.
-     * @return {void} Returns no value.
-     */
-    setLang(lang) {
-        const langVal = this.normalizeLang(lang);
-        if (!langVal || !this.supportedLangSet.has(langVal)) {
-            return;
-        }
-        if (langVal !== this.#lang()) {
-            this.#lang.set(langVal);
+    return {
+        mode: config.mode ?? 'blocking',
+        dataKey: config.dataKey?.trim() || PRESENTIA_ROUTE_NAMESPACES_DATA_KEY,
+        manifest: config.manifest,
+        mergeStrategy: config.mergeStrategy ?? 'append',
+        onError: config.onError ?? 'continue',
+    };
+}
+function patchRoutesWithNamespacePreload(routes, config) {
+    return routes.map((route) => patchRouteWithNamespacePreload(route, config));
+}
+function patchRouteWithNamespacePreload(route, config) {
+    const nextChildren = route.children ? patchRoutesWithNamespacePreload(route.children, config) : route.children;
+    if (route.redirectTo) {
+        return nextChildren === route.children ? route : { ...route, children: nextChildren };
+    }
+    const nextResolve = {
+        ...(route.resolve ?? {}),
+        [PRESENTIA_ROUTE_NAMESPACE_PRELOAD_RESOLVE_KEY]: makeRouteNamespacePreloadResolver(config),
+    };
+    return {
+        ...route,
+        ...(nextChildren ? { children: nextChildren } : {}),
+        resolve: nextResolve,
+    };
+}
+function makeRouteNamespacePreloadResolver(config) {
+    return async (route, state) => {
+        const lang = inject(LangService);
+        const diagnostics = inject(RouteNamespaceDiagnosticsService);
+        const namespaces = resolveRouteNamespaces(route, state, config);
+        diagnostics.registerRouteNamespaces(state.url, namespaces);
+        if (!namespaces.length) {
+            return true;
+        }
+        if (config.mode === 'lazy') {
+            queueMicrotask(() => {
+                void lang.loadNamespaces(namespaces);
+            });
+            return true;
+        }
+        try {
+            await lang.loadNamespaces(namespaces);
+        }
+        catch (error) {
+            if (config.onError === 'throw') {
+                throw error;
+            }
+            // Keep navigation alive; runtime lazy loading remains a fallback.
+        }
+        return true;
+    };
+}
+function resolveRouteNamespaces(route, state, config) {
+    const dataNamespaces = readNamespacesFromRouteData(route, config.dataKey);
+    const manifestNamespaces = readNamespacesFromManifest(route, state, config.manifest);
+    if (config.mergeStrategy === 'replace' && dataNamespaces.length) {
+        return dataNamespaces;
+    }
+    return uniqueNamespaces([...manifestNamespaces, ...dataNamespaces]);
+}
+function readNamespacesFromRouteData(route, dataKey) {
+    return uniqueNamespaces(route.pathFromRoot.flatMap((snapshot) => {
+        const value = snapshot.data?.[dataKey];
+        return Array.isArray(value) ? value : [];
+    }));
+}
+function readNamespacesFromManifest(route, state, manifest) {
+    if (!manifest) {
+        return [];
+    }
+    const actualUrl = normalizeUrlPath(state.url);
+    const routePath = snapshotRouteConfigPath(route);
+    return uniqueNamespaces(Object.entries(manifest)
+        .filter(([key]) => matchesManifestKey(actualUrl, routePath, key))
+        .flatMap(([, namespaces]) => namespaces));
+}
+function matchesManifestKey(actualUrl, routePath, manifestKey) {
+    const normalizedKey = normalizeUrlPath(manifestKey);
+    return compareRoutes(actualUrl, normalizedKey) || (!!routePath && routePath === normalizedKey);
+}
+function snapshotRouteConfigPath(route) {
+    const templatePath = route.pathFromRoot
+        .map((item) => item.routeConfig?.path ?? '')
+        .filter(Boolean)
+        .join('/');
+    return normalizeUrlPath(templatePath);
+}
+function normalizeUrlPath(url) {
+    const [path] = url.split(/[?#]/, 1);
+    const normalized = `/${(path ?? '').replace(/^\/+|\/+$/g, '')}`;
+    return normalized === '/' ? normalized : normalized.replace(/\/{2,}/g, '/');
+}
+function uniqueNamespaces(namespaces) {
+    return Array.from(new Set(namespaces.map((ns) => ns.trim()).filter(Boolean)));
+}
+
+/**
+ * LangService provides functionality for managing and tracking language settings
+ * and translations in the application. It is designed to handle localization needs,
+ * loading language resources, caching translations, and dynamically applying translations
+ * 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));
+    persistence = inject(LANG_PERSISTENCE_ADAPTER);
+    missingKeyHandler = inject(LANG_MISSING_KEY_HANDLER, { optional: true });
+    routeNamespaceDiagnostics = inject(RouteNamespaceDiagnosticsService, { optional: true });
+    supportedLangSet = new Set([
+        ...LangService.BUILTIN_LANGS,
+        ...this.normalizeSupportedLangs(this.config.supportedLangs ?? []),
+    ]);
+    #lang = signal(this.getStoredLang(), ...(ngDevMode ? [{ debugName: "#lang" }] : /* istanbul ignore next */ []));
+    #cache = signal({}, ...(ngDevMode ? [{ debugName: "#cache" }] : /* istanbul ignore next */ []));
+    #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 '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 === 'kg' ? (this.config?.kgValue ?? 'kg') : lang;
+    }, ...(ngDevMode ? [{ debugName: "currentLang" }] : /* istanbul ignore next */ []));
+    /**
+     * 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.
+     *
+     * @param {Langs | 'ky'} lang - The language to set.
+     * Accepts predefined type `Langs` or 'ky' to set Kyrgyz language.
+     * @return {void} Returns no value.
+     */
+    setLang(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);
+                this.persistence.set('lang', langVal);
             }
             const namespaces = Array.from(this.#loadedNamespaces.values()).map((key) => this.namespaceFromKey(key));
             this.#loadedNamespaces.clear();
@@ -660,7 +993,7 @@ class LangService {
         if (!this.isBrowser) {
             return defaultLang;
         }
-        return normalize(localStorage.getItem('lang')) ?? defaultLang;
+        return normalize(this.persistence.get('lang')) ?? defaultLang;
     }
     makeUrl(ns, lang) {
         if (this.config.requestBuilder) {
@@ -1034,425 +1367,151 @@ class LangDirective {
             mode = raw.mode;
             textKey = raw.textKey;
             attrs = raw.attrs;
-        }
-        return {
-            mode,
-            textKey: explicitText ?? textKey,
-            attrs: explicitAttrs ?? attrs,
-        };
-    }
-    isMode(value) {
-        return (value === 'only-content' ||
-            value === 'only-placeholder' ||
-            value === 'only-label' ||
-            value === 'only-title' ||
-            value === 'all');
-    }
-    /**
-     * Asynchronously loads namespace and retrieves localized value by key.
-     *
-     * @param key localization key in format `namespace.path.to.key`
-     * @returns localized string
-     */
-    async getLangValue(key) {
-        const [ns] = key.split('.', 1);
-        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.2.4", ngImport: i0, type: LangDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.4", type: LangDirective, isStandalone: true, selector: "[reLang]", inputs: { lang: { classPropertyName: "lang", publicName: "reLang", isSignal: true, isRequired: false, transformFunction: null }, langForAttr: { classPropertyName: "langForAttr", publicName: "langForAttr", isSignal: true, isRequired: false, transformFunction: null }, reLangKey: { classPropertyName: "reLangKey", publicName: "reLangKey", isSignal: false, isRequired: false, transformFunction: null }, reLangAttrs: { classPropertyName: "reLangAttrs", publicName: "reLangAttrs", isSignal: false, isRequired: false, transformFunction: null } }, ngImport: i0 });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: LangDirective, decorators: [{
-            type: Directive,
-            args: [{ selector: '[reLang]', standalone: true }]
-        }], ctorParameters: () => [], propDecorators: { lang: [{ type: i0.Input, args: [{ isSignal: true, alias: "reLang", required: false }] }], langForAttr: [{ type: i0.Input, args: [{ isSignal: true, alias: "langForAttr", required: false }] }], reLangKey: [{
-                type: Input
-            }], reLangAttrs: [{
-                type: Input
-            }] } });
-
-const LANG_PIPE_CONFIG = new InjectionToken('RE_LANG_PIPE_CONFIG');
-
-/**
- * Custom Angular pipe that transforms a language key and additional parameters into a localized string.
- *
- * The pipe is declared as standalone and impure — meaning it can be used without importing a module
- * and will be recalculated when the state changes (for example, when the language is switched).
- *
- * In its operation, the pipe observes and caches language keys to improve performance,
- * using LangService to retrieve translated strings based on the current application language.
- *
- * The transformation involves accepting a key string and optional parameters,
- * forming a cache key, and returning the localized value corresponding to that request.
- *
- * @implements {PipeTransform}
- */
-class LangPipe {
-    cache = new Map();
-    warnedUnresolved = new Set();
-    lang = inject(LangService);
-    injector = inject(Injector);
-    config;
-    ttlMs;
-    maxCacheSize;
-    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(this.injector, () => {
-            effect(() => {
-                // Clear cache on language change to avoid stale signals and unbounded growth.
-                this.lang.currentLang();
-                this.cache.clear();
-            });
-        });
-    }
-    transform(query, params) {
-        if (!query) {
-            return '';
-        }
-        const key = this.makeKey(query, params);
-        const now = Date.now();
-        const existing = this.cache.get(key);
-        if (existing) {
-            if (now - existing.ts < this.ttlMs) {
-                return existing.value();
-            }
-            this.cache.delete(key);
-        }
-        if (!this.cache.has(key)) {
-            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;
-            if (typeof placeholder === 'function') {
-                return placeholder(query);
-            }
-            if (typeof placeholder === 'string') {
-                return placeholder;
-            }
-        }
-        if (ns && this.lang.isNamespaceLoaded(ns) && !this.lang.has(query)) {
-            this.warnUnresolvedKey(query);
-        }
-        return value;
-    }
-    makeKey(query, params) {
-        if (!params) {
-            return query;
-        }
-        const entries = Object.keys(params)
-            .sort()
-            .map((k) => `${k}:${params[k]}`);
-        return `${query}::${entries.join('|')}`;
-    }
-    evictIfNeeded() {
-        while (this.cache.size > this.maxCacheSize) {
-            const firstKey = this.cache.keys().next().value;
-            if (!firstKey) {
-                return;
-            }
-            this.cache.delete(firstKey);
-        }
-    }
-    warnUnresolvedKey(query) {
-        if (typeof ngDevMode === 'undefined') {
-            return;
-        }
-        if (this.warnedUnresolved.has(query)) {
-            return;
-        }
-        this.warnedUnresolved.add(query);
-        // eslint-disable-next-line no-console
-        console.warn(`LangPipe: namespace loaded but key "${query}" is unresolved`);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: LangPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
-    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.2.4", ngImport: i0, type: LangPipe, isStandalone: true, name: "lang", pure: false });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: LangPipe, decorators: [{
-            type: Pipe,
-            args: [{ name: 'lang', standalone: true, pure: false }]
-        }], ctorParameters: () => [] });
-
-function deepestActivatedRoute(route) {
-    let current = route;
-    while (current.firstChild) {
-        current = current.firstChild;
-    }
-    return current;
-}
-function deepestRouteSnapshot(snapshot) {
-    let current = snapshot;
-    while (current.firstChild) {
-        current = current.firstChild;
-    }
-    return current;
-}
-function joinUrl(segments) {
-    return segments.length ? segments.map((segment) => segment.path).join('/') : '';
-}
-function snapshotFullPath(snapshot) {
-    return snapshot.pathFromRoot
-        .map((route) => joinUrl(route.url))
-        .filter(Boolean)
-        .join('/');
-}
-function snapshotRoutePattern(snapshot) {
-    return snapshot.pathFromRoot
-        .map((route) => route.routeConfig?.path ?? '')
-        .filter(Boolean)
-        .join('/');
-}
-function snapshotMergedParams(snapshot) {
-    return snapshot.pathFromRoot.reduce((acc, route) => ({ ...acc, ...route.params }), {});
-}
-function snapshotDeepestParams(snapshot) {
-    const mergedParams = snapshotMergedParams(snapshot);
-    const keys = extractRouteParamKeys(snapshot.routeConfig?.path ?? '');
-    if (!keys.length) {
-        return {};
-    }
-    return keys.reduce((acc, key) => {
-        const value = mergedParams[key];
-        if (value !== undefined) {
-            acc[key] = value;
-        }
-        return acc;
-    }, {});
-}
-function snapshotMergedData(snapshot) {
-    return snapshot.pathFromRoot.reduce((acc, route) => ({ ...acc, ...route.data }), {});
-}
-function extractRouteParamKeys(path) {
-    return path
-        .split('/')
-        .filter((segment) => segment.startsWith(':'))
-        .map((segment) => segment.slice(1))
-        .filter(Boolean);
-}
-
-/**
- * Reactive snapshot of the current route (the deepest active route).
- * Updates on every `NavigationEnd` event.
- */
-class RouteWatcher {
-    router = inject(Router);
-    destroyRef = inject(DestroyRef);
-    #params = signal({}, ...(ngDevMode ? [{ debugName: "#params" }] : /* istanbul ignore next */ []));
-    #deepestParams = signal({}, ...(ngDevMode ? [{ debugName: "#deepestParams" }] : /* istanbul ignore next */ []));
-    #query = signal({}, ...(ngDevMode ? [{ debugName: "#query" }] : /* istanbul ignore next */ []));
-    #data = signal({}, ...(ngDevMode ? [{ debugName: "#data" }] : /* istanbul ignore next */ []));
-    #mergedData = signal({}, ...(ngDevMode ? [{ debugName: "#mergedData" }] : /* istanbul ignore next */ []));
-    #url = signal('', ...(ngDevMode ? [{ debugName: "#url" }] : /* istanbul ignore next */ []));
-    #routePattern = signal('', ...(ngDevMode ? [{ debugName: "#routePattern" }] : /* istanbul ignore next */ []));
-    #fragment = signal(null, ...(ngDevMode ? [{ debugName: "#fragment" }] : /* istanbul ignore next */ []));
-    /** Params merged from root to deepest route. */
-    params = this.#params.asReadonly();
-    /** Params declared on the deepest route only. */
-    deepestParams = this.#deepestParams.asReadonly();
-    /** Query params from the current navigation. */
-    query = this.#query.asReadonly();
-    /** Deepest route data only. */
-    data = this.#data.asReadonly();
-    /** Route data merged from root to deepest route. */
-    mergedData = this.#mergedData.asReadonly();
-    /** Full current url path assembled from root to deepest route. */
-    url = this.#url.asReadonly();
-    /** Current route config pattern, e.g. `orgs/:orgId/users/:id`. */
-    routePattern = this.#routePattern.asReadonly();
-    /** Current url fragment without `#`. */
-    fragment = this.#fragment.asReadonly();
-    /** Combined computed snapshot. */
-    state = computed(() => ({
-        params: this.#params(),
-        deepestParams: this.#deepestParams(),
-        query: this.#query(),
-        data: this.#data(),
-        mergedData: this.#mergedData(),
-        url: this.#url(),
-        routePattern: this.#routePattern(),
-        fragment: this.#fragment(),
-    }), ...(ngDevMode ? [{ debugName: "state" }] : /* istanbul ignore next */ []));
-    constructor() {
-        const read = () => {
-            const snapshot = this.deepestSnapshot();
-            const nextUrl = snapshotFullPath(snapshot);
-            const nextRoutePattern = snapshotRoutePattern(snapshot);
-            const nextParams = snapshotMergedParams(snapshot);
-            const nextDeepestParams = snapshotDeepestParams(snapshot);
-            const nextMergedData = snapshotMergedData(snapshot);
-            const nextQuery = snapshot.queryParams;
-            const nextData = snapshot.data;
-            const nextFragment = snapshot.fragment ?? null;
-            !deepEqual(nextParams, this.#params()) && this.#params.set(nextParams);
-            !deepEqual(nextDeepestParams, this.#deepestParams()) && this.#deepestParams.set(nextDeepestParams);
-            !deepEqual(nextQuery, this.#query()) && this.#query.set(nextQuery);
-            !deepEqual(nextData, this.#data()) && this.#data.set(nextData);
-            !deepEqual(nextMergedData, this.#mergedData()) && this.#mergedData.set(nextMergedData);
-            this.#url() !== nextUrl && this.#url.set(nextUrl);
-            this.#routePattern() !== nextRoutePattern && this.#routePattern.set(nextRoutePattern);
-            this.#fragment() !== nextFragment && this.#fragment.set(nextFragment);
-        };
-        read();
-        const subscription = this.router.events.subscribe((event) => {
-            if (event instanceof NavigationEnd) {
-                read();
-            }
-        });
-        this.destroyRef.onDestroy(() => subscription.unsubscribe());
-    }
-    selectData(key, strategy = 'deepest') {
-        return computed(() => {
-            const source = strategy === 'merged' ? this.#mergedData() : this.#data();
-            return source[key];
-        });
-    }
-    selectParam(key, strategy = 'merged') {
-        return computed(() => {
-            const source = strategy === 'deepest' ? this.#deepestParams() : this.#params();
-            return source[key];
-        });
+        }
+        return {
+            mode,
+            textKey: explicitText ?? textKey,
+            attrs: explicitAttrs ?? attrs,
+        };
     }
-    matchesPath(path) {
-        const current = this.#url();
-        return typeof path === 'string' ? current === path : path.test(current);
+    isMode(value) {
+        return (value === 'only-content' ||
+            value === 'only-placeholder' ||
+            value === 'only-label' ||
+            value === 'only-title' ||
+            value === 'all');
     }
-    deepestSnapshot() {
-        return deepestRouteSnapshot(this.router.routerState.snapshot.root);
+    /**
+     * Asynchronously loads namespace and retrieves localized value by key.
+     *
+     * @param key localization key in format `namespace.path.to.key`
+     * @returns localized string
+     */
+    async getLangValue(key) {
+        const [ns] = key.split('.', 1);
+        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.2.4", ngImport: i0, type: RouteWatcher, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: RouteWatcher, providedIn: 'root' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: LangDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.4", type: LangDirective, isStandalone: true, selector: "[reLang]", inputs: { lang: { classPropertyName: "lang", publicName: "reLang", isSignal: true, isRequired: false, transformFunction: null }, langForAttr: { classPropertyName: "langForAttr", publicName: "langForAttr", isSignal: true, isRequired: false, transformFunction: null }, reLangKey: { classPropertyName: "reLangKey", publicName: "reLangKey", isSignal: false, isRequired: false, transformFunction: null }, reLangAttrs: { classPropertyName: "reLangAttrs", publicName: "reLangAttrs", isSignal: false, isRequired: false, transformFunction: null } }, ngImport: i0 });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: RouteWatcher, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: LangDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[reLang]', standalone: true }]
+        }], ctorParameters: () => [], propDecorators: { lang: [{ type: i0.Input, args: [{ isSignal: true, alias: "reLang", required: false }] }], langForAttr: [{ type: i0.Input, args: [{ isSignal: true, alias: "langForAttr", required: false }] }], reLangKey: [{
+                type: Input
+            }], reLangAttrs: [{
+                type: Input
+            }] } });
 
-const PRESENTIA_ROUTE_NAMESPACE_PRELOAD_RESOLVE_KEY = '__rePresentiaRouteNamespacePreload';
-const PRESENTIA_ROUTE_NAMESPACES_DATA_KEY = 'presentiaNamespaces';
-function providePresentiaRouteNamespacePreload() {
-    return makeEnvironmentProviders([
-        provideAppInitializer(() => {
-            const router = inject(Router, { optional: true });
-            const langConfig = inject(LANG_CONFIG);
-            const normalized = normalizeRouteNamespacePreloadConfig(langConfig.routeNamespacePreload);
-            if (!router || !normalized) {
-                return;
+const LANG_PIPE_CONFIG = new InjectionToken('RE_LANG_PIPE_CONFIG');
+
+/**
+ * Custom Angular pipe that transforms a language key and additional parameters into a localized string.
+ *
+ * The pipe is declared as standalone and impure — meaning it can be used without importing a module
+ * and will be recalculated when the state changes (for example, when the language is switched).
+ *
+ * In its operation, the pipe observes and caches language keys to improve performance,
+ * using LangService to retrieve translated strings based on the current application language.
+ *
+ * The transformation involves accepting a key string and optional parameters,
+ * forming a cache key, and returning the localized value corresponding to that request.
+ *
+ * @implements {PipeTransform}
+ */
+class LangPipe {
+    cache = new Map();
+    warnedUnresolved = new Set();
+    lang = inject(LangService);
+    injector = inject(Injector);
+    config;
+    ttlMs;
+    maxCacheSize;
+    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(this.injector, () => {
+            effect(() => {
+                // Clear cache on language change to avoid stale signals and unbounded growth.
+                this.lang.currentLang();
+                this.cache.clear();
+            });
+        });
+    }
+    transform(query, params) {
+        if (!query) {
+            return '';
+        }
+        const key = this.makeKey(query, params);
+        const now = Date.now();
+        const existing = this.cache.get(key);
+        if (existing) {
+            if (now - existing.ts < this.ttlMs) {
+                return existing.value();
             }
-            if (typeof ngDevMode !== 'undefined' && normalized.manifest && Object.keys(normalized.manifest).length === 0) {
-                // eslint-disable-next-line no-console
-                console.warn('[presentia] routeNamespacePreload.manifest is empty. Route-data preload still works, but manifest mode is effectively disabled.');
+            this.cache.delete(key);
+        }
+        if (!this.cache.has(key)) {
+            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;
+            if (typeof placeholder === 'function') {
+                return placeholder(query);
+            }
+            if (typeof placeholder === 'string') {
+                return placeholder;
             }
-            router.resetConfig(patchRoutesWithNamespacePreload(router.config, normalized));
-        }),
-    ]);
-}
-function normalizeRouteNamespacePreloadConfig(config) {
-    if (!config) {
-        return null;
-    }
-    return {
-        mode: config.mode ?? 'blocking',
-        dataKey: config.dataKey?.trim() || PRESENTIA_ROUTE_NAMESPACES_DATA_KEY,
-        manifest: config.manifest,
-        mergeStrategy: config.mergeStrategy ?? 'append',
-        onError: config.onError ?? 'continue',
-    };
-}
-function patchRoutesWithNamespacePreload(routes, config) {
-    return routes.map((route) => patchRouteWithNamespacePreload(route, config));
-}
-function patchRouteWithNamespacePreload(route, config) {
-    const nextChildren = route.children ? patchRoutesWithNamespacePreload(route.children, config) : route.children;
-    if (route.redirectTo) {
-        return nextChildren === route.children ? route : { ...route, children: nextChildren };
-    }
-    const nextResolve = {
-        ...(route.resolve ?? {}),
-        [PRESENTIA_ROUTE_NAMESPACE_PRELOAD_RESOLVE_KEY]: makeRouteNamespacePreloadResolver(config),
-    };
-    return {
-        ...route,
-        ...(nextChildren ? { children: nextChildren } : {}),
-        resolve: nextResolve,
-    };
-}
-function makeRouteNamespacePreloadResolver(config) {
-    return async (route, state) => {
-        const lang = inject(LangService);
-        const diagnostics = inject(RouteNamespaceDiagnosticsService);
-        const namespaces = resolveRouteNamespaces(route, state, config);
-        diagnostics.registerRouteNamespaces(state.url, namespaces);
-        if (!namespaces.length) {
-            return true;
         }
-        if (config.mode === 'lazy') {
-            queueMicrotask(() => {
-                void lang.loadNamespaces(namespaces);
-            });
-            return true;
+        if (ns && this.lang.isNamespaceLoaded(ns) && !this.lang.has(query)) {
+            this.warnUnresolvedKey(query);
         }
-        try {
-            await lang.loadNamespaces(namespaces);
+        return value;
+    }
+    makeKey(query, params) {
+        if (!params) {
+            return query;
         }
-        catch (error) {
-            if (config.onError === 'throw') {
-                throw error;
+        const entries = Object.keys(params)
+            .sort()
+            .map((k) => `${k}:${params[k]}`);
+        return `${query}::${entries.join('|')}`;
+    }
+    evictIfNeeded() {
+        while (this.cache.size > this.maxCacheSize) {
+            const firstKey = this.cache.keys().next().value;
+            if (!firstKey) {
+                return;
             }
-            // Keep navigation alive; runtime lazy loading remains a fallback.
+            this.cache.delete(firstKey);
         }
-        return true;
-    };
-}
-function resolveRouteNamespaces(route, state, config) {
-    const dataNamespaces = readNamespacesFromRouteData(route, config.dataKey);
-    const manifestNamespaces = readNamespacesFromManifest(route, state, config.manifest);
-    if (config.mergeStrategy === 'replace' && dataNamespaces.length) {
-        return dataNamespaces;
     }
-    return uniqueNamespaces([...manifestNamespaces, ...dataNamespaces]);
-}
-function readNamespacesFromRouteData(route, dataKey) {
-    return uniqueNamespaces(route.pathFromRoot.flatMap((snapshot) => {
-        const value = snapshot.data?.[dataKey];
-        return Array.isArray(value) ? value : [];
-    }));
-}
-function readNamespacesFromManifest(route, state, manifest) {
-    if (!manifest) {
-        return [];
+    warnUnresolvedKey(query) {
+        if (typeof ngDevMode === 'undefined') {
+            return;
+        }
+        if (this.warnedUnresolved.has(query)) {
+            return;
+        }
+        this.warnedUnresolved.add(query);
+        // eslint-disable-next-line no-console
+        console.warn(`LangPipe: namespace loaded but key "${query}" is unresolved`);
     }
-    const actualUrl = normalizeUrlPath(state.url);
-    const routePath = snapshotRouteConfigPath(route);
-    return uniqueNamespaces(Object.entries(manifest)
-        .filter(([key]) => matchesManifestKey(actualUrl, routePath, key))
-        .flatMap(([, namespaces]) => namespaces));
-}
-function matchesManifestKey(actualUrl, routePath, manifestKey) {
-    const normalizedKey = normalizeUrlPath(manifestKey);
-    return compareRoutes(actualUrl, normalizedKey) || (!!routePath && routePath === normalizedKey);
-}
-function snapshotRouteConfigPath(route) {
-    const templatePath = route.pathFromRoot
-        .map((item) => item.routeConfig?.path ?? '')
-        .filter(Boolean)
-        .join('/');
-    return normalizeUrlPath(templatePath);
-}
-function normalizeUrlPath(url) {
-    const [path] = url.split(/[?#]/, 1);
-    const normalized = `/${(path ?? '').replace(/^\/+|\/+$/g, '')}`;
-    return normalized === '/' ? normalized : normalized.replace(/\/{2,}/g, '/');
-}
-function uniqueNamespaces(namespaces) {
-    return Array.from(new Set(namespaces.map((ns) => ns.trim()).filter(Boolean)));
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: LangPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.2.4", ngImport: i0, type: LangPipe, isStandalone: true, name: "lang", pure: false });
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: LangPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'lang', standalone: true, pure: false }]
+        }], ctorParameters: () => [] });
 
 /**
  * Type-safe mapping of available theme names.
@@ -1507,10 +1566,7 @@ const THEME_CONFIG = new InjectionToken('RE_THEME_CONFIG');
 /**
  * @deprecated Prefer configuring theme persistence through `providePresentia({ theme: { persistence... } })`.
  */
-const defaultThemePersistenceAdapter = {
-    getItem: (key) => localStorage.getItem(key),
-    setItem: (key, value) => localStorage.setItem(key, value),
-};
+const defaultThemePersistenceAdapter = createPresentiaStorage('persist');
 /**
  * DI token for the persistence adapter used by `ThemeService`
  * to store and retrieve the selected theme (default key: `'theme'`).
@@ -1614,10 +1670,10 @@ class ThemeService {
         return this.registry.includes(next) ? next : (this.registry[0] ?? themes.light);
     }
     getStoredTheme() {
-        return this.persistence.getItem('theme');
+        return this.persistence.get('theme');
     }
     persistTheme(theme) {
-        this.persistence.setItem('theme', theme);
+        this.persistence.set('theme', theme);
     }
     applyThemeToDom(theme) {
         const root = this.resolveRootElement();
@@ -1713,6 +1769,7 @@ function buildPresentiaProviders(config) {
         { provide: DEVICE_BREAKPOINTS, useValue: config.breakpoints || defaultBreakpoints },
         { provide: THEME_CONFIG, useValue: config.theme || defaultThemeConfig },
         { provide: THEME_PERSISTENCE_ADAPTER, useValue: defaultThemePersistenceAdapter },
+        { provide: LANG_PERSISTENCE_ADAPTER, useValue: defaultLangPersistenceAdapter },
         { provide: LANG_CONFIG, useValue: config.locale || { defaultValue: '--------' } },
         { provide: LANG_PIPE_CONFIG, useValue: config.langPipe || {} },
         { provide: LANG_MISSING_KEY_HANDLER, useValue: config.langMissingKeyHandler ?? null },
@@ -1728,21 +1785,10 @@ function providePresentia(config) {
         ? { ...routesConfig, diagnostics: diagnosticsEnabled ?? routesConfig?.diagnostics }
         : undefined;
     const extraProviders = [];
-    if (config.theme?.persistence === 'none') {
-        extraProviders.push({
-            provide: THEME_PERSISTENCE_ADAPTER,
-            useValue: {
-                getItem: () => null,
-                setItem: () => undefined,
-            },
-        });
-    }
-    else if (config.theme?.persistenceAdapter) {
-        extraProviders.push({
-            provide: THEME_PERSISTENCE_ADAPTER,
-            useValue: config.theme.persistenceAdapter,
-        });
-    }
+    const langStorage = createPresentiaStorage(config.lang.persistence, config.lang.storage ?? config.lang.persistenceAdapter);
+    const themeStorage = createPresentiaStorage(config.theme?.persistence, config.theme?.storage ?? config.theme?.persistenceAdapter);
+    extraProviders.push({ provide: LANG_PERSISTENCE_ADAPTER, useValue: langStorage });
+    extraProviders.push({ provide: THEME_PERSISTENCE_ADAPTER, useValue: themeStorage });
     return makeEnvironmentProviders([
         buildPresentiaProviders({
             locale: {
@@ -2019,5 +2065,5 @@ function joinBaseUrl(baseUrl, path) {
  * Generated bundle index. Do not edit.
  */
 
-export { AdaptiveService, DEVICE_BREAKPOINTS, IfDeviceDirective, LANG_CONFIG, LANG_MISSING_KEY_HANDLER, LANG_PERSISTENCE_ADAPTER, LANG_PIPE_CONFIG, LangDirective, LangPipe, LangService, PRESENTIA_ROUTE_NAMESPACES_DATA_KEY, RouteNamespaceDiagnosticsService, RouteWatcher, SeoRouteListener, SeoService, THEME_CONFIG, THEME_PERSISTENCE_ADAPTER, ThemeService, darkThemePrefix, defaultBreakpoints, defaultThemeConfig, defaultThemePersistenceAdapter, innerLangVal, providePresentia, providePresentiaRouteNamespacePreload, provideReInit, themes };
+export { AdaptiveService, DEVICE_BREAKPOINTS, IfDeviceDirective, LANG_CONFIG, LANG_MISSING_KEY_HANDLER, LANG_PERSISTENCE_ADAPTER, LANG_PIPE_CONFIG, LangDirective, LangPipe, LangService, PRESENTIA_ROUTE_NAMESPACES_DATA_KEY, RouteNamespaceDiagnosticsService, RouteWatcher, SeoRouteListener, SeoService, THEME_CONFIG, THEME_PERSISTENCE_ADAPTER, ThemeService, darkThemePrefix, defaultBreakpoints, defaultLangPersistenceAdapter, defaultThemeConfig, defaultThemePersistenceAdapter, innerLangVal, providePresentia, providePresentiaRouteNamespacePreload, provideReInit, themes };
 //# sourceMappingURL=reforgium-presentia.mjs.map

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.0.0",
+  "version": "2.1.0",
   "name": "@reforgium/presentia",
   "description": "Angular infrastructure library for i18n, route-aware namespace preload, theming, adaptive breakpoints, route state, and SEO",
   "author": "rtommievich",
@@ -65,7 +65,7 @@
     "@angular/core": ">=18.0.0",
     "@angular/platform-browser": ">=18.0.0",
     "@angular/router": ">=18.0.0",
-    "@reforgium/internal": ">=1.2.0",
+    "@reforgium/internal": ">=2.0.0",
     "rxjs": ">=7.0.0"
   },
   "module": "fesm2022/reforgium-presentia.mjs",

package/types/reforgium-presentia.d.ts

@@ -1,7 +1,7 @@
 import * as _angular_core from '@angular/core';
 import { InjectionToken, Signal, PipeTransform, EnvironmentProviders } from '@angular/core';
 import * as _reforgium_internal from '@reforgium/internal';
-import { Devices, Langs, Themes as Themes$1 } from '@reforgium/internal';
+import { Devices, Langs, StorageInterface, Themes as Themes$1, StorageStrategy } from '@reforgium/internal';
 import { HttpHeaders, HttpParams, HttpContext } from '@angular/common/http';
 
 /** Breakpoints for different device types */
@@ -250,10 +250,7 @@ type LangRouteNamespacePreloadConfig = {
  * Adapter for custom persistence of language/theme selection.
  * Implement this interface to replace the default `localStorage` storage.
  */
-type PersistenceAdapter = {
-    getItem(key: string): string | null;
-    setItem(key: string, value: string): void;
-};
+type PersistenceAdapter = StorageInterface<string, string>;
 /**
  * Describes a failed namespace load attempt.
  * Exposed via `LangService.errors()` signal.
@@ -328,6 +325,7 @@ declare const LANG_MISSING_KEY_HANDLER: InjectionToken<LangMissingKeyHandler>;
  * { provide: LANG_PERSISTENCE_ADAPTER, useValue: sessionStorageAdapter }
  * ```
  */
+declare const defaultLangPersistenceAdapter: StorageInterface<string, string>;
 declare const LANG_PERSISTENCE_ADAPTER: InjectionToken<PersistenceAdapter>;
 
 /**
@@ -378,6 +376,7 @@ declare class LangService {
     private readonly config;
     private readonly http;
     private readonly isBrowser;
+    private readonly persistence;
     private readonly missingKeyHandler;
     private readonly routeNamespaceDiagnostics;
     private readonly supportedLangSet;
@@ -389,7 +388,7 @@ declare class LangService {
      * - 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.
      */
-    readonly currentLang: Signal<(string & {}) | "ru" | "kg" | "en" | "ky">;
+    readonly currentLang: Signal<"ru" | "kg" | "en" | (string & {}) | "ky">;
     /**
      * Extracts readonly value from private property `#lang` and assigns it to `innerLangVal`.
      * Expected that property `#lang` has `asReadonly` method that returns immutable representation.
@@ -718,7 +717,7 @@ declare const THEME_CONFIG: InjectionToken<ThemeConfig>;
 /**
  * @deprecated Prefer configuring theme persistence through `providePresentia({ theme: { persistence... } })`.
  */
-declare const defaultThemePersistenceAdapter: PersistenceAdapter;
+declare const defaultThemePersistenceAdapter: StorageInterface<string, string>;
 /**
  * DI token for the persistence adapter used by `ThemeService`
  * to store and retrieve the selected theme (default key: `'theme'`).
@@ -841,6 +840,12 @@ type PresentiaLangConfig = {
         maxBatchSize?: number;
     };
     cache?: LangNamespaceCacheConfig;
+    persistence?: StorageStrategy | 'none';
+    storage?: StorageInterface<string, string>;
+    /**
+     * @deprecated Prefer `storage`.
+     */
+    persistenceAdapter?: PersistenceAdapter;
     diagnostics?: {
         lateNamespaceLoads?: boolean;
     };
@@ -849,7 +854,11 @@ type PresentiaLangConfig = {
 type PresentiaThemeConfig = {
     registry?: readonly Theme[];
     defaultTheme?: ThemeConfig['defaultTheme'];
-    persistence?: 'localStorage' | 'none';
+    persistence?: StorageStrategy | 'none';
+    storage?: StorageInterface<string, string>;
+    /**
+     * @deprecated Prefer `storage`.
+     */
     persistenceAdapter?: PersistenceAdapter;
     dom?: {
         strategy?: 'root-class' | 'data-attribute';
@@ -1067,6 +1076,6 @@ declare class RouteNamespaceDiagnosticsService {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<RouteNamespaceDiagnosticsService>;
 }
 
-export { AdaptiveService, DEVICE_BREAKPOINTS, IfDeviceDirective, LANG_CONFIG, LANG_MISSING_KEY_HANDLER, LANG_PERSISTENCE_ADAPTER, LANG_PIPE_CONFIG, LangDirective, LangPipe, LangService, PRESENTIA_ROUTE_NAMESPACES_DATA_KEY, RouteNamespaceDiagnosticsService, RouteWatcher, SeoRouteListener, SeoService, THEME_CONFIG, THEME_PERSISTENCE_ADAPTER, ThemeService, darkThemePrefix, defaultBreakpoints, defaultThemeConfig, defaultThemePersistenceAdapter, innerLangVal, providePresentia, providePresentiaRouteNamespacePreload, provideReInit, themes };
+export { AdaptiveService, DEVICE_BREAKPOINTS, IfDeviceDirective, LANG_CONFIG, LANG_MISSING_KEY_HANDLER, LANG_PERSISTENCE_ADAPTER, LANG_PIPE_CONFIG, LangDirective, LangPipe, LangService, PRESENTIA_ROUTE_NAMESPACES_DATA_KEY, RouteNamespaceDiagnosticsService, RouteWatcher, SeoRouteListener, SeoService, THEME_CONFIG, THEME_PERSISTENCE_ADAPTER, ThemeService, darkThemePrefix, defaultBreakpoints, defaultLangPersistenceAdapter, defaultThemeConfig, defaultThemePersistenceAdapter, innerLangVal, providePresentia, providePresentiaRouteNamespacePreload, provideReInit, themes };
 export type { AppConfig, BaseTheme, DeviceBreakpoints, LangBatchRequestBuilder, LangBatchRequestContext, LangBatchResponseAdapter, LangBatchResponseContext, LangDirectiveConfig, LangDirectiveMode, LangDto, LangHttpRequestOptions, LangKey, LangKeyRegistry, LangMissingKeyHandler, LangModel, LangNamespaceCacheConfig, LangParamValue, LangParams, LangPipeConfig, LangRequestBuilder, LangRequestContext, LangRequestOptionsFactory, LangResponseAdapter, LangResponseContext, LangRouteNamespaceManifest, LangRouteNamespacePreloadConfig, LangRouteNamespacePreloadMergeStrategy, LangRouteNamespacePreloadMode, LoadNamespaceError, LocaleConfig, OgType, PersistenceAdapter, PresentiaAdaptiveConfig, PresentiaConfig, PresentiaLangConfig, PresentiaThemeConfig, RouteWatcherReadStrategy, RouteWatcherState, Theme, ThemeConfig, Themes, TwitterCardType };
 //# sourceMappingURL=reforgium-presentia.d.ts.map