@reforgium/presentia 1.0.0

package/fesm2022/reforgium-presentia.mjs

@@ -0,0 +1,671 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, signal, computed, inject, afterRenderEffect, Injectable, input, TemplateRef, ViewContainerRef, effect, Directive, Pipe, makeEnvironmentProviders, LOCALE_ID, DestroyRef } from '@angular/core';
+import { SELECTED_LANG, SELECTED_THEME, CURRENT_DEVICE, deepEqual } from '@reforgium/internal';
+import { BreakpointObserver } from '@angular/cdk/layout';
+import { fromEvent, debounceTime, startWith, filter as filter$1, map } from 'rxjs';
+import { HttpClient } from '@angular/common/http';
+import { Title, Meta } from '@angular/platform-browser';
+import { Router, ActivatedRoute, NavigationEnd } from '@angular/router';
+import { filter } from 'rxjs/operators';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+
+const defaultBreakpoints = {
+    'mobile': '(max-width: 719px)',
+    'tablet': '(min-width: 720px) and (max-width: 1399px)',
+    'desktop-s': '(min-width: 1400px) and (max-width: 1919px)',
+    'desktop': '(min-width: 1920px)',
+};
+const DEVICE_BREAKPOINTS = new InjectionToken('RE_DEVICE_BREAKPOINTS', {
+    providedIn: 'root',
+    factory: () => defaultBreakpoints,
+});
+
+/**
+ * Сервис `AdaptiveService` отвечает за определение типа устройства, размеров окна и ориентации экрана.
+ *
+ * Используется для построения адаптивных интерфейсов, изменения поведения компонентов и стилей
+ * в зависимости от текущего устройства или размера экрана.
+ *
+ * Основные возможности:
+ * - Реактивное отслеживание текущего устройства (`desktop`, `tablet`, `mobile`).
+ * - Поддержка вычисляемых признаков (`isDesktop`, `isPortrait`).
+ * - Автоматическое обновление при изменении размера окна и пересечении брейкпоинтов.
+ *
+ * Реализация основана на:
+ * - `BreakpointObserver` из Angular CDK — для наблюдения за медиа-запросами.
+ * - `signal` и `computed` — для реактивного состояния без зон.
+ * - `fromEvent(window, 'resize')` — для обновления размеров окна с дебаунсом.
+ *
+ * Сервис зарегистрирован как `providedIn: 'root'` и доступен во всём приложении.
+ */
+class AdaptiveService {
+    /** @internal Сигнал текущего типа устройства. */
+    #device = signal('desktop', ...(ngDevMode ? [{ debugName: "#device" }] : []));
+    /** @internal Сигналы текущей ширины и высоты окна. */
+    #width = signal(0, ...(ngDevMode ? [{ debugName: "#width" }] : []));
+    #height = signal(0, ...(ngDevMode ? [{ debugName: "#height" }] : []));
+    /**
+     * Текущий тип устройства (reactive signal).
+     * Возможные значения: `'desktop' | 'tablet' | 'mobile'`.
+     *
+     * Обновляется автоматически при изменении ширины экрана
+     * или при пересечении заданных брейкпоинтов (`DEVICE_BREAKPOINTS`).
+     */
+    device = this.#device.asReadonly();
+    /**
+     * Текущая ширина окна браузера в пикселях.
+     * Обновляется реактивно при событии `resize`.
+     */
+    width = this.#width.asReadonly();
+    /**
+     * Текущая высота окна браузера в пикселях.
+     * Обновляется реактивно при событии `resize`.
+     */
+    height = this.#height.asReadonly();
+    /**
+     * Вычисляемый сигнал, показывающий, является ли текущее устройство десктопом.
+     * Используется для условного рендера или настройки макета.
+     */
+    isDesktop = computed(() => this.#device() === 'desktop', ...(ngDevMode ? [{ debugName: "isDesktop" }] : []));
+    /**
+     * Вычисляемый сигнал, определяющий, находится ли экран в портретной ориентации.
+     * Возвращает `true`, если высота окна больше ширины.
+     */
+    isPortrait = computed(() => this.#height() > this.#width(), ...(ngDevMode ? [{ debugName: "isPortrait" }] : []));
+    deviceBreakpoints = inject(DEVICE_BREAKPOINTS);
+    devicePriority = Object.keys(this.deviceBreakpoints);
+    breakpointObserver = inject(BreakpointObserver);
+    constructor() {
+        afterRenderEffect(() => {
+            this.#width.set(window.innerWidth);
+            this.#height.set(window.innerHeight);
+        });
+        this.breakpointObserver.observe(Object.values(this.deviceBreakpoints)).subscribe((state) => {
+            const device = this.devicePriority.find((key) => state.breakpoints[this.deviceBreakpoints[key]]);
+            this.#device.set(device ?? 'desktop');
+        });
+        fromEvent(window, 'resize')
+            .pipe(debounceTime(100))
+            .subscribe(() => {
+            this.#width.set(window.innerWidth);
+            this.#height.set(window.innerHeight);
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.3", ngImport: i0, type: AdaptiveService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.3", ngImport: i0, type: AdaptiveService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.3", ngImport: i0, type: AdaptiveService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
+/**
+ * Структурная директива `*ssIfDevice`.
+ *
+ * Показывает или скрывает элемент в зависимости от текущего устройства,
+ * определяемого через `AdaptiveService`.
+ *
+ * Пример:
+ * ```html
+ * <div *ssIfDevice="'desktop'">Только для десктопа</div>
+ * <div *ssIfDevice="['mobile', 'tablet']">Для мобильных и планшетов</div>
+ * <div *ssIfDevice="'mobile'; inverse: true">Скрыть на мобильных</div>
+ * ```
+ *
+ * Параметры:
+ * - `ssIfDevice` — одно или несколько значений `Devices` (`'desktop' | 'tablet' | 'mobile'`)
+ * - `inverse` — инвертирует условие показа
+ *
+ * Работает реактивно: при изменении типа устройства в `AdaptiveService`
+ * шаблон автоматически добавляется или удаляется из DOM.
+ */
+class IfDeviceDirective {
+    device = input(undefined, { ...(ngDevMode ? { debugName: "device" } : {}), alias: 'ssIfDevice' });
+    inverse = input(false, ...(ngDevMode ? [{ debugName: "inverse" }] : []));
+    tpl = inject(TemplateRef);
+    vcr = inject(ViewContainerRef);
+    adaptive = inject(AdaptiveService);
+    allowedDevices = [];
+    hasView = false;
+    currentDevice = this.adaptive.device;
+    constructor() {
+        effect(() => {
+            const device = this.device();
+            if (device) {
+                this.allowedDevices = Array.isArray(device) ? device : [device];
+            }
+            this.updateView();
+        });
+    }
+    updateView() {
+        const isAllowed = this.allowedDevices.includes(this.currentDevice());
+        const shouldShow = this.inverse() ? !isAllowed : isAllowed;
+        if (shouldShow && !this.hasView) {
+            this.vcr.createEmbeddedView(this.tpl);
+            this.hasView = true;
+        }
+        else if (!shouldShow && this.hasView) {
+            this.vcr.clear();
+            this.hasView = false;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.3", ngImport: i0, type: IfDeviceDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.0.3", type: IfDeviceDirective, isStandalone: true, selector: "[reIfDevice]", inputs: { device: { classPropertyName: "device", publicName: "ssIfDevice", isSignal: true, isRequired: false, transformFunction: null }, inverse: { classPropertyName: "inverse", publicName: "inverse", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.3", ngImport: i0, type: IfDeviceDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[reIfDevice]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [], propDecorators: { device: [{ type: i0.Input, args: [{ isSignal: true, alias: "ssIfDevice", required: false }] }], inverse: [{ type: i0.Input, args: [{ isSignal: true, alias: "inverse", required: false }] }] } });
+
+const LANG_CONFIG = new InjectionToken('RE_LANG_CONFIG');
+
+const innerLangVal = Symbol('reInnerLangVal');
+
+/**
+ * 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 {
+    config = inject(LANG_CONFIG);
+    http = inject(HttpClient);
+    #lang = signal(this.getStoredLang(), ...(ngDevMode ? [{ debugName: "#lang" }] : []));
+    #cache = signal({}, ...(ngDevMode ? [{ debugName: "#cache" }] : []));
+    #loadedNamespaces = new Set();
+    #pendingLoads = new Map();
+    /**
+     * Computed property determining the current language setting.
+     *
+     * - If private method `#lang` returns 'ru', this property will return 'ru'.
+     * - If `#lang` returns another value, the `config.kgValue` property is checked:
+     * - If `config.kgValue` is defined, the property will return its value.
+     * - If `config.kgValue` is not defined, the property will return default value 'kg'.
+     */
+    currentLang = computed(() => {
+        const lang = this.#lang();
+        return lang === 'ru' ? 'ru' : (this.config.kgValue ?? 'kg');
+    }, ...(ngDevMode ? [{ debugName: "currentLang" }] : []));
+    /**
+     * Extracts readonly value from private property `#lang` and assigns it to `innerLangVal`.
+     * Expected that property `#lang` has `asReadonly` method that returns immutable representation.
+     */
+    [innerLangVal] = this.#lang.asReadonly();
+    /**
+     * 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 = lang === 'ky' ? 'kg' : lang;
+        if (langVal !== this.#lang()) {
+            this.#lang.set(langVal);
+            localStorage.setItem('lang', langVal);
+            const namespaces = Array.from(this.#loadedNamespaces.values()).map((key) => key.split('.')[1]);
+            this.#loadedNamespaces.clear();
+            namespaces.forEach((ns) => void this.loadNamespace(ns));
+        }
+    }
+    /**
+     * Gets value based on provided query and optionally applies specified parameters.
+     *
+     * @param {string} query - Query string used to retrieve desired value.
+     * @param {LangParams} [params] - Optional parameters to apply to retrieved value.
+     * @return {string} Retrieved value after optional parameter application,
+     * or default value if query is not found.
+     */
+    get(query, params) {
+        const value = this.getChainedValue(query);
+        if (params) {
+            return this.applyParams((value ?? query), params);
+        }
+        return value ?? this.config.defaultValue ?? query;
+    }
+    /**
+     * Observes changes to specified translation key and dynamically computes its value.
+     *
+     * @param {string} query - Translation key to observe, typically in format "namespace.key".
+     * @param {LangParams} [params] - Optional parameters for interpolation or
+     * dynamic content replacement in translation value.
+     * @return {Signal<string>} Computed value that dynamically updates
+     * with translation matching provided query and parameters.
+     */
+    observe(query, params) {
+        const [ns] = query.split('.');
+        if (!this.#loadedNamespaces.has(this.makeNamespaceKey(ns))) {
+            void this.loadNamespace(ns);
+        }
+        return computed(() => this.get(query, params));
+    }
+    /**
+     * Loads specified namespace, ensuring its caching and availability for use.
+     *
+     * @param {string} ns - Namespace name to load.
+     * @return {Promise<void>} Promise that resolves on successful namespace load,
+     * or rejects when error occurs during process.
+     */
+    async loadNamespace(ns) {
+        const key = this.makeNamespaceKey(ns);
+        if (this.#loadedNamespaces.has(key)) {
+            return;
+        }
+        if (this.#pendingLoads.has(key)) {
+            return this.#pendingLoads.get(key);
+        }
+        const promise = new Promise((resolve, reject) => {
+            this.http.get(this.makeUrl(ns)).subscribe({
+                next: (res) => {
+                    const existing = this.#cache();
+                    const resolved = Array.isArray(res) ? this.parseModelToRecord(res) : this.parseAssetToRecord(ns, res);
+                    this.#cache.set({ ...existing, ...resolved });
+                    this.#loadedNamespaces.add(key);
+                    resolve();
+                },
+                error: (err) => {
+                    this.#pendingLoads.delete(key);
+                    reject(err);
+                },
+                complete: () => this.#pendingLoads.delete(key),
+            });
+        });
+        this.#pendingLoads.set(key, promise);
+        return promise;
+    }
+    parseModelToRecord(model) {
+        const records = {};
+        for (const item of model) {
+            records[item.code] = item.localization;
+        }
+        return records;
+    }
+    parseAssetToRecord(page, data) {
+        const records = {};
+        for (const [k, v] of Object.entries(data)) {
+            records[`${page}.${k}`] = v;
+        }
+        return records;
+    }
+    applyParams(text, params) {
+        return text.replace(/\{\{(.*?)}}/g, (_, k) => params[k.trim()] ?? '');
+    }
+    getChainedValue(query = '', source = this.#cache()) {
+        const [page, key, ...normalizedPath] = query.split('.');
+        return [`${page}.${key}`, ...normalizedPath].reduce((acc, key) => (typeof acc === 'object' ? (acc[key] ?? acc[query]) : undefined), source);
+    }
+    getStoredLang() {
+        return localStorage.getItem('lang') || this.config.defaultLang || 'ru';
+    }
+    makeUrl(ns) {
+        const suffix = this.config.isFromAssets ? `.${this.#lang()}.json` : `?language=${this.#lang()}`;
+        return `${this.config.url}/${ns}${suffix}`;
+    }
+    makeNamespaceKey(ns) {
+        return `${this.#lang()}.${ns}`;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.3", ngImport: i0, type: LangService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.3", ngImport: i0, type: LangService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.3", ngImport: i0, type: LangService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/**
+ * Кастомный Angular-пайп, который преобразует языковой ключ и дополнительные параметры в локализованную строку.
+ *
+ * Пайп объявлен как standalone и impure — то есть он может использоваться без подключения модуля
+ * и будет пересчитываться при изменении состояния (например, при смене языка).
+ *
+ * В своей работе пайп наблюдает и кэширует языковые ключи для повышения производительности,
+ * используя LangService для получения переведённых строк в зависимости от текущего языка приложения.
+ *
+ * Трансформация заключается в том, чтобы принять строку-ключ и необязательные параметры,
+ * сформировать ключ для кэша и вернуть локализованное значение, соответствующее этому запросу.
+ *
+ * @implements {PipeTransform}
+ */
+class LangPipe {
+    lang = inject(LangService);
+    cache = new Map();
+    transform(query, params) {
+        const key = query + JSON.stringify(params);
+        if (!this.cache.has(key)) {
+            this.cache.set(key, this.lang.observe(query, params));
+        }
+        return this.cache.get(key)();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.3", ngImport: i0, type: LangPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.0.3", ngImport: i0, type: LangPipe, isStandalone: true, name: "lang", pure: false });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.3", ngImport: i0, type: LangPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'lang', standalone: true, pure: false }]
+        }] });
+
+const themes = {
+    light: 'light',
+    dark: 'dark',
+};
+const darkThemePrefix = 're-dark';
+
+const defaultThemeConfig = {
+    defaultTheme: themes.light,
+};
+const THEME_CONFIG = new InjectionToken('RE_THEME_CONFIG');
+
+/**
+ * Service for managing application theme.
+ *
+ * Allows getting the current theme and switching between light and dark.
+ * Automatically saves selected theme to `localStorage` and applies CSS class to `<html>` element.
+ *
+ * Example:
+ * ```ts
+ * const theme = inject(ThemeService);
+ * theme.switch('dark');
+ * console.log(theme.theme()); // 'dark'
+ * ```
+ */
+class ThemeService {
+    config = inject(THEME_CONFIG);
+    themeDefault = this.config?.defaultTheme || themes.light;
+    #theme = signal(this.themeDefault, ...(ngDevMode ? [{ debugName: "#theme" }] : []));
+    /**
+     * Current active theme (`light` or `dark`).
+     *
+     * Value is reactive — can be used in template or `computed`.
+     * ```html
+     * <div [class.dark]="themeService.theme() === 'dark'"></div>
+     * <div [class]="themeService.theme()"></div>
+     * ```
+     */
+    theme = computed(() => this.#theme(), ...(ngDevMode ? [{ debugName: "theme" }] : []));
+    /**
+     * Convenient flag returning `true` if light theme is active.
+     * Suitable for conditional style application or resource selection.
+     */
+    isLight = computed(() => this.#theme() === themes.light, ...(ngDevMode ? [{ debugName: "isLight" }] : []));
+    constructor() {
+        effect(() => {
+            const theme = localStorage.getItem('theme') || this.themeDefault;
+            this.switch(theme);
+        });
+        effect(() => localStorage.setItem('theme', this.#theme()));
+    }
+    /**
+     * Switches theme.
+     *
+     * If parameter is not provided — performs toggle between `light` and `dark`.
+     * Also automatically updates `<html>` class and saves selection to `localStorage`.
+     *
+     * @param theme — explicit theme value (`'light'` or `'dark'`).
+     */
+    switch(theme) {
+        const html = document.querySelector('html');
+        const newTheme = theme ?? (this.#theme() === themes.light ? themes.dark : themes.light);
+        newTheme === themes.dark && html.classList.add(darkThemePrefix);
+        newTheme === themes.light && html.classList.remove(darkThemePrefix);
+        this.#theme.set(newTheme);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.3", ngImport: i0, type: ThemeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.3", ngImport: i0, type: ThemeService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.3", ngImport: i0, type: ThemeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
+function provideReInit(config) {
+    return makeEnvironmentProviders([
+        { provide: SELECTED_LANG, deps: [LangService], useFactory: (ls) => ls[innerLangVal] },
+        { provide: SELECTED_THEME, deps: [ThemeService], useFactory: (ls) => ls.theme },
+        { provide: CURRENT_DEVICE, deps: [AdaptiveService], useFactory: (ls) => ls.device },
+        { provide: DEVICE_BREAKPOINTS, useValue: config.breakpoints || defaultBreakpoints },
+        { provide: THEME_CONFIG, useValue: config.theme || defaultThemeConfig },
+        { provide: LANG_CONFIG, useValue: config.locale || {} },
+        { provide: LOCALE_ID, useValue: config.locale.defaultLang ?? 'ru' },
+    ]);
+}
+
+/**
+ * Service for managing page SEO metadata.
+ *
+ * Allows centrally setting title, description, keywords,
+ * Open Graph and Twitter Card tags, canonical link, and JSON-LD schema.
+ *
+ * Example:
+ * ```ts
+ * const seo = inject(SeoService);
+ * seo.setTitle('Home Page');
+ * seo.setDescription('Site Description');
+ * seo.setOg({ title: 'Home', type: 'website' });
+ * ```
+ */
+class SeoService {
+    title = inject(Title);
+    meta = inject(Meta);
+    /**
+     * Sets page title (`<title>`).
+     * @param value title text
+     */
+    setTitle(value) {
+        this.title.setTitle(value);
+    }
+    /**
+     * Sets page description (`<meta name="description">`).
+     * @param desc brief content description
+     */
+    setDescription(desc) {
+        this.upsert({ name: 'description', content: desc });
+    }
+    /**
+     * Sets page keywords (`<meta name="keywords">`).
+     * @param keywords array of keywords
+     */
+    setKeywords(keywords) {
+        this.upsert({ name: 'keywords', content: keywords.join(', ') });
+    }
+    /**
+     * Sets directives for search engines (`<meta name="robots">`).
+     * @param value value, e.g. `"index,follow"`
+     */
+    setRobots(value) {
+        this.upsert({ name: 'robots', content: value }); // e.g. "index,follow"
+    }
+    /**
+     * Sets canonical link (`<link rel="canonical">`).
+     * @param url absolute URL of canonical page
+     */
+    setCanonical(url) {
+        this.upsertLink('canonical', url);
+    }
+    /**
+     * Sets Open Graph meta tags.
+     * @param opts object with Open Graph fields (`title`, `description`, `image`, `url`, `type`, etc.)
+     */
+    setOg(opts) {
+        for (const [k, v] of Object.entries(opts)) {
+            v && this.upsert({ property: `og:${k}`, content: v });
+        }
+    }
+    /**
+     * Sets Twitter Card meta tags.
+     * @param opts object with Twitter Card fields (`card`, `title`, `description`, `image`, etc.)
+     */
+    setTwitter(opts) {
+        for (const [k, v] of Object.entries(opts)) {
+            v && this.upsert({ name: `twitter:${k}`, content: v });
+        }
+    }
+    /**
+     * Embeds JSON-LD schema (structured data) in `<head>`.
+     * @param schema schema object (will be serialized to JSON)
+     */
+    setJsonLd(schema) {
+        const id = 'app-jsonld';
+        let el = document.getElementById(id);
+        if (!el) {
+            el = document.createElement('script');
+            el.type = 'application/ld+json';
+            el.id = id;
+            document.head.appendChild(el);
+        }
+        el.text = JSON.stringify(schema);
+    }
+    upsert(tag) {
+        if (tag.name) {
+            this.meta.updateTag(tag, `name='${tag.name}'`);
+        }
+        else if (tag.property) {
+            this.meta.updateTag(tag, `property='${tag.property}'`);
+        }
+    }
+    upsertLink(rel, href) {
+        const head = document.head;
+        let link = head.querySelector(`link[rel="${rel}"]`);
+        if (!link) {
+            link = document.createElement('link');
+            link.rel = rel;
+            head.appendChild(link);
+        }
+        link.href = href;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.3", ngImport: i0, type: SeoService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.3", ngImport: i0, type: SeoService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.3", ngImport: i0, type: SeoService, decorators: [{
+            type: Injectable
+        }] });
+
+class SeoRouteListener {
+    router = inject(Router);
+    seo = inject(SeoService);
+    ar = inject(ActivatedRoute);
+    destroyRef = inject(DestroyRef);
+    init(baseUrl) {
+        const sub = this.router.events.pipe(filter((e) => e instanceof NavigationEnd)).subscribe(() => {
+            const route = this.deepest(this.ar);
+            const data = route.snapshot.data;
+            const url = data.canonical ?? baseUrl.replace(/\/+$/, '') + this.router.url;
+            data.title && this.seo.setTitle(data.title);
+            data.description && this.seo.setDescription(data.description);
+            data.twitter && this.seo.setTwitter(data.twitter);
+            data.jsonld && this.seo.setJsonLd(data.jsonld);
+            this.seo.setRobots(data.robots ?? 'index,follow');
+            this.seo.setCanonical(url);
+            this.seo.setOg({
+                title: data.title,
+                description: data.description,
+                url: url,
+                ...data.og,
+            });
+        });
+        this.destroyRef.onDestroy(() => sub.unsubscribe());
+    }
+    deepest(r) {
+        let cur = r;
+        while (cur.firstChild) {
+            cur = cur.firstChild;
+        }
+        return cur;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.3", ngImport: i0, type: SeoRouteListener, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.3", ngImport: i0, type: SeoRouteListener, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.3", 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 = joinUrl(snap.url);
+            !deepEqual(snap.params, this.#params()) && this.#params.set(snap.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();
+        this.router.events
+            .pipe(startWith(new NavigationEnd(0, this.router.url, this.router.url)), filter$1((e) => e instanceof NavigationEnd), map(() => true), takeUntilDestroyed(this.destroyRef))
+            .subscribe(() => read());
+    }
+    /** Convenient selector for a data key with type-safe casting */
+    selectData(key) {
+        return computed(() => this.#data()[key]);
+    }
+    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.0.3", ngImport: i0, type: RouteWatcher, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.3", ngImport: i0, type: RouteWatcher, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.3", 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('/') : '';
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AdaptiveService, DEVICE_BREAKPOINTS, IfDeviceDirective, LANG_CONFIG, LangPipe, LangService, RouteWatcher, SeoRouteListener, SeoService, THEME_CONFIG, ThemeService, darkThemePrefix, defaultBreakpoints, defaultThemeConfig, provideReInit, themes };
+//# sourceMappingURL=reforgium-presentia.mjs.map