@reforgium/presentia 1.5.0 → 2.0.0

package/fesm2022/reforgium-presentia.mjs

@@ -1,13 +1,13 @@
 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, LOCALE_ID } from '@angular/core';
-import { getChainedValue, TRANSLATION, SELECTED_LANG, CHANGE_LANG, SELECTED_THEME, CHANGE_THEME, CURRENT_DEVICE, deepEqual } from '@reforgium/internal';
+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 { BreakpointObserver } from '@angular/cdk/layout';
 import { isPlatformBrowser, DOCUMENT } from '@angular/common';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
 import { HttpClient } from '@angular/common/http';
 import { firstValueFrom, tap } from 'rxjs';
+import { Router, NavigationEnd } from '@angular/router';
 import { Title, Meta } from '@angular/platform-browser';
-import { Router, ActivatedRoute, NavigationEnd } from '@angular/router';
 
 /**
  * Default breakpoints for device type detection.
@@ -73,10 +73,10 @@ const DEVICE_BREAKPOINTS = new InjectionToken('RE_DEVICE_BREAKPOINTS', {
  */
 class AdaptiveService {
     /** @internal Signal of the current device type. */
-    #device = signal('desktop', ...(ngDevMode ? [{ debugName: "#device" }] : []));
+    #device = signal('desktop', ...(ngDevMode ? [{ debugName: "#device" }] : /* istanbul ignore next */ []));
     /** @internal Signals of the current window width and height. */
-    #width = signal(0, ...(ngDevMode ? [{ debugName: "#width" }] : []));
-    #height = signal(0, ...(ngDevMode ? [{ debugName: "#height" }] : []));
+    #width = signal(0, ...(ngDevMode ? [{ debugName: "#width" }] : /* istanbul ignore next */ []));
+    #height = signal(0, ...(ngDevMode ? [{ debugName: "#height" }] : /* istanbul ignore next */ []));
     /**
      * Current device type (reactive signal).
      * Possible values: `'desktop' | 'tablet' | 'mobile'`.
@@ -99,12 +99,15 @@ class AdaptiveService {
      * Computed signal indicating whether the current device is a desktop.
      * Used for conditional rendering or layout configuration.
      */
-    isDesktop = computed(() => this.#device() === 'desktop', ...(ngDevMode ? [{ debugName: "isDesktop" }] : []));
+    isDesktop = computed(() => this.#device() === 'desktop', ...(ngDevMode ? [{ debugName: "isDesktop" }] : /* istanbul ignore next */ []));
+    isMobile = computed(() => this.#device() === 'mobile', ...(ngDevMode ? [{ debugName: "isMobile" }] : /* istanbul ignore next */ []));
+    isTablet = computed(() => this.#device() === 'tablet', ...(ngDevMode ? [{ debugName: "isTablet" }] : /* istanbul ignore next */ []));
+    isDesktopSmall = computed(() => this.#device() === 'desktop-s', ...(ngDevMode ? [{ debugName: "isDesktopSmall" }] : /* istanbul ignore next */ []));
     /**
      * Computed signal determining whether the screen is in portrait orientation.
      * Returns `true` if window height is greater than width.
      */
-    isPortrait = computed(() => this.#height() > this.#width(), ...(ngDevMode ? [{ debugName: "isPortrait" }] : []));
+    isPortrait = computed(() => this.#height() > this.#width(), ...(ngDevMode ? [{ debugName: "isPortrait" }] : /* istanbul ignore next */ []));
     deviceBreakpoints = inject(DEVICE_BREAKPOINTS);
     devicePriority = Object.keys(this.deviceBreakpoints);
     destroyRef = inject(DestroyRef);
@@ -148,10 +151,28 @@ class AdaptiveService {
             }
         });
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: AdaptiveService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: AdaptiveService, providedIn: 'root' });
+    breakpoint() {
+        return this.#device();
+    }
+    is(device) {
+        const allowed = Array.isArray(device) ? device : [device];
+        return allowed.includes(this.#device());
+    }
+    isAtLeast(device) {
+        return this.deviceRank(this.#device()) >= this.deviceRank(device);
+    }
+    isBetween(min, max) {
+        const current = this.deviceRank(this.#device());
+        return current >= this.deviceRank(min) && current <= this.deviceRank(max);
+    }
+    deviceRank(device) {
+        const index = this.devicePriority.indexOf(device);
+        return index >= 0 ? index : Number.MAX_SAFE_INTEGER;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: AdaptiveService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: AdaptiveService, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: AdaptiveService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: AdaptiveService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -179,8 +200,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.1", ngImpor
  * the template is automatically added or removed from the DOM.
  */
 class IfDeviceDirective {
-    deviceInput = signal(undefined, ...(ngDevMode ? [{ debugName: "deviceInput" }] : []));
-    inverseInput = signal(false, ...(ngDevMode ? [{ debugName: "inverseInput" }] : []));
+    deviceInput = signal(undefined, ...(ngDevMode ? [{ debugName: "deviceInput" }] : /* istanbul ignore next */ []));
+    atLeastInput = signal(undefined, ...(ngDevMode ? [{ debugName: "atLeastInput" }] : /* istanbul ignore next */ []));
+    betweenInput = signal(undefined, ...(ngDevMode ? [{ debugName: "betweenInput" }] : /* istanbul ignore next */ []));
+    inverseInput = signal(false, ...(ngDevMode ? [{ debugName: "inverseInput" }] : /* istanbul ignore next */ []));
     tpl = inject(TemplateRef);
     vcr = inject(ViewContainerRef);
     adaptive = inject(AdaptiveService);
@@ -190,20 +213,37 @@ class IfDeviceDirective {
     constructor() {
         effect(() => {
             const device = this.deviceInput();
+            const atLeast = this.atLeastInput();
+            const between = this.betweenInput();
             if (device) {
                 this.allowedDevices = Array.isArray(device) ? device : [device];
             }
+            else if (!atLeast && !between) {
+                this.allowedDevices = [];
+            }
             this.updateView();
         });
     }
     set reIfDevice(value) {
         this.deviceInput.set(value);
     }
+    set reIfDeviceAtLeast(value) {
+        this.atLeastInput.set(value);
+    }
+    set reIfDeviceBetween(value) {
+        this.betweenInput.set(value);
+    }
     set inverse(value) {
         this.inverseInput.set(!!value);
     }
     updateView() {
-        const isAllowed = this.allowedDevices.includes(this.currentDevice());
+        const between = this.betweenInput();
+        const atLeast = this.atLeastInput();
+        const isAllowed = between
+            ? this.adaptive.isBetween(between[0], between[1])
+            : atLeast
+                ? this.adaptive.isAtLeast(atLeast)
+                : this.allowedDevices.includes(this.currentDevice());
         const shouldShow = this.inverseInput() ? !isAllowed : isAllowed;
         if (shouldShow && !this.hasView) {
             this.vcr.createEmbeddedView(this.tpl);
@@ -214,18 +254,24 @@ class IfDeviceDirective {
             this.hasView = false;
         }
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: IfDeviceDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.1.1", type: IfDeviceDirective, isStandalone: true, selector: "[reIfDevice]", inputs: { reIfDevice: "reIfDevice", inverse: "inverse" }, ngImport: i0 });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: IfDeviceDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.4", type: IfDeviceDirective, isStandalone: true, selector: "[reIfDevice],[reIfDeviceAtLeast],[reIfDeviceBetween]", inputs: { reIfDevice: "reIfDevice", reIfDeviceAtLeast: "reIfDeviceAtLeast", reIfDeviceBetween: "reIfDeviceBetween", inverse: "inverse" }, ngImport: i0 });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: IfDeviceDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: IfDeviceDirective, decorators: [{
             type: Directive,
             args: [{
-                    selector: '[reIfDevice]',
+                    selector: '[reIfDevice],[reIfDeviceAtLeast],[reIfDeviceBetween]',
                     standalone: true,
                 }]
         }], ctorParameters: () => [], propDecorators: { reIfDevice: [{
                 type: Input,
                 args: ['reIfDevice']
+            }], reIfDeviceAtLeast: [{
+                type: Input,
+                args: ['reIfDeviceAtLeast']
+            }], reIfDeviceBetween: [{
+                type: Input,
+                args: ['reIfDeviceBetween']
             }], inverse: [{
                 type: Input
             }] } });
@@ -234,6 +280,19 @@ const innerLangVal = Symbol('reInnerLangVal');
 
 const LANG_MISSING_KEY_HANDLER = new InjectionToken('RE_LANG_MISSING_KEY_HANDLER');
 
+/**
+ * Optional DI token for a custom persistence adapter used by `LangService`
+ * to store and retrieve the selected language (default key: `'lang'`).
+ *
+ * When not provided the service falls back to `localStorage` directly.
+ *
+ * Example:
+ * ```ts
+ * { provide: LANG_PERSISTENCE_ADAPTER, useValue: sessionStorageAdapter }
+ * ```
+ */
+const LANG_PERSISTENCE_ADAPTER = new InjectionToken('RE_LANG_PERSISTENCE_ADAPTER');
+
 /**
  * Injection token for providing locale configuration to the language module.
  *
@@ -254,6 +313,67 @@ const LANG_MISSING_KEY_HANDLER = new InjectionToken('RE_LANG_MISSING_KEY_HANDLER
  */
 const LANG_CONFIG = new InjectionToken('RE_LANG_CONFIG');
 
+/**
+ * @deprecated Diagnostics are usually enabled through route preload config, not by consuming this service directly.
+ */
+class RouteNamespaceDiagnosticsService {
+    router = inject(Router, { optional: true });
+    enabled = !!inject(LANG_CONFIG).routeNamespacePreload?.diagnostics;
+    warned = new Set();
+    currentUrl = '';
+    currentNamespaces = new Set();
+    navigationSettled = false;
+    constructor() {
+        if (!this.enabled || !this.router) {
+            return;
+        }
+        this.router.events.subscribe((event) => {
+            if (event instanceof NavigationEnd) {
+                const url = normalizeUrlPath$1(event.urlAfterRedirects || event.url);
+                if (url === this.currentUrl) {
+                    this.navigationSettled = true;
+                }
+            }
+        });
+    }
+    registerRouteNamespaces(url, namespaces) {
+        if (!this.enabled) {
+            return;
+        }
+        this.currentUrl = normalizeUrlPath$1(url);
+        this.currentNamespaces = new Set(namespaces.map((ns) => ns.trim()).filter(Boolean));
+        this.navigationSettled = false;
+    }
+    warnLateNamespaceLoad(namespace) {
+        if (!this.enabled || !this.navigationSettled || typeof ngDevMode === 'undefined') {
+            return;
+        }
+        const normalizedNamespace = namespace.trim();
+        if (!normalizedNamespace || this.currentNamespaces.has(normalizedNamespace)) {
+            return;
+        }
+        const key = `${this.currentUrl}|${normalizedNamespace}`;
+        if (this.warned.has(key)) {
+            return;
+        }
+        this.warned.add(key);
+        // eslint-disable-next-line no-console
+        console.warn(`[presentia] Namespace "${normalizedNamespace}" was loaded after route activation for "${this.currentUrl}". ` +
+            'Add it to routeNamespacePreload manifest or route data to avoid raw i18n keys on first paint.');
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: RouteNamespaceDiagnosticsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: RouteNamespaceDiagnosticsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: RouteNamespaceDiagnosticsService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+function normalizeUrlPath$1(url) {
+    const [path] = url.split(/[?#]/, 1);
+    const normalized = `/${(path ?? '').replace(/^\/+|\/+$/g, '')}`;
+    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,
@@ -267,12 +387,13 @@ class LangService {
     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 ?? []),
     ]);
-    #lang = signal(this.getStoredLang(), ...(ngDevMode ? [{ debugName: "#lang" }] : []));
-    #cache = signal({}, ...(ngDevMode ? [{ debugName: "#cache" }] : []));
+    #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();
@@ -289,7 +410,7 @@ class LangService {
     currentLang = computed(() => {
         const lang = this.#lang();
         return lang === 'kg' ? (this.config?.kgValue ?? 'kg') : lang;
-    }, ...(ngDevMode ? [{ debugName: "currentLang" }] : []));
+    }, ...(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.
@@ -357,6 +478,7 @@ class LangService {
         if (this.isNamespaceValid(key)) {
             return;
         }
+        this.routeNamespaceDiagnostics?.warnLateNamespaceLoad(ns);
         this.tryExpireNamespace(key);
         if (this.#pendingLoads.has(key)) {
             return this.#pendingLoads.get(key);
@@ -411,14 +533,27 @@ class LangService {
             await Promise.all(toLoad.map((ns) => this.loadNamespace(ns)));
             return;
         }
-        const batchKey = this.makeBatchKey(requestedLang, toLoad);
+        const maxBatchSize = this.normalizeMaxBatchSize(this.config.maxBatchSize);
+        const chunks = maxBatchSize && toLoad.length > maxBatchSize ? this.chunkNamespaces(toLoad, maxBatchSize) : [toLoad];
+        await Promise.all(chunks.map((chunk) => {
+            if (chunk.length < 2) {
+                return this.loadNamespace(chunk[0]);
+            }
+            return this.loadNamespaceBatch(chunk, requestedLang);
+        }));
+    }
+    async loadNamespaceBatch(namespaces, requestedLang) {
+        for (const ns of namespaces) {
+            this.routeNamespaceDiagnostics?.warnLateNamespaceLoad(ns);
+        }
+        const batchKey = this.makeBatchKey(requestedLang, namespaces);
         if (this.#pendingBatchLoads.has(batchKey)) {
             return this.#pendingBatchLoads.get(batchKey);
         }
         const promise = (async () => {
             try {
                 const context = {
-                    namespaces: toLoad,
+                    namespaces,
                     lang: requestedLang,
                     isFromAssets: this.config.isFromAssets,
                     baseUrl: this.config.url,
@@ -430,7 +565,7 @@ class LangService {
                 }
                 const payloads = this.config.batchResponseAdapter(response, this.toBatchResponseContext(context));
                 const merged = {};
-                for (const ns of toLoad) {
+                for (const ns of namespaces) {
                     const nsPayload = payloads[ns];
                     if (!nsPayload) {
                         continue;
@@ -450,6 +585,19 @@ class LangService {
         this.#pendingBatchLoads.set(batchKey, promise);
         return promise;
     }
+    normalizeMaxBatchSize(value) {
+        if (!value || value < 1) {
+            return null;
+        }
+        return Math.floor(value);
+    }
+    chunkNamespaces(namespaces, size) {
+        const chunks = [];
+        for (let i = 0; i < namespaces.length; i += size) {
+            chunks.push(namespaces.slice(i, i + size));
+        }
+        return chunks;
+    }
     evictNamespace(ns) {
         const key = this.makeNamespaceKey(ns);
         if (!this.#loadedNamespaces.has(key)) {
@@ -664,10 +812,10 @@ class LangService {
             .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' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: LangService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: LangService, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: LangService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: LangService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [] });
@@ -705,19 +853,19 @@ class LangDirective {
      * Localization mode: defines which parts of the element will be translated.
      * @default 'all'
      */
-    lang = input('all', { ...(ngDevMode ? { debugName: "lang" } : {}), alias: 'reLang' });
+    lang = input('all', { ...(ngDevMode ? { debugName: "lang" } : /* istanbul ignore next */ {}), alias: 'reLang' });
     /**
      * Explicit key for text content translation.
      */
-    reLangKeySig = signal(undefined, ...(ngDevMode ? [{ debugName: "reLangKeySig" }] : []));
+    reLangKeySig = signal(undefined, ...(ngDevMode ? [{ debugName: "reLangKeySig" }] : /* istanbul ignore next */ []));
     /**
      * Explicit attribute-to-key map for translation.
      */
-    reLangAttrsSig = signal(undefined, ...(ngDevMode ? [{ debugName: "reLangAttrsSig" }] : []));
+    reLangAttrsSig = signal(undefined, ...(ngDevMode ? [{ debugName: "reLangAttrsSig" }] : /* istanbul ignore next */ []));
     /**
      * Name of an additional attribute to localize (besides standard `title`, `label`, `placeholder`).
      */
-    langForAttr = input(...(ngDevMode ? [undefined, { debugName: "langForAttr" }] : []));
+    langForAttr = input(...(ngDevMode ? [undefined, { debugName: "langForAttr" }] : /* istanbul ignore next */ []));
     el = inject(ElementRef);
     renderer = inject(Renderer2);
     service = inject(LangService);
@@ -913,10 +1061,10 @@ class LangDirective {
         }
         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 });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.1.1", 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 });
+    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.1.1", ngImport: i0, type: LangDirective, decorators: [{
+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: [{
@@ -1024,14 +1172,288 @@ class LangPipe {
         // 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.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 });
+    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.1.1", ngImport: i0, type: LangPipe, decorators: [{
+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];
+        });
+    }
+    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: () => [] });
+
+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));
+        }),
+    ]);
+}
+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;
+        }
+        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)));
+}
+
 /**
  * Type-safe mapping of available theme names.
  *
@@ -1053,27 +1475,12 @@ const themes = {
     dark: 'dark',
 };
 /**
- * CSS class prefix used for dark theme styling.
- *
- * This constant defines the prefix applied to HTML elements when the dark theme is active.
- * It is typically added to the root element or specific components to enable dark theme styles.
- *
- * @example
- * ```typescript
- * document.body.classList.add(darkThemePrefix); // Applies 're-dark' class
- * ```
+ * @deprecated Prefer `theme.dom.darkClassName` via `providePresentia(...)`.
  */
 const darkThemePrefix = 're-dark';
 
 /**
- * Default theme configuration object.
- *
- * Defines the initial theme settings for the application.
- * By default, sets the light theme as the active theme.
- *
- * This configuration can be overridden when providing `THEME_CONFIG` token
- * at the module or application level.
- * ```
+ * @deprecated Prefer configuring themes through `providePresentia({ theme: ... })`.
  */
 const defaultThemeConfig = {
     defaultTheme: themes.light,
@@ -1097,6 +1504,28 @@ const defaultThemeConfig = {
  */
 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),
+};
+/**
+ * DI token for the persistence adapter used by `ThemeService`
+ * to store and retrieve the selected theme (default key: `'theme'`).
+ *
+ * By default `presentia` provides a `localStorage`-backed adapter.
+ *
+ * Example:
+ * ```ts
+ * { provide: THEME_PERSISTENCE_ADAPTER, useValue: sessionStorageAdapter }
+ * ```
+ */
+const THEME_PERSISTENCE_ADAPTER = new InjectionToken('RE_THEME_PERSISTENCE_ADAPTER', {
+    factory: () => defaultThemePersistenceAdapter,
+});
+
 /**
  * Service for managing application theme.
  *
@@ -1112,11 +1541,18 @@ const THEME_CONFIG = new InjectionToken('RE_THEME_CONFIG');
  */
 class ThemeService {
     config = inject(THEME_CONFIG);
-    themeDefault = this.config?.defaultTheme || themes.light;
-    darkPrefix = this.config?.darkThemePrefix || darkThemePrefix;
+    registry = this.resolveRegistry(this.config?.registry);
+    themeDefault = this.resolveInitialTheme(this.config?.defaultTheme);
+    domStrategy = this.config?.dom?.strategy ?? 'root-class';
+    darkPrefix = this.config?.dom?.darkThemePrefix || this.config?.darkThemePrefix || darkThemePrefix;
+    attributeName = this.config?.dom?.attributeName || 'data-theme';
+    themeClassPrefix = this.config?.dom?.themeClassPrefix;
+    classNameBuilder = this.config?.dom?.classNameBuilder;
+    rootSelector = this.config?.dom?.rootSelector;
+    persistence = inject(THEME_PERSISTENCE_ADAPTER);
     isBrowser = isPlatformBrowser(inject(PLATFORM_ID));
     document = inject(DOCUMENT);
-    #theme = signal(this.themeDefault, ...(ngDevMode ? [{ debugName: "#theme" }] : []));
+    #theme = signal(this.themeDefault, ...(ngDevMode ? [{ debugName: "#theme" }] : /* istanbul ignore next */ []));
     /**
      * Current active theme (`light` or `dark`).
      *
@@ -1126,26 +1562,22 @@ class ThemeService {
      * <div [class]="themeService.theme()"></div>
      * ```
      */
-    theme = computed(() => this.#theme(), ...(ngDevMode ? [{ debugName: "theme" }] : []));
+    theme = computed(() => this.#theme(), ...(ngDevMode ? [{ debugName: "theme" }] : /* istanbul ignore next */ []));
     /**
      * 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" }] : []));
+    isLight = computed(() => this.#theme() === themes.light, ...(ngDevMode ? [{ debugName: "isLight" }] : /* istanbul ignore next */ []));
+    isDark = computed(() => this.#theme() === themes.dark, ...(ngDevMode ? [{ debugName: "isDark" }] : /* istanbul ignore next */ []));
     constructor() {
         effect(() => {
             if (!this.isBrowser) {
                 this.#theme.set(this.themeDefault);
                 return;
             }
-            const theme = this.resolveTheme(localStorage.getItem('theme'));
+            const theme = this.resolveTheme(this.getStoredTheme());
             this.switch(theme);
         });
-        effect(() => {
-            if (this.isBrowser) {
-                localStorage.setItem('theme', this.#theme());
-            }
-        });
     }
     /**
      * Switches theme.
@@ -1157,28 +1589,116 @@ class ThemeService {
      */
     switch(theme) {
         const requestedTheme = theme ? this.resolveTheme(theme) : undefined;
-        const newTheme = requestedTheme ?? (this.#theme() === themes.light ? themes.dark : themes.light);
+        const newTheme = requestedTheme ?? this.nextTheme();
         if (this.isBrowser) {
-            const html = this.document.documentElement;
-            newTheme === themes.dark && html.classList.add(this.darkPrefix);
-            newTheme === themes.light && html.classList.remove(this.darkPrefix);
+            this.applyThemeToDom(newTheme);
+            this.persistTheme(newTheme);
         }
         this.#theme.set(newTheme);
     }
+    is(theme) {
+        const allowed = Array.isArray(theme) ? theme : [theme];
+        return allowed.includes(this.#theme());
+    }
     resolveTheme(theme) {
-        return theme === themes.dark ? themes.dark : themes.light;
+        if (theme && this.registry.includes(theme)) {
+            return theme;
+        }
+        return this.themeDefault;
+    }
+    resolveRegistry(registry) {
+        return registry?.length ? registry : [themes.light, themes.dark];
+    }
+    resolveInitialTheme(theme) {
+        const next = theme ?? themes.light;
+        return this.registry.includes(next) ? next : (this.registry[0] ?? themes.light);
+    }
+    getStoredTheme() {
+        return this.persistence.getItem('theme');
+    }
+    persistTheme(theme) {
+        this.persistence.setItem('theme', theme);
+    }
+    applyThemeToDom(theme) {
+        const root = this.resolveRootElement();
+        if (!root) {
+            return;
+        }
+        if (this.domStrategy === 'data-attribute') {
+            root.setAttribute(this.attributeName, theme);
+            return;
+        }
+        this.clearThemeClasses(root);
+        if (theme === themes.dark) {
+            root.classList.add(this.darkPrefix);
+        }
+        else {
+            root.classList.remove(this.darkPrefix);
+        }
+        const className = this.resolveThemeClassName(theme);
+        if (className) {
+            root.classList.add(className);
+        }
+    }
+    nextTheme() {
+        const currentIndex = this.registry.indexOf(this.#theme());
+        if (currentIndex < 0) {
+            return this.themeDefault;
+        }
+        return this.registry[(currentIndex + 1) % this.registry.length] ?? this.themeDefault;
+    }
+    resolveRootElement() {
+        if (!this.rootSelector) {
+            return this.document.documentElement;
+        }
+        return this.document.querySelector(this.rootSelector);
+    }
+    resolveThemeClassName(theme) {
+        if (this.classNameBuilder) {
+            return this.classNameBuilder(theme);
+        }
+        if (this.themeClassPrefix) {
+            return `${this.themeClassPrefix}${theme}`;
+        }
+        return null;
+    }
+    clearThemeClasses(root) {
+        if (!this.classNameBuilder && !this.themeClassPrefix) {
+            return;
+        }
+        for (const registeredTheme of this.registry) {
+            const className = this.resolveThemeClassName(registeredTheme);
+            if (className) {
+                root.classList.remove(className);
+            }
+        }
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: ThemeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: ThemeService, providedIn: 'root' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: ThemeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: ThemeService, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: ThemeService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: ThemeService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
         }], ctorParameters: () => [] });
 
+let warnedLegacyProvider = false;
+/**
+ * @deprecated Prefer `providePresentia(...)` for new integrations.
+ */
 function provideReInit(config) {
+    if (typeof ngDevMode !== 'undefined' && !warnedLegacyProvider) {
+        warnedLegacyProvider = true;
+        // eslint-disable-next-line no-console
+        console.warn('[presentia] provideReInit(...) is the legacy 1.x provider. Prefer providePresentia(...) for the grouped v2 config API.');
+    }
+    return buildPresentiaProviders(config);
+}
+function __resetPresentiaProviderWarningsForTests() {
+    warnedLegacyProvider = false;
+}
+function buildPresentiaProviders(config) {
     return makeEnvironmentProviders([
         { provide: TRANSLATION, deps: [LangService], useFactory: (ls) => ls },
         { provide: SELECTED_LANG, deps: [LangService], useFactory: (ls) => ls[innerLangVal] },
@@ -1192,13 +1712,88 @@ 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: THEME_PERSISTENCE_ADAPTER, useValue: defaultThemePersistenceAdapter },
         { 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' },
+        providePresentiaRouteNamespacePreload(),
+    ]);
+}
+
+function providePresentia(config) {
+    const routesConfig = config.lang.preload?.routes;
+    const diagnosticsEnabled = config.lang.diagnostics?.lateNamespaceLoads;
+    const routeNamespacePreload = routesConfig || diagnosticsEnabled
+        ? { ...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,
+        });
+    }
+    return makeEnvironmentProviders([
+        buildPresentiaProviders({
+            locale: {
+                url: config.lang.source.url,
+                isFromAssets: config.lang.source.fromAssets,
+                defaultLang: config.lang.source.defaultLang,
+                fallbackLang: config.lang.source.fallbackLang,
+                supportedLangs: config.lang.source.supportedLangs,
+                kgValue: config.lang.source.kgValue,
+                defaultValue: config.lang.rendering?.missingValue,
+                preloadNamespaces: config.lang.preload?.global,
+                requestBuilder: config.lang.transport?.requestBuilder,
+                requestOptionsFactory: config.lang.transport?.requestOptionsFactory,
+                responseAdapter: config.lang.transport?.responseAdapter,
+                batchRequestBuilder: config.lang.transport?.batchRequestBuilder,
+                batchResponseAdapter: config.lang.transport?.batchResponseAdapter,
+                namespaceCache: config.lang.cache,
+                routeNamespacePreload,
+                maxBatchSize: config.lang.transport?.maxBatchSize,
+            },
+            theme: config.theme
+                ? {
+                    registry: config.theme.registry,
+                    defaultTheme: config.theme.defaultTheme,
+                    darkThemePrefix: config.theme.dom?.darkClassName,
+                    dom: config.theme.dom
+                        ? {
+                            strategy: config.theme.dom.strategy,
+                            rootSelector: config.theme.dom.rootSelector,
+                            darkThemePrefix: config.theme.dom.darkClassName,
+                            attributeName: config.theme.dom.attributeName,
+                            themeClassPrefix: config.theme.dom.classPrefix,
+                            classNameBuilder: config.theme.dom.classNameBuilder,
+                        }
+                        : undefined,
+                }
+                : undefined,
+            breakpoints: config.adaptive?.breakpoints,
+            langPipe: {
+                placeholder: config.lang.rendering?.placeholder,
+            },
+            langMissingKeyHandler: config.lang.missingKeyHandler,
+        }),
+        ...extraProviders,
     ]);
 }
 
+/**
+ * @deprecated Prefer `providePresentia(...)` for new integrations.
+ */
+
 /**
  * Service for managing page SEO metadata.
  *
@@ -1326,10 +1921,10 @@ class SeoService {
             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, providedIn: 'root' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: SeoService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: SeoService, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: SeoService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: SeoService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -1355,7 +1950,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.1", ngImpor
 class SeoRouteListener {
     router = inject(Router);
     seo = inject(SeoService);
-    ar = inject(ActivatedRoute);
     destroyRef = inject(DestroyRef);
     initialized = false;
     baseUrl = '';
@@ -1369,9 +1963,9 @@ class SeoRouteListener {
     init(baseUrl) {
         this.baseUrl = baseUrl.replace(/\/+$/, '');
         const applyRouteSeo = () => {
-            const route = this.deepest(this.ar);
-            const data = route.snapshot.data;
-            const url = data.canonical ?? this.baseUrl + this.router.url;
+            const snapshot = deepestRouteSnapshot(this.router.routerState.snapshot.root);
+            const data = snapshotMergedData(snapshot);
+            const url = resolveCanonicalUrl(data.canonical, this.baseUrl, snapshotFullPath(snapshot));
             data.title && this.seo.setTitle(data.title);
             data.description && this.seo.setDescription(data.description);
             data.twitter && this.seo.setTwitter(data.twitter);
@@ -1397,123 +1991,33 @@ class SeoRouteListener {
         });
         this.destroyRef.onDestroy(() => subscription.unsubscribe());
     }
-    /**
-     * Recursively finds the deepest (most nested) activated route in the route tree.
-     * This is used to extract route data from the currently active leaf route.
-     *
-     * @param r - The root activated route to start traversing from.
-     * @returns The deepest child route in the hierarchy.
-     */
-    deepest(r) {
-        let cur = r;
-        while (cur.firstChild) {
-            cur = cur.firstChild;
-        }
-        return cur;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: SeoRouteListener, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: SeoRouteListener, providedIn: 'root' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: SeoRouteListener, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: SeoRouteListener, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: SeoRouteListener, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: SeoRouteListener, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
-
-/**
- * Reactive snapshot of the current route (the deepest active route).
- * Updates on every `NavigationEnd` event.
- *
- * Provides:
- * - `params` / `query` — strings (as in Angular Router)
- * - `data` — arbitrary data (from route configuration/resolvers)
- * - `url` — string assembled from `UrlSegment[]`
- * - `fragment` — hash (#section)
- * - `selectData(key)` — type-safe selector for `data`
- * - `state` — combined computed object (convenient for single subscriber)
- */
-class RouteWatcher {
-    router = inject(Router);
-    destroyRef = inject(DestroyRef);
-    #params = signal({}, ...(ngDevMode ? [{ debugName: "#params" }] : []));
-    #query = signal({}, ...(ngDevMode ? [{ debugName: "#query" }] : []));
-    #data = signal({}, ...(ngDevMode ? [{ debugName: "#data" }] : []));
-    #url = signal('', ...(ngDevMode ? [{ debugName: "#url" }] : []));
-    #fragment = signal(null, ...(ngDevMode ? [{ debugName: "#fragment" }] : []));
-    /** Signal for tracking and retrieving URL parameters */
-    params = this.#params.asReadonly();
-    /** Signal for tracking and retrieving query parameters */
-    query = this.#query.asReadonly();
-    /** Signal for tracking and retrieving route data */
-    data = this.#data.asReadonly();
-    /** Signal for tracking and retrieving URL */
-    url = this.#url.asReadonly();
-    /** Signal for tracking and retrieving URL fragment */
-    fragment = this.#fragment.asReadonly();
-    /** Combined computed snapshot (to avoid multiple effects) */
-    state = computed(() => ({
-        params: this.#params(),
-        query: this.#query(),
-        data: this.#data(),
-        url: this.#url(),
-        fragment: this.#fragment(),
-    }), ...(ngDevMode ? [{ debugName: "state" }] : []));
-    constructor() {
-        const read = () => {
-            const snap = this.deepestSnapshot();
-            const url = snapshotFullPath(snap);
-            const params = snapshotMergedParams(snap);
-            !deepEqual(params, this.#params()) && this.#params.set(params);
-            !deepEqual(snap.queryParams, this.#query()) && this.#query.set(snap.queryParams);
-            !deepEqual(snap.data, this.#data()) && this.#data.set(snap.data);
-            this.#url() !== url && this.#url.set(url);
-            this.#fragment() !== snap.fragment && this.#fragment.set(snap.fragment ?? null);
-        };
-        read();
-        const subscription = this.router.events.subscribe((event) => {
-            if (event instanceof NavigationEnd) {
-                read();
-            }
-        });
-        this.destroyRef.onDestroy(() => subscription.unsubscribe());
+function resolveCanonicalUrl(canonical, baseUrl, path) {
+    if (!canonical) {
+        return joinBaseUrl(baseUrl, path);
     }
-    /** Convenient selector for a data key with type-safe casting */
-    selectData(key) {
-        return computed(() => this.#data()[key]);
+    if (/^https?:\/\//i.test(canonical)) {
+        return canonical;
     }
-    deepestSnapshot() {
-        // work with snapshot — we need a "frozen" point at NavigationEnd moment
-        let snap = this.router.routerState.snapshot.root;
-        while (snap.firstChild) {
-            snap = snap.firstChild;
-        }
-        return snap;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: RouteWatcher, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: RouteWatcher, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.1", ngImport: i0, type: RouteWatcher, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [] });
-/** Joins `UrlSegment[]` into a path string */
-function joinUrl(segments) {
-    return segments.length ? segments.map((s) => s.path).join('/') : '';
+    return joinBaseUrl(baseUrl, canonical);
 }
-/** Builds a full route path from root to current snapshot */
-function snapshotFullPath(snap) {
-    return snap.pathFromRoot
-        .map((s) => joinUrl(s.url))
-        .filter(Boolean)
-        .join('/');
-}
-/** Merges params from root to the deepest snapshot (child keys override parent). */
-function snapshotMergedParams(snap) {
-    return snap.pathFromRoot.reduce((acc, route) => ({ ...acc, ...route.params }), {});
+function joinBaseUrl(baseUrl, path) {
+    const normalizedPath = path.replace(/^\/+/, '');
+    if (!baseUrl) {
+        return normalizedPath ? `/${normalizedPath}` : '/';
+    }
+    return normalizedPath ? `${baseUrl}/${normalizedPath}` : baseUrl;
 }
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-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 };
+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 };
 //# sourceMappingURL=reforgium-presentia.mjs.map