ngx-cho-common 0.0.1

package/esm2022/lib/security/services/auth.service.mjs

@@ -0,0 +1,131 @@
+import { AuthUser } from '../models/auth-user.model';
+import { AuthorizationContext } from '../models/authorization-context.model';
+import { BehaviorSubject } from 'rxjs';
+import { Inject, Injectable } from '@angular/core';
+import { SECURITY_POLICIES } from '../security-policies';
+import { UserManager } from 'oidc-client';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "../../services/session-storage.service";
+import * as i3 from "ngx-spinner";
+// function getClientSettings(): UserManagerSettings {
+//     return {
+//         authority: environment.auth.authority,
+//         client_id: environment.auth.clientId,
+//         redirect_uri: `${environment.webApp}/auth-callback`,
+//         post_logout_redirect_uri: environment.webApp,
+//         response_type: 'id_token token',
+//         scope: `openid profile ${environment.auth.resourceId}`,
+//         filterProtocolClaims: true,
+//         loadUserInfo: true,
+//         automaticSilentRenew: true,
+//         silent_redirect_uri: `${environment.webApp}/silent-refresh.html`,
+//         //extraQueryParams: { resource: environment.auth.resourceId }
+//         // This is useful for testing silent refresh.  Don't set this any lower, otherwise
+//         // the token authority will likely block you.
+//         //accessTokenExpiringNotificationTime: 3545
+//     };
+// }
+export class AuthService {
+    constructor(securityPolicies, webAppUrl, userManagerSettings, router, sessionStorage, spinnerService) {
+        this.securityPolicies = securityPolicies;
+        this.webAppUrl = webAppUrl;
+        this.userManagerSettings = userManagerSettings;
+        this.router = router;
+        this.sessionStorage = sessionStorage;
+        this.spinnerService = spinnerService;
+        this.returnUrlKey = 'AuthService.returnUrl';
+        this.userManager = new UserManager(this.userManagerSettings);
+        this._currentUser = AuthUser.anonymous;
+        this.userStream = new BehaviorSubject(AuthUser.anonymous);
+        this.userManager.events.addSilentRenewError(err => {
+            console.error(err);
+        });
+        this.checkIsAuthenticated();
+    }
+    /**
+     * Gets the current user.
+     */
+    get currentUser() {
+        return this._currentUser;
+    }
+    /**
+     * Sets the current user.
+     */
+    set currentUser(user) {
+        this._currentUser = user;
+        const authContext = new AuthorizationContext(user);
+        this.securityPolicies.forEach(p => p.evaluate(authContext));
+        this.userStream.next(user);
+    }
+    /**
+     * Checks that the specified security policy is satisfied.
+     *
+     * @param name
+     * @returns
+     */
+    checkPolicy(name) {
+        return this.securityPolicies.some(p => p.name === name && p.succeeded);
+    }
+    /**
+     * Completes the authentication process, redirecting to the return URL if specified
+     * in the start authentication call.
+     *
+     * @returns A void promise.
+     */
+    async completeAuthentication() {
+        this.currentUser = AuthUser.from(await this.userManager.signinRedirectCallback());
+        let returnUrl = this.sessionStorage.getItem(this.returnUrlKey) || this.webAppUrl;
+        this.sessionStorage.removeItem(this.returnUrlKey);
+        if (returnUrl.endsWith('login')) {
+            returnUrl = this.webAppUrl;
+        }
+        this.router.navigateByUrl(returnUrl, { replaceUrl: true });
+    }
+    /**
+     * Determines whether the user is authenticated.
+     */
+    async checkIsAuthenticated() {
+        this.currentUser = AuthUser.from(await this.userManager.getUser());
+        return this.currentUser.isAuthenticated;
+    }
+    /**
+     * Signs the current user out of the sytem.
+     */
+    async signout() {
+        await this.userManager.signoutRedirect();
+        this.userManager.removeUser();
+        this.currentUser = AuthUser.anonymous;
+    }
+    /**
+     * Begins the authentication process.
+     *
+     * @param returnUrl Optional.  Destination after authentication is complete.
+     * @returns A void promise.
+     */
+    startAuthentication(returnUrl) {
+        if (returnUrl) {
+            this.sessionStorage.setItem(this.returnUrlKey, returnUrl);
+        }
+        this.spinnerService.show();
+        return this.userManager.signinRedirect().then(() => {
+            this.spinnerService.hide();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthService, deps: [{ token: SECURITY_POLICIES }, { token: 'webAppUrl' }, { token: 'userManagerSettings' }, { token: i1.Router }, { token: i2.SessionStorageService }, { token: i3.NgxSpinnerService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [SECURITY_POLICIES]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['webAppUrl']
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['userManagerSettings']
+                }] }, { type: i1.Router }, { type: i2.SessionStorageService }, { type: i3.NgxSpinnerService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.service.js","sourceRoot":"","sources":["../../../../../../projects/ngx-cho-common/src/lib/security/services/auth.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { AuthUser } from '../models/auth-user.model';\nimport { AuthorizationContext } from '../models/authorization-context.model';\nimport { BehaviorSubject } from 'rxjs';\nimport { Inject, Injectable } from '@angular/core';\nimport { NgxSpinnerService } from 'ngx-spinner';\nimport { Router } from '@angular/router';\nimport { SECURITY_POLICIES } from '../security-policies';\nimport { SecurityPolicy } from '../models/security-policy.model';\nimport { UserManager, UserManagerSettings } from 'oidc-client';\nimport { SessionStorageService } from '../../services/session-storage.service';\n\n// function getClientSettings(): UserManagerSettings {\n//     return {\n//         authority: environment.auth.authority,\n//         client_id: environment.auth.clientId,\n//         redirect_uri: `${environment.webApp}/auth-callback`,\n//         post_logout_redirect_uri: environment.webApp,\n//         response_type: 'id_token token',\n//         scope: `openid profile ${environment.auth.resourceId}`,\n//         filterProtocolClaims: true,\n//         loadUserInfo: true,\n//         automaticSilentRenew: true,\n//         silent_redirect_uri: `${environment.webApp}/silent-refresh.html`,\n//         //extraQueryParams: { resource: environment.auth.resourceId }\n//         // This is useful for testing silent refresh.  Don't set this any lower, otherwise\n//         // the token authority will likely block you.\n//         //accessTokenExpiringNotificationTime: 3545\n//     };\n// }\n\n@Injectable({ providedIn: 'root' })\nexport class AuthService {\n    private readonly returnUrlKey = 'AuthService.returnUrl';\n    private readonly userManager = new UserManager(this.userManagerSettings);\n\n    private _currentUser = AuthUser.anonymous;\n    public readonly userStream = new BehaviorSubject<AuthUser>(AuthUser.anonymous);\n\n    constructor(\n        @Inject(SECURITY_POLICIES)\n        public readonly securityPolicies: SecurityPolicy[],\n        @Inject('webAppUrl') private readonly webAppUrl: string,\n        @Inject('userManagerSettings') private readonly userManagerSettings: UserManagerSettings,\n        private readonly router: Router,\n        private readonly sessionStorage: SessionStorageService,\n        private readonly spinnerService: NgxSpinnerService\n    ) {\n        this.userManager.events.addSilentRenewError(err => {\n            console.error(err);\n        });\n        this.checkIsAuthenticated();\n    }\n\n    /**\n     * Gets the current user.\n     */\n    get currentUser(): AuthUser {\n        return this._currentUser;\n    }\n\n    /**\n     * Sets the current user.\n     */\n    private set currentUser(user: AuthUser) {\n        this._currentUser = user;\n\n        const authContext = new AuthorizationContext(user);\n        this.securityPolicies.forEach(p => p.evaluate(authContext));\n\n        this.userStream.next(user);\n    }\n\n    /**\n     * Checks that the specified security policy is satisfied.\n     *\n     * @param name\n     * @returns\n     */\n    checkPolicy(name: string): boolean {\n        return this.securityPolicies.some(p => p.name === name && p.succeeded);\n    }\n\n    /**\n     * Completes the authentication process, redirecting to the return URL if specified\n     * in the start authentication call.\n     *\n     * @returns A void promise.\n     */\n    async completeAuthentication(): Promise<void> {\n        this.currentUser = AuthUser.from(await this.userManager.signinRedirectCallback());\n\n        let returnUrl =\n            this.sessionStorage.getItem<string>(this.returnUrlKey) || this.webAppUrl;\n        this.sessionStorage.removeItem(this.returnUrlKey);\n\n        if (returnUrl.endsWith('login')) {\n            returnUrl = this.webAppUrl;\n        }\n\n        this.router.navigateByUrl(returnUrl, { replaceUrl: true });\n    }\n\n    /**\n     * Determines whether the user is authenticated.\n     */\n    async checkIsAuthenticated(): Promise<boolean> {\n        this.currentUser = AuthUser.from(await this.userManager.getUser());\n        return this.currentUser.isAuthenticated;\n    }\n\n    /**\n     * Signs the current user out of the sytem.\n     */\n    async signout(): Promise<void> {\n        await this.userManager.signoutRedirect();\n\n        this.userManager.removeUser();\n        this.currentUser = AuthUser.anonymous;\n    }\n\n    /**\n     * Begins the authentication process.\n     *\n     * @param returnUrl Optional.  Destination after authentication is complete.\n     * @returns A void promise.\n     */\n    startAuthentication(returnUrl?: string): Promise<void> {\n        if (returnUrl) {\n            this.sessionStorage.setItem(this.returnUrlKey, returnUrl);\n        }\n\n        this.spinnerService.show();\n\n        return this.userManager.signinRedirect().then(() => {\n            this.spinnerService.hide();\n        });\n    }\n}\n"]}

package/esm2022/lib/security/signin/signin.component.mjs

@@ -0,0 +1,18 @@
+import { Component } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/auth.service";
+export class SigninComponent {
+    constructor(authService) {
+        this.authService = authService;
+    }
+    ngOnInit() {
+        this.authService.startAuthentication('/');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SigninComponent, deps: [{ token: i1.AuthService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: SigninComponent, selector: "app-signin", ngImport: i0, template: "<section class=\"container-fluid\">\n    <p>Redirecting to sign in page...</p>\n</section>\n" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SigninComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-signin', template: "<section class=\"container-fluid\">\n    <p>Redirecting to sign in page...</p>\n</section>\n" }]
+        }], ctorParameters: () => [{ type: i1.AuthService }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2lnbmluLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1jaG8tY29tbW9uL3NyYy9saWIvc2VjdXJpdHkvc2lnbmluL3NpZ25pbi5jb21wb25lbnQudHMiLCIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtY2hvLWNvbW1vbi9zcmMvbGliL3NlY3VyaXR5L3NpZ25pbi9zaWduaW4uY29tcG9uZW50Lmh0bWwiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBVSxNQUFNLGVBQWUsQ0FBQzs7O0FBT2xELE1BQU0sT0FBTyxlQUFlO0lBQ3hCLFlBQTZCLFdBQXdCO1FBQXhCLGdCQUFXLEdBQVgsV0FBVyxDQUFhO0lBQUcsQ0FBQztJQUV6RCxRQUFRO1FBQ0osSUFBSSxDQUFDLFdBQVcsQ0FBQyxtQkFBbUIsQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUM5QyxDQUFDOytHQUxRLGVBQWU7bUdBQWYsZUFBZSxrRENQNUIsOEZBR0E7OzRGRElhLGVBQWU7a0JBSjNCLFNBQVM7K0JBQ0ksWUFBWSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbXBvbmVudCwgT25Jbml0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBBdXRoU2VydmljZSB9IGZyb20gJy4uL3NlcnZpY2VzL2F1dGguc2VydmljZSc7XG5cbkBDb21wb25lbnQoe1xuICAgIHNlbGVjdG9yOiAnYXBwLXNpZ25pbicsXG4gICAgdGVtcGxhdGVVcmw6ICcuL3NpZ25pbi5jb21wb25lbnQuaHRtbCcsXG59KVxuZXhwb3J0IGNsYXNzIFNpZ25pbkNvbXBvbmVudCBpbXBsZW1lbnRzIE9uSW5pdCB7XG4gICAgY29uc3RydWN0b3IocHJpdmF0ZSByZWFkb25seSBhdXRoU2VydmljZTogQXV0aFNlcnZpY2UpIHt9XG5cbiAgICBuZ09uSW5pdCgpOiB2b2lkIHtcbiAgICAgICAgdGhpcy5hdXRoU2VydmljZS5zdGFydEF1dGhlbnRpY2F0aW9uKCcvJyk7XG4gICAgfVxufVxuIiwiPHNlY3Rpb24gY2xhc3M9XCJjb250YWluZXItZmx1aWRcIj5cbiAgICA8cD5SZWRpcmVjdGluZyB0byBzaWduIGluIHBhZ2UuLi48L3A+XG48L3NlY3Rpb24+XG4iXX0=

package/esm2022/lib/security/signout/signout.component.mjs

@@ -0,0 +1,18 @@
+import { Component } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/auth.service";
+export class SignoutComponent {
+    constructor(authService) {
+        this.authService = authService;
+    }
+    ngOnInit() {
+        this.authService.signout();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SignoutComponent, deps: [{ token: i1.AuthService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: SignoutComponent, selector: "app-signout", ngImport: i0, template: "<section class=\"container-fluid\">\n    <p>Signing out...</p>\n</section>\n" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SignoutComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-signout', template: "<section class=\"container-fluid\">\n    <p>Signing out...</p>\n</section>\n" }]
+        }], ctorParameters: () => [{ type: i1.AuthService }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2lnbm91dC5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtY2hvLWNvbW1vbi9zcmMvbGliL3NlY3VyaXR5L3NpZ25vdXQvc2lnbm91dC5jb21wb25lbnQudHMiLCIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtY2hvLWNvbW1vbi9zcmMvbGliL3NlY3VyaXR5L3NpZ25vdXQvc2lnbm91dC5jb21wb25lbnQuaHRtbCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFVLE1BQU0sZUFBZSxDQUFDOzs7QUFPbEQsTUFBTSxPQUFPLGdCQUFnQjtJQUN6QixZQUE2QixXQUF3QjtRQUF4QixnQkFBVyxHQUFYLFdBQVcsQ0FBYTtJQUFHLENBQUM7SUFFekQsUUFBUTtRQUNKLElBQUksQ0FBQyxXQUFXLENBQUMsT0FBTyxFQUFFLENBQUM7SUFDL0IsQ0FBQzsrR0FMUSxnQkFBZ0I7bUdBQWhCLGdCQUFnQixtRENQN0IsOEVBR0E7OzRGRElhLGdCQUFnQjtrQkFKNUIsU0FBUzsrQkFDSSxhQUFhIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50LCBPbkluaXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEF1dGhTZXJ2aWNlIH0gZnJvbSAnLi4vc2VydmljZXMvYXV0aC5zZXJ2aWNlJztcblxuQENvbXBvbmVudCh7XG4gICAgc2VsZWN0b3I6ICdhcHAtc2lnbm91dCcsXG4gICAgdGVtcGxhdGVVcmw6ICcuL3NpZ25vdXQuY29tcG9uZW50Lmh0bWwnLFxufSlcbmV4cG9ydCBjbGFzcyBTaWdub3V0Q29tcG9uZW50IGltcGxlbWVudHMgT25Jbml0IHtcbiAgICBjb25zdHJ1Y3Rvcihwcml2YXRlIHJlYWRvbmx5IGF1dGhTZXJ2aWNlOiBBdXRoU2VydmljZSkge31cblxuICAgIG5nT25Jbml0KCk6IHZvaWQge1xuICAgICAgICB0aGlzLmF1dGhTZXJ2aWNlLnNpZ25vdXQoKTtcbiAgICB9XG59XG4iLCI8c2VjdGlvbiBjbGFzcz1cImNvbnRhaW5lci1mbHVpZFwiPlxuICAgIDxwPlNpZ25pbmcgb3V0Li4uPC9wPlxuPC9zZWN0aW9uPlxuIl19

package/esm2022/lib/services/date.service.mjs

@@ -0,0 +1,40 @@
+import { Injectable } from '@angular/core';
+import moment from 'moment';
+import * as i0 from "@angular/core";
+export class DateService {
+    getMonthItems(startMonth = 1, endMonth = 12) {
+        const items = [];
+        const d = moment().startOf('year');
+        let i = startMonth;
+        while (i <= endMonth) {
+            d.set('month', i - 1);
+            items.push({ value: i, name: d.format('MMMM') });
+            i++;
+        }
+        return items;
+    }
+    getYearItems(startYear, endYear) {
+        startYear = startYear || moment().year();
+        endYear = endYear || moment().year();
+        const items = [];
+        let i = startYear;
+        while (i <= endYear) {
+            items.push({ value: i, name: i.toString() });
+            i++;
+        }
+        return items;
+    }
+    toDateString(input) {
+        return moment(input).format('yyyy-MM-DD');
+    }
+    toISOString(input) {
+        return moment(input).toISOString();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DateService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DateService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/download.service.mjs

@@ -0,0 +1,49 @@
+import { Injectable } from '@angular/core';
+import { shareReplay } from 'rxjs';
+import { saveAs } from 'file-saver';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class DownloadService {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+        this.octetStreamMime = 'application/octet-stream';
+    }
+    downloadFile(url, params) {
+        const download$ = this.httpClient
+            .get(url, {
+            responseType: 'arraybuffer',
+            observe: 'response',
+            params: params,
+        })
+            .pipe(shareReplay());
+        download$.subscribe(r => this.processDownload(r));
+        return download$;
+    }
+    processDownload(response) {
+        const filename = this.getFileNameFromResponse(response);
+        const contentType = response.headers.get('content-type') || this.octetStreamMime;
+        if (response.body) {
+            const blob = new Blob([response.body], { type: contentType });
+            saveAs(blob, filename);
+        }
+    }
+    getFileNameFromResponse(response) {
+        // attempt to get from response headers
+        let fileName = response.headers.get('x-filename') || response.headers.get('filename');
+        if (!fileName) {
+            // attempt to get from content disposition
+            const disposition = response.headers.get('content-disposition');
+            if (disposition) {
+                fileName = disposition.split(';')[1].split('=')[1].replace(/"/g, '');
+            }
+        }
+        return fileName || 'download.bin';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DownloadService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DownloadService, providedIn: 'any' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DownloadService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'any' }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/feature.service.mjs

@@ -0,0 +1,66 @@
+import { Inject, Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "./rest-client.service";
+export class FeatureService {
+    constructor(webApiUrl, restClient) {
+        this.webApiUrl = webApiUrl;
+        this.restClient = restClient;
+        this.featureStream = new BehaviorSubject([]);
+        this._enabledFeatures = [];
+        this._isInitialized = false;
+        this.routePrefix = `${this.webApiUrl}/common/features`;
+        this.checkEnabledFeatures();
+    }
+    /**
+     * Gets the enabled features.
+     */
+    get enabledFeatures() {
+        return this._enabledFeatures;
+    }
+    /**
+     * Sets the enabled features.
+     */
+    set enabledFeatures(enabledFeatures) {
+        this._enabledFeatures = enabledFeatures;
+        this._isInitialized = true;
+        this.featureStream.next(enabledFeatures);
+    }
+    /**
+     * Gets whether features have been initialized
+     */
+    get isInitialized() {
+        return this._isInitialized;
+    }
+    /**
+     * Checks that the enabled features are set and returns the list.
+     *
+     * @param name
+     * @returns
+     */
+    async checkEnabledFeatures() {
+        if (!this._enabledFeatures) {
+            this.enabledFeatures = await this.restClient.get(`${this.routePrefix}/enabled`);
+        }
+        return this.enabledFeatures;
+    }
+    /**
+     * Checks that the specified feature is enabled.
+     *
+     * @param name
+     * @returns
+     */
+    checkFeatureIsEnabled(name) {
+        return this._enabledFeatures?.some(p => p === name);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FeatureService, deps: [{ token: 'webApiUrl' }, { token: i1.RestClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FeatureService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FeatureService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['webApiUrl']
+                }] }, { type: i1.RestClient }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/interval.service.mjs

@@ -0,0 +1,115 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export var FireImmediately;
+(function (FireImmediately) {
+    FireImmediately[FireImmediately["never"] = 0] = "never";
+    FireImmediately[FireImmediately["whenShown"] = 1] = "whenShown";
+    FireImmediately[FireImmediately["whenFocused"] = 2] = "whenFocused";
+})(FireImmediately || (FireImmediately = {}));
+export class IntervalService {
+    static { this.defaultOptions = { fireImmediately: FireImmediately.never }; }
+    create(action, interval, options = IntervalService.defaultOptions) {
+        const timer = new IntervalTimer(action, interval, options);
+        timer.initialize();
+        return timer;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: IntervalService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: IntervalService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: IntervalService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+export class IntervalTimer {
+    constructor(action, interval, options) {
+        this.action = action;
+        this.interval = interval;
+        this.options = options;
+        this.currentInterval = 0;
+        this.isStopped = true;
+    }
+    initialize() {
+        if (this.options.hiddenInterval != null) {
+            document.addEventListener('visibilitychange', () => {
+                if (document.hidden) {
+                    this.onHidden();
+                }
+                else {
+                    this.onShown();
+                }
+            });
+        }
+        if (this.options.blurInterval != null) {
+            window.addEventListener('blur', () => this.onBlur());
+            window.addEventListener('focus', () => this.onFocus());
+        }
+    }
+    start() {
+        if (this.isStopped) {
+            if (!document.hidden) {
+                this.isStopped = false;
+                this.onShown();
+            }
+            else {
+                this.setInterval(this.interval);
+                this.isStopped = false;
+            }
+        }
+    }
+    stop() {
+        this.setInterval(0);
+        this.isStopped = true;
+    }
+    async callActionAndScheduleNext(nextInterval) {
+        this.setInterval(0); // pause while the action runs
+        await this.action();
+        this.setInterval(nextInterval);
+    }
+    onBlur() {
+        if (this.isStopped) {
+            return;
+        }
+        this.setInterval(this.options?.blurInterval);
+    }
+    onFocus() {
+        if (this.isStopped) {
+            return;
+        }
+        if (this.options?.fireImmediately === FireImmediately.whenFocused) {
+            this.callActionAndScheduleNext(this.interval);
+            return;
+        }
+        this.setInterval(this.interval);
+    }
+    onHidden() {
+        if (this.isStopped) {
+            return;
+        }
+        this.setInterval(this.options?.hiddenInterval);
+    }
+    onShown() {
+        if (this.isStopped) {
+            return;
+        }
+        if (this.options.fireImmediately === FireImmediately.whenShown) {
+            this.callActionAndScheduleNext(this.interval);
+            return;
+        }
+        this.setInterval(this.interval);
+    }
+    setInterval(interval) {
+        if (this.$handle) {
+            if (interval === this.currentInterval) {
+                return;
+            }
+            window.clearTimeout(this.$handle);
+            this.$handle = undefined;
+        }
+        if (!interval) {
+            return;
+        }
+        this.$handle = window.setTimeout(() => this.callActionAndScheduleNext(interval), interval);
+        this.currentInterval = interval;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interval.service.js","sourceRoot":"","sources":["../../../../../projects/ngx-cho-common/src/lib/services/interval.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\n\nexport type IntervalOptions = {\n    fireImmediately: FireImmediately;\n    blurInterval?: number;\n    hiddenInterval?: number;\n};\n\ntype Action = () => Promise<unknown>;\n\nexport enum FireImmediately {\n    never,\n    whenShown,\n    whenFocused,\n}\n\n@Injectable({ providedIn: 'root' })\nexport class IntervalService {\n    static readonly defaultOptions: IntervalOptions = { fireImmediately: FireImmediately.never };\n\n    create(\n        action: Action,\n        interval: number,\n        options: IntervalOptions = IntervalService.defaultOptions\n    ): IntervalTimer {\n        const timer = new IntervalTimer(action, interval, options);\n        timer.initialize();\n\n        return timer;\n    }\n}\n\nexport class IntervalTimer {\n    $handle?: number;\n    currentInterval = 0;\n    isStopped = true;\n\n    constructor(\n        private readonly action: Action,\n        private readonly interval: number,\n        private readonly options: IntervalOptions\n    ) {}\n\n    initialize(): void {\n        if (this.options.hiddenInterval != null) {\n            document.addEventListener('visibilitychange', () => {\n                if (document.hidden) {\n                    this.onHidden();\n                } else {\n                    this.onShown();\n                }\n            });\n        }\n\n        if (this.options.blurInterval != null) {\n            window.addEventListener('blur', () => this.onBlur());\n            window.addEventListener('focus', () => this.onFocus());\n        }\n    }\n\n    start(): void {\n        if (this.isStopped) {\n            if (!document.hidden) {\n                this.isStopped = false;\n                this.onShown();\n            } else {\n                this.setInterval(this.interval);\n                this.isStopped = false;\n            }\n        }\n    }\n\n    stop(): void {\n        this.setInterval(0);\n        this.isStopped = true;\n    }\n\n    private async callActionAndScheduleNext(nextInterval: number): Promise<void> {\n        this.setInterval(0); // pause while the action runs\n        await this.action();\n        this.setInterval(nextInterval);\n    }\n\n    private onBlur(): void {\n        if (this.isStopped) {\n            return;\n        }\n\n        this.setInterval(this.options?.blurInterval);\n    }\n\n    private onFocus(): void {\n        if (this.isStopped) {\n            return;\n        }\n\n        if (this.options?.fireImmediately === FireImmediately.whenFocused) {\n            this.callActionAndScheduleNext(this.interval);\n            return;\n        }\n\n        this.setInterval(this.interval);\n    }\n\n    private onHidden(): void {\n        if (this.isStopped) {\n            return;\n        }\n\n        this.setInterval(this.options?.hiddenInterval);\n    }\n\n    private onShown(): void {\n        if (this.isStopped) {\n            return;\n        }\n\n        if (this.options.fireImmediately === FireImmediately.whenShown) {\n            this.callActionAndScheduleNext(this.interval);\n            return;\n        }\n\n        this.setInterval(this.interval);\n    }\n\n    private setInterval(interval?: number): void {\n        if (this.$handle) {\n            if (interval === this.currentInterval) {\n                return;\n            }\n\n            window.clearTimeout(this.$handle);\n            this.$handle = undefined;\n        }\n\n        if (!interval) {\n            return;\n        }\n\n        this.$handle = window.setTimeout(() => this.callActionAndScheduleNext(interval), interval);\n        this.currentInterval = interval;\n    }\n}\n"]}

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

@@ -0,0 +1,29 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class LocalStorageService {
+    checkIfKeyExists(key) {
+        return globalThis.localStorage.getItem(key) !== null;
+    }
+    getItem(key) {
+        const valueString = globalThis.localStorage.getItem(key);
+        if (valueString === null) {
+            return undefined;
+        }
+        const value = JSON.parse(valueString);
+        return value;
+    }
+    setItem(key, value) {
+        const valueString = JSON.stringify(value);
+        globalThis.localStorage.setItem(key, valueString);
+    }
+    removeItem(key) {
+        globalThis.localStorage.removeItem(key);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocalStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocalStorageService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocalStorageService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/modal.service.mjs

@@ -0,0 +1,34 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@ng-bootstrap/ng-bootstrap";
+export class ModalService {
+    constructor(ngbModal) {
+        this.ngbModal = ngbModal;
+    }
+    async showModal(component, componentParameters, modalOptions = { backdrop: 'static' }) {
+        const modal = this.ngbModal.open(component, modalOptions);
+        const componentInstance = modal.componentInstance;
+        Object.assign(componentInstance, componentParameters);
+        let result;
+        try {
+            result = await modal.result;
+        }
+        catch (error) {
+            result = null;
+            if (error === undefined) {
+                throw 'modal dismiss';
+            }
+            throw error;
+        }
+        return { result, componentInstance };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ModalService, deps: [{ token: i1.NgbModal }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ModalService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ModalService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.NgbModal }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/navigation.service.mjs

@@ -0,0 +1,45 @@
+// from https://nils-mehlhorn.de/posts/angular-navigate-back-previous-page
+import { Injectable } from '@angular/core';
+import { NavigationEnd } from '@angular/router';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "@angular/common";
+export class NavigationService {
+    constructor(router, location) {
+        this.router = router;
+        this.location = location;
+        this.history = [];
+        this.router.events.subscribe(event => {
+            if (event instanceof NavigationEnd) {
+                this.history.push(event.urlAfterRedirects);
+            }
+        });
+    }
+    goBack() {
+        this.goBackOrDefault('/');
+    }
+    goBackOrDefault(defaultUrl) {
+        if (this.history.length > 0) {
+            this.history.pop();
+            this.location.back();
+        }
+        else {
+            this.router.navigateByUrl(defaultUrl);
+        }
+    }
+    setQueryParams(params) {
+        this.router.navigate([], {
+            queryParams: params,
+            queryParamsHandling: 'merge',
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NavigationService, deps: [{ token: i1.Router }, { token: i2.Location }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NavigationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NavigationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.Router }, { type: i2.Location }] });
+//# sourceMappingURL=data:application/json;base64,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