@dontdrinkandroot/ngx-extensions 0.0.5 → 0.2.0

package/esm2020/src/jwt/jwt.service.mjs

@@ -0,0 +1,82 @@
+import { Inject, Injectable } from '@angular/core';
+import { DDR_STORAGE_PREFIX } from '../ddr-extensions.module';
+import * as i0 from "@angular/core";
+export 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]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/methoddecorator/debounce.mjs

@@ -0,0 +1,13 @@
+export 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;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVib3VuY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbWV0aG9kZGVjb3JhdG9yL2RlYm91bmNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sVUFBVSxRQUFRLENBQUMsUUFBZ0IsR0FBRztJQUV4QyxJQUFJLGdCQUFnQixHQUF3QixTQUFTLENBQUE7SUFFckQsT0FBTyxDQUFDLE1BQWMsRUFBRSxXQUE0QixFQUFFLFVBQXdDLEVBQUUsRUFBRTtRQUM5RixNQUFNLFFBQVEsR0FBRyxVQUFVLENBQUMsS0FBSyxDQUFDO1FBQ2xDLFVBQVUsQ0FBQyxLQUFLLEdBQUcsVUFBVSxHQUFHLElBQVM7WUFDckMsSUFBSSxJQUFJLElBQUksZ0JBQWdCO2dCQUFFLFlBQVksQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDO1lBQzdELGdCQUFnQixHQUFHLFVBQVUsQ0FBQyxHQUFHLEVBQUUsQ0FBQyxRQUFRLENBQUMsS0FBSyxDQUFDLElBQUksRUFBRSxJQUFJLENBQUMsRUFBRSxLQUFLLENBQUMsQ0FBQztRQUMzRSxDQUFDLENBQUM7UUFFRixPQUFPLFVBQVUsQ0FBQztJQUN0QixDQUFDLENBQUM7QUFDTixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFRpbWVvdXQgPSBOb2RlSlMuVGltZW91dDtcblxuZXhwb3J0IGZ1bmN0aW9uIERlYm91bmNlKGRlbGF5OiBudW1iZXIgPSAyNTApOiBNZXRob2REZWNvcmF0b3JcbntcbiAgICBsZXQgdGltZW91dFJlZmVyZW5jZTogVGltZW91dCB8IHVuZGVmaW5lZCA9IHVuZGVmaW5lZFxuXG4gICAgcmV0dXJuICh0YXJnZXQ6IE9iamVjdCwgcHJvcGVydHlLZXk6IHN0cmluZyB8IHN5bWJvbCwgZGVzY3JpcHRvcjogVHlwZWRQcm9wZXJ0eURlc2NyaXB0b3I8YW55PikgPT4ge1xuICAgICAgICBjb25zdCBvcmlnaW5hbCA9IGRlc2NyaXB0b3IudmFsdWU7XG4gICAgICAgIGRlc2NyaXB0b3IudmFsdWUgPSBmdW5jdGlvbiAoLi4uYXJnczogYW55KSB7XG4gICAgICAgICAgICBpZiAobnVsbCAhPSB0aW1lb3V0UmVmZXJlbmNlKSBjbGVhclRpbWVvdXQodGltZW91dFJlZmVyZW5jZSk7XG4gICAgICAgICAgICB0aW1lb3V0UmVmZXJlbmNlID0gc2V0VGltZW91dCgoKSA9PiBvcmlnaW5hbC5hcHBseSh0aGlzLCBhcmdzKSwgZGVsYXkpO1xuICAgICAgICB9O1xuXG4gICAgICAgIHJldHVybiBkZXNjcmlwdG9yO1xuICAgIH07XG59XG4iXX0=

package/esm2020/src/methoddecorator/limit.mjs

@@ -0,0 +1,16 @@
+export 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;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGltaXQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbWV0aG9kZGVjb3JhdG9yL2xpbWl0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sVUFBVSxLQUFLLENBQUMsT0FBZSxHQUFHO0lBRXBDLElBQUksZ0JBQWdCLEdBQStCLFNBQVMsQ0FBQTtJQUU1RCxPQUFPLENBQUMsTUFBYyxFQUFFLFdBQTRCLEVBQUUsVUFBd0MsRUFBRSxFQUFFO1FBQzlGLE1BQU0sUUFBUSxHQUFHLFVBQVUsQ0FBQyxLQUFLLENBQUM7UUFDbEMsVUFBVSxDQUFDLEtBQUssR0FBRyxVQUFVLEdBQUcsSUFBUztZQUNyQyxJQUFJLElBQUksSUFBSSxnQkFBZ0IsRUFBRTtnQkFDMUIsZ0JBQWdCLEdBQUcsVUFBVSxDQUFDLEdBQUcsRUFBRTtvQkFDL0IsUUFBUSxDQUFDLEtBQUssQ0FBQyxJQUFJLEVBQUUsSUFBSSxDQUFDLENBQUM7b0JBQzNCLGdCQUFnQixHQUFHLFNBQVMsQ0FBQTtnQkFDaEMsQ0FBQyxFQUFFLElBQUksQ0FBQyxDQUFDO2FBQ1o7UUFDTCxDQUFDLENBQUM7UUFFRixPQUFPLFVBQVUsQ0FBQztJQUN0QixDQUFDLENBQUM7QUFDTixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGZ1bmN0aW9uIExpbWl0KHJhdGU6IG51bWJlciA9IDI1MCk6IE1ldGhvZERlY29yYXRvclxue1xuICAgIGxldCB0aW1lb3V0UmVmZXJlbmNlOiBOb2RlSlMuVGltZW91dCB8IHVuZGVmaW5lZCA9IHVuZGVmaW5lZFxuXG4gICAgcmV0dXJuICh0YXJnZXQ6IE9iamVjdCwgcHJvcGVydHlLZXk6IHN0cmluZyB8IHN5bWJvbCwgZGVzY3JpcHRvcjogVHlwZWRQcm9wZXJ0eURlc2NyaXB0b3I8YW55PikgPT4ge1xuICAgICAgICBjb25zdCBvcmlnaW5hbCA9IGRlc2NyaXB0b3IudmFsdWU7XG4gICAgICAgIGRlc2NyaXB0b3IudmFsdWUgPSBmdW5jdGlvbiAoLi4uYXJnczogYW55KSB7XG4gICAgICAgICAgICBpZiAobnVsbCA9PSB0aW1lb3V0UmVmZXJlbmNlKSB7XG4gICAgICAgICAgICAgICAgdGltZW91dFJlZmVyZW5jZSA9IHNldFRpbWVvdXQoKCkgPT4ge1xuICAgICAgICAgICAgICAgICAgICBvcmlnaW5hbC5hcHBseSh0aGlzLCBhcmdzKTtcbiAgICAgICAgICAgICAgICAgICAgdGltZW91dFJlZmVyZW5jZSA9IHVuZGVmaW5lZFxuICAgICAgICAgICAgICAgIH0sIHJhdGUpO1xuICAgICAgICAgICAgfVxuICAgICAgICB9O1xuXG4gICAgICAgIHJldHVybiBkZXNjcmlwdG9yO1xuICAgIH07XG59XG4iXX0=

package/esm2020/src/scroll/bottom-hit.directive.mjs

@@ -0,0 +1,60 @@
+import { __decorate } from "tslib";
+import { Directive, EventEmitter, HostListener, Output } from '@angular/core';
+import { Limit } from '../methoddecorator/limit';
+import * as i0 from "@angular/core";
+export 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']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/scroll/scroll.service.mjs

@@ -0,0 +1,38 @@
+import { NavigationStart } from '@angular/router';
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "@angular/common";
+export 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 }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/util/collection-utils.mjs

@@ -0,0 +1,27 @@
+import { ObjectUtils } from './object-utils';
+export 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) {
+        const map = new Map();
+        for (const entry of entries) {
+            const value = ObjectUtils.getProperty(entry, property);
+            const existingEntries = map.get(value) ?? [];
+            existingEntries.push(entry);
+            map.set(value, existingEntries);
+        }
+        return map;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/util/number-utils.mjs

@@ -0,0 +1,10 @@
+export class NumberUtils {
+    static getNextPowerOfTwo(value) {
+        let target = 2;
+        while (target < value) {
+            target *= 2;
+        }
+        return target;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibnVtYmVyLXV0aWxzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3V0aWwvbnVtYmVyLXV0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sT0FBTyxXQUFXO0lBRWIsTUFBTSxDQUFDLGlCQUFpQixDQUFDLEtBQWE7UUFFekMsSUFBSSxNQUFNLEdBQUcsQ0FBQyxDQUFDO1FBQ2YsT0FBTyxNQUFNLEdBQUcsS0FBSyxFQUFFO1lBQ25CLE1BQU0sSUFBSSxDQUFDLENBQUM7U0FDZjtRQUVELE9BQU8sTUFBTSxDQUFDO0lBQ2xCLENBQUM7Q0FDSiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjbGFzcyBOdW1iZXJVdGlsc1xue1xuICAgIHB1YmxpYyBzdGF0aWMgZ2V0TmV4dFBvd2VyT2ZUd28odmFsdWU6IG51bWJlcik6IG51bWJlclxuICAgIHtcbiAgICAgICAgbGV0IHRhcmdldCA9IDI7XG4gICAgICAgIHdoaWxlICh0YXJnZXQgPCB2YWx1ZSkge1xuICAgICAgICAgICAgdGFyZ2V0ICo9IDI7XG4gICAgICAgIH1cblxuICAgICAgICByZXR1cm4gdGFyZ2V0O1xuICAgIH1cbn1cbiJdfQ==

package/esm2020/src/util/object-utils.mjs

@@ -0,0 +1,9 @@
+export class ObjectUtils {
+    static deepCopy(value) {
+        return JSON.parse(JSON.stringify(value));
+    }
+    static getProperty(o, propertyName) {
+        return o[propertyName];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2JqZWN0LXV0aWxzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3V0aWwvb2JqZWN0LXV0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sT0FBTyxXQUFXO0lBRWIsTUFBTSxDQUFDLFFBQVEsQ0FBSSxLQUFRO1FBRTlCLE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7SUFDN0MsQ0FBQztJQUVNLE1BQU0sQ0FBQyxXQUFXLENBQXVCLENBQUksRUFBRSxZQUFlO1FBRWpFLE9BQU8sQ0FBQyxDQUFDLFlBQVksQ0FBQyxDQUFDO0lBQzNCLENBQUM7Q0FDSiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjbGFzcyBPYmplY3RVdGlsc1xue1xuICAgIHB1YmxpYyBzdGF0aWMgZGVlcENvcHk8VD4odmFsdWU6IFQpOiBUXG4gICAge1xuICAgICAgICByZXR1cm4gSlNPTi5wYXJzZShKU09OLnN0cmluZ2lmeSh2YWx1ZSkpO1xuICAgIH1cblxuICAgIHB1YmxpYyBzdGF0aWMgZ2V0UHJvcGVydHk8VCwgSyBleHRlbmRzIGtleW9mIFQ+KG86IFQsIHByb3BlcnR5TmFtZTogSyk6IFRbS11cbiAgICB7XG4gICAgICAgIHJldHVybiBvW3Byb3BlcnR5TmFtZV07XG4gICAgfVxufVxuIl19

package/esm2020/src/util/string-utils.mjs

@@ -0,0 +1,35 @@
+export 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;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/util/type-utils.mjs

@@ -0,0 +1,9 @@
+export class TypeUtils {
+    static notNull(value, message = 'Value must not be null') {
+        if (null == value) {
+            throw new Error(message);
+        }
+        return value;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZS11dGlscy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy91dGlsL3R5cGUtdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxPQUFPLFNBQVM7SUFFWCxNQUFNLENBQUMsT0FBTyxDQUFJLEtBQTJCLEVBQUUsVUFBa0Isd0JBQXdCO1FBRTVGLElBQUksSUFBSSxJQUFJLEtBQUssRUFBRTtZQUNmLE1BQU0sSUFBSSxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUM7U0FDNUI7UUFFRCxPQUFPLEtBQUssQ0FBQztJQUNqQixDQUFDO0NBQ0oiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY2xhc3MgVHlwZVV0aWxzXG57XG4gICAgcHVibGljIHN0YXRpYyBub3ROdWxsPFQ+KHZhbHVlOiBUIHwgbnVsbCB8IHVuZGVmaW5lZCwgbWVzc2FnZTogc3RyaW5nID0gJ1ZhbHVlIG11c3Qgbm90IGJlIG51bGwnKTogVFxuICAgIHtcbiAgICAgICAgaWYgKG51bGwgPT0gdmFsdWUpIHtcbiAgICAgICAgICAgIHRocm93IG5ldyBFcnJvcihtZXNzYWdlKTtcbiAgICAgICAgfVxuXG4gICAgICAgIHJldHVybiB2YWx1ZTtcbiAgICB9XG59XG4iXX0=

package/esm2020/src/visibility/visibility.service.mjs

@@ -0,0 +1,19 @@
+import { Injectable } from '@angular/core';
+import { fromEvent, merge } from 'rxjs';
+import { debounceTime, distinctUntilChanged, map, shareReplay, startWith } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+export 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 []; } });
+//# sourceMappingURL=data:application/json;base64,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