@smartsoft001-mobilems/angular 2.9.0 → 2.11.0

package/fesm2022/smartsoft001-mobilems-angular.mjs

@@ -1,17 +1,18 @@
 import { __decorate, __metadata } from 'tslib';
 import * as i0 from '@angular/core';
-import { Injectable, inject, signal, Component, Directive, effect, contentChild, HostListener, Inject, APP_INITIALIZER, NgModule } from '@angular/core';
-import { DomSanitizer } from '@angular/platform-browser';
-import { ReduxAction, AppBaseComponent, PageBaseComponent, BaseComponent } from '@smartsoft001/angular';
+import { Injectable, inject, PLATFORM_ID, signal, effect, computed, Component, Directive, contentChild, HostListener, Inject, ElementRef, input, APP_INITIALIZER, NgModule } from '@angular/core';
+import { Meta, Title, DomSanitizer } from '@angular/platform-browser';
+import { StyleService as StyleService$1, ReduxAction, AppBaseComponent, PageBaseComponent, BaseComponent } from '@smartsoft001/angular';
 import { HttpClient } from '@angular/common/http';
 import * as moment from 'moment';
 import { lastValueFrom, combineLatest, firstValueFrom, of, throwError } from 'rxjs';
-import { map, catchError } from 'rxjs/operators';
+import { map, filter, catchError } from 'rxjs/operators';
+import { isPlatformBrowser, DOCUMENT } from '@angular/common';
+import { Router, ActivatedRoute, NavigationEnd, RouterOutlet, RouterModule } from '@angular/router';
+import { TranslateService } from '@ngx-translate/core';
 import { CrudService, CrudFacade } from '@smartsoft001/crud-shell-angular';
-import { RouterOutlet, RouterModule } from '@angular/router';
 import * as _ from 'lodash';
 import { Debounce } from 'lodash-decorators';
-import { DOCUMENT } from '@angular/common';
 
 function setTranslationsAndLang(service) {
     const map = {
@@ -35,11 +36,57 @@ const TRANSLATE_DATA_PL = {
 const environment = {
     production: false,
     apiUrl: '',
+    multimediaUrl: '',
+    mainLogoPath: '/assets/gfx/logo/main-logo.png',
 };
 
+class AuthStorageService {
+    constructor() {
+        this.STORAGE_KEY = 'user';
+    }
+    setUser(user) {
+        if (typeof localStorage !== 'undefined') {
+            localStorage.setItem(this.STORAGE_KEY, JSON.stringify(user));
+        }
+    }
+    getUser() {
+        if (typeof localStorage !== 'undefined') {
+            const item = localStorage.getItem(this.STORAGE_KEY);
+            if (item) {
+                try {
+                    return JSON.parse(item);
+                }
+                catch (error) {
+                    console.error('Failed to parse user from localStorage', error);
+                    return null;
+                }
+            }
+        }
+        return null;
+    }
+    removeUser() {
+        if (typeof localStorage !== 'undefined') {
+            localStorage.removeItem(this.STORAGE_KEY);
+        }
+    }
+    hasUser() {
+        return this.getUser() !== null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: AuthStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: AuthStorageService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: AuthStorageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
 class SharedConfig {
     constructor() {
         this.apiUrl = '';
+        this.multimediaUrl = '';
+        this.mainLogoPath = '/assets/gfx/logo/main-logo.png';
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: SharedConfig, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: SharedConfig }); }
@@ -87,6 +134,71 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.0", ngImpor
                 }]
         }] });
 
+const DEFAULT_COLORS = {
+    black: 'black',
+    yellow: 'yellow',
+    white: 'white',
+    transparentBlack: 'rgba(0, 0, 0, 0.9)',
+    wcagColor1: '#F4B735',
+    wcagColor2: '#1B1B1B',
+};
+class ContrastService {
+    constructor() {
+        this.platformId = inject(PLATFORM_ID);
+        this.isBrowser = isPlatformBrowser(this.platformId);
+        this.isActive = signal(false, ...(ngDevMode ? [{ debugName: "isActive" }] : []));
+        // Apply contrast changes to DOM
+        effect(() => {
+            if (this.isBrowser) {
+                this.applyContrast(this.isActive());
+            }
+        });
+    }
+    changeTheme(active) {
+        this.isActive.set(active);
+    }
+    toggle() {
+        this.isActive.update((value) => !value);
+    }
+    applyContrast(active) {
+        if (!this.isBrowser)
+            return;
+        const docElement = document.documentElement;
+        if (active) {
+            this.setProperties(docElement);
+            docElement.classList.add('cv');
+        }
+        else {
+            this.removeProperties(docElement);
+            docElement.classList.remove('cv');
+        }
+    }
+    setProperties(element) {
+        element.style.setProperty('--cv-black', DEFAULT_COLORS.black);
+        element.style.setProperty('--cv-yellow', DEFAULT_COLORS.yellow);
+        element.style.setProperty('--cv-white', DEFAULT_COLORS.white);
+        element.style.setProperty('--cv-black-transparent', DEFAULT_COLORS.transparentBlack);
+        element.style.setProperty('--cv-wcag-color-1', DEFAULT_COLORS.wcagColor1);
+        element.style.setProperty('--cv-wcag-color-2', DEFAULT_COLORS.wcagColor2);
+    }
+    removeProperties(element) {
+        element.style.removeProperty('--cv-black');
+        element.style.removeProperty('--cv-yellow');
+        element.style.removeProperty('--cv-white');
+        element.style.removeProperty('--cv-black-transparent');
+        element.style.removeProperty('--cv-wcag-color-1');
+        element.style.removeProperty('--cv-wcag-color-2');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: ContrastService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: ContrastService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: ContrastService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
 class DictionaryService {
     constructor() {
         this.httpClient = inject(HttpClient);
@@ -126,6 +238,561 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.0", ngImpor
                 }]
         }] });
 
+class FileUrlService {
+    constructor() {
+        this.config = inject(SharedConfig);
+    }
+    get(fileOrPath, mode = 'cache', noImagePlaceholder = 'assets/no-image.svg') {
+        const multimediaUrl = this.config.multimediaUrl;
+        if (!multimediaUrl) {
+            return noImagePlaceholder;
+        }
+        let path;
+        if (typeof fileOrPath === 'string') {
+            path = fileOrPath;
+        }
+        else {
+            if (!fileOrPath || !fileOrPath.filePath) {
+                return noImagePlaceholder;
+            }
+            // Check if it's an upload path (direct URL)
+            if (fileOrPath.filePath.indexOf('upload') === -1) {
+                return (multimediaUrl + this.getPath(mode) + this.getFileName(fileOrPath));
+            }
+            path = fileOrPath.filePath;
+        }
+        // Remove leading slash if present
+        if (path[0] === '/') {
+            path = path.substring(1);
+        }
+        return multimediaUrl + path;
+    }
+    getFileName(file) {
+        if (file.filePath &&
+            file.extension &&
+            file.filePath.indexOf(file.extension) > -1) {
+            return file.filePath;
+        }
+        return file.filePath + '.' + file.extension;
+    }
+    getPath(mode) {
+        switch (mode) {
+            case 'big':
+                return 'upload/cache/multimedia_big/';
+            case 'cache':
+                return 'upload/cache/multimedia_detail/';
+            case 'noCache':
+                return 'upload/multimedia/';
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: FileUrlService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: FileUrlService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: FileUrlService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class GlobalService {
+    constructor() {
+        this.showHeader = signal(true, ...(ngDevMode ? [{ debugName: "showHeader" }] : []));
+        this.showFooter = signal(true, ...(ngDevMode ? [{ debugName: "showFooter" }] : []));
+    }
+    setHeaderVisibility(visible) {
+        this.showHeader.set(visible);
+    }
+    setFooterVisibility(visible) {
+        this.showFooter.set(visible);
+    }
+    hexToRgb(hex) {
+        if (!hex)
+            return null;
+        // Remove # if present
+        let cleanHex = hex.replace(/^#/, '');
+        // Expand 3-character hex to 6-character (#abc -> #aabbcc)
+        if (cleanHex.length === 3) {
+            cleanHex = cleanHex
+                .split('')
+                .map((char) => char + char)
+                .join('');
+        }
+        // Parse 6-character hex
+        const result = cleanHex.match(/.{2}/g);
+        if (!result || result.length !== 3)
+            return null;
+        return result.map((x) => parseInt(x, 16));
+    }
+    rgbToHex(r, g, b) {
+        return ('#' +
+            [r, g, b]
+                .map((x) => {
+                const hex = x.toString(16);
+                return hex.length === 1 ? '0' + hex : hex;
+            })
+                .join(''));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: GlobalService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: GlobalService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: GlobalService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+const TRANSLATION_CONFIG_KEY = 'TRANSLATION_CONFIG';
+class TranslationService {
+    constructor() {
+        this.translateService = inject(TranslateService);
+        this._config = signal({
+            language: this.getInitialLanguage(),
+        }, ...(ngDevMode ? [{ debugName: "_config" }] : []));
+        this.config = this._config.asReadonly();
+        this.config$ = this.translateService.onLangChange.pipe();
+        this.currentLanguage = computed(() => this._config().language, ...(ngDevMode ? [{ debugName: "currentLanguage" }] : []));
+    }
+    getInitialLanguage() {
+        if (typeof localStorage !== 'undefined') {
+            const stored = localStorage.getItem(TRANSLATION_CONFIG_KEY);
+            if (stored) {
+                try {
+                    const parsed = JSON.parse(stored);
+                    return parsed.language;
+                }
+                catch (error) {
+                    console.warn('Failed to parse translation config', error);
+                }
+            }
+        }
+        return this.translateService.getBrowserLang() || 'en';
+    }
+    get(key, params) {
+        return this.translateService.instant(key, params);
+    }
+    async init(defaultLang = 'en', availableLangs = ['en', 'pl']) {
+        this.translateService.setDefaultLang(defaultLang);
+        this.translateService.addLangs(availableLangs);
+        let lang = this._config().language;
+        if (!availableLangs.includes(lang)) {
+            lang = defaultLang;
+            this._config.set({ language: lang });
+        }
+        await this.translateService.use(lang).toPromise();
+    }
+    setLanguage(language) {
+        this._config.set({ language });
+        this.save();
+        this.translateService.use(language);
+    }
+    save() {
+        if (typeof localStorage !== 'undefined') {
+            localStorage.setItem(TRANSLATION_CONFIG_KEY, JSON.stringify(this._config()));
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: TranslationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: TranslationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: TranslationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class MetaService {
+    constructor() {
+        this.meta = inject(Meta);
+        this.title = inject(Title);
+        this.translationService = inject(TranslationService);
+        this.router = inject(Router);
+        this.activatedRoute = inject(ActivatedRoute);
+        this.config = inject(SharedConfig);
+        this.resetMetadata();
+    }
+    keepUpdatingPageTitle(onRouteChange) {
+        if (onRouteChange) {
+            this.routerSubscription = this.router.events
+                .pipe(filter((event) => event instanceof NavigationEnd), map(() => this.getRouteTitle()))
+                .subscribe((dynamicTitle) => {
+                if (dynamicTitle) {
+                    this.setTitle(dynamicTitle);
+                }
+            });
+            return this.routerSubscription;
+        }
+        else {
+            const dynamicTitle = this.getRouteTitle();
+            if (dynamicTitle) {
+                this.setTitle(dynamicTitle);
+            }
+        }
+    }
+    setPageMetadata(title = '', description = '') {
+        if (title) {
+            this.setTitle(title);
+        }
+        if (description) {
+            this.setDescription(description);
+        }
+    }
+    setObjectMetadata(objectData) {
+        if (objectData.image) {
+            this.setImageMetadata(objectData.image, objectData.title, objectData.type);
+        }
+        if (objectData.title) {
+            this.setTitle(objectData.title);
+        }
+        if (objectData.description) {
+            this.setDescription(objectData.description);
+        }
+    }
+    setImageMetadata(image, imageAlt, type) {
+        const multimediaUrl = this.config.multimediaUrl;
+        if (!multimediaUrl || !image?.filePath) {
+            return;
+        }
+        try {
+            const imageUrl = this.buildImageUrl(multimediaUrl, image, type);
+            this.meta.updateTag({ property: 'og:image', content: imageUrl });
+            this.meta.updateTag({ property: 'og:image:type', content: 'image/jpeg' });
+            this.meta.updateTag({ property: 'og:image:width', content: '600' });
+            this.meta.updateTag({ property: 'og:image:height', content: '600' });
+            if (imageAlt) {
+                this.meta.updateTag({
+                    property: 'og:image:alt',
+                    content: this.removeHtmlTags(imageAlt),
+                });
+            }
+            else {
+                this.meta.removeTag("property='og:image:alt'");
+            }
+        }
+        catch (error) {
+            console.warn('Failed to set image metadata', error);
+        }
+    }
+    resetMetadata() {
+        const baseTitle = this.translationService.get('base-portal-title') || 'Portal';
+        this.meta.updateTag({ property: 'og:type', content: 'website' });
+        this.meta.updateTag({ property: 'og:title', content: baseTitle });
+        this.meta.updateTag({ property: 'og:description', content: '' });
+        this.meta.updateTag({ name: 'description', content: '' });
+        this.meta.updateTag({
+            property: 'og:image',
+            content: 'assets/gfx/no-img/no-img-header.jpg',
+        });
+        this.meta.updateTag({ property: 'og:image:alt', content: baseTitle });
+        this.meta.updateTag({ property: 'og:image:type', content: 'image/jpeg' });
+        this.meta.updateTag({ property: 'og:image:width', content: '250' });
+        this.meta.updateTag({ property: 'og:image:height', content: '250' });
+    }
+    updateTag(tag) {
+        this.meta.updateTag(tag);
+    }
+    setTitle(titleText) {
+        const plainTitle = this.removeHtmlTags(titleText);
+        this.title.setTitle(plainTitle);
+        this.meta.updateTag({ property: 'og:title', content: plainTitle });
+    }
+    setDescription(description) {
+        const plainDesc = this.removeHtmlTags(description);
+        this.meta.updateTag({ property: 'og:description', content: plainDesc });
+        this.meta.updateTag({ name: 'description', content: plainDesc });
+    }
+    destroy() {
+        this.routerSubscription?.unsubscribe();
+    }
+    buildImageUrl(baseUrl, image, type) {
+        const cleanBaseUrl = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
+        if (type === 'object' && image.filePath) {
+            return `${cleanBaseUrl}/${image.filePath}.jpg`;
+        }
+        return `${cleanBaseUrl}/${image.filePath}`;
+    }
+    removeHtmlTags(value) {
+        if (!value)
+            return '';
+        return value
+            .replace(/<.*?>/g, '')
+            .replace(/&nbsp;/g, ' ')
+            .replace(/&hyphen;/g, '-')
+            .replace(/&ndash;/g, '-')
+            .replace(/&mdash;/g, '-')
+            .replace(/&#8211;/g, '-')
+            .replace(/&#8212;/g, '-')
+            .replace(/&bdquo;/g, '"')
+            .replace(/&oacute;/g, 'ó')
+            .replace(/&rdquo;/g, '"')
+            .replace(/&quot;/g, '"');
+    }
+    getRouteTitle() {
+        let child = this.activatedRoute.firstChild;
+        while (child?.firstChild) {
+            child = child.firstChild;
+        }
+        if (!child)
+            return '';
+        const snapshot = child.snapshot;
+        if (snapshot.data['subtitle']) {
+            return snapshot.data['subtitle'];
+        }
+        if (snapshot.data['title']) {
+            return snapshot.data['title'];
+        }
+        return '';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: MetaService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: MetaService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: MetaService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
+class SeoService {
+    constructor() {
+        this.title = inject(Title);
+        this.meta = inject(Meta);
+    }
+    updateTitle(titleText) {
+        const decodedTitle = this.decodeHtml(titleText);
+        if (decodedTitle) {
+            this.title.setTitle(decodedTitle);
+        }
+    }
+    updateMetaTags(metaTags) {
+        metaTags.forEach((tag) => this.meta.updateTag(tag));
+    }
+    updateDescription(description) {
+        const decodedDesc = this.decodeHtml(description);
+        if (decodedDesc) {
+            this.meta.updateTag({ name: 'description', content: decodedDesc });
+        }
+    }
+    updateOgTags(title, description, image, url) {
+        const tags = [];
+        if (title) {
+            tags.push({
+                property: 'og:title',
+                content: this.decodeHtml(title) || title,
+            });
+        }
+        if (description) {
+            tags.push({
+                property: 'og:description',
+                content: this.decodeHtml(description) || description,
+            });
+        }
+        if (image) {
+            tags.push({ property: 'og:image', content: image });
+        }
+        if (url) {
+            tags.push({ property: 'og:url', content: url });
+        }
+        this.updateMetaTags(tags);
+    }
+    decodeHtml(encodedStr) {
+        if (!encodedStr)
+            return encodedStr;
+        try {
+            const parser = new DOMParser();
+            const doc = parser.parseFromString(encodedStr, 'text/html');
+            return doc.documentElement.textContent;
+        }
+        catch (error) {
+            console.warn('Failed to decode HTML', error);
+            return encodedStr;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: SeoService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: SeoService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: SeoService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class SettingsService {
+    constructor() {
+        this.translationService = inject(TranslationService);
+        this.config = inject(SharedConfig);
+    }
+    getMediaUrl() {
+        const multimediaUrl = this.config.multimediaUrl;
+        if (!multimediaUrl) {
+            return '';
+        }
+        // Remove trailing slash if present
+        return multimediaUrl.endsWith('/')
+            ? multimediaUrl.substring(0, multimediaUrl.length - 1)
+            : multimediaUrl;
+    }
+    getBaseTitle() {
+        return this.translationService.get('base-portal-title');
+    }
+    getCanLink() {
+        // Could be extended with preview mode config in the future
+        return true;
+    }
+    getMainLogo() {
+        return this.config.mainLogoPath;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: SettingsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: SettingsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: SettingsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class StyleService {
+    constructor() {
+        this.smartStyleService = inject(StyleService$1);
+        this.config = inject(SharedConfig);
+    }
+    init(elementRef, customVariables) {
+        const variables = {
+            ...this.config.styleVariables,
+            ...customVariables,
+        };
+        this.smartStyleService.init(elementRef, variables);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: StyleService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: StyleService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: StyleService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+const WCAG_CONFIG_KEY = 'WCAG_CONFIG';
+const DEFAULT_CONFIG = {
+    contrast: 'normal',
+    text: 'normal',
+    letterSpacing: 'small',
+    wordSpacing: 'small',
+};
+class WcagService {
+    constructor() {
+        this.translationService = inject(TranslationService);
+        this.platformId = inject(PLATFORM_ID);
+        this.isBrowser = isPlatformBrowser(this.platformId);
+        this._config = signal(this.loadConfig(), ...(ngDevMode ? [{ debugName: "_config" }] : []));
+        this.config = this._config.asReadonly();
+        this.wordSpacingValue = computed(() => this.getSpacingValue(this._config().wordSpacing), ...(ngDevMode ? [{ debugName: "wordSpacingValue" }] : []));
+        this.letterSpacingValue = computed(() => this.getSpacingValue(this._config().letterSpacing), ...(ngDevMode ? [{ debugName: "letterSpacingValue" }] : []));
+        // Apply config changes to DOM
+        effect(() => {
+            const config = this._config();
+            this.applyConfigToDOM(config);
+        });
+    }
+    async init() {
+        // Config is already loaded in constructor
+        // This method kept for backward compatibility
+    }
+    setContrast(value) {
+        this._config.update((config) => ({ ...config, contrast: value }));
+        this.announceChange('setContrast', value);
+        this.save();
+    }
+    setText(value) {
+        this._config.update((config) => ({ ...config, text: value }));
+        this.announceChange('setText', value);
+        this.save();
+    }
+    setLetterSpacing(value) {
+        this._config.update((config) => ({ ...config, letterSpacing: value }));
+        this.announceChange('setLetterSpacing', value);
+        this.save();
+    }
+    setWordSpacing(value) {
+        this._config.update((config) => ({ ...config, wordSpacing: value }));
+        this.announceChange('setWordSpacing', value);
+        this.save();
+    }
+    reset() {
+        this._config.set(DEFAULT_CONFIG);
+        this.save();
+    }
+    getSpacingValue(spacing) {
+        switch (spacing) {
+            case 'normal':
+                return 1;
+            case 'large':
+                return 2;
+            default:
+                return 0;
+        }
+    }
+    loadConfig() {
+        if (this.isBrowser && typeof localStorage !== 'undefined') {
+            const stored = localStorage.getItem(WCAG_CONFIG_KEY);
+            if (stored) {
+                try {
+                    const parsed = JSON.parse(stored);
+                    return { ...DEFAULT_CONFIG, ...parsed };
+                }
+                catch (error) {
+                    console.warn('Failed to parse WCAG config', error);
+                }
+            }
+        }
+        return DEFAULT_CONFIG;
+    }
+    save() {
+        if (this.isBrowser && typeof localStorage !== 'undefined') {
+            localStorage.setItem(WCAG_CONFIG_KEY, JSON.stringify(this._config()));
+        }
+    }
+    applyConfigToDOM(config) {
+        if (!this.isBrowser)
+            return;
+        const body = document.getElementsByTagName('body')[0];
+        if (!body)
+            return;
+        body.className = '';
+        body.className += ` contrast-${config.contrast}`;
+        body.className += ` text-${config.text}`;
+        body.className += ` letter-spacing-${config.letterSpacing}`;
+        body.className += ` word-spacing-${config.wordSpacing}`;
+    }
+    announceChange(type, value) {
+        if (!this.isBrowser)
+            return;
+        let announceElement = document.getElementById('wcag-change');
+        if (!announceElement) {
+            announceElement = document.createElement('span');
+            announceElement.id = 'wcag-change';
+            announceElement.className = 'sr-only';
+            announceElement.setAttribute('aria-atomic', 'true');
+            announceElement.setAttribute('aria-live', 'polite');
+            document.body.appendChild(announceElement);
+        }
+        const translationKey = `WCAG.${type}.${value}`;
+        announceElement.innerHTML = this.translationService.get(translationKey);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: WcagService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: WcagService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: WcagService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
 class CrudBaseService extends CrudService {
     downloadPdf(name, id) {
         return fetch(this.config.apiUrl + this.getUrlNameForDetails() + '/' + id + '/pdf')
@@ -210,7 +877,21 @@ class CrudBaseService extends CrudService {
     }
 }
 
-const SERVICES = [DictionaryService, ConfigsService, ConfigsFacade];
+const SERVICES = [
+    DictionaryService,
+    ConfigsService,
+    ConfigsFacade,
+    AuthStorageService,
+    TranslationService,
+    GlobalService,
+    FileUrlService,
+    SettingsService,
+    WcagService,
+    ContrastService,
+    MetaService,
+    SeoService,
+    StyleService,
+];
 
 class ConfigsFacade {
     constructor() {
@@ -652,6 +1333,161 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.0", ngImpor
 
 const COMPONENTS = [AppComponent];
 
+/**
+ * Directive that adds a "hover" CSS class to the host element on mouse enter
+ * and removes it on mouse leave.
+ *
+ * @example
+ * ```html
+ * <div smartHover>Hover me</div>
+ * ```
+ */
+class HoverDirective {
+    constructor() {
+        this.el = inject(ElementRef);
+    }
+    /**
+     * Adds the "hover" class when the mouse enters the element
+     */
+    onMouseEnter() {
+        this.el.nativeElement.classList.add('hover');
+    }
+    /**
+     * Removes the "hover" class when the mouse leaves the element
+     */
+    onMouseLeave() {
+        this.el.nativeElement.classList.remove('hover');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: HoverDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.1.0", type: HoverDirective, isStandalone: true, selector: "[smartHover]", host: { listeners: { "mouseenter": "onMouseEnter()", "mouseleave": "onMouseLeave()" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: HoverDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[smartHover]',
+                    standalone: true,
+                }]
+        }], propDecorators: { onMouseEnter: [{
+                type: HostListener,
+                args: ['mouseenter']
+            }], onMouseLeave: [{
+                type: HostListener,
+                args: ['mouseleave']
+            }] } });
+
+/**
+ * Directive that provides programmatic scrolling and overflow detection
+ * for horizontally or vertically scrollable containers.
+ *
+ * @example
+ * ```html
+ * <div smartScrollable [scrollUnit]="200" #scroll="smartScrollable">
+ *   <!-- scrollable content -->
+ * </div>
+ * <button (click)="scroll.scrollHorizontal(1)" [disabled]="!scroll.canScrollEndHorizontal">
+ *   Next →
+ * </button>
+ * ```
+ */
+class ScrollableDirective {
+    constructor() {
+        this.el = inject(ElementRef);
+        /**
+         * The number of pixels to scroll per unit when using scroll methods.
+         * Can be updated dynamically to change scroll behavior.
+         */
+        this.scrollUnit = input.required(...(ngDevMode ? [{ debugName: "scrollUnit" }] : []));
+        /** Indicates if the container can scroll further to the right */
+        this.canScrollEndHorizontal = signal(false, ...(ngDevMode ? [{ debugName: "canScrollEndHorizontal" }] : []));
+        /** Indicates if the container can scroll further to the left */
+        this.canScrollStartHorizontal = signal(false, ...(ngDevMode ? [{ debugName: "canScrollStartHorizontal" }] : []));
+        /** Indicates if the container can scroll further down */
+        this.canScrollEndVertical = signal(false, ...(ngDevMode ? [{ debugName: "canScrollEndVertical" }] : []));
+        /** Indicates if the container can scroll further up */
+        this.canScrollStartVertical = signal(false, ...(ngDevMode ? [{ debugName: "canScrollStartVertical" }] : []));
+        /** Current horizontal scroll position */
+        this.scrollLeftPosition = signal(0, ...(ngDevMode ? [{ debugName: "scrollLeftPosition" }] : []));
+        /** Current vertical scroll position */
+        this.scrollTopPosition = signal(0, ...(ngDevMode ? [{ debugName: "scrollTopPosition" }] : []));
+        // Update overflow detection when scrollUnit changes
+        effect(() => {
+            this.scrollUnit();
+            this.updateOverflow();
+        });
+    }
+    ngOnInit() {
+        this.updateOverflow();
+        this.addScrollListener();
+        this.addResizeListener();
+    }
+    /**
+     * Scrolls the container horizontally by the specified number of units.
+     * @param units Number of scroll units (can be negative for backward scroll)
+     */
+    scrollHorizontal(units) {
+        const element = this.el.nativeElement;
+        const scrollAmount = units * this.scrollUnit();
+        element.scrollLeft += scrollAmount;
+        this.updateOverflow();
+    }
+    /**
+     * Scrolls the container vertically by the specified number of units.
+     * @param units Number of scroll units (can be negative for upward scroll)
+     */
+    scrollVertical(units) {
+        const element = this.el.nativeElement;
+        const scrollAmount = units * this.scrollUnit();
+        element.scrollTop += scrollAmount;
+        this.updateOverflow();
+    }
+    /**
+     * Updates all overflow detection signals based on current scroll position
+     */
+    updateOverflow() {
+        const element = this.el.nativeElement;
+        // Horizontal overflow detection
+        const scrollLeft = element.scrollLeft;
+        const scrollWidth = element.scrollWidth;
+        const clientWidth = element.clientWidth;
+        this.scrollLeftPosition.set(scrollLeft);
+        this.canScrollStartHorizontal.set(scrollLeft > 0);
+        this.canScrollEndHorizontal.set(scrollLeft + clientWidth < scrollWidth);
+        // Vertical overflow detection
+        const scrollTop = element.scrollTop;
+        const scrollHeight = element.scrollHeight;
+        const clientHeight = element.clientHeight;
+        this.scrollTopPosition.set(scrollTop);
+        this.canScrollStartVertical.set(scrollTop > 0);
+        this.canScrollEndVertical.set(scrollTop + clientHeight < scrollHeight);
+    }
+    /**
+     * Adds scroll event listener to track scroll position changes
+     */
+    addScrollListener() {
+        this.el.nativeElement.addEventListener('scroll', () => {
+            this.updateOverflow();
+        });
+    }
+    /**
+     * Adds window resize listener to recalculate overflow on resize
+     */
+    addResizeListener() {
+        window.addEventListener('resize', () => {
+            this.updateOverflow();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: ScrollableDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "20.1.0", type: ScrollableDirective, isStandalone: true, selector: "[smartScrollable]", inputs: { scrollUnit: { classPropertyName: "scrollUnit", publicName: "scrollUnit", isSignal: true, isRequired: true, transformFunction: null } }, exportAs: ["smartScrollable"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.0", ngImport: i0, type: ScrollableDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[smartScrollable]',
+                    standalone: true,
+                    exportAs: 'smartScrollable',
+                }]
+        }], ctorParameters: () => [] });
+
 const DIRECTIVES = [];
 
 function initializeApp(configsFacade) {
@@ -724,5 +1560,5 @@ class ImageBox {
  * Generated bundle index. Do not edit.
  */
 
-export { AppComponent, COMPONENTS, ConfigsFacade, ConfigsService, CrudBaseService, DictionaryService, FiltersBaseComponent, FiltersContext, GameType, ImageBox, ListMode, PageComponent, SERVICES, ScrollTopComponent, SharedConfig, SharedModule, TRANSLATE_DATA_PL, environment, setTranslationsAndLang };
+export { AppComponent, AuthStorageService, COMPONENTS, ConfigsFacade, ConfigsService, ContrastService, CrudBaseService, DIRECTIVES, DictionaryService, FileUrlService, FiltersBaseComponent, FiltersContext, GameType, GlobalService, HoverDirective, ImageBox, ListMode, MetaService, PageComponent, SERVICES, ScrollTopComponent, ScrollableDirective, SeoService, SettingsService, SharedConfig, SharedModule, StyleService, TRANSLATE_DATA_PL, TranslationService, WcagService, environment, setTranslationsAndLang };
 //# sourceMappingURL=smartsoft001-mobilems-angular.mjs.map