cmat 0.0.3

package/esm2022/services/data/data.service.mjs

@@ -0,0 +1,169 @@
+import { Injectable } from '@angular/core';
+import { HttpParams } from '@angular/common/http';
+import { Subject } from 'rxjs';
+import { catchError, map, retry, takeUntil, tap } from 'rxjs/operators';
+import { CmatUtilsService } from 'cmat/services/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "cmat/services/config";
+export class CmatDataService {
+    constructor(_http, _urlStateConfigService) {
+        this._http = _http;
+        this._urlStateConfigService = _urlStateConfigService;
+        this._enableDataProtect = false;
+        this._unsubscribeAll = new Subject();
+        this._urlStateConfigService.config$
+            .pipe(takeUntil(this._unsubscribeAll))
+            .subscribe((config) => {
+            this._enableDataProtect = config.enableDataProtect;
+        });
+    }
+    ngOnDestroy() {
+        this._unsubscribeAll.next(void 0);
+        this._unsubscribeAll.complete();
+    }
+    get(url, params = {}, auth = true) {
+        const httpParams = new HttpParams();
+        const headers = auth ? CmatUtilsService.getRequestHeaders() : CmatUtilsService.getRequestCryptoHeaders('');
+        if (Object.keys(params).length !== 0) {
+            if (this._enableDataProtect) {
+                httpParams.appendAll({
+                    params: CmatUtilsService.getEncryptData(JSON.stringify({ params: params }))
+                });
+            }
+            else {
+                httpParams.appendAll(params);
+            }
+        }
+        const options = { params: httpParams };
+        if (this._enableDataProtect) {
+            return this._http.get(url, { ...options, headers: headers })
+                .pipe(retry({ count: 3, delay: 1000 }), map((res) => {
+                if (res) {
+                    return JSON.parse(CmatUtilsService.getDecryptData(res));
+                }
+                return res;
+            }), catchError((err) => CmatUtilsService.handleError(err)));
+        }
+        else {
+            return this._http.get(url, { ...options, headers: headers })
+                .pipe(retry({ count: 3, delay: 1000 }), tap((res) => res), catchError((err) => CmatUtilsService.handleError(err)));
+        }
+    }
+    post(url, data, params = {}, auth = true) {
+        const httpParams = new HttpParams();
+        const headers = auth ? CmatUtilsService.getRequestBypassHeaders() : CmatUtilsService.getRequestCryptoBypassHeaders('');
+        if (Object.keys(params).length !== 0) {
+            if (this._enableDataProtect) {
+                httpParams.appendAll({
+                    params: CmatUtilsService.getEncryptData(JSON.stringify(params))
+                });
+            }
+            else {
+                httpParams.appendAll(params);
+            }
+        }
+        const options = { params: httpParams };
+        if (this._enableDataProtect) {
+            data = CmatUtilsService.getEncryptData(JSON.stringify(data));
+            return this._http.post(url, data, { ...options, headers: headers })
+                .pipe(map((res) => {
+                if (res) {
+                    return JSON.parse(CmatUtilsService.getDecryptData(res));
+                }
+                return res;
+            }), catchError((err) => CmatUtilsService.handleError(err)));
+        }
+        else {
+            return this._http.post(url, data, { ...options, headers: headers })
+                .pipe(tap((res) => res), catchError((err) => CmatUtilsService.handleError(err)));
+        }
+    }
+    put(url, data, params = {}, auth = true) {
+        const httpParams = new HttpParams();
+        const headers = auth ? CmatUtilsService.getRequestBypassHeaders() : CmatUtilsService.getRequestCryptoBypassHeaders('');
+        if (Object.keys(params).length !== 0) {
+            if (this._enableDataProtect) {
+                httpParams.appendAll({
+                    params: CmatUtilsService.getEncryptData(JSON.stringify(params))
+                });
+            }
+            else {
+                httpParams.appendAll(params);
+            }
+        }
+        const options = { params: httpParams };
+        if (this._enableDataProtect) {
+            data = CmatUtilsService.getEncryptData(JSON.stringify(data));
+            return this._http.put(url, data, { ...options, headers: headers })
+                .pipe(map((res) => {
+                if (res) {
+                    return JSON.parse(CmatUtilsService.getDecryptData(res));
+                }
+                return res;
+            }), catchError((err) => CmatUtilsService.handleError(err)));
+        }
+        else {
+            return this._http.put(url, data, { ...options, headers: headers })
+                .pipe(tap((res) => res), catchError((err) => CmatUtilsService.handleError(err)));
+        }
+    }
+    delete(url, params = {}, auth = true) {
+        const httpParams = new HttpParams();
+        const headers = auth ? CmatUtilsService.getRequestBypassHeaders() : CmatUtilsService.getRequestCryptoBypassHeaders('');
+        if (Object.keys(params).length !== 0) {
+            if (this._enableDataProtect) {
+                httpParams.appendAll({
+                    params: CmatUtilsService.getEncryptData(JSON.stringify(params))
+                });
+            }
+            else {
+                httpParams.appendAll(params);
+            }
+        }
+        const options = { params: httpParams };
+        return this._http.delete(url, {
+            ...options,
+            headers: headers
+        })
+            .pipe(tap((res) => res), catchError((err) => CmatUtilsService.handleError(err)));
+    }
+    patch(url, data, params = {}, auth = true) {
+        const httpParams = new HttpParams();
+        const headers = auth ? CmatUtilsService.getRequestBypassHeaders() : CmatUtilsService.getRequestCryptoBypassHeaders('');
+        if (Object.keys(params).length !== 0) {
+            if (this._enableDataProtect) {
+                httpParams.appendAll({
+                    params: CmatUtilsService.getEncryptData(JSON.stringify(params))
+                });
+            }
+            else {
+                httpParams.appendAll(params);
+            }
+        }
+        const options = { params: httpParams };
+        if (this._enableDataProtect) {
+            data = CmatUtilsService.getEncryptData(JSON.stringify(data));
+            return this._http.patch(url, data, { ...options, headers: headers })
+                .pipe(map((res) => {
+                if (res) {
+                    return JSON.parse(CmatUtilsService.getDecryptData(res));
+                }
+                return res;
+            }), catchError((err) => CmatUtilsService.handleError(err)));
+        }
+        else {
+            return this._http.patch(url, data, { ...options, headers: headers })
+                .pipe(tap((res) => res), catchError((err) => CmatUtilsService.handleError(err)));
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatDataService, deps: [{ token: i1.HttpClient }, { token: i2.CmatUrlStateConfigService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatDataService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatDataService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.CmatUrlStateConfigService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data.service.js","sourceRoot":"","sources":["../../../../../projects/cmat/services/data/data.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, OnDestroy } from '@angular/core';\r\nimport { HttpClient, HttpParams } from '@angular/common/http';\r\n\r\nimport { Observable, Subject } from 'rxjs';\r\nimport { catchError, map, retry, takeUntil, tap } from 'rxjs/operators';\r\nimport { CmatUrlStateConfigService, IUrlStateCONFIG } from 'cmat/services/config';\r\nimport { CmatUtilsService } from 'cmat/services/utils';\r\n\r\n@Injectable({\r\n    providedIn: 'root'\r\n})\r\nexport class CmatDataService implements OnDestroy {\r\n    private _enableDataProtect: boolean = false;\r\n    private _unsubscribeAll: Subject<void> = new Subject<void>();\r\n\r\n    constructor(private _http: HttpClient, private _urlStateConfigService: CmatUrlStateConfigService) {\r\n        this._urlStateConfigService.config$\r\n            .pipe(takeUntil(this._unsubscribeAll))\r\n            .subscribe((config: IUrlStateCONFIG) => {\r\n                this._enableDataProtect = config.enableDataProtect;\r\n            });\r\n    }\r\n\r\n    ngOnDestroy(): void {\r\n        this._unsubscribeAll.next(void 0);\r\n        this._unsubscribeAll.complete();\r\n    }\r\n\r\n    get<T>(url: string, params = {}, auth: boolean = true): Observable<T> {\r\n        const httpParams = new HttpParams();\r\n        const headers = auth ? CmatUtilsService.getRequestHeaders() : CmatUtilsService.getRequestCryptoHeaders('');\r\n\r\n        if (Object.keys(params).length !== 0) {\r\n\r\n            if (this._enableDataProtect) {\r\n                httpParams.appendAll(\r\n                    {\r\n                        params:\r\n                            CmatUtilsService.getEncryptData(JSON.stringify({ params: params }))\r\n                    });\r\n            } else {\r\n                httpParams.appendAll(params);\r\n            }\r\n        }\r\n        const options = { params: httpParams };\r\n\r\n        if (this._enableDataProtect) {\r\n            return this._http.get<string>(url, { ...options, headers: headers })\r\n                .pipe(\r\n                    retry({ count: 3, delay: 1000 }),\r\n                    map((res: string) => {\r\n                        if (res) {\r\n                            return JSON.parse(CmatUtilsService.getDecryptData(res));\r\n                        }\r\n                        return res;\r\n                    }),\r\n                    catchError((err: any) => CmatUtilsService.handleError(err))\r\n                );\r\n        } else {\r\n            return this._http.get<T>(url, { ...options, headers: headers })\r\n                .pipe(\r\n                    retry({ count: 3, delay: 1000 }),\r\n                    tap((res: T) => res),\r\n                    catchError((err: any) => CmatUtilsService.handleError(err))\r\n                );\r\n        }\r\n\r\n    }\r\n\r\n    post<T>(url: string, data: any, params = {}, auth: boolean = true): Observable<T> {\r\n        const httpParams = new HttpParams();\r\n        const headers = auth ? CmatUtilsService.getRequestBypassHeaders() : CmatUtilsService.getRequestCryptoBypassHeaders('');\r\n\r\n        if (Object.keys(params).length !== 0) {\r\n\r\n            if (this._enableDataProtect) {\r\n                httpParams.appendAll(\r\n                    {\r\n                        params:\r\n                            CmatUtilsService.getEncryptData(JSON.stringify(params))\r\n                    });\r\n            } else {\r\n                httpParams.appendAll(params);\r\n            }\r\n        }\r\n        const options = { params: httpParams };\r\n\r\n        if (this._enableDataProtect) {\r\n            data = CmatUtilsService.getEncryptData(JSON.stringify(data));\r\n\r\n            return this._http.post<string>(url, data, { ...options, headers: headers })\r\n                .pipe(\r\n                    map((res: string) => {\r\n                        if (res) {\r\n                            return JSON.parse(CmatUtilsService.getDecryptData(res));\r\n                        }\r\n                        return res;\r\n                    }),\r\n                    catchError((err: any) => CmatUtilsService.handleError(err))\r\n                );\r\n        } else {\r\n            return this._http.post<T>(url, data, { ...options, headers: headers })\r\n                .pipe(\r\n                    tap((res: T) => res),\r\n                    catchError((err: any) => CmatUtilsService.handleError(err))\r\n                );\r\n        }\r\n    }\r\n\r\n    put<T>(url: string, data: any, params = {}, auth: boolean = true): Observable<T> {\r\n        const httpParams = new HttpParams();\r\n        const headers = auth ? CmatUtilsService.getRequestBypassHeaders() : CmatUtilsService.getRequestCryptoBypassHeaders('');\r\n\r\n        if (Object.keys(params).length !== 0) {\r\n\r\n            if (this._enableDataProtect) {\r\n                httpParams.appendAll(\r\n                    {\r\n                        params:\r\n                            CmatUtilsService.getEncryptData(JSON.stringify(params))\r\n                    });\r\n            } else {\r\n                httpParams.appendAll(params);\r\n            }\r\n        }\r\n        const options = { params: httpParams };\r\n\r\n        if (this._enableDataProtect) {\r\n            data = CmatUtilsService.getEncryptData(JSON.stringify(data));\r\n\r\n            return this._http.put<string>(url, data, { ...options, headers: headers })\r\n                .pipe(\r\n                    map((res: string) => {\r\n                        if (res) {\r\n                            return JSON.parse(CmatUtilsService.getDecryptData(res));\r\n                        }\r\n                        return res;\r\n                    }),\r\n                    catchError((err: any) => CmatUtilsService.handleError(err))\r\n                );\r\n        } else {\r\n            return this._http.put<T>(url, data, { ...options, headers: headers })\r\n                .pipe(\r\n                    tap((res: T) => res),\r\n                    catchError((err: any) => CmatUtilsService.handleError(err))\r\n                );\r\n        }\r\n    }\r\n\r\n    delete<T>(url: string, params = {}, auth: boolean = true): Observable<T> {\r\n        const httpParams = new HttpParams();\r\n        const headers = auth ? CmatUtilsService.getRequestBypassHeaders() : CmatUtilsService.getRequestCryptoBypassHeaders('');\r\n\r\n        if (Object.keys(params).length !== 0) {\r\n\r\n            if (this._enableDataProtect) {\r\n                httpParams.appendAll(\r\n                    {\r\n                        params:\r\n                            CmatUtilsService.getEncryptData(JSON.stringify(params))\r\n                    });\r\n            } else {\r\n                httpParams.appendAll(params);\r\n            }\r\n        }\r\n\r\n        const options = { params: httpParams };\r\n\r\n        return this._http.delete<T>(url, {\r\n            ...options,\r\n            headers: headers\r\n        })\r\n            .pipe(\r\n                tap((res: T) => res),\r\n                catchError((err: any) => CmatUtilsService.handleError(err))\r\n            );\r\n    }\r\n\r\n    patch<T>(url: string, data: any, params = {}, auth: boolean = true): Observable<T> {\r\n        const httpParams = new HttpParams();\r\n        const headers = auth ? CmatUtilsService.getRequestBypassHeaders() : CmatUtilsService.getRequestCryptoBypassHeaders('');\r\n\r\n        if (Object.keys(params).length !== 0) {\r\n\r\n            if (this._enableDataProtect) {\r\n                httpParams.appendAll(\r\n                    {\r\n                        params:\r\n                            CmatUtilsService.getEncryptData(JSON.stringify(params))\r\n                    });\r\n            } else {\r\n                httpParams.appendAll(params);\r\n            }\r\n        }\r\n\r\n        const options = { params: httpParams };\r\n\r\n        if (this._enableDataProtect) {\r\n            data = CmatUtilsService.getEncryptData(JSON.stringify(data));\r\n\r\n            return this._http.patch<string>(url, data, { ...options, headers: headers })\r\n                .pipe(\r\n                    map((res: string) => {\r\n                        if (res) {\r\n                            return JSON.parse(CmatUtilsService.getDecryptData(res));\r\n                        }\r\n                        return res;\r\n                    }),\r\n                    catchError((err: any) => CmatUtilsService.handleError(err))\r\n                );\r\n        } else {\r\n            return this._http.patch<T>(url, data, { ...options, headers: headers })\r\n                .pipe(\r\n                    tap((res: T) => res),\r\n                    catchError((err: any) => CmatUtilsService.handleError(err))\r\n                );\r\n        }\r\n    }\r\n}\r\n"]}

package/esm2022/services/data/public-api.mjs

@@ -0,0 +1,2 @@
+export * from './data.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NtYXQvc2VydmljZXMvZGF0YS9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsZ0JBQWdCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2RhdGEuc2VydmljZSc7XHJcbiJdfQ==

package/esm2022/services/loading/cmat-services-loading.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY21hdC1zZXJ2aWNlcy1sb2FkaW5nLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY21hdC9zZXJ2aWNlcy9sb2FkaW5nL2NtYXQtc2VydmljZXMtbG9hZGluZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2022/services/loading/loading.interceptor.mjs

@@ -0,0 +1,29 @@
+import { Injectable } from '@angular/core';
+import { finalize } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "./loading.service";
+export class CmatLoadingInterceptor {
+    constructor(_cmatLoadingService) {
+        this._cmatLoadingService = _cmatLoadingService;
+        this._cmatLoadingService.auto$
+            .subscribe((value) => {
+            this.handleRequestsAutomatically = value;
+        });
+    }
+    intercept(req, next) {
+        if (!this.handleRequestsAutomatically || req.url.indexOf('file/download/') > -1) {
+            return next.handle(req);
+        }
+        this._cmatLoadingService.setLoadingStatus(true, req.url);
+        return next.handle(req).pipe(finalize(() => {
+            // Set the status to false if there are any errors or the request is completed
+            this._cmatLoadingService.setLoadingStatus(false, req.url);
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatLoadingInterceptor, deps: [{ token: i1.CmatLoadingService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatLoadingInterceptor }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatLoadingInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.CmatLoadingService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/loading/loading.service.mjs

@@ -0,0 +1,72 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class CmatLoadingService {
+    constructor(_httpClient) {
+        this._httpClient = _httpClient;
+        this._auto$ = new BehaviorSubject(true);
+        this._mode$ = new BehaviorSubject('indeterminate');
+        this._progress$ = new BehaviorSubject(0);
+        this._show$ = new BehaviorSubject(false);
+        this._urlMap = new Map();
+    }
+    get auto$() {
+        return this._auto$.asObservable();
+    }
+    get mode$() {
+        return this._mode$.asObservable();
+    }
+    get progress$() {
+        return this._progress$.asObservable();
+    }
+    get show$() {
+        return this._show$.asObservable();
+    }
+    show() {
+        this._show$.next(true);
+    }
+    hide() {
+        this._show$.next(false);
+    }
+    setAutoMode(value) {
+        this._auto$.next(value);
+    }
+    setMode(value) {
+        this._mode$.next(value);
+    }
+    setProgress(value) {
+        if (value < 0 || value > 100) {
+            console.error('Progress value must be between 0 and 100!');
+            return;
+        }
+        this._progress$.next(value);
+    }
+    setLoadingStatus(status, url) {
+        // Return if the url was not provided
+        if (!url) {
+            console.error('The request URL must be provided!');
+            return;
+        }
+        if (status === true) {
+            this._urlMap.set(url, status);
+            this._show$.next(true);
+        }
+        else if (status === false && this._urlMap.has(url)) {
+            this._urlMap.delete(url);
+        }
+        // Only set the status to 'false' if all outgoing requests are completed
+        if (this._urlMap.size === 0) {
+            this._show$.next(false);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatLoadingService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatLoadingService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatLoadingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/loading/public-api.mjs

@@ -0,0 +1,3 @@
+export * from './loading.service';
+export * from './loading.interceptor';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NtYXQvc2VydmljZXMvbG9hZGluZy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyx1QkFBdUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbG9hZGluZy5zZXJ2aWNlJztcclxuZXhwb3J0ICogZnJvbSAnLi9sb2FkaW5nLmludGVyY2VwdG9yJzsiXX0=

package/esm2022/services/local-storage/cmat-services-local-storage.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY21hdC1zZXJ2aWNlcy1sb2NhbC1zdG9yYWdlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY21hdC9zZXJ2aWNlcy9sb2NhbC1zdG9yYWdlL2NtYXQtc2VydmljZXMtbG9jYWwtc3RvcmFnZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2022/services/local-storage/local-storage.service.mjs

@@ -0,0 +1,22 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class CmatLocalStorageService {
+    getItem(key) {
+        return localStorage.getItem(key);
+    }
+    setItem(key, item) {
+        localStorage.setItem(key, item);
+    }
+    removeItem(key) {
+        localStorage.removeItem(key);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatLocalStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatLocalStorageService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatLocalStorageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9jYWwtc3RvcmFnZS5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY21hdC9zZXJ2aWNlcy9sb2NhbC1zdG9yYWdlL2xvY2FsLXN0b3JhZ2Uuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUszQyxNQUFNLE9BQU8sdUJBQXVCO0lBQ2hDLE9BQU8sQ0FBQyxHQUFXO1FBQ2YsT0FBTyxZQUFZLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQ3JDLENBQUM7SUFFRCxPQUFPLENBQUMsR0FBVyxFQUFFLElBQVk7UUFDN0IsWUFBWSxDQUFDLE9BQU8sQ0FBQyxHQUFHLEVBQUUsSUFBSSxDQUFDLENBQUM7SUFDcEMsQ0FBQztJQUVELFVBQVUsQ0FBQyxHQUFXO1FBQ2xCLFlBQVksQ0FBQyxVQUFVLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDakMsQ0FBQzs4R0FYUSx1QkFBdUI7a0hBQXZCLHVCQUF1QixjQUZwQixNQUFNOzsyRkFFVCx1QkFBdUI7a0JBSG5DLFVBQVU7bUJBQUM7b0JBQ1IsVUFBVSxFQUFFLE1BQU07aUJBQ3JCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5cclxuQEluamVjdGFibGUoe1xyXG4gICAgcHJvdmlkZWRJbjogJ3Jvb3QnXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBDbWF0TG9jYWxTdG9yYWdlU2VydmljZSB7XHJcbiAgICBnZXRJdGVtKGtleTogc3RyaW5nKTogc3RyaW5nIHwgbnVsbCB7XHJcbiAgICAgICAgcmV0dXJuIGxvY2FsU3RvcmFnZS5nZXRJdGVtKGtleSk7XHJcbiAgICB9XHJcblxyXG4gICAgc2V0SXRlbShrZXk6IHN0cmluZywgaXRlbTogc3RyaW5nKTogdm9pZCB7XHJcbiAgICAgICAgbG9jYWxTdG9yYWdlLnNldEl0ZW0oa2V5LCBpdGVtKTtcclxuICAgIH1cclxuXHJcbiAgICByZW1vdmVJdGVtKGtleTogc3RyaW5nKTogdm9pZCB7XHJcbiAgICAgICAgbG9jYWxTdG9yYWdlLnJlbW92ZUl0ZW0oa2V5KTtcclxuICAgIH1cclxufVxyXG4iXX0=

package/esm2022/services/local-storage/public-api.mjs

@@ -0,0 +1,2 @@
+export * from './local-storage.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NtYXQvc2VydmljZXMvbG9jYWwtc3RvcmFnZS9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMseUJBQXlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xvY2FsLXN0b3JhZ2Uuc2VydmljZSc7XHJcbiJdfQ==

package/esm2022/services/media-watcher/cmat-services-media-watcher.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY21hdC1zZXJ2aWNlcy1tZWRpYS13YXRjaGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY21hdC9zZXJ2aWNlcy9tZWRpYS13YXRjaGVyL2NtYXQtc2VydmljZXMtbWVkaWEtd2F0Y2hlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2022/services/media-watcher/media-watcher.service.mjs

@@ -0,0 +1,55 @@
+import { Injectable } from '@angular/core';
+import { ReplaySubject, Subject } from 'rxjs';
+import { map, switchMap, takeUntil } from 'rxjs/operators';
+import { fromPairs } from 'lodash-es';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/layout";
+import * as i2 from "cmat/services/config";
+export class CmatMediaWatcherService {
+    constructor(_breakpointObserver, _cmatConfigService) {
+        this._breakpointObserver = _breakpointObserver;
+        this._cmatConfigService = _cmatConfigService;
+        this._onMediaChange = new ReplaySubject(1);
+        this._unsubscribeAll = new Subject();
+        this._cmatConfigService.config$.pipe(takeUntil(this._unsubscribeAll), map(config => fromPairs(Object.entries(config.screens).map(([alias, screen]) => ([alias, `(min-width: ${screen})`])))), switchMap(screens => this._breakpointObserver.observe(Object.values(screens)).pipe(map((state) => {
+            // Prepare the observable values and set their defaults
+            const matchingAliases = [];
+            const matchingQueries = {};
+            // Get the matching breakpoints and use them to fill the subject
+            const matchingBreakpoints = Object.entries(state.breakpoints).filter(([, matches]) => matches) ?? [];
+            for (const [query] of matchingBreakpoints) {
+                // Find the alias of the matching query
+                const matchingAlias = Object.entries(screens).find(([, q]) => q === query)?.[0];
+                // Add the matching query to the observable values
+                if (matchingAlias) {
+                    matchingAliases.push(matchingAlias);
+                    matchingQueries[matchingAlias] = query;
+                }
+            }
+            // Execute the observable
+            this._onMediaChange.next({
+                matchingAliases,
+                matchingQueries
+            });
+        })))).subscribe();
+    }
+    get onMediaChange$() {
+        return this._onMediaChange.asObservable();
+    }
+    ngOnDestroy() {
+        this._unsubscribeAll.next(void 0);
+        this._unsubscribeAll.complete();
+    }
+    onMediaQueryChange$(query) {
+        return this._breakpointObserver.observe(query);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatMediaWatcherService, deps: [{ token: i1.BreakpointObserver }, { token: i2.CmatConfigService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatMediaWatcherService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatMediaWatcherService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.BreakpointObserver }, { type: i2.CmatConfigService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/media-watcher/public-api.mjs

@@ -0,0 +1,2 @@
+export * from './media-watcher.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NtYXQvc2VydmljZXMvbWVkaWEtd2F0Y2hlci9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMseUJBQXlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL21lZGlhLXdhdGNoZXIuc2VydmljZSc7XHJcbiJdfQ==

package/esm2022/services/platform/cmat-services-platform.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY21hdC1zZXJ2aWNlcy1wbGF0Zm9ybS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NtYXQvc2VydmljZXMvcGxhdGZvcm0vY21hdC1zZXJ2aWNlcy1wbGF0Zm9ybS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2022/services/platform/platform.service.mjs

@@ -0,0 +1,46 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/platform";
+export class CmatPlatformService {
+    constructor(_platform) {
+        this._platform = _platform;
+        this.osName = 'os-unknown';
+        // If the platform is not a browser, return immediately
+        if (!this._platform.isBrowser) {
+            return;
+        }
+        // Windows
+        if (navigator.userAgent.includes('Win')) {
+            this.osName = 'os-windows';
+        }
+        // Mac OS
+        if (navigator.userAgent.includes('Mac')) {
+            this.osName = 'os-mac';
+        }
+        // Unix
+        if (navigator.userAgent.includes('X11')) {
+            this.osName = 'os-unix';
+        }
+        // Linux
+        if (navigator.userAgent.includes('Linux')) {
+            this.osName = 'os-linux';
+        }
+        // iOS
+        if (this._platform.IOS) {
+            this.osName = 'os-ios';
+        }
+        // Android
+        if (this._platform.ANDROID) {
+            this.osName = 'os-android';
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatPlatformService, deps: [{ token: i1.Platform }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatPlatformService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatPlatformService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.Platform }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/platform/public-api.mjs

@@ -0,0 +1,2 @@
+export * from './platform.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NtYXQvc2VydmljZXMvcGxhdGZvcm0vcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG9CQUFvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9wbGF0Zm9ybS5zZXJ2aWNlJztcclxuIl19

package/esm2022/services/splash-screen/cmat-services-splash-screen.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY21hdC1zZXJ2aWNlcy1zcGxhc2gtc2NyZWVuLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY21hdC9zZXJ2aWNlcy9zcGxhc2gtc2NyZWVuL2NtYXQtc2VydmljZXMtc3BsYXNoLXNjcmVlbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2022/services/splash-screen/public-api.mjs

@@ -0,0 +1,2 @@
+export * from './splash-screen.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NtYXQvc2VydmljZXMvc3BsYXNoLXNjcmVlbi9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMseUJBQXlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3NwbGFzaC1zY3JlZW4uc2VydmljZSc7XHJcbiJdfQ==

package/esm2022/services/splash-screen/splash-screen.service.mjs

@@ -0,0 +1,42 @@
+import { Inject, Injectable } from '@angular/core';
+import { DOCUMENT } from '@angular/common';
+import { NavigationEnd } from '@angular/router';
+import { filter, take, takeUntil } from 'rxjs/operators';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+export class CmatSplashScreenService {
+    constructor(_document, _router) {
+        this._document = _document;
+        this._router = _router;
+        this._unsubscribeAll = new Subject();
+        // Hide it on the first NavigationEnd event
+        this._router.events
+            .pipe(takeUntil(this._unsubscribeAll), filter(event => event instanceof NavigationEnd), take(1))
+            .subscribe(() => {
+            this.hide();
+        });
+    }
+    ngOnDestroy() {
+        this._unsubscribeAll.next(void 0);
+        this._unsubscribeAll.complete();
+    }
+    show() {
+        this._document.body.classList.remove('cmat-splash-screen-hidden');
+    }
+    hide() {
+        this._document.body.classList.add('cmat-splash-screen-hidden');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatSplashScreenService, deps: [{ token: DOCUMENT }, { token: i1.Router }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatSplashScreenService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatSplashScreenService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i1.Router }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/title/cmat-services-title.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY21hdC1zZXJ2aWNlcy10aXRsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NtYXQvc2VydmljZXMvdGl0bGUvY21hdC1zZXJ2aWNlcy10aXRsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2022/services/title/public-api.mjs

@@ -0,0 +1,2 @@
+export * from './title.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NtYXQvc2VydmljZXMvdGl0bGUvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGlCQUFpQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi90aXRsZS5zZXJ2aWNlJztcclxuIl19