@elementar-rt/components 0.6.55

package/fesm2022/elementar-rt-components-core.mjs

@@ -0,0 +1,837 @@
+import * as i0 from '@angular/core';
+import { inject, ElementRef, Directive, input, booleanAttribute, output, DestroyRef, afterNextRender, ViewContainerRef, Renderer2, PLATFORM_ID, ChangeDetectorRef, contentChildren, EventEmitter, forwardRef, Output, numberAttribute, Pipe, InjectionToken, Injectable, DOCUMENT, isDevMode } from '@angular/core';
+import { FocusMonitor } from '@angular/cdk/a11y';
+import { fromEvent, Subject, defer, merge, switchMap, filter, debounceTime } from 'rxjs';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { MatProgressSpinner } from '@angular/material/progress-spinner';
+import { MatButton } from '@angular/material/button';
+import { isPlatformServer } from '@angular/common';
+import { MAT_OPTION_PARENT_COMPONENT } from '@angular/material/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { MatOption } from '@angular/material/select';
+import { SelectionModel } from '@angular/cdk/collections';
+import { DomSanitizer, Title, Meta } from '@angular/platform-browser';
+import { Router, NavigationEnd, TitleStrategy } from '@angular/router';
+import { signalStore, withState, withMethods, patchState } from '@ngrx/signals';
+
+class AutoFocusDirective {
+    _elementRef = inject(ElementRef);
+    ngAfterViewInit() {
+        this._elementRef.nativeElement.focus();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AutoFocusDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.3.10", type: AutoFocusDirective, isStandalone: true, selector: "[emrAutoFocus]", exportAs: ["emrAutoFocus"], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AutoFocusDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[emrAutoFocus]',
+                    exportAs: 'emrAutoFocus',
+                    standalone: true
+                }]
+        }] });
+
+class FocusElementDirective {
+    _elementRef = inject(ElementRef);
+    _focusMonitor = inject(FocusMonitor);
+    checkChildren = input(true, ...(ngDevMode ? [{ debugName: "checkChildren", transform: booleanAttribute }] : [{
+            transform: booleanAttribute
+        }]));
+    elementFocused = output();
+    elementBlurred = output();
+    ngAfterViewInit() {
+        this._focusMonitor
+            .monitor(this._elementRef.nativeElement, this.checkChildren())
+            .subscribe(origin => {
+            this._emitFocusEvent(origin);
+        });
+    }
+    ngOnDestroy() {
+        this._focusMonitor.stopMonitoring(this._elementRef.nativeElement);
+    }
+    _emitFocusEvent(origin) {
+        if (origin) {
+            this.elementFocused.emit();
+        }
+        else {
+            this.elementBlurred.emit();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: FocusElementDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "20.3.10", type: FocusElementDirective, isStandalone: true, selector: "[emrFocusElement]", inputs: { checkChildren: { classPropertyName: "checkChildren", publicName: "checkChildren", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { elementFocused: "elementFocused", elementBlurred: "elementBlurred" }, exportAs: ["emrFocusElement"], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: FocusElementDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[emrFocusElement]',
+                    exportAs: 'emrFocusElement',
+                    standalone: true
+                }]
+        }], propDecorators: { checkChildren: [{ type: i0.Input, args: [{ isSignal: true, alias: "checkChildren", required: false }] }], elementFocused: [{ type: i0.Output, args: ["elementFocused"] }], elementBlurred: [{ type: i0.Output, args: ["elementBlurred"] }] } });
+
+class SoundEffectDirective {
+    soundSrc = input('assets/sound-effects/mouse-click.ogg', ...(ngDevMode ? [{ debugName: "soundSrc" }] : []));
+    _elementRef = inject(ElementRef);
+    _destroyRef = inject(DestroyRef);
+    constructor() {
+        afterNextRender(() => {
+            this._init();
+        });
+    }
+    _init() {
+        const audio = new Audio(this.soundSrc());
+        audio.volume = 0.15;
+        fromEvent(this._elementRef.nativeElement, 'click')
+            .pipe(takeUntilDestroyed(this._destroyRef))
+            .subscribe(async (e) => {
+            await audio.play();
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: SoundEffectDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "20.3.10", type: SoundEffectDirective, isStandalone: true, selector: "[emrSoundEffect]", inputs: { soundSrc: { classPropertyName: "soundSrc", publicName: "soundSrc", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: SoundEffectDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[emrSoundEffect]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [], propDecorators: { soundSrc: [{ type: i0.Input, args: [{ isSignal: true, alias: "soundSrc", required: false }] }] } });
+
+class ButtonDirective {
+    _matButton = inject(MatButton);
+    _viewContainerRef = inject(ViewContainerRef);
+    _renderer = inject(Renderer2);
+    _spinner;
+    _platformId = inject(PLATFORM_ID);
+    loading = input(false, ...(ngDevMode ? [{ debugName: "loading", alias: 'emrButtonLoading',
+            transform: booleanAttribute }] : [{
+            alias: 'emrButtonLoading',
+            transform: booleanAttribute
+        }]));
+    disabled = input(false, ...(ngDevMode ? [{ debugName: "disabled", transform: booleanAttribute }] : [{
+            transform: booleanAttribute
+        }]));
+    color = input(...(ngDevMode ? [undefined, { debugName: "color" }] : []));
+    ngOnChanges(changes) {
+        if (!changes['loading']) {
+            return;
+        }
+        if (isPlatformServer(this._platformId)) {
+            return;
+        }
+        if (changes['loading'].currentValue) {
+            this._matButton._elementRef.nativeElement.classList.add('emr-button-loading');
+            this._matButton.disabled = true;
+            this.createSpinner();
+        }
+        else if (!changes['loading'].firstChange) {
+            this._matButton._elementRef.nativeElement.classList.remove('emr-button-loading');
+            this._matButton.disabled = this.disabled();
+            this.destroySpinner();
+        }
+    }
+    createSpinner() {
+        if (!this._spinner) {
+            this._spinner = this._viewContainerRef.createComponent(MatProgressSpinner);
+            this._spinner.instance.color = this.color();
+            this._spinner.instance.diameter = 20;
+            this._spinner.instance.mode = 'indeterminate';
+            this._renderer.appendChild(this._matButton._elementRef.nativeElement, this._spinner.instance._elementRef.nativeElement);
+        }
+    }
+    destroySpinner() {
+        if (this._spinner) {
+            this._spinner.destroy();
+            this._spinner = null;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: ButtonDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "20.3.10", type: ButtonDirective, isStandalone: true, selector: "[emrButtonLoading]", inputs: { loading: { classPropertyName: "loading", publicName: "emrButtonLoading", isSignal: true, isRequired: false, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "disabled", isSignal: true, isRequired: false, transformFunction: null }, color: { classPropertyName: "color", publicName: "color", isSignal: true, isRequired: false, transformFunction: null } }, exportAs: ["emrButtonLoading"], usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: ButtonDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[emrButtonLoading]',
+                    exportAs: 'emrButtonLoading'
+                }]
+        }], propDecorators: { loading: [{ type: i0.Input, args: [{ isSignal: true, alias: "emrButtonLoading", required: false }] }], disabled: [{ type: i0.Input, args: [{ isSignal: true, alias: "disabled", required: false }] }], color: [{ type: i0.Input, args: [{ isSignal: true, alias: "color", required: false }] }] } });
+
+class MenuOptionGroupDirective {
+    _changeDetectorRef = inject(ChangeDetectorRef);
+    _destroyRef = inject(DestroyRef);
+    disableRipple = false;
+    multiple = false;
+    inertGroups = false;
+    hideSingleSelectionIndicator = false;
+    _selectionModel;
+    _value;
+    options = contentChildren(MatOption, ...(ngDevMode ? [{ debugName: "options", descendants: true }] : [{ descendants: true }]));
+    _initialized = new Subject();
+    valueChange = new EventEmitter();
+    optionSelectionChanges = defer(() => {
+        const options = this.options();
+        if (options) {
+            return merge(...options.map(option => option.onSelectionChange));
+        }
+        return this._initialized.pipe(switchMap(() => this.optionSelectionChanges));
+    });
+    onChange = () => { };
+    onTouched = () => { };
+    ngOnInit() {
+        this._selectionModel = new SelectionModel(this.multiple);
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    ngAfterContentInit() {
+        this._selectOptionByValue();
+        this.optionSelectionChanges
+            .pipe(takeUntilDestroyed(this._destroyRef))
+            .subscribe((res) => {
+            this._value = res.source.value;
+            this.options().forEach(option => {
+                if (option.value !== this._value) {
+                    option.setInactiveStyles();
+                    option.deselect(false);
+                }
+            });
+            this.onChange(this._value);
+            this._changeDetectorRef.markForCheck();
+        });
+    }
+    _selectOptionByValue() {
+        const options = this.options();
+        if (!options) {
+            return;
+        }
+        options.forEach(option => option.setInactiveStyles());
+        options.forEach(option => {
+            option.deselect(false);
+            if (option.value === this._value) {
+                option.select(false);
+                this._changeDetectorRef.markForCheck();
+            }
+        });
+    }
+    writeValue(newValue) {
+        if (newValue !== this._value) {
+            this._value = newValue;
+            this._selectOptionByValue();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: MenuOptionGroupDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.2.0", version: "20.3.10", type: MenuOptionGroupDirective, isStandalone: true, selector: "[emrMenuOptionGroup]", outputs: { valueChange: "valueChange" }, providers: [
+            {
+                provide: MAT_OPTION_PARENT_COMPONENT,
+                useExisting: MenuOptionGroupDirective
+            },
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => MenuOptionGroupDirective),
+                multi: true
+            }
+        ], queries: [{ propertyName: "options", predicate: MatOption, descendants: true, isSignal: true }], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: MenuOptionGroupDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[emrMenuOptionGroup]',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: MAT_OPTION_PARENT_COMPONENT,
+                            useExisting: MenuOptionGroupDirective
+                        },
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => MenuOptionGroupDirective),
+                            multi: true
+                        }
+                    ]
+                }]
+        }], propDecorators: { options: [{ type: i0.ContentChildren, args: [i0.forwardRef(() => MatOption), { ...{ descendants: true }, isSignal: true }] }], valueChange: [{
+                type: Output
+            }] } });
+
+class DebounceTimeDirective {
+    elementRef;
+    renderer;
+    debounceTimer;
+    debounceTime = input(300, ...(ngDevMode ? [{ debugName: "debounceTime", transform: numberAttribute }] : [{ transform: numberAttribute }]));
+    onChange = () => { };
+    onTouched = () => { };
+    constructor(elementRef, renderer) {
+        this.elementRef = elementRef;
+        this.renderer = renderer;
+    }
+    writeValue(value) {
+        this.renderer.setProperty(this.elementRef.nativeElement, 'value', value ?? '');
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.renderer.setProperty(this.elementRef.nativeElement, 'disabled', isDisabled);
+    }
+    handleInput(event) {
+        clearTimeout(this.debounceTimer);
+        const target = event.target;
+        const value = target?.value ?? '';
+        if (!this.debounceTime()) {
+            this.onChange(value);
+        }
+        else {
+            this.debounceTimer = setTimeout(() => {
+                this.onChange(value);
+            }, this.debounceTime());
+        }
+    }
+    handleBlur() {
+        this.onTouched();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: DebounceTimeDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "20.3.10", type: DebounceTimeDirective, isStandalone: true, selector: "[emrDebounceTime][ngModel]", inputs: { debounceTime: { classPropertyName: "debounceTime", publicName: "debounceTime", isSignal: true, isRequired: false, transformFunction: null } }, host: { listeners: { "input": "handleInput($event)", "blur": "handleBlur()" } }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => DebounceTimeDirective),
+                multi: true,
+            },
+        ], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: DebounceTimeDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[emrDebounceTime][ngModel]',
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => DebounceTimeDirective),
+                            multi: true,
+                        },
+                    ],
+                    host: {
+                        '(input)': 'handleInput($event)',
+                        '(blur)': 'handleBlur()'
+                    }
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }], propDecorators: { debounceTime: [{ type: i0.Input, args: [{ isSignal: true, alias: "debounceTime", required: false }] }] } });
+
+class InitialsPipe {
+    transform(value) {
+        if (!value) {
+            return '';
+        }
+        const initials = [...value.toString().matchAll(/(\p{L}{1})\p{L}+/gu)];
+        const result = ((initials.shift()?.[1] || '') + (initials.pop()?.[1] || '')).toUpperCase();
+        return result ? result : value[0];
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: InitialsPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "20.3.10", ngImport: i0, type: InitialsPipe, isStandalone: true, name: "initials" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: InitialsPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'initials',
+                    standalone: true
+                }]
+        }] });
+
+class FormatFileSizePipe {
+    transform(bytes, decimalPoint = 2) {
+        if (bytes == 0) {
+            return '0 Bytes';
+        }
+        const k = 1000;
+        const dm = decimalPoint || 2;
+        const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
+        const index = Math.floor(Math.log(bytes) / Math.log(k));
+        return parseFloat((bytes / Math.pow(k, index)).toFixed(dm)) + ' ' + sizes[index];
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: FormatFileSizePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "20.3.10", ngImport: i0, type: FormatFileSizePipe, isStandalone: true, name: "formatFileSize" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: FormatFileSizePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'formatFileSize',
+                    standalone: true
+                }]
+        }] });
+
+class OrderByPipe {
+    transform(value, property, direction = 'asc') {
+        if (!Array.isArray(value)) {
+            throw new Error('Order By value should be an array');
+        }
+        const sorted = value.sort((a, b) => {
+            if (a[property] < b[property]) {
+                return -1;
+            }
+            else if (a[property] > b[property]) {
+                return 1;
+            }
+            else {
+                return 0;
+            }
+        });
+        if (direction === 'asc') {
+            return sorted;
+        }
+        else if (direction === 'desc') {
+            return sorted.reverse();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: OrderByPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "20.3.10", ngImport: i0, type: OrderByPipe, isStandalone: true, name: "orderBy" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: OrderByPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'orderBy',
+                    standalone: true
+                }]
+        }] });
+
+class SafeHtmlPipe {
+    _domSanitizer = inject(DomSanitizer);
+    transform(value) {
+        return this._domSanitizer.bypassSecurityTrustHtml(value);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: SafeHtmlPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "20.3.10", ngImport: i0, type: SafeHtmlPipe, isStandalone: true, name: "safeHtml" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: SafeHtmlPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'safeHtml',
+                    standalone: true
+                }]
+        }] });
+
+class SafeResourceUrlPipe {
+    _domSanitizer = inject(DomSanitizer);
+    transform(value) {
+        return this._domSanitizer.bypassSecurityTrustResourceUrl(value);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: SafeResourceUrlPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "20.3.10", ngImport: i0, type: SafeResourceUrlPipe, isStandalone: true, name: "safeResourceUrl" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: SafeResourceUrlPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'safeResourceUrl',
+                    standalone: true
+                }]
+        }] });
+
+class FilterByPropertyPipe {
+    getNestedValue(obj, path) {
+        return path.split('.').reduce((acc, part) => acc && acc[part], obj);
+    }
+    transform(items, propPath, value, strict = false) {
+        if (!items) {
+            return [];
+        }
+        if (value === undefined || typeof value === 'undefined') {
+            return items;
+        }
+        if (!strict && (value === null || value === '')) {
+            return items;
+        }
+        return items.filter(item => {
+            const propertyValue = this.getNestedValue(item, propPath);
+            return propertyValue === value;
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: FilterByPropertyPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "20.3.10", ngImport: i0, type: FilterByPropertyPipe, isStandalone: true, name: "filterByProperty" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: FilterByPropertyPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'filterByProperty',
+                }]
+        }] });
+
+class SearchByPropertyPipe {
+    getNestedValue(obj, path) {
+        return path.split('.').reduce((acc, part) => acc && acc[part], obj);
+    }
+    transform(items, propPath, searchValue) {
+        if (!items) {
+            return [];
+        }
+        if (!searchValue) {
+            return items;
+        }
+        const lowercasedSearchValue = searchValue.toLowerCase();
+        return items.filter(item => {
+            const propertyValue = this.getNestedValue(item, propPath);
+            if (typeof propertyValue === 'string') {
+                return propertyValue.toLowerCase().includes(lowercasedSearchValue);
+            }
+            return false;
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: SearchByPropertyPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "20.3.10", ngImport: i0, type: SearchByPropertyPipe, isStandalone: true, name: "searchByProperty" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: SearchByPropertyPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'searchByProperty',
+                }]
+        }] });
+
+const ENVIRONMENT = new InjectionToken('ENVIRONMENT');
+class EnvironmentService {
+    _environment = inject(ENVIRONMENT, {
+        optional: true
+    }) || {};
+    getValue(key, defaultValue) {
+        return this._environment[key] || defaultValue;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: EnvironmentService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: EnvironmentService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: EnvironmentService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class AnalyticsService {
+    _platformId = inject(PLATFORM_ID);
+    _router = inject(Router);
+    _document = inject(DOCUMENT);
+    _environmentService = inject(EnvironmentService);
+    trackPageViews() {
+        const googleAnalyticsId = this._environmentService.getValue('googleAnalyticsId');
+        if (isDevMode() || !googleAnalyticsId) {
+            return;
+        }
+        try {
+            const url = 'https://www.googletagmanager.com/gtag/js?id=';
+            const gTagScript = this._document.createElement('script');
+            gTagScript.async = true;
+            gTagScript.src = `${url}${googleAnalyticsId}`;
+            this._document.head.appendChild(gTagScript);
+            const dataLayerScript = this._document.createElement('script');
+            dataLayerScript.innerHTML = `
+        window.dataLayer = window.dataLayer || [];
+        function gtag(){dataLayer.push(arguments);}
+        gtag('js', new Date());
+        gtag('config', '${googleAnalyticsId}');`;
+            this._document.head.appendChild(dataLayerScript);
+            if (isPlatformServer(this._platformId)) {
+                return;
+            }
+            this._router.events.pipe(filter((event) => event instanceof NavigationEnd)).subscribe((event) => {
+                gtag('event', 'page_view', {
+                    page_title: this._document.head.title,
+                    page_path: event.urlAfterRedirects,
+                    page_location: this._document.location.href
+                });
+            });
+        }
+        catch (e) {
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AnalyticsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AnalyticsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AnalyticsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class InactivityTrackerService {
+    _destroyRef = inject(DestroyRef);
+    _document = inject(DOCUMENT);
+    _interval = 10000 * 60; // 5 minutes
+    _timeout;
+    _interactionEvents$ = merge(fromEvent(this._document, 'click'), fromEvent(this._document, 'keydown'), fromEvent(this._document, 'mousemove'), fromEvent(this._document, 'scroll')).pipe(debounceTime(250));
+    _noInteraction = new EventEmitter();
+    setupInactivityTimer(interval) {
+        if (interval) {
+            this._interval = interval;
+        }
+        this._setupTimer();
+        this._interactionEvents$.pipe(takeUntilDestroyed(this._destroyRef)).subscribe(() => {
+            this._setupTimer();
+        });
+        return this._noInteraction.pipe(takeUntilDestroyed(this._destroyRef));
+    }
+    reset() {
+        this._setupTimer();
+    }
+    _setupTimer() {
+        clearTimeout(this._timeout);
+        this._timeout = setTimeout(() => {
+            this._noInteraction.emit();
+        }, this._interval);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: InactivityTrackerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: InactivityTrackerService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: InactivityTrackerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+const initialGlobalState = {
+    screenLoading: true,
+    sidebarHidden: false,
+    pageTitle: ''
+};
+const GlobalStore = signalStore({ providedIn: 'root' }, withState(initialGlobalState), withMethods((store) => ({
+    setScreenLoading(isLoading) {
+        patchState(store, {
+            screenLoading: isLoading
+        });
+    },
+    setPageTitle(pageTitle) {
+        patchState(store, {
+            pageTitle
+        });
+    }
+})));
+
+class PageTitleStrategyService extends TitleStrategy {
+    _title = inject(Title);
+    _globalStore = inject(GlobalStore);
+    updateTitle(routerState) {
+        const title = this.buildTitle(routerState);
+        if (title !== undefined) {
+            this._title.setTitle(`${title} | ${this._globalStore.pageTitle()}`);
+        }
+        else {
+            this._title.setTitle(this._globalStore.pageTitle());
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: PageTitleStrategyService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: PageTitleStrategyService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: PageTitleStrategyService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class ScreenLoaderService {
+    _globalStore = inject(GlobalStore);
+    show() {
+        this._globalStore.setScreenLoading(true);
+    }
+    hide() {
+        this._globalStore.setScreenLoading(false);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: ScreenLoaderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: ScreenLoaderService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: ScreenLoaderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class SeoService {
+    _router = inject(Router);
+    _destroyRef = inject(DestroyRef);
+    _document = inject(DOCUMENT);
+    _platformId = inject(PLATFORM_ID);
+    _linkCanonical;
+    _title = inject(Title);
+    _meta = inject(Meta);
+    _globalStore = inject(GlobalStore);
+    get meta() {
+        return this._meta;
+    }
+    updateDescription(content) {
+        if (!content) {
+            return;
+        }
+        this.meta.updateTag({
+            name: 'description',
+            content
+        });
+        this.meta.updateTag({
+            name: 'og:description',
+            content
+        });
+    }
+    updateOgUrl(content) {
+        if (!content) {
+            return;
+        }
+        this.meta.updateTag({
+            name: 'og:url',
+            content
+        });
+    }
+    updateOgImage(content) {
+        if (!content) {
+            return;
+        }
+        this.meta.updateTag({
+            name: 'og:image',
+            content
+        });
+    }
+    trackCanonicalChanges(siteUrl) {
+        this._createCanonicalTag(siteUrl);
+        if (isPlatformServer(this._platformId)) {
+            return;
+        }
+        this._router.events
+            .pipe(filter((event) => event instanceof NavigationEnd), takeUntilDestroyed(this._destroyRef))
+            .subscribe(() => {
+            const href = this.getCanonicalUrl(siteUrl);
+            this._linkCanonical?.setAttribute('href', href);
+            this.updateOgUrl(href);
+        });
+    }
+    updateTitle(title) {
+        this._title.setTitle(`${title} | ${this._globalStore.pageTitle()}`);
+        this.meta.updateTag({
+            name: 'og:title',
+            content: title
+        });
+    }
+    getCanonicalUrl(siteUrl) {
+        if (this._document.URL.startsWith('http')) {
+            return this._document.URL;
+        }
+        return siteUrl + this._document.URL;
+    }
+    _createCanonicalTag(siteUrl) {
+        this._linkCanonical = this._document.querySelector('link[rel="canonical"]');
+        if (!this._linkCanonical) {
+            this._linkCanonical = this._document.createElement('link');
+            this._linkCanonical.setAttribute('rel', 'canonical');
+            this._document.head.appendChild(this._linkCanonical);
+        }
+        this._linkCanonical.setAttribute('href', this.getCanonicalUrl(siteUrl));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: SeoService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: SeoService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: SeoService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+const LOCAL_STORAGE_KEY = 'emr-admin';
+class ThemeManagerService {
+    _document = inject(DOCUMENT);
+    _window = this._document.defaultView;
+    _colorScheme;
+    constructor() {
+        afterNextRender(() => {
+            if (this._window !== null && this._window.matchMedia) {
+                this._window
+                    .matchMedia('(prefers-color-scheme: dark)')
+                    .addEventListener('change', () => {
+                    const storedColorScheme = this._getStoredColorScheme();
+                    if (storedColorScheme !== 'light' && storedColorScheme !== 'dark') {
+                        this.setColorScheme(this.getPreferredColorScheme());
+                    }
+                });
+            }
+        });
+    }
+    getColorScheme() {
+        return this._colorScheme;
+    }
+    toggleColorScheme() {
+        if (this._getStoredColorScheme() === 'dark') {
+            this.changeColorScheme('light');
+        }
+        else {
+            this.changeColorScheme('dark');
+        }
+    }
+    changeColorScheme(colorScheme) {
+        this._colorScheme = colorScheme;
+        this._setStoredColorScheme(colorScheme);
+        this.setColorScheme(colorScheme);
+    }
+    _getStoredColorScheme() {
+        if (typeof localStorage === 'undefined') {
+            return;
+        }
+        return JSON.parse(localStorage.getItem(LOCAL_STORAGE_KEY) ?? '{}').colorScheme;
+    }
+    ;
+    _setStoredColorScheme(colorScheme) {
+        if (typeof localStorage === 'undefined') {
+            return;
+        }
+        const meta = JSON.parse(localStorage.getItem(LOCAL_STORAGE_KEY) ?? '{}');
+        meta.colorScheme = colorScheme;
+        localStorage.setItem(LOCAL_STORAGE_KEY, JSON.stringify(meta));
+    }
+    ;
+    getPreferredColorScheme() {
+        const storedTheme = this._getStoredColorScheme();
+        if (storedTheme) {
+            return storedTheme;
+        }
+        if (this._window !== null && this._window.matchMedia) {
+            return this._window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light';
+        }
+        return 'light';
+    }
+    ;
+    setColorScheme(colorScheme) {
+        if (this._window !== null && this._window.matchMedia) {
+            if (colorScheme === 'auto' &&
+                this._window.matchMedia('(prefers-color-scheme: dark)').matches) {
+                this._colorScheme = 'dark';
+                this._document.documentElement.classList.add('dark');
+            }
+            else {
+                if (colorScheme === 'dark') {
+                    this._colorScheme = 'dark';
+                    this._document.documentElement.classList.add('dark');
+                }
+                else {
+                    this._colorScheme = 'light';
+                    this._document.documentElement.classList.remove('dark');
+                }
+            }
+        }
+    }
+    ;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: ThemeManagerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: ThemeManagerService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: ThemeManagerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AnalyticsService, AutoFocusDirective, ButtonDirective, DebounceTimeDirective, ENVIRONMENT, EnvironmentService, FilterByPropertyPipe, FocusElementDirective, FormatFileSizePipe, GlobalStore, InactivityTrackerService, InitialsPipe, MenuOptionGroupDirective, OrderByPipe, PageTitleStrategyService, SafeHtmlPipe, SafeResourceUrlPipe, ScreenLoaderService, SearchByPropertyPipe, SeoService, SoundEffectDirective, ThemeManagerService };
+//# sourceMappingURL=elementar-rt-components-core.mjs.map