@dontdrinkandroot/ngx-extensions 0.0.5 → 0.2.0

package/{esm2015/dontdrinkandroot-ngx-extensions.js → esm2020/dontdrinkandroot-ngx-extensions.mjs}

@@ -2,4 +2,4 @@
  * Generated bundle index. Do not edit.
  */
 export * from './public-api';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG9udGRyaW5rYW5kcm9vdC1uZ3gtZXh0ZW5zaW9ucy5qcyIsInNvdXJjZVJvb3QiOiIuLi8uLi8iLCJzb3VyY2VzIjpbImRvbnRkcmlua2FuZHJvb3Qtbmd4LWV4dGVuc2lvbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG9udGRyaW5rYW5kcm9vdC1uZ3gtZXh0ZW5zaW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL2RvbnRkcmlua2FuZHJvb3Qtbmd4LWV4dGVuc2lvbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2020/public-api.mjs

@@ -0,0 +1,24 @@
+/*
+ * Public API Surface of ngx-extensions
+ */
+export * from './src/ddr-extensions.module';
+export * from './src/cookie/cookie.service';
+export * from './src/util/collection-utils';
+export * from './src/util/string-utils';
+export * from './src/util/object-utils';
+export * from './src/util/number-utils';
+export * from './src/util/type-utils';
+export * from './src/scroll/scroll.service';
+export * from './src/methoddecorator/debounce';
+export * from './src/methoddecorator/limit';
+export * from './src/image/lazy-image.directive';
+export * from './src/scroll/bottom-hit.directive';
+export * from './src/visibility/visibility.service';
+export * from './src/http/with-credentials-interceptor.service';
+export * from './src/http/url-info';
+export * from './src/http/redirect-to-login-interceptor.service';
+export * from './src/jwt/jwt-interceptor.service';
+export * from './src/jwt/jwt.service';
+export * from './src/jwt/jwt-refresh-token-interceptor.service';
+export * from './src/jwt/jwt-token-response';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyxnQ0FBZ0MsQ0FBQztBQUMvQyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsa0NBQWtDLENBQUM7QUFDakQsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLHFDQUFxQyxDQUFDO0FBRXBELGNBQWMsaURBQWlELENBQUM7QUFDaEUsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGtEQUFrRCxDQUFDO0FBRWpFLGNBQWMsbUNBQW1DLENBQUM7QUFDbEQsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLGlEQUFpRCxDQUFDO0FBQ2hFLGNBQWMsOEJBQThCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIG5neC1leHRlbnNpb25zXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9zcmMvZGRyLWV4dGVuc2lvbnMubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vc3JjL2Nvb2tpZS9jb29raWUuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NyYy91dGlsL2NvbGxlY3Rpb24tdXRpbHMnO1xuZXhwb3J0ICogZnJvbSAnLi9zcmMvdXRpbC9zdHJpbmctdXRpbHMnO1xuZXhwb3J0ICogZnJvbSAnLi9zcmMvdXRpbC9vYmplY3QtdXRpbHMnO1xuZXhwb3J0ICogZnJvbSAnLi9zcmMvdXRpbC9udW1iZXItdXRpbHMnO1xuZXhwb3J0ICogZnJvbSAnLi9zcmMvdXRpbC90eXBlLXV0aWxzJztcbmV4cG9ydCAqIGZyb20gJy4vc3JjL3Njcm9sbC9zY3JvbGwuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NyYy9tZXRob2RkZWNvcmF0b3IvZGVib3VuY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9zcmMvbWV0aG9kZGVjb3JhdG9yL2xpbWl0JztcbmV4cG9ydCAqIGZyb20gJy4vc3JjL2ltYWdlL2xhenktaW1hZ2UuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vc3JjL3Njcm9sbC9ib3R0b20taGl0LmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL3NyYy92aXNpYmlsaXR5L3Zpc2liaWxpdHkuc2VydmljZSc7XG5cbmV4cG9ydCAqIGZyb20gJy4vc3JjL2h0dHAvd2l0aC1jcmVkZW50aWFscy1pbnRlcmNlcHRvci5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vc3JjL2h0dHAvdXJsLWluZm8nO1xuZXhwb3J0ICogZnJvbSAnLi9zcmMvaHR0cC9yZWRpcmVjdC10by1sb2dpbi1pbnRlcmNlcHRvci5zZXJ2aWNlJztcblxuZXhwb3J0ICogZnJvbSAnLi9zcmMvand0L2p3dC1pbnRlcmNlcHRvci5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vc3JjL2p3dC9qd3Quc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NyYy9qd3Qvand0LXJlZnJlc2gtdG9rZW4taW50ZXJjZXB0b3Iuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NyYy9qd3Qvand0LXRva2VuLXJlc3BvbnNlJztcbiJdfQ==

package/esm2020/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');
+    }
+}
+CookieService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.2", ngImport: i0, type: CookieService, deps: [{ token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+CookieService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.2", ngImport: i0, type: CookieService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.2", ngImport: i0, type: CookieService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ 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/esm2020/src/ddr-extensions.module.mjs

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

package/esm2020/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);
+        }));
+    }
+}
+RedirectToLoginInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.2", ngImport: i0, type: RedirectToLoginInterceptor, deps: [{ token: i1.Router }, { token: DDR_LOGIN_PATH }], target: i0.ɵɵFactoryTarget.Injectable });
+RedirectToLoginInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.2", ngImport: i0, type: RedirectToLoginInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.2", ngImport: i0, type: RedirectToLoginInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DDR_LOGIN_PATH]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/http/url-info.mjs

@@ -0,0 +1,26 @@
+export class UrlInfo {
+    constructor(protocol, host, hostname, port, pathname, hash, search) {
+        this.protocol = protocol;
+        this.host = host;
+        this.hostname = hostname;
+        this.port = port;
+        this.pathname = pathname;
+        this.hash = hash;
+        this.search = search;
+    }
+    static parse(urlString) {
+        const parser = document.createElement('a');
+        parser.href = urlString;
+        return new UrlInfo(parser.protocol, parser.host, parser.hostname, parser.port === '' ? 80 : +parser.port, parser.pathname, parser.hash, parser.search);
+    }
+    getRoot() {
+        let root = this.protocol + '//' + this.hostname;
+        if (this.port !== 80)
+            root += ':' + this.port;
+        return root;
+    }
+    getUrl() {
+        return this.getRoot() + this.pathname;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/http/with-credentials-interceptor.service.mjs

@@ -0,0 +1,19 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class WithCredentialsInterceptor {
+    /**
+     * @override
+     */
+    intercept(req, next) {
+        const cloned = req.clone({
+            withCredentials: true
+        });
+        return next.handle(cloned);
+    }
+}
+WithCredentialsInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.2", ngImport: i0, type: WithCredentialsInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+WithCredentialsInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.2", ngImport: i0, type: WithCredentialsInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.2", ngImport: i0, type: WithCredentialsInterceptor, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2l0aC1jcmVkZW50aWFscy1pbnRlcmNlcHRvci5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2h0dHAvd2l0aC1jcmVkZW50aWFscy1pbnRlcmNlcHRvci5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxVQUFVLEVBQUMsTUFBTSxlQUFlLENBQUM7O0FBS3pDLE1BQU0sT0FBTywwQkFBMEI7SUFFbkM7O09BRUc7SUFDSSxTQUFTLENBQUMsR0FBcUIsRUFBRSxJQUFpQjtRQUVyRCxNQUFNLE1BQU0sR0FBRyxHQUFHLENBQUMsS0FBSyxDQUFDO1lBQ3JCLGVBQWUsRUFBRSxJQUFJO1NBQ3hCLENBQUMsQ0FBQztRQUVILE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUMvQixDQUFDOzt1SEFaUSwwQkFBMEI7MkhBQTFCLDBCQUEwQjsyRkFBMUIsMEJBQTBCO2tCQUR0QyxVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtJbmplY3RhYmxlfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7SHR0cEV2ZW50LCBIdHRwSGFuZGxlciwgSHR0cEludGVyY2VwdG9yLCBIdHRwUmVxdWVzdH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uL2h0dHAnO1xuaW1wb3J0IHtPYnNlcnZhYmxlfSBmcm9tICdyeGpzJztcblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIFdpdGhDcmVkZW50aWFsc0ludGVyY2VwdG9yIGltcGxlbWVudHMgSHR0cEludGVyY2VwdG9yXG57XG4gICAgLyoqXG4gICAgICogQG92ZXJyaWRlXG4gICAgICovXG4gICAgcHVibGljIGludGVyY2VwdChyZXE6IEh0dHBSZXF1ZXN0PGFueT4sIG5leHQ6IEh0dHBIYW5kbGVyKTogT2JzZXJ2YWJsZTxIdHRwRXZlbnQ8YW55Pj5cbiAgICB7XG4gICAgICAgIGNvbnN0IGNsb25lZCA9IHJlcS5jbG9uZSh7XG4gICAgICAgICAgICB3aXRoQ3JlZGVudGlhbHM6IHRydWVcbiAgICAgICAgfSk7XG5cbiAgICAgICAgcmV0dXJuIG5leHQuaGFuZGxlKGNsb25lZCk7XG4gICAgfVxufVxuIl19

package/esm2020/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';
+    }
+}
+LazyImageDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.2", ngImport: i0, type: LazyImageDirective, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive });
+LazyImageDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.2", 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: "14.2.2", ngImport: i0, type: LazyImageDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[ddrLazyImage]' }]
+        }], ctorParameters: function () { return [{ 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":";AAAA,OAAO,EAEH,SAAS,EAET,WAAW,EACX,YAAY,EACZ,KAAK,EAGR,MAAM,eAAe,CAAC;AACvB,OAAO,EAAC,WAAW,EAAC,MAAM,sBAAsB,CAAC;AACjD,OAAO,EAAC,WAAW,EAAC,MAAM,sBAAsB,CAAC;AACjD,OAAO,EAAC,QAAQ,EAAC,MAAM,6BAA6B,CAAC;AACrD,OAAO,EAAC,KAAK,EAAC,MAAM,0BAA0B,CAAC;;AAI/C,MAAM,OAAO,kBAAkB;IA2B3B,YAAoB,OAAmB,EAAU,iBAAoC;QAAjE,YAAO,GAAP,OAAO,CAAY;QAAU,sBAAiB,GAAjB,iBAAiB,CAAmB;QArB9E,cAAS,GAAwB,SAAS,CAAC;QAG3C,WAAM,GAAG,IAAI,CAAC;QAGd,YAAO,GAAG,wBAAwB,CAAC;QASnC,uBAAkB,GAAG,SAAS,CAAC;QAE9B,cAAS,GAAG,KAAK,CAAC;QAElB,uBAAkB,GAA6C,IAAI,CAAC;IAI5E,CAAC;IAIM,aAAa,CAAC,MAAa;QAE9B,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;QACvB,IAAI,CAAC,KAAK,EAAE,CAAC;IACjB,CAAC;IAIM,YAAY,CAAC,MAAa;QAE7B,IAAI,CAAC,KAAK,EAAE,CAAC;IACjB,CAAC;IAED;;OAEG;IACI,WAAW,CAAC,OAAsB;QAErC,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;QACvB,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC;QAC/B,IAAI,CAAC,KAAK,EAAE,CAAC;IACjB,CAAC;IAEO,KAAK;QAET,IAAI,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,aAAa,CAAC,WAAW,GAAG,CAAC,EAAE;YAC1D,IAAI,CAAC,OAAO,EAAE,CAAC;SAClB;aAAM;YACH,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAC;SACvC;IACL,CAAC;IAEO,OAAO;QAEX,IAAI,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,EAAE;YAC7D,OAAO;SACV;QAED,IAAI,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,IAAI,CAAC,MAAM,CAAC,EAAE;YAChE,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;YACtB,MAAM,SAAS,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;YACtC,IAAI,CAAC,gBAAgB,GAAG,SAAS,CAAC,KAAK,CAAC;YACxC,IAAI,CAAC,iBAAiB,GAAG,SAAS,CAAC,MAAM,CAAC;YAE1C,IACI,IAAI,CAAC,kBAAkB,IAAI,IAAI;mBAC5B,IAAI,CAAC,kBAAmB,CAAC,KAAK,IAAI,SAAS,CAAC,KAAK;mBACjD,IAAI,CAAC,kBAAmB,CAAC,MAAM,IAAI,SAAS,CAAC,MAAM,EACxD;gBACE,wCAAwC;gBACxC,OAAO;aACV;YAED,IAAI,CAAC,kBAAkB,GAAG,SAAS,CAAC;YAEpC,IAAI,UAAU,CAAC;YACf,IAAI,IAAI,CAAC,SAAS,KAAK,OAAO,EAAE;gBAC5B,UAAU,GAAG,WAAW,CAAC,iBAAiB,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,KAAK,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;gBACxF,IAAI,CAAC,kBAAkB,GAAG,OAAO,CAAC;aACrC;iBAAM;gBACH,UAAU,GAAG,WAAW,CAAC,iBAAiB,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,KAAK,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;gBACxF,IAAI,CAAC,kBAAkB,GAAG,SAAS,CAAC;aACvC;YACD,IAAI,CAAC,OAAO,GAAG,WAAW,CAAC,kBAAkB,CAAC,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC;YACpF,IAAI,CAAC,iBAAiB,CAAC,YAAY,EAAE,CAAC;SACzC;IACL,CAAC;IAEO,gBAAgB,CAAC,OAAoB,EAAE,SAAiB;QAE5D,MAAM,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC;QAC5C,MAAM,WAAW,GAAG,MAAM,CAAC,WAAW,IAAI,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC;QACvE,MAAM,YAAY,GAAG,MAAM,CAAC,WAAW,IAAI,aAAa,CAAC,IAAI,CAAC,UAAU,CAAC;QAEzE,MAAM,aAAa,GAAG,MAAM,CAAC,UAAU,IAAI,CAAC,aAAa,CAAC,eAAe,CAAC,WAAW,IAAI,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QACpH,MAAM,cAAc,GAAG,MAAM,CAAC,WAAW,IAAI,CAAC,aAAa,CAAC,eAAe,CAAC,YAAY,IAAI,QAAQ,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACxH,MAAM,SAAS,GAAG,OAAO,CAAC,qBAAqB,EAAE,CAAC,GAAG,GAAG,WAAW,GAAG,aAAa,CAAC,eAAe,CAAC,SAAS,CAAC;QAC9G,MAAM,UAAU,GAAG,OAAO,CAAC,qBAAqB,EAAE,CAAC,IAAI,GAAG,YAAY,GAAG,aAAa,CAAC,eAAe,CAAC,UAAU,CAAC;QAElH,MAAM,eAAe,GAAG,cAAc,GAAG,WAAW,IAAI,SAAS,GAAG,SAAS,CAAC;QAC9E,MAAM,mBAAmB,GAAG,aAAa,GAAG,MAAM,CAAC,WAAW,IAAI,UAAU,GAAG,SAAS,CAAC;QACzF,MAAM,eAAe,GAAG,WAAW,IAAI,SAAS,GAAG,SAAS,GAAG,OAAO,CAAC,YAAY,CAAC;QACpF,MAAM,kBAAkB,GAAG,YAAY,IAAI,UAAU,GAAG,SAAS,GAAG,OAAO,CAAC,WAAW,CAAC;QAExF,OAAO,CAAC,eAAe,IAAI,CAAC,eAAe,IAAI,CAAC,mBAAmB,IAAI,CAAC,kBAAkB,CAAC;IAC/F,CAAC;IAEO,YAAY;QAEhB,OAAO;YACH,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,aAAa,CAAC,WAAW;YAC3D,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,aAAa,CAAC,YAAY;SAChE,CAAC;IACN,CAAC;IAEO,QAAQ,CAAC,OAAoB;QAEjC,OAAO,MAAM,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,OAAO,KAAK,MAAM,CAAC;IAC/D,CAAC;;+GAnIQ,kBAAkB;mGAAlB,kBAAkB;;IAgC1B,QAAQ,EAAE;uDAKV;;IAGA,KAAK,EAAE;sDAIP;2FA5CQ,kBAAkB;kBAD9B,SAAS;mBAAC,EAAC,QAAQ,EAAE,gBAAgB,EAAC;iIAI5B,GAAG;sBADT,KAAK;uBAAC,cAAc;gBAId,SAAS;sBADf,KAAK;gBAIC,MAAM;sBADZ,KAAK;gBAIC,OAAO;sBADb,WAAW;uBAAC,KAAK;gBAIX,gBAAgB;sBADtB,WAAW;uBAAC,gBAAgB;gBAItB,iBAAiB;sBADvB,WAAW;uBAAC,iBAAiB;gBAIvB,kBAAkB;sBADxB,WAAW;uBAAC,kBAAkB;gBAaxB,aAAa;sBAFnB,YAAY;uBAAC,eAAe,EAAE,CAAC,QAAQ,CAAC;gBAUlC,YAAY;sBAFlB,YAAY;uBAAC,eAAe,EAAE,CAAC,QAAQ,CAAC","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/esm2020/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);
+    }
+}
+JwtInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.2", ngImport: i0, type: JwtInterceptor, deps: [{ token: i1.JwtService }], target: i0.ɵɵFactoryTarget.Injectable });
+JwtInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.2", ngImport: i0, type: JwtInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.2", ngImport: i0, type: JwtInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.JwtService }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiand0LWludGVyY2VwdG9yLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvand0L2p3dC1pbnRlcmNlcHRvci5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBQyxVQUFVLEVBQUMsTUFBTSxlQUFlLENBQUM7OztBQUt6QyxNQUFNLE9BQU8sY0FBYztJQUV2QixZQUFvQixVQUFzQjtRQUF0QixlQUFVLEdBQVYsVUFBVSxDQUFZO0lBRTFDLENBQUM7SUFFRDs7T0FFRztJQUNJLFNBQVMsQ0FBQyxHQUFxQixFQUFFLElBQWlCO1FBRXJELE1BQU0sS0FBSyxHQUFHLElBQUksQ0FBQyxVQUFVLENBQUMsUUFBUSxFQUFFLENBQUM7UUFFekMsSUFBSSxJQUFJLEtBQUssS0FBSyxJQUFJLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxTQUFTLEVBQUUsRUFBRTtZQUNoRCxHQUFHLEdBQUcsR0FBRyxDQUFDLEtBQUssQ0FBQztnQkFDWixPQUFPLEVBQUUsR0FBRyxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsZUFBZSxFQUFFLFNBQVMsR0FBRyxLQUFLLENBQUM7YUFDL0QsQ0FBQyxDQUFDO1NBQ047UUFFRCxPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDNUIsQ0FBQzs7MkdBcEJRLGNBQWM7K0dBQWQsY0FBYzsyRkFBZCxjQUFjO2tCQUQxQixVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtIdHRwRXZlbnQsIEh0dHBIYW5kbGVyLCBIdHRwSW50ZXJjZXB0b3IsIEh0dHBSZXF1ZXN0fSBmcm9tICdAYW5ndWxhci9jb21tb24vaHR0cCc7XG5pbXBvcnQge0luamVjdGFibGV9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHtPYnNlcnZhYmxlfSBmcm9tICdyeGpzJztcbmltcG9ydCB7Snd0U2VydmljZX0gZnJvbSAnLi9qd3Quc2VydmljZSc7XG5cbkBJbmplY3RhYmxlKClcbmV4cG9ydCBjbGFzcyBKd3RJbnRlcmNlcHRvciBpbXBsZW1lbnRzIEh0dHBJbnRlcmNlcHRvclxue1xuICAgIGNvbnN0cnVjdG9yKHByaXZhdGUgand0U2VydmljZTogSnd0U2VydmljZSlcbiAgICB7XG4gICAgfVxuXG4gICAgLyoqXG4gICAgICogQG92ZXJyaWRlXG4gICAgICovXG4gICAgcHVibGljIGludGVyY2VwdChyZXE6IEh0dHBSZXF1ZXN0PGFueT4sIG5leHQ6IEh0dHBIYW5kbGVyKTogT2JzZXJ2YWJsZTxIdHRwRXZlbnQ8YW55Pj5cbiAgICB7XG4gICAgICAgIGNvbnN0IHRva2VuID0gdGhpcy5qd3RTZXJ2aWNlLmdldFRva2VuKCk7XG5cbiAgICAgICAgaWYgKG51bGwgIT09IHRva2VuICYmICF0aGlzLmp3dFNlcnZpY2UuaXNFeHBpcmVkKCkpIHtcbiAgICAgICAgICAgIHJlcSA9IHJlcS5jbG9uZSh7XG4gICAgICAgICAgICAgICAgaGVhZGVyczogcmVxLmhlYWRlcnMuc2V0KCdBdXRob3JpemF0aW9uJywgJ0JlYXJlciAnICsgdG9rZW4pXG4gICAgICAgICAgICB9KTtcbiAgICAgICAgfVxuXG4gICAgICAgIHJldHVybiBuZXh0LmhhbmRsZShyZXEpO1xuICAgIH1cbn1cbiJdfQ==

package/esm2020/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$;
+    }
+}
+JwtRefreshTokenInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.2", ngImport: i0, type: JwtRefreshTokenInterceptor, deps: [{ token: i1.JwtService }, { token: i2.HttpClient }, { token: DDR_JWT_REFRESH_TOKEN_URL }], target: i0.ɵɵFactoryTarget.Injectable });
+JwtRefreshTokenInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.2", ngImport: i0, type: JwtRefreshTokenInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.2", ngImport: i0, type: JwtRefreshTokenInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ 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/src/jwt/jwt-token-response.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiand0LXRva2VuLXJlc3BvbnNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2p3dC9qd3QtdG9rZW4tcmVzcG9uc2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgSnd0VG9rZW5SZXNwb25zZVxue1xuICAgIHRva2VuOiBzdHJpbmc7XG4gICAgcmVmcmVzaF90b2tlbjogc3RyaW5nO1xufVxuIl19