@dontdrinkandroot/ngx-extensions 0.3.2 → 0.5.0

package/esm2022/src/cookie/cookie.service.mjs

@@ -0,0 +1,135 @@
+// This service is based on the `ng2-cookies` package which sadly is not a service and does
+// not use `DOCUMENT` injection and therefore doesn't work well with AoT production builds.
+// Package: https://github.com/BCJTI/ng2-cookies
+import { Inject, Injectable } from '@angular/core';
+import { DOCUMENT } from '@angular/common';
+import * as i0 from "@angular/core";
+export class CookieService {
+    constructor(document) {
+        this.document = document;
+        // To avoid issues with server side prerendering, check if `document` is defined.
+        this.documentIsAccessible = document !== undefined;
+    }
+    /**
+     * @param name Cookie name
+     */
+    check(name) {
+        if (!this.documentIsAccessible) {
+            return false;
+        }
+        name = encodeURIComponent(name);
+        const regExp = this.getCookieRegExp(name);
+        return regExp.test(this.document.cookie);
+    }
+    /**
+     * @param name Cookie name
+     */
+    get(name) {
+        if (this.documentIsAccessible && this.check(name)) {
+            name = encodeURIComponent(name);
+            const regExp = this.getCookieRegExp(name);
+            const result = regExp.exec(this.document.cookie);
+            if (null == result)
+                return '';
+            return decodeURIComponent(result[1]);
+        }
+        else {
+            return '';
+        }
+    }
+    getAll() {
+        if (!this.documentIsAccessible) {
+            return {};
+        }
+        const cookies = {};
+        const document = this.document;
+        if (document.cookie && document.cookie !== '') {
+            const split = document.cookie.split(';');
+            for (let i = 0; i < split.length; i += 1) {
+                const currentCookie = split[i].split('=');
+                currentCookie[0] = currentCookie[0].replace(/^ /, '');
+                // @ts-ignore
+                cookies[decodeURIComponent(currentCookie[0])] = decodeURIComponent(currentCookie[1]);
+            }
+        }
+        return cookies;
+    }
+    /**
+     * @param name    Cookie name
+     * @param value   Cookie value
+     * @param expires Number of days until the cookies expires or an actual `Date`
+     * @param path    Cookie path
+     * @param domain  Cookie domain
+     * @param secure  Secure flag
+     */
+    set(name, value, expires, path, domain, secure) {
+        if (!this.documentIsAccessible) {
+            return;
+        }
+        let cookieString = encodeURIComponent(name) + '=' + encodeURIComponent(value) + ';';
+        if (expires) {
+            if (typeof expires === 'number') {
+                const dateExpires = new Date(new Date().getTime() + expires * 1000 * 60 * 60 * 24);
+                cookieString += 'expires=' + dateExpires.toUTCString() + ';';
+            }
+            else {
+                cookieString += 'expires=' + expires.toUTCString() + ';';
+            }
+        }
+        if (path) {
+            cookieString += 'path=' + path + ';';
+        }
+        if (domain) {
+            cookieString += 'domain=' + domain + ';';
+        }
+        if (secure) {
+            cookieString += 'secure;';
+        }
+        this.document.cookie = cookieString;
+    }
+    /**
+     * @param name   Cookie name
+     * @param path   Cookie path
+     * @param domain Cookie domain
+     */
+    delete(name, path, domain) {
+        if (!this.documentIsAccessible) {
+            return;
+        }
+        this.set(name, '', -1, path, domain);
+    }
+    /**
+     * @param path   Cookie path
+     * @param domain Cookie domain
+     */
+    deleteAll(path, domain) {
+        if (!this.documentIsAccessible) {
+            return;
+        }
+        const cookies = this.getAll();
+        for (const cookieName in cookies) {
+            if (cookies.hasOwnProperty(cookieName)) {
+                this.delete(cookieName, path, domain);
+            }
+        }
+    }
+    /**
+     * @param name Cookie name
+     */
+    getCookieRegExp(name) {
+        const escapedName = name.replace(/([\[\]{}()|=;+?,.*^$])/ig, '\\$1');
+        return new RegExp('(?:^' + escapedName + '|;\\s*' + escapedName + ')=(.*?)(?:;|$)', 'g');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: CookieService, deps: [{ token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: CookieService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: CookieService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cookie.service.js","sourceRoot":"","sources":["../../../../src/cookie/cookie.service.ts"],"names":[],"mappings":"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","sourcesContent":["// This service is based on the `ng2-cookies` package which sadly is not a service and does\n// not use `DOCUMENT` injection and therefore doesn't work well with AoT production builds.\n// Package: https://github.com/BCJTI/ng2-cookies\n\nimport {Inject, Injectable} from '@angular/core';\nimport {DOCUMENT} from '@angular/common';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class CookieService\n{\n    private readonly documentIsAccessible: boolean;\n\n    constructor(\n        @Inject(DOCUMENT) private document: Document\n    )\n    {\n        // To avoid issues with server side prerendering, check if `document` is defined.\n        this.documentIsAccessible = document !== undefined;\n    }\n\n    /**\n     * @param name Cookie name\n     */\n    check(name: string): boolean\n    {\n        if (!this.documentIsAccessible) {\n            return false;\n        }\n\n        name = encodeURIComponent(name);\n\n        const regExp: RegExp = this.getCookieRegExp(name);\n        return regExp.test(this.document.cookie);\n    }\n\n    /**\n     * @param name Cookie name\n     */\n    get(name: string): string\n    {\n        if (this.documentIsAccessible && this.check(name)) {\n            name = encodeURIComponent(name);\n\n            const regExp = this.getCookieRegExp(name);\n            const result = regExp.exec(this.document.cookie);\n            if (null == result) return ''\n\n            return decodeURIComponent(result[1]);\n        } else {\n            return '';\n        }\n    }\n\n    getAll(): {}\n    {\n        if (!this.documentIsAccessible) {\n            return {};\n        }\n\n        const cookies: {} = {};\n        const document: any = this.document;\n\n        if (document.cookie && document.cookie !== '') {\n            const split: Array<string> = document.cookie.split(';');\n\n            for (let i = 0; i < split.length; i += 1) {\n                const currentCookie: Array<string> = split[i].split('=');\n\n                currentCookie[0] = currentCookie[0].replace(/^ /, '');\n                // @ts-ignore\n                cookies[decodeURIComponent(currentCookie[0])] = decodeURIComponent(currentCookie[1]);\n            }\n        }\n\n        return cookies;\n    }\n\n    /**\n     * @param name    Cookie name\n     * @param value   Cookie value\n     * @param expires Number of days until the cookies expires or an actual `Date`\n     * @param path    Cookie path\n     * @param domain  Cookie domain\n     * @param secure  Secure flag\n     */\n    set(\n        name: string,\n        value: string,\n        expires?: number | Date,\n        path?: string,\n        domain?: string,\n        secure?: boolean\n    ): void\n    {\n        if (!this.documentIsAccessible) {\n            return;\n        }\n\n        let cookieString: string = encodeURIComponent(name) + '=' + encodeURIComponent(value) + ';';\n\n        if (expires) {\n            if (typeof expires === 'number') {\n                const dateExpires: Date = new Date(new Date().getTime() + expires * 1000 * 60 * 60 * 24);\n\n                cookieString += 'expires=' + dateExpires.toUTCString() + ';';\n            } else {\n                cookieString += 'expires=' + expires.toUTCString() + ';';\n            }\n        }\n\n        if (path) {\n            cookieString += 'path=' + path + ';';\n        }\n\n        if (domain) {\n            cookieString += 'domain=' + domain + ';';\n        }\n\n        if (secure) {\n            cookieString += 'secure;';\n        }\n\n        this.document.cookie = cookieString;\n    }\n\n    /**\n     * @param name   Cookie name\n     * @param path   Cookie path\n     * @param domain Cookie domain\n     */\n    delete(name: string, path?: string, domain?: string): void\n    {\n        if (!this.documentIsAccessible) {\n            return;\n        }\n\n        this.set(name, '', -1, path, domain);\n    }\n\n    /**\n     * @param path   Cookie path\n     * @param domain Cookie domain\n     */\n    deleteAll(path?: string, domain?: string): void\n    {\n        if (!this.documentIsAccessible) {\n            return;\n        }\n\n        const cookies: any = this.getAll();\n\n        for (const cookieName in cookies) {\n            if (cookies.hasOwnProperty(cookieName)) {\n                this.delete(cookieName, path, domain);\n            }\n        }\n    }\n\n    /**\n     * @param name Cookie name\n     */\n    private getCookieRegExp(name: string): RegExp\n    {\n        const escapedName: string = name.replace(/([\\[\\]{}()|=;+?,.*^$])/ig, '\\\\$1');\n\n        return new RegExp('(?:^' + escapedName + '|;\\\\s*' + escapedName + ')=(.*?)(?:;|$)', 'g');\n    }\n}\n"]}

package/esm2022/src/ddr-extensions.module.mjs

@@ -0,0 +1,67 @@
+import { InjectionToken, NgModule } from '@angular/core';
+import { LazyImageDirective } from './image/lazy-image.directive';
+import { BottomHitDirective } from './scroll/bottom-hit.directive';
+import { Logger } from './logger/logger.service';
+import { ConsoleLogger } from './logger/console-logger.service';
+import { DDR_STORAGE_PREFIX, StorageService } from './storage/storage.service';
+import { LocalStorageService } from './storage/local-storage.service';
+import * as i0 from "@angular/core";
+export const DDR_JWT_REFRESH_TOKEN_URL = new InjectionToken('DDR_JWT_REFRESH_TOKEN_URL');
+export const DDR_LOGIN_PATH = new InjectionToken('DDR_LOGIN_PATH');
+export class DdrExtensionsModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: DdrExtensionsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.8", ngImport: i0, type: DdrExtensionsModule, declarations: [LazyImageDirective,
+            BottomHitDirective], exports: [LazyImageDirective,
+            BottomHitDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: DdrExtensionsModule, providers: [
+            {
+                provide: DDR_LOGIN_PATH,
+                useValue: '/login'
+            },
+            {
+                provide: Logger,
+                useClass: ConsoleLogger
+            },
+            {
+                provide: DDR_STORAGE_PREFIX,
+                useValue: 'ddr'
+            },
+            {
+                provide: StorageService,
+                useClass: LocalStorageService
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: DdrExtensionsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        LazyImageDirective,
+                        BottomHitDirective
+                    ],
+                    imports: [],
+                    providers: [
+                        {
+                            provide: DDR_LOGIN_PATH,
+                            useValue: '/login'
+                        },
+                        {
+                            provide: Logger,
+                            useClass: ConsoleLogger
+                        },
+                        {
+                            provide: DDR_STORAGE_PREFIX,
+                            useValue: 'ddr'
+                        },
+                        {
+                            provide: StorageService,
+                            useClass: LocalStorageService
+                        },
+                    ],
+                    exports: [
+                        LazyImageDirective,
+                        BottomHitDirective
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/http/redirect-to-login-interceptor.service.mjs

@@ -0,0 +1,35 @@
+import { HttpErrorResponse } from '@angular/common/http';
+import { Inject, Injectable } from '@angular/core';
+import { throwError } from 'rxjs';
+import { catchError } from 'rxjs/operators';
+import { DDR_LOGIN_PATH } from '../ddr-extensions.module';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+export class RedirectToLoginInterceptor {
+    constructor(router, loginPath) {
+        this.router = router;
+        this.loginPath = loginPath;
+    }
+    /**
+     * @override
+     */
+    intercept(req, next) {
+        return next.handle(req).pipe(catchError((err) => {
+            if (err instanceof HttpErrorResponse) {
+                if (err.status === 401) {
+                    this.router.navigate([this.loginPath]);
+                }
+            }
+            return throwError(err);
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: RedirectToLoginInterceptor, deps: [{ token: i1.Router }, { token: DDR_LOGIN_PATH }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: RedirectToLoginInterceptor }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: RedirectToLoginInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.Router }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DDR_LOGIN_PATH]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVkaXJlY3QtdG8tbG9naW4taW50ZXJjZXB0b3Iuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9odHRwL3JlZGlyZWN0LXRvLWxvZ2luLWludGVyY2VwdG9yLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLGlCQUFpQixFQUF1RCxNQUFNLHNCQUFzQixDQUFDO0FBQzdHLE9BQU8sRUFBQyxNQUFNLEVBQUUsVUFBVSxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBQ2pELE9BQU8sRUFBYSxVQUFVLEVBQUMsTUFBTSxNQUFNLENBQUM7QUFDNUMsT0FBTyxFQUFDLFVBQVUsRUFBQyxNQUFNLGdCQUFnQixDQUFDO0FBRTFDLE9BQU8sRUFBQyxjQUFjLEVBQUMsTUFBTSwwQkFBMEIsQ0FBQzs7O0FBR3hELE1BQU0sT0FBTywwQkFBMEI7SUFFbkMsWUFBb0IsTUFBYyxFQUFrQyxTQUFpQjtRQUFqRSxXQUFNLEdBQU4sTUFBTSxDQUFRO1FBQWtDLGNBQVMsR0FBVCxTQUFTLENBQVE7SUFFckYsQ0FBQztJQUVEOztPQUVHO0lBQ0ksU0FBUyxDQUFDLEdBQXFCLEVBQUUsSUFBaUI7UUFFckQsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsQ0FBQyxHQUFHLEVBQUUsRUFBRTtZQUU1QyxJQUFJLEdBQUcsWUFBWSxpQkFBaUIsRUFBRSxDQUFDO2dCQUNuQyxJQUFJLEdBQUcsQ0FBQyxNQUFNLEtBQUssR0FBRyxFQUFFLENBQUM7b0JBQ3JCLElBQUksQ0FBQyxNQUFNLENBQUMsUUFBUSxDQUFDLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUM7Z0JBQzNDLENBQUM7WUFDTCxDQUFDO1lBRUQsT0FBTyxVQUFVLENBQUMsR0FBRyxDQUFDLENBQUM7UUFDM0IsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUNSLENBQUM7OEdBckJRLDBCQUEwQix3Q0FFUyxjQUFjO2tIQUZqRCwwQkFBMEI7OzJGQUExQiwwQkFBMEI7a0JBRHRDLFVBQVU7OzBCQUc4QixNQUFNOzJCQUFDLGNBQWMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0h0dHBFcnJvclJlc3BvbnNlLCBIdHRwRXZlbnQsIEh0dHBIYW5kbGVyLCBIdHRwSW50ZXJjZXB0b3IsIEh0dHBSZXF1ZXN0fSBmcm9tICdAYW5ndWxhci9jb21tb24vaHR0cCc7XG5pbXBvcnQge0luamVjdCwgSW5qZWN0YWJsZX0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge09ic2VydmFibGUsIHRocm93RXJyb3J9IGZyb20gJ3J4anMnO1xuaW1wb3J0IHtjYXRjaEVycm9yfSBmcm9tICdyeGpzL29wZXJhdG9ycyc7XG5pbXBvcnQge1JvdXRlcn0gZnJvbSAnQGFuZ3VsYXIvcm91dGVyJztcbmltcG9ydCB7RERSX0xPR0lOX1BBVEh9IGZyb20gJy4uL2Rkci1leHRlbnNpb25zLm1vZHVsZSc7XG5cbkBJbmplY3RhYmxlKClcbmV4cG9ydCBjbGFzcyBSZWRpcmVjdFRvTG9naW5JbnRlcmNlcHRvciBpbXBsZW1lbnRzIEh0dHBJbnRlcmNlcHRvclxue1xuICAgIGNvbnN0cnVjdG9yKHByaXZhdGUgcm91dGVyOiBSb3V0ZXIsIEBJbmplY3QoRERSX0xPR0lOX1BBVEgpIHByaXZhdGUgbG9naW5QYXRoOiBzdHJpbmcpXG4gICAge1xuICAgIH1cblxuICAgIC8qKlxuICAgICAqIEBvdmVycmlkZVxuICAgICAqL1xuICAgIHB1YmxpYyBpbnRlcmNlcHQocmVxOiBIdHRwUmVxdWVzdDxhbnk+LCBuZXh0OiBIdHRwSGFuZGxlcik6IE9ic2VydmFibGU8SHR0cEV2ZW50PGFueT4+XG4gICAge1xuICAgICAgICByZXR1cm4gbmV4dC5oYW5kbGUocmVxKS5waXBlKGNhdGNoRXJyb3IoKGVycikgPT4ge1xuXG4gICAgICAgICAgICBpZiAoZXJyIGluc3RhbmNlb2YgSHR0cEVycm9yUmVzcG9uc2UpIHtcbiAgICAgICAgICAgICAgICBpZiAoZXJyLnN0YXR1cyA9PT0gNDAxKSB7XG4gICAgICAgICAgICAgICAgICAgIHRoaXMucm91dGVyLm5hdmlnYXRlKFt0aGlzLmxvZ2luUGF0aF0pO1xuICAgICAgICAgICAgICAgIH1cbiAgICAgICAgICAgIH1cblxuICAgICAgICAgICAgcmV0dXJuIHRocm93RXJyb3IoZXJyKTtcbiAgICAgICAgfSkpO1xuICAgIH1cbn1cbiJdfQ==

package/{esm2020 → esm2022}/src/http/with-credentials-interceptor.service.mjs

@@ -10,10 +10,10 @@ export class WithCredentialsInterceptor {
         });
         return next.handle(cloned);
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: WithCredentialsInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: WithCredentialsInterceptor }); }
 }
-WithCredentialsInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.4", ngImport: i0, type: WithCredentialsInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-WithCredentialsInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.4", ngImport: i0, type: WithCredentialsInterceptor });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.4", ngImport: i0, type: WithCredentialsInterceptor, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: WithCredentialsInterceptor, decorators: [{
             type: Injectable
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2l0aC1jcmVkZW50aWFscy1pbnRlcmNlcHRvci5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2h0dHAvd2l0aC1jcmVkZW50aWFscy1pbnRlcmNlcHRvci5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxVQUFVLEVBQUMsTUFBTSxlQUFlLENBQUM7O0FBS3pDLE1BQU0sT0FBTywwQkFBMEI7SUFFbkM7O09BRUc7SUFDSSxTQUFTLENBQUMsR0FBcUIsRUFBRSxJQUFpQjtRQUVyRCxNQUFNLE1BQU0sR0FBRyxHQUFHLENBQUMsS0FBSyxDQUFDO1lBQ3JCLGVBQWUsRUFBRSxJQUFJO1NBQ3hCLENBQUMsQ0FBQztRQUVILE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUMvQixDQUFDOzt1SEFaUSwwQkFBMEI7MkhBQTFCLDBCQUEwQjsyRkFBMUIsMEJBQTBCO2tCQUR0QyxVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtJbmplY3RhYmxlfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7SHR0cEV2ZW50LCBIdHRwSGFuZGxlciwgSHR0cEludGVyY2VwdG9yLCBIdHRwUmVxdWVzdH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uL2h0dHAnO1xuaW1wb3J0IHtPYnNlcnZhYmxlfSBmcm9tICdyeGpzJztcblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIFdpdGhDcmVkZW50aWFsc0ludGVyY2VwdG9yIGltcGxlbWVudHMgSHR0cEludGVyY2VwdG9yXG57XG4gICAgLyoqXG4gICAgICogQG92ZXJyaWRlXG4gICAgICovXG4gICAgcHVibGljIGludGVyY2VwdChyZXE6IEh0dHBSZXF1ZXN0PGFueT4sIG5leHQ6IEh0dHBIYW5kbGVyKTogT2JzZXJ2YWJsZTxIdHRwRXZlbnQ8YW55Pj5cbiAgICB7XG4gICAgICAgIGNvbnN0IGNsb25lZCA9IHJlcS5jbG9uZSh7XG4gICAgICAgICAgICB3aXRoQ3JlZGVudGlhbHM6IHRydWVcbiAgICAgICAgfSk7XG5cbiAgICAgICAgcmV0dXJuIG5leHQuaGFuZGxlKGNsb25lZCk7XG4gICAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2l0aC1jcmVkZW50aWFscy1pbnRlcmNlcHRvci5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2h0dHAvd2l0aC1jcmVkZW50aWFscy1pbnRlcmNlcHRvci5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxVQUFVLEVBQUMsTUFBTSxlQUFlLENBQUM7O0FBS3pDLE1BQU0sT0FBTywwQkFBMEI7SUFFbkM7O09BRUc7SUFDSSxTQUFTLENBQUMsR0FBcUIsRUFBRSxJQUFpQjtRQUVyRCxNQUFNLE1BQU0sR0FBRyxHQUFHLENBQUMsS0FBSyxDQUFDO1lBQ3JCLGVBQWUsRUFBRSxJQUFJO1NBQ3hCLENBQUMsQ0FBQztRQUVILE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUMvQixDQUFDOzhHQVpRLDBCQUEwQjtrSEFBMUIsMEJBQTBCOzsyRkFBMUIsMEJBQTBCO2tCQUR0QyxVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtJbmplY3RhYmxlfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7SHR0cEV2ZW50LCBIdHRwSGFuZGxlciwgSHR0cEludGVyY2VwdG9yLCBIdHRwUmVxdWVzdH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uL2h0dHAnO1xuaW1wb3J0IHtPYnNlcnZhYmxlfSBmcm9tICdyeGpzJztcblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIFdpdGhDcmVkZW50aWFsc0ludGVyY2VwdG9yIGltcGxlbWVudHMgSHR0cEludGVyY2VwdG9yXG57XG4gICAgLyoqXG4gICAgICogQG92ZXJyaWRlXG4gICAgICovXG4gICAgcHVibGljIGludGVyY2VwdChyZXE6IEh0dHBSZXF1ZXN0PGFueT4sIG5leHQ6IEh0dHBIYW5kbGVyKTogT2JzZXJ2YWJsZTxIdHRwRXZlbnQ8YW55Pj5cbiAgICB7XG4gICAgICAgIGNvbnN0IGNsb25lZCA9IHJlcS5jbG9uZSh7XG4gICAgICAgICAgICB3aXRoQ3JlZGVudGlhbHM6IHRydWVcbiAgICAgICAgfSk7XG5cbiAgICAgICAgcmV0dXJuIG5leHQuaGFuZGxlKGNsb25lZCk7XG4gICAgfVxufVxuIl19

package/esm2022/src/image/lazy-image.directive.mjs

@@ -0,0 +1,132 @@
+import { __decorate } from "tslib";
+import { Directive, HostBinding, HostListener, Input } from '@angular/core';
+import { NumberUtils } from '../util/number-utils';
+import { StringUtils } from '../util/string-utils';
+import { Debounce } from '../methoddecorator/debounce';
+import { Limit } from '../methoddecorator/limit';
+import * as i0 from "@angular/core";
+export class LazyImageDirective {
+    constructor(element, changeDetectorRef) {
+        this.element = element;
+        this.changeDetectorRef = changeDetectorRef;
+        this.objectFit = 'contain';
+        this.offset = 1000;
+        this.hostSrc = 'assets/placeholder.gif';
+        this.hostStyleObjectFit = 'contain';
+        this.displayed = false;
+        this.maxLoadedDimension = null;
+    }
+    windowResized($event) {
+        this.displayed = false;
+        this.check();
+    }
+    windowScroll($event) {
+        this.check();
+    }
+    /**
+     * @override
+     */
+    ngOnChanges(changes) {
+        this.displayed = false;
+        this.maxLoadedDimension = null;
+        this.check();
+    }
+    check() {
+        if (this.element.nativeElement.parentElement.offsetWidth > 0) {
+            this.doCheck();
+        }
+        else {
+            setTimeout(() => this.doCheck(), 1);
+        }
+    }
+    doCheck() {
+        if (this.displayed || this.isHidden(this.element.nativeElement)) {
+            return;
+        }
+        if (this.isInsideViewport(this.element.nativeElement, this.offset)) {
+            this.displayed = true;
+            const dimension = this.getDimension();
+            this.hostStyleWidthPx = dimension.width;
+            this.hostStyleHeightPx = dimension.height;
+            if (this.maxLoadedDimension != null
+                && this.maxLoadedDimension.width >= dimension.width
+                && this.maxLoadedDimension.height >= dimension.height) {
+                // console.log('has smaller dimension');
+                return;
+            }
+            this.maxLoadedDimension = dimension;
+            let wantedSize;
+            if (this.objectFit === 'cover') {
+                wantedSize = NumberUtils.getNextPowerOfTwo(Math.max(dimension.width, dimension.height));
+                this.hostStyleObjectFit = 'cover';
+            }
+            else {
+                wantedSize = NumberUtils.getNextPowerOfTwo(Math.min(dimension.width, dimension.height));
+                this.hostStyleObjectFit = 'contain';
+            }
+            this.hostSrc = StringUtils.updateUrlParameter(this.src, 'size', String(wantedSize));
+            this.changeDetectorRef.markForCheck();
+        }
+    }
+    isInsideViewport(element, threshold) {
+        const ownerDocument = element.ownerDocument;
+        const documentTop = window.pageYOffset || ownerDocument.body.scrollTop;
+        const documentLeft = window.pageXOffset || ownerDocument.body.scrollLeft;
+        const documentWidth = window.innerWidth || (ownerDocument.documentElement.clientWidth || document.body.clientWidth);
+        const documentHeight = window.innerHeight || (ownerDocument.documentElement.clientHeight || document.body.clientHeight);
+        const topOffset = element.getBoundingClientRect().top + documentTop - ownerDocument.documentElement.clientTop;
+        const leftOffset = element.getBoundingClientRect().left + documentLeft - ownerDocument.documentElement.clientLeft;
+        const isBelowViewport = documentHeight + documentTop <= topOffset - threshold;
+        const isAtRightOfViewport = documentWidth + window.pageXOffset <= leftOffset - threshold;
+        const isAboveViewport = documentTop >= topOffset + threshold + element.offsetHeight;
+        const isAtLeftOfViewport = documentLeft >= leftOffset + threshold + element.offsetWidth;
+        return !isBelowViewport && !isAboveViewport && !isAtRightOfViewport && !isAtLeftOfViewport;
+    }
+    getDimension() {
+        return {
+            width: this.element.nativeElement.parentElement.offsetWidth,
+            height: this.element.nativeElement.parentElement.offsetHeight,
+        };
+    }
+    isHidden(element) {
+        return window.getComputedStyle(element).display === 'none';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: LazyImageDirective, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.8", type: LazyImageDirective, selector: "[ddrLazyImage]", inputs: { src: ["ddrLazyImage", "src"], objectFit: "objectFit", offset: "offset" }, host: { listeners: { "window:resize": "windowResized($event)", "window:scroll": "windowScroll($event)" }, properties: { "src": "this.hostSrc", "style.width.px": "this.hostStyleWidthPx", "style.height.px": "this.hostStyleHeightPx", "style.object-fit": "this.hostStyleObjectFit" } }, usesOnChanges: true, ngImport: i0 }); }
+}
+__decorate([
+    Debounce()
+], LazyImageDirective.prototype, "windowResized", null);
+__decorate([
+    Limit()
+], LazyImageDirective.prototype, "windowScroll", null);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: LazyImageDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[ddrLazyImage]' }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.ChangeDetectorRef }], propDecorators: { src: [{
+                type: Input,
+                args: ['ddrLazyImage']
+            }], objectFit: [{
+                type: Input
+            }], offset: [{
+                type: Input
+            }], hostSrc: [{
+                type: HostBinding,
+                args: ['src']
+            }], hostStyleWidthPx: [{
+                type: HostBinding,
+                args: ['style.width.px']
+            }], hostStyleHeightPx: [{
+                type: HostBinding,
+                args: ['style.height.px']
+            }], hostStyleObjectFit: [{
+                type: HostBinding,
+                args: ['style.object-fit']
+            }], windowResized: [{
+                type: HostListener,
+                args: ['window:resize', ['$event']]
+            }], windowScroll: [{
+                type: HostListener,
+                args: ['window:scroll', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lazy-image.directive.js","sourceRoot":"","sources":["../../../../src/image/lazy-image.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    ChangeDetectorRef,\n    Directive,\n    ElementRef,\n    HostBinding,\n    HostListener,\n    Input,\n    OnChanges,\n    SimpleChanges\n} from '@angular/core';\nimport {NumberUtils} from '../util/number-utils';\nimport {StringUtils} from '../util/string-utils';\nimport {Debounce} from '../methoddecorator/debounce';\nimport {Limit} from '../methoddecorator/limit';\n\n\n@Directive({selector: '[ddrLazyImage]'})\nexport class LazyImageDirective implements OnChanges\n{\n    @Input('ddrLazyImage')\n    public src!: string;\n\n    @Input()\n    public objectFit: 'cover' | 'contain' = 'contain';\n\n    @Input()\n    public offset = 1000;\n\n    @HostBinding('src')\n    public hostSrc = 'assets/placeholder.gif';\n\n    @HostBinding('style.width.px')\n    public hostStyleWidthPx!: number;\n\n    @HostBinding('style.height.px')\n    public hostStyleHeightPx!: number;\n\n    @HostBinding('style.object-fit')\n    public hostStyleObjectFit = 'contain';\n\n    private displayed = false;\n\n    private maxLoadedDimension: { width: number, height: number } | null = null;\n\n    constructor(private element: ElementRef, private changeDetectorRef: ChangeDetectorRef)\n    {\n    }\n\n    @HostListener('window:resize', ['$event'])\n    @Debounce()\n    public windowResized($event: Event): void\n    {\n        this.displayed = false;\n        this.check();\n    }\n\n    @HostListener('window:scroll', ['$event'])\n    @Limit()\n    public windowScroll($event: Event): void\n    {\n        this.check();\n    }\n\n    /**\n     * @override\n     */\n    public ngOnChanges(changes: SimpleChanges): void\n    {\n        this.displayed = false;\n        this.maxLoadedDimension = null;\n        this.check();\n    }\n\n    private check(): void\n    {\n        if (this.element.nativeElement.parentElement.offsetWidth > 0) {\n            this.doCheck();\n        } else {\n            setTimeout(() => this.doCheck(), 1);\n        }\n    }\n\n    private doCheck(): void\n    {\n        if (this.displayed || this.isHidden(this.element.nativeElement)) {\n            return;\n        }\n\n        if (this.isInsideViewport(this.element.nativeElement, this.offset)) {\n            this.displayed = true;\n            const dimension = this.getDimension();\n            this.hostStyleWidthPx = dimension.width;\n            this.hostStyleHeightPx = dimension.height;\n\n            if (\n                this.maxLoadedDimension != null\n                && this.maxLoadedDimension!.width >= dimension.width\n                && this.maxLoadedDimension!.height >= dimension.height\n            ) {\n                // console.log('has smaller dimension');\n                return;\n            }\n\n            this.maxLoadedDimension = dimension;\n\n            let wantedSize;\n            if (this.objectFit === 'cover') {\n                wantedSize = NumberUtils.getNextPowerOfTwo(Math.max(dimension.width, dimension.height));\n                this.hostStyleObjectFit = 'cover';\n            } else {\n                wantedSize = NumberUtils.getNextPowerOfTwo(Math.min(dimension.width, dimension.height));\n                this.hostStyleObjectFit = 'contain';\n            }\n            this.hostSrc = StringUtils.updateUrlParameter(this.src, 'size', String(wantedSize));\n            this.changeDetectorRef.markForCheck();\n        }\n    }\n\n    private isInsideViewport(element: HTMLElement, threshold: number): boolean\n    {\n        const ownerDocument = element.ownerDocument;\n        const documentTop = window.pageYOffset || ownerDocument.body.scrollTop;\n        const documentLeft = window.pageXOffset || ownerDocument.body.scrollLeft;\n\n        const documentWidth = window.innerWidth || (ownerDocument.documentElement.clientWidth || document.body.clientWidth);\n        const documentHeight = window.innerHeight || (ownerDocument.documentElement.clientHeight || document.body.clientHeight);\n        const topOffset = element.getBoundingClientRect().top + documentTop - ownerDocument.documentElement.clientTop;\n        const leftOffset = element.getBoundingClientRect().left + documentLeft - ownerDocument.documentElement.clientLeft;\n\n        const isBelowViewport = documentHeight + documentTop <= topOffset - threshold;\n        const isAtRightOfViewport = documentWidth + window.pageXOffset <= leftOffset - threshold;\n        const isAboveViewport = documentTop >= topOffset + threshold + element.offsetHeight;\n        const isAtLeftOfViewport = documentLeft >= leftOffset + threshold + element.offsetWidth;\n\n        return !isBelowViewport && !isAboveViewport && !isAtRightOfViewport && !isAtLeftOfViewport;\n    }\n\n    private getDimension(): { width: number, height: number }\n    {\n        return {\n            width: this.element.nativeElement.parentElement.offsetWidth,\n            height: this.element.nativeElement.parentElement.offsetHeight,\n        };\n    }\n\n    private isHidden(element: HTMLElement): boolean\n    {\n        return window.getComputedStyle(element).display === 'none';\n    }\n}\n"]}

package/esm2022/src/jwt/jwt-interceptor.service.mjs

@@ -0,0 +1,26 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./jwt.service";
+export class JwtInterceptor {
+    constructor(jwtService) {
+        this.jwtService = jwtService;
+    }
+    /**
+     * @override
+     */
+    intercept(req, next) {
+        const token = this.jwtService.getToken();
+        if (null !== token && !this.jwtService.isExpired()) {
+            req = req.clone({
+                headers: req.headers.set('Authorization', 'Bearer ' + token)
+            });
+        }
+        return next.handle(req);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: JwtInterceptor, deps: [{ token: i1.JwtService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: JwtInterceptor }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: JwtInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.JwtService }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiand0LWludGVyY2VwdG9yLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvand0L2p3dC1pbnRlcmNlcHRvci5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBQyxVQUFVLEVBQUMsTUFBTSxlQUFlLENBQUM7OztBQUt6QyxNQUFNLE9BQU8sY0FBYztJQUV2QixZQUFvQixVQUFzQjtRQUF0QixlQUFVLEdBQVYsVUFBVSxDQUFZO0lBRTFDLENBQUM7SUFFRDs7T0FFRztJQUNJLFNBQVMsQ0FBQyxHQUFxQixFQUFFLElBQWlCO1FBRXJELE1BQU0sS0FBSyxHQUFHLElBQUksQ0FBQyxVQUFVLENBQUMsUUFBUSxFQUFFLENBQUM7UUFFekMsSUFBSSxJQUFJLEtBQUssS0FBSyxJQUFJLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxTQUFTLEVBQUUsRUFBRSxDQUFDO1lBQ2pELEdBQUcsR0FBRyxHQUFHLENBQUMsS0FBSyxDQUFDO2dCQUNaLE9BQU8sRUFBRSxHQUFHLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxlQUFlLEVBQUUsU0FBUyxHQUFHLEtBQUssQ0FBQzthQUMvRCxDQUFDLENBQUM7UUFDUCxDQUFDO1FBRUQsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQzVCLENBQUM7OEdBcEJRLGNBQWM7a0hBQWQsY0FBYzs7MkZBQWQsY0FBYztrQkFEMUIsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7SHR0cEV2ZW50LCBIdHRwSGFuZGxlciwgSHR0cEludGVyY2VwdG9yLCBIdHRwUmVxdWVzdH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uL2h0dHAnO1xuaW1wb3J0IHtJbmplY3RhYmxlfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7T2JzZXJ2YWJsZX0gZnJvbSAncnhqcyc7XG5pbXBvcnQge0p3dFNlcnZpY2V9IGZyb20gJy4vand0LnNlcnZpY2UnO1xuXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgY2xhc3MgSnd0SW50ZXJjZXB0b3IgaW1wbGVtZW50cyBIdHRwSW50ZXJjZXB0b3JcbntcbiAgICBjb25zdHJ1Y3Rvcihwcml2YXRlIGp3dFNlcnZpY2U6IEp3dFNlcnZpY2UpXG4gICAge1xuICAgIH1cblxuICAgIC8qKlxuICAgICAqIEBvdmVycmlkZVxuICAgICAqL1xuICAgIHB1YmxpYyBpbnRlcmNlcHQocmVxOiBIdHRwUmVxdWVzdDxhbnk+LCBuZXh0OiBIdHRwSGFuZGxlcik6IE9ic2VydmFibGU8SHR0cEV2ZW50PGFueT4+XG4gICAge1xuICAgICAgICBjb25zdCB0b2tlbiA9IHRoaXMuand0U2VydmljZS5nZXRUb2tlbigpO1xuXG4gICAgICAgIGlmIChudWxsICE9PSB0b2tlbiAmJiAhdGhpcy5qd3RTZXJ2aWNlLmlzRXhwaXJlZCgpKSB7XG4gICAgICAgICAgICByZXEgPSByZXEuY2xvbmUoe1xuICAgICAgICAgICAgICAgIGhlYWRlcnM6IHJlcS5oZWFkZXJzLnNldCgnQXV0aG9yaXphdGlvbicsICdCZWFyZXIgJyArIHRva2VuKVxuICAgICAgICAgICAgfSk7XG4gICAgICAgIH1cblxuICAgICAgICByZXR1cm4gbmV4dC5oYW5kbGUocmVxKTtcbiAgICB9XG59XG4iXX0=

package/esm2022/src/jwt/jwt-refresh-token-interceptor.service.mjs

@@ -0,0 +1,50 @@
+import { throwError } from 'rxjs';
+import { Inject, Injectable } from '@angular/core';
+import { catchError, map, shareReplay, switchMap } from 'rxjs/operators';
+import { DDR_JWT_REFRESH_TOKEN_URL } from '../ddr-extensions.module';
+import * as i0 from "@angular/core";
+import * as i1 from "./jwt.service";
+import * as i2 from "@angular/common/http";
+export class JwtRefreshTokenInterceptor {
+    constructor(jwtService, httpClient, jwtRefreshTokenUrl) {
+        this.jwtService = jwtService;
+        this.httpClient = httpClient;
+        this.jwtRefreshTokenUrl = jwtRefreshTokenUrl;
+        this.refreshTokenRequest$ = null;
+    }
+    /**
+     * @override
+     */
+    intercept(req, next) {
+        if (this.jwtService.isAboutToExpire() && !(req.url === this.jwtRefreshTokenUrl)) {
+            const refreshToken = this.jwtService.getRefreshToken();
+            if (null != refreshToken) {
+                return this.getRefreshTokenRequest(refreshToken).pipe(switchMap(() => next.handle(req)));
+            }
+        }
+        return next.handle(req);
+    }
+    getRefreshTokenRequest(refreshToken) {
+        if (null == this.refreshTokenRequest$) {
+            this.refreshTokenRequest$ = this.httpClient.post(this.jwtRefreshTokenUrl, { refresh_token: refreshToken }).pipe(map(response => {
+                this.jwtService.setTokens(response.token, response.refresh_token);
+                this.refreshTokenRequest$ = null;
+                return response;
+            }), catchError(error => {
+                this.jwtService.clear();
+                this.refreshTokenRequest$ = null;
+                return throwError(error);
+            }), shareReplay(1));
+        }
+        return this.refreshTokenRequest$;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: JwtRefreshTokenInterceptor, deps: [{ token: i1.JwtService }, { token: i2.HttpClient }, { token: DDR_JWT_REFRESH_TOKEN_URL }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: JwtRefreshTokenInterceptor }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: JwtRefreshTokenInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.JwtService }, { type: i2.HttpClient }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DDR_JWT_REFRESH_TOKEN_URL]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/src/jwt/jwt.service.mjs

@@ -69,13 +69,13 @@ export class JwtService {
     getRefreshTokenStorageKey() {
         return 'jwt.refresh_token';
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: JwtService, deps: [{ token: i1.StorageService }, { token: i2.Logger }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: JwtService, providedIn: 'root' }); }
 }
-JwtService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.4", ngImport: i0, type: JwtService, deps: [{ token: i1.StorageService }, { token: i2.Logger }], target: i0.ɵɵFactoryTarget.Injectable });
-JwtService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.4", ngImport: i0, type: JwtService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.4", ngImport: i0, type: JwtService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: JwtService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
                 }]
-        }], ctorParameters: function () { return [{ type: i1.StorageService }, { type: i2.Logger }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+        }], ctorParameters: () => [{ type: i1.StorageService }, { type: i2.Logger }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/logger/console-logger.service.mjs

@@ -0,0 +1,43 @@
+import { Logger } from './logger.service';
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ConsoleLogger extends Logger {
+    /**
+     * @override
+     */
+    debug(...data) {
+        if (this.debugEnabled) {
+            console.debug(...data);
+        }
+    }
+    /**
+     * @override
+     */
+    info(...data) {
+        if (this.infoEnabled) {
+            console.info(...data);
+        }
+    }
+    /**
+     * @override
+     */
+    warn(...data) {
+        if (this.warnEnabled) {
+            console.warn(...data);
+        }
+    }
+    /**
+     * @override
+     */
+    error(...data) {
+        if (this.errorEnabled) {
+            console.error(...data);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: ConsoleLogger, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: ConsoleLogger }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: ConsoleLogger, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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