@dontdrinkandroot/ngx-extensions 0.0.5 → 0.2.0

package/fesm2015/dontdrinkandroot-ngx-extensions.mjs

@@ -0,0 +1,760 @@
+import * as i0 from '@angular/core';
+import { Directive, Input, HostBinding, HostListener, EventEmitter, Output, InjectionToken, NgModule, Injectable, Inject } from '@angular/core';
+import { __decorate } from 'tslib';
+import * as i2 from '@angular/common';
+import { DOCUMENT } from '@angular/common';
+import * as i1 from '@angular/router';
+import { NavigationStart } from '@angular/router';
+import { merge, fromEvent, throwError } from 'rxjs';
+import { debounceTime, startWith, map, distinctUntilChanged, shareReplay, catchError, switchMap } from 'rxjs/operators';
+import * as i2$1 from '@angular/common/http';
+import { HttpErrorResponse } from '@angular/common/http';
+
+class NumberUtils {
+    static getNextPowerOfTwo(value) {
+        let target = 2;
+        while (target < value) {
+            target *= 2;
+        }
+        return target;
+    }
+}
+
+class StringUtils {
+    static capitalizeFirstLetter(text) {
+        return text.charAt(0).toUpperCase() + text.slice(1);
+    }
+    static stripTrailingSlash(text) {
+        const lastChar = text.charAt(text.length - 1);
+        if ('/' === lastChar) {
+            return text.slice(0, text.length - 1);
+        }
+        return text;
+    }
+    static updateUrlParameter(uri, key, value) {
+        // remove the hash part before operating on the uri
+        const i = uri.indexOf('#');
+        const hash = i === -1 ? '' : uri.substr(i);
+        uri = i === -1 ? uri : uri.substr(0, i);
+        const re = new RegExp('([?&])' + key + '=.*?(&|$)', 'i');
+        const separator = uri.indexOf('?') !== -1 ? '&' : '?';
+        if (uri.match(re)) {
+            uri = uri.replace(re, '$1' + key + '=' + value + '$2');
+        }
+        else {
+            uri = uri + separator + key + '=' + value;
+        }
+        return uri + hash; // finally append the hash as well
+    }
+    static createRandomString(lengthOfCode, possible) {
+        let text = '';
+        for (let i = 0; i < lengthOfCode; i++) {
+            text += possible.charAt(Math.floor(Math.random() * possible.length));
+        }
+        return text;
+    }
+}
+
+function Debounce(delay = 250) {
+    let timeoutReference = undefined;
+    return (target, propertyKey, descriptor) => {
+        const original = descriptor.value;
+        descriptor.value = function (...args) {
+            if (null != timeoutReference)
+                clearTimeout(timeoutReference);
+            timeoutReference = setTimeout(() => original.apply(this, args), delay);
+        };
+        return descriptor;
+    };
+}
+
+function Limit(rate = 250) {
+    let timeoutReference = undefined;
+    return (target, propertyKey, descriptor) => {
+        const original = descriptor.value;
+        descriptor.value = function (...args) {
+            if (null == timeoutReference) {
+                timeoutReference = setTimeout(() => {
+                    original.apply(this, args);
+                    timeoutReference = undefined;
+                }, rate);
+            }
+        };
+        return descriptor;
+    };
+}
+
+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']]
+            }] } });
+
+class BottomHitDirective {
+    constructor() {
+        this.offset = 1000;
+        this.onWindowBottomHit = new EventEmitter();
+        this.onElementBottomHit = new EventEmitter();
+    }
+    scrolled($event) {
+        this.elementScrollEvent($event);
+    }
+    windowScrolled($event) {
+        this.windowScrollEvent($event);
+    }
+    windowScrollEvent($event) {
+        const pageHeight = Math.max(document.body.scrollHeight, document.documentElement.scrollHeight, document.body.offsetHeight, document.documentElement.offsetHeight, document.body.clientHeight, document.documentElement.clientHeight);
+        const viewportHeight = document.documentElement.clientHeight;
+        const scrollPosition = window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0;
+        const distanceToBottom = pageHeight - (scrollPosition + viewportHeight);
+        if (distanceToBottom < this.offset) {
+            this.onWindowBottomHit.emit();
+        }
+    }
+    elementScrollEvent($event) {
+        const target = $event.target;
+        const scrollPosition = target.scrollHeight - target.scrollTop;
+        const offsetHeight = target.offsetHeight;
+        const isReachingBottom = (scrollPosition - offsetHeight) < this.offset;
+        if (isReachingBottom) {
+            this.onElementBottomHit.emit();
+        }
+    }
+}
+BottomHitDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.2", ngImport: i0, type: BottomHitDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+BottomHitDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.2", type: BottomHitDirective, selector: "[ddrBottomHit]", outputs: { onWindowBottomHit: "onWindowBottomHit", onElementBottomHit: "onElementBottomHit" }, host: { listeners: { "scroll": "scrolled($event)", "window:scroll": "windowScrolled($event)" } }, ngImport: i0 });
+__decorate([
+    Limit()
+], BottomHitDirective.prototype, "scrolled", null);
+__decorate([
+    Limit()
+], BottomHitDirective.prototype, "windowScrolled", null);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.2", ngImport: i0, type: BottomHitDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ddrBottomHit]'
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { onWindowBottomHit: [{
+                type: Output
+            }], onElementBottomHit: [{
+                type: Output
+            }], scrolled: [{
+                type: HostListener,
+                args: ['scroll', ['$event']]
+            }], windowScrolled: [{
+                type: HostListener,
+                args: ['window:scroll', ['$event']]
+            }] } });
+
+const DDR_STORAGE_PREFIX = new InjectionToken('DDR_STORAGE_PREFIX');
+const DDR_JWT_REFRESH_TOKEN_URL = new InjectionToken('DDR_JWT_REFRESH_TOKEN_URL');
+const DDR_LOGIN_PATH = new InjectionToken('DDR_LOGIN_PATH');
+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
+                    ]
+                }]
+        }] });
+
+// This service is based on the `ng2-cookies` package which sadly is not a service and does
+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]
+                    }] }];
+    } });
+
+class ObjectUtils {
+    static deepCopy(value) {
+        return JSON.parse(JSON.stringify(value));
+    }
+    static getProperty(o, propertyName) {
+        return o[propertyName];
+    }
+}
+
+class CollectionUtils {
+    /**
+     * Maps an array into a Map by a specific property which should be unique.
+     */
+    static mapByProperty(entries, property) {
+        const map = new Map();
+        for (const entry of entries) {
+            map.set(ObjectUtils.getProperty(entry, property), entry);
+        }
+        return map;
+    }
+    /**
+     * Maps an array into a Map by a specified property and aggregates them into an array.
+     */
+    static mapArrayByProperty(entries, property) {
+        var _a;
+        const map = new Map();
+        for (const entry of entries) {
+            const value = ObjectUtils.getProperty(entry, property);
+            const existingEntries = (_a = map.get(value)) !== null && _a !== void 0 ? _a : [];
+            existingEntries.push(entry);
+            map.set(value, existingEntries);
+        }
+        return map;
+    }
+}
+
+class TypeUtils {
+    static notNull(value, message = 'Value must not be null') {
+        if (null == value) {
+            throw new Error(message);
+        }
+        return value;
+    }
+}
+
+class ScrollService {
+    constructor(router, viewportScroller) {
+        this.router = router;
+        this.viewportScroller = viewportScroller;
+        this.scrollPositionMap = new Map();
+        this.router.events
+            .subscribe(e => {
+            if (e instanceof NavigationStart) {
+                this.scrollPositionMap.set(this.router.url, this.viewportScroller.getScrollPosition());
+            }
+        });
+    }
+    restore() {
+        const url = this.router.url;
+        if (this.scrollPositionMap.has(url)) {
+            /* Restore after timeout so rendering was completed */
+            setTimeout(() => {
+                let scrollPosition = this.scrollPositionMap.get(url);
+                if (null != scrollPosition)
+                    this.viewportScroller.scrollToPosition(scrollPosition);
+            }, 1);
+        }
+    }
+}
+ScrollService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.2", ngImport: i0, type: ScrollService, deps: [{ token: i1.Router }, { token: i2.ViewportScroller }], target: i0.ɵɵFactoryTarget.Injectable });
+ScrollService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.2", ngImport: i0, type: ScrollService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.2", ngImport: i0, type: ScrollService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: i2.ViewportScroller }]; } });
+
+class VisibilityService {
+    constructor() {
+        this.visibility$ = merge(fromEvent(document, 'visibilitychange'), fromEvent(window, 'focus'), fromEvent(window, 'blur')).pipe(debounceTime(50), startWith(true), map(() => document.hasFocus()), distinctUntilChanged(), shareReplay(1));
+    }
+    getVisibilityObservable() {
+        return this.visibility$;
+    }
+}
+VisibilityService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.2", ngImport: i0, type: VisibilityService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+VisibilityService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.2", ngImport: i0, type: VisibilityService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.2", ngImport: i0, type: VisibilityService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return []; } });
+
+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
+        }] });
+
+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;
+    }
+}
+
+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]
+                    }] }];
+    } });
+
+class JwtService {
+    constructor(storagePrefix) {
+        this.storagePrefix = storagePrefix;
+        /**
+         * The current token.
+         */
+        this.token = null;
+        /**
+         * The expiry of the current token.
+         */
+        this.tokenExpiry = null;
+    }
+    /**
+     * Sets the current token and a refresh token.
+     */
+    setTokens(token, refreshToken) {
+        this.setToken(token);
+        localStorage.setItem(this.getRefreshTokenStorageKey(), refreshToken);
+    }
+    /**
+     * Sets the current token.
+     */
+    setToken(token) {
+        this.token = token;
+        const decodedToken = JSON.parse(atob(token.split('.')[1]));
+        this.tokenExpiry = decodedToken.exp * 1000;
+        console.log('New refresh token, expiry', new Date(this.tokenExpiry));
+    }
+    /**
+     * Gets the current token.
+     */
+    getToken() {
+        return this.token;
+    }
+    /**
+     * Gets the refresh token.
+     */
+    getRefreshToken() {
+        return localStorage.getItem(this.getRefreshTokenStorageKey());
+    }
+    /**
+     * Checks if the current token expired.
+     */
+    isExpired() {
+        const now = new Date().getTime();
+        return null == this.tokenExpiry || this.tokenExpiry < now;
+    }
+    /**
+     * Checks if the current token is about to expire.
+     * @param expiryMs
+     */
+    isAboutToExpire(expiryMs = 60000) {
+        const now = new Date().getTime();
+        return null == this.tokenExpiry || this.tokenExpiry - expiryMs < now;
+    }
+    /**
+     * Clears all token information.
+     */
+    clear() {
+        this.token = null;
+        this.tokenExpiry = null;
+        localStorage.removeItem(this.getRefreshTokenStorageKey());
+    }
+    getRefreshTokenStorageKey() {
+        return this.storagePrefix + '.jwt.refresh_token';
+    }
+}
+JwtService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.2", ngImport: i0, type: JwtService, deps: [{ token: DDR_STORAGE_PREFIX }], target: i0.ɵɵFactoryTarget.Injectable });
+JwtService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.2", ngImport: i0, type: JwtService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.2", ngImport: i0, type: JwtService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: [DDR_STORAGE_PREFIX]
+                    }] }];
+    } });
+
+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: 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: JwtService }]; } });
+
+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: JwtService }, { token: i2$1.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: JwtService }, { type: i2$1.HttpClient }, { type: undefined, decorators: [{
+                        type: Inject,
+                        args: [DDR_JWT_REFRESH_TOKEN_URL]
+                    }] }];
+    } });
+
+/*
+ * Public API Surface of ngx-extensions
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { BottomHitDirective, CollectionUtils, CookieService, DDR_JWT_REFRESH_TOKEN_URL, DDR_LOGIN_PATH, DDR_STORAGE_PREFIX, DdrExtensionsModule, Debounce, JwtInterceptor, JwtRefreshTokenInterceptor, JwtService, LazyImageDirective, Limit, NumberUtils, ObjectUtils, RedirectToLoginInterceptor, ScrollService, StringUtils, TypeUtils, UrlInfo, VisibilityService, WithCredentialsInterceptor };
+//# sourceMappingURL=dontdrinkandroot-ngx-extensions.mjs.map