@lenne.tech/ng-base 13.1.0 → 13.3.0

package/fesm2015/lenne.tech-ng-base-src-lib-base.mjs

@@ -1,2470 +0,0 @@
-import * as i1$2 from 'apollo-angular';
-import { APOLLO_OPTIONS, gql } from 'apollo-angular';
-import { HttpLink } from 'apollo-angular/http';
-import * as i0 from '@angular/core';
-import { InjectionToken, Injectable, Inject, Directive, Input, Output, HostBinding, PLATFORM_ID, HostListener, Pipe, NgModule } from '@angular/core';
-import { BehaviorSubject, Observable, of, throwError } from 'rxjs';
-import { ApolloLink, split, concat } from '@apollo/client/core';
-import { InMemoryCache } from '@apollo/client/cache';
-import { WebSocketLink } from '@apollo/client/link/ws';
-import { getMainDefinition } from '@apollo/client/utilities';
-import { __awaiter } from 'tslib';
-import { isPlatformBrowser } from '@angular/common';
-import * as i1 from '@angular/platform-browser';
-import * as i1$1 from '@angular/router';
-import { buildClientSchema, getIntrospectionQuery } from 'graphql';
-import { map } from 'rxjs/operators';
-
-const BASE_MODULE_CONFIG = new InjectionToken('BASE_MODULE_CONFIG');
-
-/**
- * Storage service for local data storage
- */
-class StorageService {
-    /**
-     * Initializations
-     */
-    constructor(moduleConfig) {
-        this.moduleConfig = moduleConfig;
-        /**
-         * Storage
-         */
-        this.storage = null;
-        /**
-         * Prefix for storage keys
-         */
-        this.prefix = '';
-        // Set storage
-        const type = moduleConfig.storageType ? moduleConfig.storageType : 'local';
-        if (window[type + 'Storage']) {
-            this.storage = window[type + 'Storage'];
-        }
-        // Set prefix
-        this.prefix = '';
-        if (moduleConfig.prefix) {
-            this.prefix += moduleConfig.prefix + '_';
-        }
-        if (moduleConfig.version) {
-            this.prefix += moduleConfig.version + '_';
-        }
-    }
-    /**
-     * Save itemKeys
-     *
-     * If you want to save one item, use itemKeys and value parameters like these:
-     * save('KEY_OF_THE_ITEM', ITEM)
-     *
-     * If you want to save multiple items, use itemKeys only (value parameter will be ignored):
-     * save({'KEY_OF_ITEM_1': ITEM_1, 'KEY_OF_ITEM_2': ITEM_2, ...})
-     */
-    save(itemKeys, value) {
-        // Check local storage
-        if (!this.storage) {
-            return false;
-        }
-        // Check item keys and value
-        if (!itemKeys ||
-            (typeof itemKeys === 'object' && !Object.keys(itemKeys).length) ||
-            (typeof itemKeys === 'string' && value === undefined)) {
-            return false;
-        }
-        if (typeof itemKeys === 'object') {
-            for (const [itemKey, itemValue] of Object.entries(itemKeys)) {
-                this.storage.setItem(this.prefix + itemKey, JSON.stringify(itemValue));
-            }
-            return true;
-        }
-        this.storage.setItem(this.prefix + itemKeys, JSON.stringify(value));
-        return true;
-    }
-    /**
-     * Load items via key(s)
-     */
-    load(itemKeys) {
-        // Check local storage
-        if (!this.storage) {
-            return;
-        }
-        // Check item keys
-        if (!itemKeys || (Array.isArray(itemKeys) && !itemKeys.length)) {
-            return null;
-        }
-        if (Array.isArray(itemKeys)) {
-            const back = {};
-            itemKeys.forEach((itemKey) => {
-                const loadedItem = this.storage.getItem(this.prefix + itemKey);
-                if (loadedItem) {
-                    back[itemKey] = JSON.parse(loadedItem);
-                }
-                else {
-                    back[itemKey] = null;
-                }
-            });
-            return back;
-        }
-        let value = this.storage.getItem(this.prefix + itemKeys);
-        if (value) {
-            value = JSON.parse(value);
-        }
-        return value;
-    }
-    /**
-     * Remove item from storage
-     *
-     * @param itemKeys keys or key to remove
-     */
-    remove(itemKeys) {
-        // Check local storage
-        if (!this.storage) {
-            return false;
-        }
-        if (Array.isArray(itemKeys)) {
-            itemKeys.forEach((key) => {
-                this.storage.removeItem(this.prefix + key);
-            });
-            return true;
-        }
-        this.storage.removeItem(this.prefix + itemKeys);
-        return true;
-    }
-    /**
-     * Clear local storage
-     */
-    reset() {
-        this.storage.clear();
-    }
-}
-StorageService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: StorageService, deps: [{ token: BASE_MODULE_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable });
-StorageService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: StorageService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: StorageService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: function () {
-        return [{ type: undefined, decorators: [{
-                        type: Inject,
-                        args: [BASE_MODULE_CONFIG]
-                    }] }];
-    } });
-
-class WsService {
-    reconnect() {
-        var _a, _b;
-        (_a = this.client) === null || _a === void 0 ? void 0 : _a.close();
-        (_b = this.client) === null || _b === void 0 ? void 0 : _b.connect();
-    }
-}
-WsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: WsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-WsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: WsService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: WsService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }] });
-
-/**
- * Authentication service
- */
-class AuthService {
-    /**
-     * Constructor
-     */
-    constructor(moduleConfig, storageService, wsService) {
-        this.moduleConfig = moduleConfig;
-        this.storageService = storageService;
-        this.wsService = wsService;
-        // Subjects
-        this._currentUser = new BehaviorSubject(null);
-        this._token = new BehaviorSubject(null);
-        this.token = this.storageService.load('token');
-        this.currentUser = this.storageService.load('currentUser');
-    }
-    /**
-     * Logout
-     */
-    logout() {
-        this.storageService.remove(['token', 'currentUser']);
-        this.currentUser = null;
-        this.token = null;
-    }
-    // #################################################################
-    // Current User
-    // #################################################################
-    get currentUser() {
-        return this._currentUser.value;
-    }
-    set currentUser(user) {
-        this._currentUser.next(user);
-        this.storageService.save('currentUser', user);
-    }
-    get currentUserObservable() {
-        return this._currentUser.asObservable();
-    }
-    // #################################################################
-    // Token
-    // #################################################################
-    get token() {
-        return this._token.value;
-    }
-    set token(token) {
-        this._token.next(token);
-        this.storageService.save('token', token);
-        this.wsService.reconnect();
-    }
-    get tokenObservable() {
-        return this._token.asObservable();
-    }
-}
-AuthService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: AuthService, deps: [{ token: BASE_MODULE_CONFIG }, { token: StorageService }, { token: WsService }], target: i0.ɵɵFactoryTarget.Injectable });
-AuthService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: AuthService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: AuthService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: function () {
-        return [{ type: undefined, decorators: [{
-                        type: Inject,
-                        args: [BASE_MODULE_CONFIG]
-                    }] }, { type: StorageService }, { type: WsService }];
-    } });
-
-/**
- * Factory for apollo-angular options
- */
-function apolloOptionsFactory(baseModuleConfig, httpLink, authService, wsService) {
-    const links = [];
-    const defaultUrl = 'api.' + window.location.href + '/graphql';
-    const http = httpLink.create({
-        uri: baseModuleConfig.apiUrl ? baseModuleConfig.apiUrl : 'https://' + defaultUrl,
-    });
-    const authMiddleware = new ApolloLink((operation, forward) => {
-        const headers = {};
-        if (localStorage) {
-            const token = authService.token || null;
-            if (token) {
-                headers.Authorization = 'Bearer ' + token;
-            }
-            operation.setContext(() => ({ headers }));
-        }
-        return forward(operation);
-    });
-    if (baseModuleConfig.wsUrl) {
-        const wsLink = new WebSocketLink({
-            uri: baseModuleConfig.wsUrl,
-            options: {
-                reconnect: true,
-                connectionParams: () => ({
-                    Authorization: authService.token ? 'Bearer ' + authService.token : undefined,
-                }),
-            },
-        });
-        // Set client for reconnection on logout/login
-        wsService.client = wsLink.subscriptionClient;
-        // using the ability to split links, you can send data to each link
-        // depending on what kind of operation is being sent
-        links.push(split(
-        // split based on operation type
-        ({ query }) => {
-            // @ts-ignore
-            const { kind, operation } = getMainDefinition(query);
-            return kind === 'OperationDefinition' && operation === 'subscription';
-        }, wsLink, concat(authMiddleware, http)));
-    }
-    else {
-        links.push(http);
-        links.push(authMiddleware);
-    }
-    return {
-        link: ApolloLink.from(links),
-        cache: new InMemoryCache(),
-        defaultOptions: {
-            query: {
-                fetchPolicy: 'network-only',
-            },
-        },
-    };
-}
-
-/**
- * Directive vor context menu
- * See https://stackblitz.com/edit/angular-custom-context-menu
- */
-class ContextMenuDirective {
-    constructor(el) {
-        this.el = el;
-        this.xGap = 0;
-        this.yGap = 0;
-        this.overflowSpace = 10;
-        this.selectors = '*';
-        this.clickedElement = null;
-        this.previousDisplayStatus = null;
-    }
-    ngOnInit() {
-        if (this.ltContextMenu) {
-            this.previousDisplayStatus = this.ltContextMenu.style.display;
-        }
-        // Add a click listener to the window,
-        // so that we can close the context menu on left click
-        window.addEventListener('click', () => {
-            this.showContextMenu(null, false);
-        });
-        // Close context menu when escape is pressed
-        window.addEventListener('keydown', (e) => {
-            if (e.code === 'Escape') {
-                this.showContextMenu(null, false);
-            }
-        });
-        // Add an event listener to listen to the 'contextmenu' event
-        this.el.nativeElement.addEventListener('contextmenu', (e) => {
-            // Prevent the default context menu to popup
-            if (e.preventDefault) {
-                e.preventDefault();
-            }
-            // Shows our own context menu
-            this.showContextMenu(e, true);
-        });
-    }
-    // Shows or hides our custom context menu, which is specified as a input
-    showContextMenu(event, show) {
-        var _a;
-        const cm = this.ltContextMenu;
-        if (cm) {
-            // Try to open context menu
-            if (show && event && event instanceof MouseEvent) {
-                // Get valid clicked structureElement
-                const clickedElement = (_a = event === null || event === void 0 ? void 0 : event.target) === null || _a === void 0 ? void 0 : _a.closest(this.selectors);
-                if (clickedElement) {
-                    // Set clicked structureElement
-                    this.clickedElement = clickedElement;
-                    setTimeout(() => {
-                        // Set display status
-                        cm.style.display = 'block';
-                        // Calculate top position
-                        let top = event.y + this.yGap;
-                        if (top + cm.offsetHeight + 10 > document.documentElement.clientHeight) {
-                            top = document.documentElement.clientHeight - cm.offsetHeight - this.overflowSpace;
-                        }
-                        // Calculate left position
-                        let left = event.x + this.xGap;
-                        if (left + cm.offsetWidth + 10 > document.documentElement.clientWidth) {
-                            left = document.documentElement.clientWidth - cm.offsetWidth - this.overflowSpace;
-                        }
-                        // Set position
-                        cm.style.top = top + 'px';
-                        cm.style.left = left + 'px';
-                        // Show
-                        cm.style.opacity = '1.0';
-                        cm.style['pointer-events'] = 'auto';
-                    }, 1);
-                    return;
-                }
-            }
-            // Close context menu
-            this.clickedElement = null;
-            if (this.previousDisplayStatus) {
-                cm.style.display = this.previousDisplayStatus;
-            }
-            cm.style.opacity = '0.01';
-            cm.style['pointer-events'] = 'none';
-        }
-    }
-}
-ContextMenuDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: ContextMenuDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
-ContextMenuDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.0", type: ContextMenuDirective, selector: "[ltContextMenu]", inputs: { contextMenuData: "contextMenuData", ltContextMenu: "ltContextMenu", xGap: "xGap", yGap: "yGap", overflowSpace: "overflowSpace", selectors: "selectors" }, outputs: { clickedElement: "clickedElement" }, exportAs: ["contextMenuData"], ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: ContextMenuDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[ltContextMenu]',
-                    exportAs: 'contextMenuData',
-                }]
-        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { contextMenuData: [{
-                type: Input
-            }], ltContextMenu: [{
-                type: Input
-            }], xGap: [{
-                type: Input
-            }], yGap: [{
-                type: Input
-            }], overflowSpace: [{
-                type: Input
-            }], selectors: [{
-                type: Input
-            }], clickedElement: [{
-                type: Output
-            }] } });
-
-/**
- * Directive for lazy loading images
- */
-class LazyLoadDirective {
-    constructor(el) {
-        this.el = el;
-        this.srcAttr = null;
-    }
-    ngAfterViewInit() {
-        this.canLazyLoad() ? this.lazyLoadImage() : this.loadImage();
-    }
-    canLazyLoad() {
-        return window && 'IntersectionObserver' in window;
-    }
-    lazyLoadImage() {
-        const obs = new IntersectionObserver((entries) => {
-            entries.forEach(({ isIntersecting }) => {
-                if (isIntersecting) {
-                    this.loadImage();
-                    obs.unobserve(this.el.nativeElement);
-                }
-            });
-        });
-        obs.observe(this.el.nativeElement);
-    }
-    loadImage() {
-        this.srcAttr = this.src;
-    }
-}
-LazyLoadDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: LazyLoadDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
-LazyLoadDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.0", type: LazyLoadDirective, selector: "img[ltLazyLoad]", inputs: { src: "src" }, host: { properties: { "attr.src": "this.srcAttr" } }, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: LazyLoadDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: 'img[ltLazyLoad]',
-                }]
-        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { srcAttr: [{
-                type: HostBinding,
-                args: ['attr.src']
-            }], src: [{
-                type: Input
-            }] } });
-
-/**
- * Helper class
- */
-class Helper {
-    /**
-     * Simple filter function for plain objects
-     */
-    static filter(objects, filter) {
-        return ((objects === null || objects === void 0 ? void 0 : objects.filter((element) => {
-            for (const [key, value] of Object.entries(filter)) {
-                if (Array.isArray(element[key])) {
-                    for (const item of element[key]) {
-                        if (!element[key].includs(value)) {
-                            return false;
-                        }
-                    }
-                }
-                else if (element[key] !== value) {
-                    return false;
-                }
-            }
-            return true;
-        })) || []);
-    }
-    /**
-     * Convert to a url/uri conform string
-     * Only:
-     * - lower case
-     * - chars, numbers and hyphens
-     */
-    static urlString(str, options = {}) {
-        // Config
-        const config = Object.assign({ allowAll: false }, options);
-        // To string
-        str = str + '';
-        // Trim
-        str = str.trim();
-        // Lower case
-        str = str.toLowerCase();
-        if (!config.allowAll) {
-            // Replace spaces
-            str = str.trim().replace(/\s+/g, '-');
-            // Replace some special chars
-            str = str.replace('ä', 'ae');
-            str = str.replace('ö', 'oe');
-            str = str.replace('ü', 'ue');
-            str = str.replace('ß', 'ss');
-            // Remove other special chars
-            str = str.replace(/[^a-zA-Z0-9-]/g, '');
-        }
-        // Return url conform string
-        return encodeURI(str);
-    }
-    /**
-     * Simple map function
-     */
-    static map(source, target, options = {}) {
-        // Set config
-        const config = Object.assign({ funcAllowed: false, dateStringToDate: true }, options);
-        // Check source
-        if (!source || typeof source !== 'object' || Array.isArray(source)) {
-            return target;
-        }
-        // Update properties
-        for (const key of Object.keys(target)) {
-            if (source[key] !== undefined && (config.funcAllowed || typeof (source[key] !== 'function'))) {
-                if (typeof source[key] === 'string' && config.dateStringToDate) {
-                    if (Array.isArray(config.dateStringToDate)) {
-                        if (config.dateStringToDate.includes(key)) {
-                            target[key] = Helper.parseDate(source[key]);
-                        }
-                    }
-                    else {
-                        target[key] = Helper.parseDate(source[key]);
-                    }
-                }
-                else {
-                    target[key] = source[key];
-                }
-            }
-        }
-        // Return target
-        return target;
-    }
-    /**
-     * Create Object or Objects of specified type with specified data
-     */
-    static maps(data, targetClass) {
-        // Check data
-        if (!data || typeof data !== 'object') {
-            return undefined;
-        }
-        // Check array
-        if (!Array.isArray(data)) {
-            data = [data];
-        }
-        // Map
-        return data.map((item) => {
-            return targetClass.map(item);
-        });
-    }
-    /**
-     * Get plain parameter
-     */
-    static getPlainParameter(parameter) {
-        var _a, _b, _c;
-        if (!parameter) {
-            return parameter;
-        }
-        return (_c = (_b = (_a = parameter === null || parameter === void 0 ? void 0 : parameter.split('?')) === null || _a === void 0 ? void 0 : _a.shift()) === null || _b === void 0 ? void 0 : _b.split('#')) === null || _c === void 0 ? void 0 : _c.shift();
-    }
-    /**
-     * Get ID of an url parameter
-     */
-    static getParameterId(parameter) {
-        var _a;
-        if (!parameter) {
-            return parameter;
-        }
-        return (_a = Helper.getPlainParameter(parameter)) === null || _a === void 0 ? void 0 : _a.split('-').pop();
-    }
-    /**
-     * Delay
-     */
-    static delay(ms) {
-        const promise = new Promise((resolve) => setTimeout(resolve, ms));
-        return promise;
-    }
-    /**
-     * Deep freeze
-     * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze#What_is_shallow_freeze
-     */
-    static deepFreeze(object, preparedObjects = []) {
-        // Prevent infinit regress
-        if (preparedObjects.includes(object)) {
-            return object;
-        }
-        preparedObjects.push(object);
-        // Retrieve the property names defined on object
-        const propNames = Object.getOwnPropertyNames(object);
-        // Freeze properties before freezing self
-        for (const name of propNames) {
-            const value = object[name];
-            if (value && typeof value === 'object') {
-                Helper.deepFreeze(value, preparedObjects);
-            }
-        }
-        return Object.freeze(object);
-    }
-    /**
-     * Generates an unique identifier with 24 characters
-     */
-    static getUID() {
-        let dt = new Date().getTime();
-        const uuid = 'xxxxxxxxxxxxxxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
-            // eslint-disable-next-line no-bitwise
-            const r = (dt + Math.random() * 16) % 16 | 0;
-            dt = Math.floor(dt / 16);
-            // eslint-disable-next-line no-bitwise
-            return (c === 'x' ? r : (r & 0x3) | 0x8).toString(16);
-        });
-        return uuid;
-    }
-    /**
-     * Parse date string to date object
-     */
-    static parseDate(dateString) {
-        const reISO = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*))(?:Z|(\+|-)([\d|:]*))?$/;
-        const reMsAjax = /^\/Date\((d|-|.*)\)[\/|\\]$/;
-        if (typeof dateString === 'string') {
-            const isoExec = reISO.exec(dateString);
-            if (isoExec) {
-                return new Date(dateString);
-            }
-            const msAjaxExec = reMsAjax.exec(dateString);
-            if (msAjaxExec) {
-                const cleaned = msAjaxExec[1].split(/[-+,.]/);
-                return new Date(cleaned[0] ? +cleaned[0] : 0 - +cleaned[1]);
-            }
-        }
-        return dateString;
-    }
-    /**
-     * Get browser name and version
-     */
-    static getBrowser() {
-        const userAgent = navigator.userAgent;
-        let data = userAgent.match(/(opera|chrome|safari|firefox|msie|trident(?=\/))\/?\s*(\d+)/i) || [];
-        let version;
-        if (/trident/i.test(data[1])) {
-            version = /\brv[ :]+(\d+)/g.exec(userAgent) || [];
-            return { name: 'IE', version: version[1] || '' };
-        }
-        if (data[1] === 'Chrome') {
-            version = userAgent.match(/\bOPR|Edge\/(\d+)/);
-            if (version != null) {
-                return { name: 'Opera', version: version[1] };
-            }
-        }
-        data = data[2] ? [data[1], data[2]] : [navigator.appName, navigator.appVersion, '-?'];
-        version = userAgent.match(/version\/(\d+)/i);
-        if (version !== null) {
-            data.splice(1, 1, version[1]);
-        }
-        return {
-            name: data[0],
-            version: data[1],
-        };
-    }
-    /**
-     * Whether first parameter is a deep subset of second parameter
-     * Hint: functions will be ignored
-     */
-    static isSubset(a, b) {
-        // Equal
-        if (a === b) {
-            return true;
-        }
-        // Different type
-        if (typeof a !== typeof b) {
-            return false;
-        }
-        // Process array
-        if (Array.isArray(a)) {
-            for (const [key, value] of Object.entries(a)) {
-                if (Helper.isSubset(value, b[key])) {
-                    return false;
-                }
-            }
-            return true;
-        }
-        // Process object
-        if (typeof a === 'object') {
-            const plain = JSON.parse(JSON.stringify(a));
-            for (const [key, value] of Object.entries(plain)) {
-                if (Helper.isSubset(value, b[key])) {
-                    return false;
-                }
-            }
-            return true;
-        }
-        // Else
-        return true;
-    }
-    /**
-     * Whether parameters are equal (have equal properties)
-     * Hint: functions will be ignored
-     */
-    static isEqual(a, b) {
-        return Helper.isSubset(a, b) && Helper.isSubset(b, a);
-    }
-    /**
-     * First level difference of two objects
-     * Hint: functions will be ignored and when an array or an object is different the hole array or object will used as property value
-     *
-     * @returns Record<string, any> Object with properties from first object
-     */
-    static getDiff(a, b, clone = true) {
-        const result = {};
-        let firstObject = a;
-        if (clone) {
-            firstObject = JSON.parse(JSON.stringify(a));
-        }
-        for (const [key, value] of Object.entries(firstObject)) {
-            if (!Helper.isSubset(value, b[key])) {
-                result[key] = value;
-            }
-        }
-        return result;
-    }
-    /**
-     * Check if propertie is type of HTMLCollection or NodeList
-     * See https://stackoverflow.com/a/7238344
-     *
-     * @param nodes
-     */
-    static isNodeList(nodes) {
-        try {
-            const stringRepr = Object.prototype.toString.call(nodes);
-            return (typeof nodes === 'object' &&
-                /^\[object (HTMLCollection|NodeList|Object)\]$/.test(stringRepr) &&
-                typeof nodes.length === 'number' &&
-                (nodes.length === 0 || (typeof nodes[0] === 'object' && nodes[0].nodeType > 0)));
-        }
-        catch (e) {
-            return false;
-        }
-    }
-}
-
-/**
- * Image service
- */
-class ImageService {
-    /**
-     * Preaload images (for lazy handling)
-     *
-     * @param options
-     * @protected
-     */
-    preLoadImages(options) {
-        // Init configuration
-        const config = Object.assign({ doneFunnction: undefined, elements: document, regExp: undefined }, options);
-        return new Promise((resolve) => {
-            var _a;
-            // Convert element(s) into array
-            if (!Array.isArray(config.elements)) {
-                // NodeList or HTMLCollection
-                if (Helper.isNodeList(config.elements)) {
-                    config.elements = Array.from(config.elements);
-                }
-                // Single element
-                else {
-                    config.elements = [config.elements];
-                }
-            }
-            // Init loading
-            const promises = [];
-            // Get all images
-            let images = [];
-            config.elements.forEach((element) => {
-                images = images.concat(Array.from(element.getElementsByTagName('img')));
-            });
-            // Prepare images
-            for (let image of images) {
-                const src = image.getAttribute('src');
-                // Check if changes are necessary and possible
-                if ((image.complete && image.naturalHeight !== 0) || // already laoded
-                    !src || // Image has no src
-                    ((_a = config.regExp) === null || _a === void 0 ? void 0 : _a.test(src)) // Test if src matches regular expression
-                ) {
-                    continue;
-                }
-                // Replace lazy loading image with immediately loading image
-                if (image.getAttribute('loading') === 'lazy') {
-                    const newImage = document.createElement('img');
-                    Array.from(image.attributes).forEach((attr) => {
-                        if (attr.name !== 'loading' && attr.name !== 'src') {
-                            newImage.setAttribute(attr.name, attr.value);
-                        }
-                    });
-                    image.replaceWith(newImage);
-                    image = newImage;
-                }
-                // Wait for laoding
-                promises.push(this.loadImage(image, src));
-            }
-            // Wait until all images loaded
-            Promise.all(promises)
-                .catch((e) => console.error('Error during image loading', e))
-                .finally(() => __awaiter(this, void 0, void 0, function* () {
-                // Return result
-                let result;
-                if (config.doneFunnction) {
-                    result = yield config.doneFunction();
-                }
-                resolve(result);
-            }));
-        });
-    }
-    /**
-     * Load image for image element
-     *
-     * @param imageElement
-     * @param src
-     * @protected
-     */
-    loadImage(imageElement, src) {
-        return __awaiter(this, void 0, void 0, function* () {
-            src = src || imageElement.src;
-            return new Promise((resolve, reject) => {
-                imageElement.onload = () => resolve(imageElement);
-                imageElement.onerror = reject;
-                imageElement.src = src;
-            });
-        });
-    }
-}
-ImageService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: ImageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-ImageService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: ImageService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: ImageService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }] });
-
-/**
- * Set same height (maximum) to different elements
- */
-class MatchHeightDirective {
-    constructor(el, imageService, platformId) {
-        this.el = el;
-        this.imageService = imageService;
-        // Replace lazy loading images with immediate loading images
-        this.loadImages = true;
-        this.isBrowser = isPlatformBrowser(platformId);
-    }
-    onResize() {
-        this.matchHeight(this.el.nativeElement, this.ltMatchHeight);
-    }
-    ngOnInit() {
-        this.matchHeight(this.el.nativeElement, this.ltMatchHeight);
-    }
-    matchHeight(parent, target) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!parent) {
-                return;
-            }
-            let classNames;
-            if (!Array.isArray(target)) {
-                classNames = [target];
-            }
-            else {
-                classNames = target;
-            }
-            for (const className of classNames) {
-                // find all child structureElements with the selected class name
-                const children = parent.getElementsByClassName(className);
-                if (!children || children.length < 2) {
-                    continue;
-                }
-                // Load images of children
-                if (this.loadImages) {
-                    yield this.imageService.preLoadImages({ elements: children });
-                }
-                // reset all children height
-                Array.from(children).forEach((element) => {
-                    element.style.height = 'initial';
-                });
-                // get all the child structureElements heights
-                const itemHeights = Array.from(children).map((element) => {
-                    if (element.getBoundingClientRect) {
-                        return element.getBoundingClientRect().height;
-                    }
-                    return 0;
-                });
-                // find out the tallest one
-                const maxHeight = itemHeights.reduce((prev, curr) => (curr > prev ? curr : prev), 0);
-                // update the child structureElements height to the tallest one
-                Array.from(children).forEach((element) => (element.style.height = `${maxHeight}px`));
-            }
-        });
-    }
-}
-MatchHeightDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: MatchHeightDirective, deps: [{ token: i0.ElementRef }, { token: ImageService }, { token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Directive });
-MatchHeightDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.0", type: MatchHeightDirective, selector: "[ltMatchHeight]", inputs: { ltMatchHeight: "ltMatchHeight", loadImages: "loadImages" }, host: { listeners: { "window:resize": "onResize()" } }, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: MatchHeightDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[ltMatchHeight]',
-                }]
-        }], ctorParameters: function () {
-        return [{ type: i0.ElementRef }, { type: ImageService }, { type: undefined, decorators: [{
-                        type: Inject,
-                        args: [PLATFORM_ID]
-                    }] }];
-    }, propDecorators: { ltMatchHeight: [{
-                type: Input
-            }], loadImages: [{
-                type: Input
-            }], onResize: [{
-                type: HostListener,
-                args: ['window:resize']
-            }] } });
-
-/**
- * Reszise detection
- * (inpsired by: https://stackblitz.com/edit/angular-resizable)
- */
-class ResizableDirective {
-    constructor(el) {
-        this.el = el;
-        this.resizableGrabWidth = 8;
-        this.resizableMinWidth = 10;
-        this.dragging = false;
-    }
-    ngOnInit() {
-        this.addListenerToDocument();
-        this.addListenerToElement();
-    }
-    mouseMoveG(evt) {
-        if (!this.dragging) {
-            return;
-        }
-        this.newWidth(evt.clientX - this.el.nativeElement.offsetLeft);
-        evt.stopPropagation();
-    }
-    newWidth(wid) {
-        const result = Math.max(this.resizableMinWidth, wid);
-        this.el.nativeElement.style.width = result + 'px';
-    }
-    mouseDown(evt) {
-        if (this.inDragRegion(evt)) {
-            this.dragging = true;
-            this.preventGlobalMouseEvents();
-            evt.stopPropagation();
-        }
-    }
-    restoreGlobalMouseEvents() {
-        document.body.style['pointer-events'] = 'auto';
-    }
-    mouseUpG(evt) {
-        if (!this.dragging) {
-            return;
-        }
-        this.restoreGlobalMouseEvents();
-        this.dragging = false;
-        evt.stopPropagation();
-    }
-    mouseMove(evt) {
-        if (this.inDragRegion(evt) || this.dragging) {
-            this.el.nativeElement.style.cursor = 'col-resize';
-        }
-        else {
-            this.el.nativeElement.style.cursor = 'default';
-        }
-    }
-    preventGlobalMouseEvents() {
-        document.body.style['pointer-events'] = 'none';
-    }
-    inDragRegion(evt) {
-        return this.el.nativeElement.clientWidth - evt.clientX + this.el.nativeElement.offsetLeft < this.resizableGrabWidth;
-    }
-    addListenerToDocument() {
-        document.addEventListener('mousemove', (e) => {
-            this.mouseMoveG(e);
-        }, true);
-        document.addEventListener('mouseup', (e) => {
-            this.mouseUpG(e);
-        }, true);
-    }
-    addListenerToElement() {
-        this.el.nativeElement.addEventListener('mousedown', (e) => {
-            this.mouseDown(e);
-        }, true);
-        this.el.nativeElement.addEventListener('mousemove', (e) => {
-            this.mouseMove(e);
-        }, true);
-    }
-}
-ResizableDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: ResizableDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
-ResizableDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.0", type: ResizableDirective, selector: "[ltResizable]", inputs: { resizableGrabWidth: "resizableGrabWidth", resizableMinWidth: "resizableMinWidth" }, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: ResizableDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[ltResizable]',
-                }]
-        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { resizableGrabWidth: [{
-                type: Input
-            }], resizableMinWidth: [{
-                type: Input
-            }] } });
-
-/**
- * Truncate string with ellipses
- */
-class EllipsesPipe {
-    transform(value, limit) {
-        if (!value) {
-            return null;
-        }
-        return value.length > limit ? value.substring(0, limit) + '...' : value;
-    }
-}
-EllipsesPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: EllipsesPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
-EllipsesPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: EllipsesPipe, name: "ltEllipses" });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: EllipsesPipe, decorators: [{
-            type: Pipe,
-            args: [{
-                    name: 'ltEllipses',
-                }]
-        }] });
-
-/**
- * Declarate html as safe
- */
-class SafeHtmlPipe {
-    constructor(sanitized) {
-        this.sanitized = sanitized;
-    }
-    transform(value) {
-        return this.sanitized.bypassSecurityTrustHtml(value);
-    }
-}
-SafeHtmlPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: SafeHtmlPipe, deps: [{ token: i1.DomSanitizer }], target: i0.ɵɵFactoryTarget.Pipe });
-SafeHtmlPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: SafeHtmlPipe, name: "ltSafeHtml" });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: SafeHtmlPipe, decorators: [{
-            type: Pipe,
-            args: [{ name: 'ltSafeHtml' }]
-        }], ctorParameters: function () { return [{ type: i1.DomSanitizer }]; } });
-
-// Imported and exported elements
-const elements = [
-    // Directives
-    ContextMenuDirective,
-    LazyLoadDirective,
-    MatchHeightDirective,
-    ResizableDirective,
-    // Pipes
-    EllipsesPipe,
-    SafeHtmlPipe,
-];
-/**
- * Base module
- */
-class BaseModule {
-    /**
-     * Set configuration of base module in root module of the app
-     */
-    static forRoot(baseModuleConfig = {}, AppAuthService) {
-        // Default config
-        const config = Object.assign({ apiUrl: 'localhost:3000', authGuardRedirectUrl: '/auth', logging: false, version: null, prefix: null, scrollDetectionOffset: 200, scrollOffset: 100, storageType: 'local' }, baseModuleConfig);
-        // Prepare providers
-        const providers = [
-            {
-                provide: BASE_MODULE_CONFIG,
-                useValue: baseModuleConfig,
-            },
-        ];
-        // Add apollo features if API URL is set
-        if (baseModuleConfig.apiUrl) {
-            providers.push({
-                provide: APOLLO_OPTIONS,
-                useFactory: apolloOptionsFactory,
-                deps: [BASE_MODULE_CONFIG, HttpLink, AppAuthService ? AppAuthService : AuthService, WsService],
-            });
-        }
-        else if (config.logging) {
-            console.log('apiUrl is missing, ApolloLink is not initialized');
-        }
-        // Return root module
-        return {
-            ngModule: BaseModule,
-            providers,
-        };
-    }
-}
-BaseModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: BaseModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-BaseModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: BaseModule, declarations: [
-        // Directives
-        ContextMenuDirective,
-        LazyLoadDirective,
-        MatchHeightDirective,
-        ResizableDirective,
-        // Pipes
-        EllipsesPipe,
-        SafeHtmlPipe
-    ], exports: [
-        // Directives
-        ContextMenuDirective,
-        LazyLoadDirective,
-        MatchHeightDirective,
-        ResizableDirective,
-        // Pipes
-        EllipsesPipe,
-        SafeHtmlPipe
-    ] });
-BaseModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: BaseModule });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: BaseModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    declarations: elements,
-                    exports: elements,
-                }]
-        }] });
-
-/**
- * Standard class
- * Other classes should extend the Standard class, if they offer own functions
- * If the extended class uses object properties with own map functions, it should implement its own map function
- */
-class Standard {
-    /**
-     * Static map method
-     */
-    static map(data, item = new this()) {
-        return item.map(data);
-    }
-    /**
-     * Map data into an object
-     */
-    map(data) {
-        return Helper.map(data, this);
-    }
-    /**
-     * Clone object (and map additional data)
-     */
-    clone(mapData) {
-        const current = JSON.parse(JSON.stringify(this));
-        if (mapData) {
-            Object.assign(current, mapData);
-        }
-        return new this.constructor().map(current);
-    }
-    /**
-     * Compare this with another object
-     * Hint: functions will be ignored and when an array or an object is different the hole array or object will used as property value
-     *
-     * @return Record<string, any> with properties of this object which are different
-     */
-    getDiff(compare, clone = true) {
-        return Helper.getDiff(this, compare, clone);
-    }
-}
-
-/**
- * User class
- */
-class BasicUser extends Standard {
-    constructor() {
-        super(...arguments);
-        this.id = undefined;
-        this.email = undefined;
-        this.firstName = undefined;
-        this.lastName = undefined;
-        this.roles = [];
-        this.username = undefined;
-    }
-    // ===================================================================================================================
-    // Methods
-    // ===================================================================================================================
-    /**
-     * Mapping
-     */
-    map(data) {
-        Helper.map(data, this);
-        return this;
-    }
-    /**
-     * Checks whether the user has at least one of the required roles
-     */
-    hasRole(roles) {
-        if (typeof roles === 'string') {
-            roles = [roles];
-        }
-        if (!this.roles || this.roles.length < 1) {
-            return false;
-        }
-        return !roles || roles.length < 1 ? true : this.roles.some((role) => roles.includes(role));
-    }
-    /**
-     * Checks whether the user has all required roles
-     */
-    hasAllRoles(roles) {
-        if (typeof roles === 'string') {
-            roles = [roles];
-        }
-        if (!this.roles || this.roles.length < 1) {
-            return false;
-        }
-        return !roles ? true : roles.every((role) => this.roles.includes(role));
-    }
-}
-
-/**
- * GraphQL enum
- */
-class GraphQLEnum {
-    constructor(value) {
-        this.value = value;
-    }
-}
-
-/**
- * GraphQL type
- */
-class GraphQLType extends Standard {
-    constructor() {
-        super(...arguments);
-        this.type = '';
-        this.isEnum = false;
-        this.validEnums = [];
-    }
-}
-
-/**
- * GraphQL meta
- */
-class GraphQLMeta {
-    /**
-     * Integrate schema
-     */
-    constructor(schema) {
-        this.schema = schema;
-        // Frozen caches
-        this.args = {};
-        this.fields = {};
-        if (!schema) {
-            throw Error('Missing schema');
-        }
-    }
-    /**
-     * Get arguments of GraphQL function
-     */
-    getArgs(functionName, options = {}) {
-        const { cache, freeze, type } = Object.assign({ cache: true, freeze: true, type: undefined }, options);
-        // Get cache
-        if (cache && freeze) {
-            const args = this.args[functionName + type];
-            if (args) {
-                return args;
-            }
-        }
-        const func = this.getFunction(functionName, { type });
-        const result = {};
-        if (func === null || func === void 0 ? void 0 : func.args) {
-            func.args.forEach((item) => {
-                result[item.name] = this.getDeepType(item.type);
-            });
-        }
-        // Set cache
-        if (freeze) {
-            this.args[functionName + type] = Helper.deepFreeze(result);
-        }
-        return result;
-    }
-    /**
-     * Get fields of GraphQL function
-     */
-    getFields(functionName, options = {}) {
-        const { cache, freeze, type } = Object.assign({ cache: true, freeze: true, type: undefined }, options);
-        // Get cache
-        if (cache && freeze) {
-            const args = this.fields[functionName + type];
-            if (args) {
-                return args;
-            }
-        }
-        const func = this.getFunction(functionName, options);
-        const result = this.getDeepType(func.type);
-        // Set cache
-        if (freeze) {
-            this.fields[functionName + type] = Helper.deepFreeze(result);
-        }
-        return result;
-    }
-    /**
-     * Get GraphQL function
-     */
-    getFunction(name, options = {}) {
-        // Set config
-        const config = Object.assign({}, options);
-        // Init possible functions
-        let functions = {};
-        // If function type is set
-        if (config.type) {
-            const graphQLType = config.type.charAt(0).toUpperCase() + config.type.slice(1);
-            const type = this.schema.getType(graphQLType);
-            if (type) {
-                functions = type.getFields();
-            }
-        }
-        // If function type is not set
-        else {
-            ['Subscription', 'Mutation', 'Query'].forEach((item) => {
-                const type = this.schema.getType(item);
-                if (type) {
-                    functions = Object.assign(Object.assign({}, functions), (type.getFields() || {}));
-                }
-            });
-        }
-        // Get function via name
-        return functions[name];
-    }
-    /**
-     * Get type
-     */
-    getType(name) {
-        return this.schema.getType(name);
-    }
-    /**
-     * Get deep type data
-     */
-    getDeepType(type, prepared = new WeakMap()) {
-        // Check type
-        if (!type) {
-            return type;
-        }
-        // Infinite regress protection
-        const preparedObject = {};
-        // Check prepared
-        if (typeof type === 'object') {
-            const preparedType = prepared.get(type);
-            if (preparedType) {
-                return preparedType;
-            }
-            // Set prepared
-            prepared.set(type, preparedObject);
-        }
-        // Search deeper
-        if (type.ofType) {
-            const ofTypeResult = this.getDeepType(type.ofType, prepared);
-            Object.assign(preparedObject, ofTypeResult);
-            return ofTypeResult;
-        }
-        // Process fields
-        if (type._fields) {
-            const result = {};
-            for (const [key, value] of Object.entries(type._fields)) {
-                result[key] = this.getDeepType(value, prepared);
-            }
-            Object.assign(preparedObject, result);
-            return result;
-        }
-        // Get type name
-        if (type.type) {
-            const typeResult = this.getDeepType(type.type, prepared);
-            Object.assign(preparedObject, typeResult);
-            return typeResult;
-        }
-        // Initialize GraphQLType
-        const graphqlType = GraphQLType.map({
-            type: type.name,
-        });
-        // Set enum values
-        if (!!type._values) {
-            graphqlType.isEnum = true;
-            for (const [key, value] of Object.entries(type._nameLookup)) {
-                if (!value.isDeprecated) {
-                    graphqlType.validEnums.push(key);
-                }
-            }
-        }
-        // Finish
-        prepared.set(type, graphqlType);
-        return graphqlType;
-    }
-}
-
-/**
- * Authentication guard
- */
-class AuthGuard {
-    /**
-     * Imports
-     */
-    constructor(router, authService, moduleConfig) {
-        this.router = router;
-        this.authService = authService;
-        this.moduleConfig = moduleConfig;
-    }
-    /**
-     * Can activate main route
-     */
-    canActivate(route, state) {
-        return new Observable((subscriber) => {
-            var _a, _b, _c, _d;
-            let allowed = false;
-            const opposite = ((_a = route === null || route === void 0 ? void 0 : route.data) === null || _a === void 0 ? void 0 : _a.opposite) ? (_b = route === null || route === void 0 ? void 0 : route.data) === null || _b === void 0 ? void 0 : _b.opposite : false;
-            const redirectUrl = ((_c = route === null || route === void 0 ? void 0 : route.data) === null || _c === void 0 ? void 0 : _c.redirectUrl) ? route.data.redirectUrl : this.moduleConfig.authGuardRedirectUrl;
-            if (this.authService.token && !opposite) {
-                if (route.data.allowedRole) {
-                    const user = this.authService.currentUser;
-                    allowed = (_d = user === null || user === void 0 ? void 0 : user.roles) === null || _d === void 0 ? void 0 : _d.includes(route.data.allowedRole);
-                }
-                else {
-                    allowed = true;
-                }
-            }
-            else if (!this.authService.token && opposite) {
-                allowed = true;
-            }
-            if (!allowed) {
-                this.router.navigate([redirectUrl]);
-            }
-            subscriber.next(allowed);
-            subscriber.complete();
-        });
-    }
-    /**
-     * Can activate child route
-     */
-    canActivateChild(route, state) {
-        return this.canActivate(route, state);
-    }
-}
-AuthGuard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: AuthGuard, deps: [{ token: i1$1.Router }, { token: AuthService }, { token: BASE_MODULE_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable });
-AuthGuard.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: AuthGuard });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: AuthGuard, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () {
-        return [{ type: i1$1.Router }, { type: AuthService }, { type: undefined, decorators: [{
-                        type: Inject,
-                        args: [BASE_MODULE_CONFIG]
-                    }] }];
-    } });
-
-/**
- * Guard to check if a component can be deactivated
- */
-class CanDeactivateGuard {
-    canDeactivate(component) {
-        return component.canDeactivate ? component.canDeactivate() : true;
-    }
-}
-CanDeactivateGuard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: CanDeactivateGuard, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-CanDeactivateGuard.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: CanDeactivateGuard });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: CanDeactivateGuard, decorators: [{
-            type: Injectable
-        }] });
-
-/**
- * Logout guard
- */
-class LogoutGuard {
-    constructor(router, authService) {
-        this.router = router;
-        this.authService = authService;
-    }
-    canActivate(route, state) {
-        return new Observable((subscriber) => {
-            if (this.authService.token) {
-                this.authService.logout();
-            }
-            subscriber.next(true);
-            subscriber.complete();
-        });
-    }
-    canActivateChild(route, state) {
-        return this.canActivate(route, state);
-    }
-}
-LogoutGuard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: LogoutGuard, deps: [{ token: i1$1.Router }, { token: AuthService }], target: i0.ɵɵFactoryTarget.Injectable });
-LogoutGuard.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: LogoutGuard });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: LogoutGuard, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: i1$1.Router }, { type: AuthService }]; } });
-
-/**
- * Comparison operator enum
- */
-var ComparisonOperatorEnum;
-(function (ComparisonOperatorEnum) {
-    ComparisonOperatorEnum["EQ"] = "EQ";
-    ComparisonOperatorEnum["GT"] = "GT";
-    ComparisonOperatorEnum["GTE"] = "GTE";
-    ComparisonOperatorEnum["IN"] = "IN";
-    ComparisonOperatorEnum["LT"] = "LT";
-    ComparisonOperatorEnum["LTE"] = "LTE";
-    ComparisonOperatorEnum["NE"] = "NE";
-    ComparisonOperatorEnum["NIN"] = "NIN";
-    ComparisonOperatorEnum["REGEX"] = "REGEX";
-})(ComparisonOperatorEnum || (ComparisonOperatorEnum = {}));
-
-/**
- * GraphQL request type enum
- */
-var GraphQLRequestType;
-(function (GraphQLRequestType) {
-    GraphQLRequestType["QUERY"] = "query";
-    GraphQLRequestType["MUTATION"] = "mutation";
-    GraphQLRequestType["SUBSCRIPTION"] = "subscription";
-})(GraphQLRequestType || (GraphQLRequestType = {}));
-
-/**
- * Logical operator enum
- */
-var LogicalOperatorEnum;
-(function (LogicalOperatorEnum) {
-    LogicalOperatorEnum["AND"] = "AND";
-    LogicalOperatorEnum["NOR"] = "NOR";
-    LogicalOperatorEnum["OR"] = "OR";
-})(LogicalOperatorEnum || (LogicalOperatorEnum = {}));
-
-var SortOrderEnum;
-(function (SortOrderEnum) {
-    SortOrderEnum["ASC"] = "ASC";
-    SortOrderEnum["DESC"] = "DESC";
-})(SortOrderEnum || (SortOrderEnum = {}));
-
-/**
- * Fullscreen service
- */
-class FullscreenService {
-    constructor() {
-        this._isFullscreenActive = new BehaviorSubject(false);
-        this.listenToFullscreenEvent();
-    }
-    get fullscreenState() {
-        return this._isFullscreenActive.value;
-    }
-    get fullscreenStateAsObservable() {
-        return this._isFullscreenActive.asObservable();
-    }
-    toggleFullscreen() {
-        const elem = document.documentElement;
-        if (!this._isFullscreenActive.value) {
-            elem.requestFullscreen();
-            this._isFullscreenActive.next(true);
-        }
-        else {
-            document.exitFullscreen();
-            this._isFullscreenActive.next(false);
-        }
-    }
-    /**
-     * Event Listener for fullscreen toggle
-     */
-    listenToFullscreenEvent() {
-        document.addEventListener('fullscreenchange', () => {
-            if (document.fullscreenElement) {
-                this._isFullscreenActive.next(true);
-            }
-            else {
-                this._isFullscreenActive.next(false);
-            }
-        });
-    }
-}
-FullscreenService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: FullscreenService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-FullscreenService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: FullscreenService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: FullscreenService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: function () { return []; } });
-
-/**
- * GraphQL meta service
- *
- * For collecting meta information of the GraphQL API
- */
-class GraphQLMetaService {
-    /**
-     * Include services
-     */
-    constructor(apollo) {
-        this.apollo = apollo;
-    }
-    /**
-     * Getter of introspectionQuery
-     */
-    get introspectionQuery() {
-        return JSON.parse(JSON.stringify(this._introspectionQuery));
-    }
-    /**
-     * Get schema for API
-     * See https://www.apollographql.com/blog/three-ways-to-represent-your-graphql-schema-a41f4175100d
-     */
-    getSchema(options = {}) {
-        // Get configurations
-        const config = Object.assign({ cache: true, freeze: true }, options);
-        // Use caching
-        if (config.cache) {
-            if (config.freeze && this._frozenSchema) {
-                return of(this._frozenSchema);
-            }
-            if (this._introspectionQuery) {
-                return of(buildClientSchema(this.introspectionQuery));
-            }
-            if (config.freeze && this._frozenSchemaObservable) {
-                return this._frozenSchemaObservable;
-            }
-            else if (!config.freeze && this._schemaObservable) {
-                return this._schemaObservable;
-            }
-        }
-        // Request schema from server
-        const observable = this.apollo
-            .query({
-            query: gql(getIntrospectionQuery({ descriptions: false })),
-        })
-            .pipe(map((schema) => {
-            // Cache introspectionQuery
-            this._introspectionQuery = schema.data;
-            // Convert schema to GraphQLSchema
-            this._frozenSchema = Helper.deepFreeze(buildClientSchema(this.introspectionQuery));
-            // Return GraphQLSchema
-            if (config.freeze) {
-                return this._frozenSchema;
-            }
-            return buildClientSchema(schema.data);
-        }));
-        // Set observables
-        if (config.freeze) {
-            this._frozenSchemaObservable = observable;
-        }
-        else {
-            this._schemaObservable = observable;
-        }
-        // Return result
-        return observable;
-    }
-    /**
-     * Get meta for API
-     * See https://www.apollographql.com/blog/three-ways-to-represent-your-graphql-schema-a41f4175100d
-     */
-    getMeta(options = {}) {
-        // Get configurations
-        const config = Object.assign({ cache: true, log: false }, options);
-        // Use caching
-        if (config.cache) {
-            if (this._meta) {
-                return of(this._meta);
-            }
-            else if (this._metaObservable) {
-                return this._metaObservable;
-            }
-        }
-        // Request schema from server
-        const observable = this.getSchema(options).pipe(map((schema) => {
-            // Log
-            if (config.log) {
-                console.log({ schema });
-            }
-            this._meta = new GraphQLMeta(schema);
-            return this._meta;
-        }));
-        // Set observables
-        this._metaObservable = observable;
-        // Return result
-        return observable;
-    }
-}
-GraphQLMetaService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: GraphQLMetaService, deps: [{ token: i1$2.Apollo }], target: i0.ɵɵFactoryTarget.Injectable });
-GraphQLMetaService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: GraphQLMetaService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: GraphQLMetaService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: function () { return [{ type: i1$2.Apollo }]; } });
-
-/**
- * GraphQL service
- */
-class GraphQLService {
-    /**
-     * Include services
-     */
-    constructor(apollo, graphQLMetaService) {
-        this.apollo = apollo;
-        this.graphQLMetaService = graphQLMetaService;
-    }
-    /**
-     * GraphQL request
-     */
-    graphQl(graphql, options = {}) {
-        // Check arguments
-        if (!graphql) {
-            throwError('Missing graphql argument');
-        }
-        // Get config
-        const config = Object.assign({ arguments: null, fields: null, log: false, model: null, type: GraphQLRequestType.QUERY }, options);
-        // Convert class to Object for arguments
-        if (typeof config.arguments === 'function') {
-            config.arguments = new config.arguments();
-        }
-        // Convert class to Object for fields
-        if (typeof config.fields === 'function') {
-            config.fields = new config.fields();
-        }
-        // Log
-        if (config.log) {
-            console.log({ config });
-        }
-        // Send request
-        return new Observable((subscriber) => {
-            // Get meta
-            this.graphQLMetaService.getMeta({ log: config.log }).subscribe((meta) => {
-                // Prepare fields
-                let fields;
-                let allowedFields;
-                // Log meta
-                if (config.log) {
-                    console.log({ meta });
-                }
-                if (config.fields) {
-                    allowedFields = meta.getFields(graphql, { type: config.type });
-                    // Log meta
-                    if (config.log) {
-                        console.log({ allowedFields });
-                    }
-                    const fieldsData = this.prepareFields(config.fields, {
-                        allowed: allowedFields,
-                    });
-                    // Log fields data
-                    if (config.log) {
-                        fieldsData.usedFields.sort();
-                        fieldsData.schemaFields.sort();
-                        const filtered = fieldsData.schemaFields.filter((field) => !fieldsData.usedFields.includes(field));
-                        const unused = this.graphQLTypeCollectionToStringArray(allowedFields).filter((field) => !fieldsData.usedFields.includes(field));
-                        console.log({ fieldsData, filtered, unused });
-                    }
-                    fields = fieldsData.fieldsString;
-                }
-                if (fields && !fields.startsWith('{')) {
-                    fields = '{' + fields + '\n}';
-                }
-                // Log fields
-                if (config.log) {
-                    console.log({ fields });
-                }
-                // Get allowed args
-                const allowedArgs = meta.getArgs(graphql, { type: config.type });
-                // Log allowed args
-                if (config.log) {
-                    console.log({ allowedArgs });
-                }
-                const argsData = this.prepareArguments(config.arguments, {
-                    allowed: allowedArgs,
-                });
-                // Log args data
-                if (config.log) {
-                    argsData.usedArgs.sort();
-                    argsData.schemaArgs.sort();
-                    const filtered = argsData.schemaArgs.filter((field) => !argsData.usedArgs.includes(field));
-                    const unused = this.graphQLTypeCollectionToStringArray(allowedArgs)
-                        .sort()
-                        .filter((field) => !argsData.usedArgs.includes(field));
-                    console.log({ argsData, filtered, unused });
-                }
-                const args = (argsData === null || argsData === void 0 ? void 0 : argsData.argsString) || '';
-                // Log
-                if (config.log) {
-                    console.log({ graphQL: graphql, args, fields, type: config.type });
-                }
-                // Prepare request
-                const documentNode = fields
-                    ? gql(config.type + '{\n' + graphql + args + fields + '\n}')
-                    : gql(config.type + '{\n' + graphql + args + '\n}');
-                // Log
-                if (config.log) {
-                    console.log({ documentNode });
-                }
-                const request = {};
-                request[config.type] = documentNode;
-                // Log
-                if (config.log) {
-                    console.log({ request });
-                }
-                let func;
-                if (config.type === GraphQLRequestType.MUTATION) {
-                    func = 'mutate';
-                    request[config.type] = documentNode;
-                }
-                else if (config.type === GraphQLRequestType.SUBSCRIPTION) {
-                    func = 'subscribe';
-                    request.query = documentNode;
-                }
-                else {
-                    func = config.type;
-                    request[config.type] = documentNode;
-                }
-                this.apollo[func](request).subscribe((result) => {
-                    var _a;
-                    const data = ((_a = result === null || result === void 0 ? void 0 : result.data) === null || _a === void 0 ? void 0 : _a[graphql]) !== undefined ? result.data[graphql] : result;
-                    // Direct data
-                    if (!config.model) {
-                        subscriber.next(data);
-                    }
-                    // Map data as array
-                    else if (Array.isArray(data)) {
-                        subscriber.next(data.map((item) => {
-                            return config.model.map(item);
-                        }));
-                    }
-                    // Map data
-                    else {
-                        subscriber.next(config.model.map(data));
-                    }
-                    if (config.type !== GraphQLRequestType.SUBSCRIPTION) {
-                        // Done
-                        subscriber.complete();
-                    }
-                }, (error) => {
-                    subscriber.error(error);
-                    subscriber.complete();
-                });
-            });
-        });
-    }
-    /**
-     * Get fields / args from IGraphQLTypeCollection
-     */
-    graphQLTypeCollectionToStringArray(collection, current = '', result = [], cacheNode = []) {
-        if (collection) {
-            if (collection instanceof GraphQLType) {
-                result.push(current);
-            }
-            else {
-                if (current === null || current === void 0 ? void 0 : current.includes('.')) {
-                    cacheNode.push(current.split('.')[1]);
-                }
-                else if (current) {
-                    cacheNode.push(current);
-                }
-                for (const key of Object.keys(collection)) {
-                    if (current === key || cacheNode.includes(key)) {
-                        continue;
-                    }
-                    this.graphQLTypeCollectionToStringArray(collection[key], current ? current + '.' + key : key, result, cacheNode);
-                }
-            }
-        }
-        return result;
-    }
-    /**
-     * Prepare arguments for GraphQL request
-     */
-    prepareArguments(args, options = {}) {
-        // Init config variables
-        const { allowed, level, parent, schemaArgs, usedArgs } = Object.assign({ allowed: null, level: 1, parent: '', schemaArgs: [], usedArgs: [] }, options);
-        // Check args
-        if (args === undefined || args === null) {
-            return { argsString: '', schemaArgs, usedArgs };
-        }
-        // Init args
-        const result = [];
-        // Process array
-        if (Array.isArray(args)) {
-            const allowedKeys = allowed ? Object.keys(allowed) : null;
-            for (const item of args) {
-                let key = null;
-                if (allowed) {
-                    if (allowed.length < 1) {
-                        break;
-                    }
-                    key = allowedKeys === null || allowedKeys === void 0 ? void 0 : allowedKeys.shift();
-                }
-                // Process value
-                result.push(this.prepareArguments(item, {
-                    allowed: key ? allowed[key] : null,
-                    level: level + 1,
-                    parent: parent + key + '.',
-                    schemaArgs,
-                    usedArgs,
-                }).argsString);
-            }
-            // Encapsulation of the array result
-            if (result.length) {
-                // Complete result, encapsulated via round brackets
-                if (level === 1) {
-                    return { argsString: '(' + result.join(', ') + ')', schemaArgs, usedArgs };
-                }
-                // Deeper result part, encapsulated via square brackets
-                else {
-                    return { argsString: '[' + result.join(', ') + ']', schemaArgs, usedArgs };
-                }
-            }
-        }
-        // Process object
-        else if (typeof args === 'object') {
-            // Check object is empty
-            if (args && Object.keys(args).length === 0 && Object.getPrototypeOf(args) === Object.prototype) {
-                return { argsString: '{}', schemaArgs, usedArgs };
-            }
-            // Process all object entries
-            for (const [key, value] of Object.entries(args)) {
-                // Init data for current entry
-                const currentKey = parent + key;
-                schemaArgs.push(currentKey);
-                // If the allowed key handling is enabled and the current key is not included in the list of allowed keys,
-                // the current key will be skipped
-                if (allowed && !allowed[key]) {
-                    continue;
-                }
-                // Skip value if not exists
-                if (value === undefined || value === null) {
-                    continue;
-                }
-                // Add current key to metadata
-                usedArgs.push(currentKey);
-                // Process GraphQLEnum
-                if (value instanceof GraphQLEnum) {
-                    result.push(key + ':' + value.value);
-                    continue;
-                }
-                // Process array
-                else if (Array.isArray(value)) {
-                    result.push(key +
-                        ': [' +
-                        value.map((item) => this.prepareArguments(item, {
-                            allowed: allowed[key],
-                            level: level + 1,
-                            parent: currentKey + '.',
-                            schemaArgs,
-                            usedArgs,
-                        }).argsString) +
-                        ']');
-                    continue;
-                }
-                // Prepare additional result string
-                let additionalResult = key + ': ';
-                // Value is a date object
-                if (typeof value === 'object' && Object.prototype.toString.call(value) === '[object Date]') {
-                    additionalResult += `"""${value.toString()}"""`;
-                }
-                // Value is a string
-                else if (typeof value === 'string') {
-                    // Enum (doesn't need quotation marks)
-                    if (allowed[key].isEnum) {
-                        additionalResult += value;
-                    }
-                    // String
-                    else {
-                        additionalResult += `"""${value.replace(/"/g, '\\"')}"""`;
-                    }
-                }
-                // Value is a simple boolean or a number
-                else if (typeof value === 'boolean' || typeof value === 'number') {
-                    additionalResult += value;
-                }
-                // Others
-                else {
-                    additionalResult += this.prepareArguments(value, {
-                        allowed: allowed[key],
-                        level: level + 1,
-                        parent: currentKey + '.',
-                        schemaArgs,
-                        usedArgs,
-                    }).argsString;
-                }
-                // Push deeper part into result array
-                result.push(additionalResult);
-            }
-            // Encapsulation of the object result
-            if (result.length) {
-                // Complete result, encapsulated via round brackets
-                if (level === 1) {
-                    return { argsString: '(' + result.join(', ') + ')', schemaArgs, usedArgs };
-                }
-                // Deeper result part, encapsulated via curly brackets
-                else {
-                    return { argsString: '{' + result.join(', ') + '}', schemaArgs, usedArgs };
-                }
-            }
-        }
-        // Prepare and process other / unknown values as JSON
-        else {
-            return { argsString: JSON.stringify(args), schemaArgs, usedArgs };
-        }
-    }
-    /**
-     * Prepare fields for GraphQL request
-     */
-    prepareFields(fields, options = {}) {
-        // Config
-        const { allowed, parent, schemaFields, spaces, tab, usedFields } = Object.assign({ allowed: null, parent: '', schemaFields: [], spaces: 2, tab: 1, usedFields: [] }, options);
-        // Init fields string
-        let fieldsString = '';
-        // Check fields
-        if (!fields) {
-            return { fieldsString, schemaFields, usedFields };
-        }
-        // Process string
-        if (typeof fields === 'string') {
-            if (allowed &&
-                ((typeof allowed === 'string' && allowed !== fields) || (typeof allowed === 'object' && !allowed[fields]))) {
-                return { fieldsString, schemaFields, usedFields };
-            }
-            return { fieldsString: '\n' + ' '.repeat(spaces).repeat(tab) + fields, schemaFields, usedFields };
-        }
-        // Process array
-        else if (Array.isArray(fields)) {
-            for (const item of fields) {
-                if (typeof item === 'object') {
-                    fieldsString =
-                        fieldsString +
-                            this.prepareFields(item, {
-                                allowed,
-                                parent,
-                                spaces,
-                                schemaFields,
-                                tab: tab + 1,
-                                usedFields,
-                            }).fieldsString;
-                    continue;
-                }
-                const currentPath = parent + item;
-                schemaFields.push(currentPath);
-                if (allowed && !(allowed === null || allowed === void 0 ? void 0 : allowed[item])) {
-                    continue;
-                }
-                usedFields.push(currentPath);
-                fieldsString =
-                    fieldsString +
-                        this.prepareFields(item, {
-                            allowed: typeof (allowed === null || allowed === void 0 ? void 0 : allowed[item]) === 'object' && !((allowed === null || allowed === void 0 ? void 0 : allowed[item]) instanceof GraphQLType) ? allowed === null || allowed === void 0 ? void 0 : allowed[item] : item,
-                            parent: currentPath + '.',
-                            spaces,
-                            schemaFields,
-                            tab: tab + 1,
-                            usedFields,
-                        }).fieldsString;
-            }
-        }
-        // Process object
-        else if (typeof fields === 'object') {
-            for (const [key, val] of Object.entries(fields)) {
-                const currentPath = parent + key;
-                schemaFields.push(currentPath);
-                if (allowed && !allowed[key]) {
-                    continue;
-                }
-                usedFields.push(currentPath);
-                if (typeof val !== 'object' || !Object.keys(val).length) {
-                    fieldsString = fieldsString + '\n' + ' '.repeat(spaces).repeat(tab) + key;
-                }
-                else {
-                    fieldsString =
-                        fieldsString +
-                            '\n' +
-                            ' '.repeat(spaces).repeat(tab) +
-                            key +
-                            ' ' +
-                            '{' +
-                            this.prepareFields(val, {
-                                allowed: typeof (allowed === null || allowed === void 0 ? void 0 : allowed[key]) === 'object' && !((allowed === null || allowed === void 0 ? void 0 : allowed[key]) instanceof GraphQLType) ? allowed === null || allowed === void 0 ? void 0 : allowed[key] : key,
-                                parent: currentPath + '.',
-                                spaces,
-                                schemaFields,
-                                tab: tab + 1,
-                                usedFields,
-                            }).fieldsString +
-                            '\n' +
-                            ' '.repeat(spaces).repeat(tab) +
-                            '}';
-                }
-            }
-        }
-        // Return result
-        return { fieldsString, schemaFields, usedFields };
-    }
-}
-GraphQLService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: GraphQLService, deps: [{ token: i1$2.Apollo }, { token: GraphQLMetaService }], target: i0.ɵɵFactoryTarget.Injectable });
-GraphQLService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: GraphQLService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: GraphQLService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: function () { return [{ type: i1$2.Apollo }, { type: GraphQLMetaService }]; } });
-
-/**
- * Loader service for loading indication
- */
-class LoaderService {
-    constructor() {
-        this.isLoading = new BehaviorSubject(false);
-    }
-    start() {
-        this.isLoading.next(true);
-    }
-    stop() {
-        this.isLoading.next(false);
-    }
-    getAsObservable() {
-        return this.isLoading.asObservable();
-    }
-}
-LoaderService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: LoaderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-LoaderService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: LoaderService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: LoaderService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }] });
-
-/**
- * GraphQL plus service, for extra error handling and loading indication
- */
-class GraphQLPlusService extends GraphQLService {
-    /**
-     * Include services
-     */
-    constructor(apollo, graphqlMetaService, loaderService) {
-        super(apollo, graphqlMetaService);
-        this.apollo = apollo;
-        this.graphqlMetaService = graphqlMetaService;
-        this.loaderService = loaderService;
-    }
-    graphQl(graphql, options = {}) {
-        this.handleLoader('start', options);
-        return new Observable((subscriber) => {
-            super.graphQl(graphql, options).subscribe((response) => {
-                if (response && response.errors) {
-                    this.handleError(response.errors, options.excludedErrors);
-                    subscriber.error(response);
-                    this.handleLoader('stop', options);
-                    subscriber.complete();
-                }
-                subscriber.next(response);
-                this.handleLoader('stop', options);
-                if (options.type !== GraphQLRequestType.SUBSCRIPTION) {
-                    subscriber.complete();
-                }
-            }, (error) => {
-                if (!options.ignoreErrors) {
-                    this.handleError(error, options.excludedErrors);
-                }
-                subscriber.error(error);
-                this.handleLoader('stop', options);
-                subscriber.complete();
-            });
-        });
-    }
-    handleLoader(state, options) {
-        if (options.loading) {
-            if (state === 'start') {
-                this.loaderService.start();
-            }
-            else if (state === 'stop') {
-                this.loaderService.stop();
-            }
-        }
-    }
-    handleError(error, excludedErrors = null) {
-        if (excludedErrors) {
-            if (Array.isArray(excludedErrors)) {
-                excludedErrors.forEach((excludedError) => {
-                    if (error.message.includes(excludedError.toLowerCase())) {
-                        return;
-                    }
-                });
-            }
-            else if (error.message.toLowerCase().includes(excludedErrors === null || excludedErrors === void 0 ? void 0 : excludedErrors.toLowerCase())) {
-                return;
-            }
-        }
-        this.displayError(error);
-    }
-    displayError(error) {
-        console.error(error);
-    }
-}
-GraphQLPlusService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: GraphQLPlusService, deps: [{ token: i1$2.Apollo }, { token: GraphQLMetaService }, { token: LoaderService }], target: i0.ɵɵFactoryTarget.Injectable });
-GraphQLPlusService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: GraphQLPlusService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: GraphQLPlusService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: function () { return [{ type: i1$2.Apollo }, { type: GraphQLMetaService }, { type: LoaderService }]; } });
-
-/**
- * Scroll service for autoscroll to specific fragments
- */
-class ScrollService {
-    /**
-     * Initializer
-     */
-    constructor(router, moduleConfig, imageService) {
-        this.router = router;
-        this.moduleConfig = moduleConfig;
-        this.imageService = imageService;
-        /**
-         * Is a scroll listener set
-         *
-         * @protected
-         */
-        this.scrollListener = false;
-        /**
-         * Current scroll timer;
-         *
-         * @protected
-         */
-        this.scrollTimer = -1;
-        const config = Object.assign({ scrollDetectionOffset: 200, scrollOffset: 100, scrollSamplingRate: 100 }, moduleConfig);
-        this.detectionOffset = config.scrollDetectionOffset;
-        this.scrollOffset = config.scrollOffset;
-        this.scrollSamplingRate = config.scrollSamplingRate;
-    }
-    /**
-     * Scroll to structureElement with specific ID
-     */
-    scrollTo(id, options = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Prepare config
-            const config = Object.assign({ checkUrl: false, loadImagesBefore: true, resetStyles: false, setOverflow: true, stopPropagation: true }, options);
-            // Check current URL
-            if (config.checkUrl && this.router.url !== '/' && !this.router.url.startsWith('/#')) {
-                yield this.router.navigate(['/'], { fragment: id });
-                return !config.stopPropagation;
-            }
-            // Check if target element exits
-            const el = document.getElementById(id);
-            if (!el) {
-                console.error('Missing scroll element with ID:', id);
-                return !config.stopPropagation;
-            }
-            // Check if body overflow is visible
-            // This is necessary for scroll handling
-            const body = document.querySelector('body');
-            let undoOverflowChanges = false;
-            const scrollBodyStyles = JSON.parse(JSON.stringify(window.getComputedStyle(body)));
-            if (config.setOverflow && (scrollBodyStyles.overflowX !== 'visible' || scrollBodyStyles.overflowY !== 'visible')) {
-                // Set body overflow to visible
-                console.warn('Style of body element for overflowX and overflowY will be set to "visible" for scrolling!');
-                body.style.overflowX = 'visible';
-                body.style.overflowY = 'visible';
-                undoOverflowChanges = true;
-            }
-            // Load images before scrolling (once)
-            if (config.loadImagesBefore) {
-                yield this.imageService.preLoadImages();
-            }
-            // Get get bounding rect of target element
-            const cords = el.getBoundingClientRect();
-            // Scroll to element
-            window.scrollBy({ top: cords.top - this.scrollOffset, behavior: 'smooth' });
-            yield this.scrollDone({
-                doneFunction: () => {
-                    // Undo changes
-                    if (undoOverflowChanges && config.resetStyles) {
-                        body.style.overflowX = scrollBodyStyles.overflowX;
-                        body.style.overflowY = scrollBodyStyles.overflowY;
-                        console.warn('Original style of body element for overflowX and overflowY is set.');
-                    }
-                },
-            });
-            // Return stop propagation configuration
-            return !config.stopPropagation;
-        });
-    }
-    /**
-     * Get last active structureElement
-     */
-    getLastActiveElement(list) {
-        const currentScrollPosition = window.scrollY;
-        const elementsWithId = document.querySelectorAll('[id]');
-        let lastId = null;
-        let lastPosition = 0 - this.detectionOffset - 1;
-        elementsWithId.forEach((element) => {
-            const cords = element.getBoundingClientRect();
-            const top = cords.top + window.pageYOffset - this.detectionOffset;
-            if ((!list || !list.length || list.includes(element.id)) && // In list
-                top < currentScrollPosition && // In active area
-                lastPosition < top // Higher than the last one
-            ) {
-                lastId = element.id;
-                lastPosition = top;
-            }
-        });
-        return lastId;
-    }
-    /**
-     * Check if ID is active
-     */
-    isActive(id, list, isFirst) {
-        const lastActiveElement = this.getLastActiveElement(list);
-        return id === lastActiveElement || (lastActiveElement === null && isFirst);
-    }
-    /**
-     * Scroll done promise
-     */
-    scrollDone(options = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Init configuration
-            const config = Object.assign({ doneFunction: undefined }, options);
-            // Wait for scroll done
-            yield this.scrollDoneDetection();
-            // Get result
-            if (config.doneFunction) {
-                return config.doneFunction();
-            }
-        });
-    }
-    /**
-     * Scroll done detecton
-     *
-     * @protected
-     */
-    scrollDoneDetection() {
-        // Return current scroll promise (Singelton)
-        if (this.scrollPromise) {
-            return this.scrollPromise;
-        }
-        // Create current scroll promise
-        this.scrollPromise = new Promise((resolve) => {
-            this.scrollPromiseResolve = resolve;
-            if (this.scrollTimer !== -1) {
-                window.clearTimeout(this.scrollTimer);
-            }
-            this.scrollTimer = window.setTimeout(() => {
-                window.removeEventListener('scroll', this.scrollDoneDetection.bind(this));
-                this.scrollPromise = undefined;
-                resolve();
-            }, this.scrollSamplingRate);
-        });
-        // Lisitening to scroll event;
-        window.addEventListener('scroll', this.scrollDoneDetection.bind(this));
-        // Return promise
-        return this.scrollPromise;
-    }
-}
-ScrollService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: ScrollService, deps: [{ token: i1$1.Router }, { token: BASE_MODULE_CONFIG }, { token: ImageService }], target: i0.ɵɵFactoryTarget.Injectable });
-ScrollService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: ScrollService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: ScrollService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: function () {
-        return [{ type: i1$1.Router }, { type: undefined, decorators: [{
-                        type: Inject,
-                        args: [BASE_MODULE_CONFIG]
-                    }] }, { type: ImageService }];
-    } });
-
-/**
- * SEO service for setting HTML meta data
- */
-class SEOService {
-    constructor(titleService, metaTagService) {
-        this.titleService = titleService;
-        this.metaTagService = metaTagService;
-    }
-    initPageForSEO(input) {
-        this.setGeneralData(input);
-        this.setTwitterData(input);
-        this.setTwitterData(input);
-        this.setFacebookData(input);
-        if (input.keywords) {
-            this.setPageKeywords(input.keywords);
-        }
-    }
-    /**
-     * Set general metadata
-     *
-     * @param data
-     * @private
-     */
-    setGeneralData(data) {
-        this.titleService.setTitle(data.title);
-        this.metaTagService.updateTag({ name: 'description', content: data.description });
-    }
-    /**
-     * Set metadata for twitter
-     *
-     * @param data
-     * @private
-     */
-    setTwitterData(data) {
-        this.metaTagService.updateTag({ name: 'twitter:title', content: data.title });
-        this.metaTagService.updateTag({ name: 'twitter:description', content: data.description });
-        this.metaTagService.updateTag({
-            property: 'twitter:url',
-            content: data.url ? data.url : window.location.href,
-        });
-        if (data.image) {
-            this.metaTagService.updateTag({
-                property: 'twitter:image',
-                content: data.image,
-            });
-            this.metaTagService.updateTag({
-                property: 'twitter:card',
-                content: 'summary_large_image',
-            });
-        }
-    }
-    /**
-     * Set metadata for facebook
-     *
-     * @param data
-     * @private
-     */
-    setFacebookData(data) {
-        this.metaTagService.updateTag({ property: 'og:title', content: data.title });
-        this.metaTagService.updateTag({ property: 'og:description', content: data.description });
-        this.metaTagService.updateTag({
-            property: 'og:type',
-            content: 'website',
-        });
-        this.metaTagService.updateTag({
-            property: 'og:url',
-            content: data.url ? data.url : window.location.href,
-        });
-        if (data.image) {
-            this.metaTagService.updateTag({
-                property: 'og:image',
-                content: data.image,
-            });
-        }
-    }
-    /**
-     * Set page keywords
-     *
-     * @param keywords
-     * @private
-     */
-    setPageKeywords(keywords) {
-        this.metaTagService.updateTag({ name: 'keywords', content: keywords });
-    }
-}
-SEOService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: SEOService, deps: [{ token: i1.Title }, { token: i1.Meta }], target: i0.ɵɵFactoryTarget.Injectable });
-SEOService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: SEOService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: SEOService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: function () { return [{ type: i1.Title }, { type: i1.Meta }]; } });
-
-/**
- * Custom validator to check that two fields match
- * (inspirated by https://jasonwatmore.com/post/2018/11/07/angular-7-reactive-forms-validation-example)
- */
-function MustMatch(controlName, matchingControlName) {
-    return (formGroup) => {
-        const control = formGroup.controls[controlName];
-        const matchingControl = formGroup.controls[matchingControlName];
-        if (matchingControl.errors && !matchingControl.errors.mustMatch) {
-            // return if another validator has already found an error on the matchingControl
-            return;
-        }
-        // set error on matchingControl if validation fails
-        if (control.value !== matchingControl.value) {
-            matchingControl.setErrors({ mustMatch: true });
-        }
-        else {
-            matchingControl.setErrors(null);
-        }
-    };
-}
-
-/**
- * Exports for public API
- */
-
-/**
- * Generated bundle index. Do not edit.
- */
-
-export { AuthGuard, AuthService, BASE_MODULE_CONFIG, BaseModule, BasicUser, CanDeactivateGuard, ComparisonOperatorEnum, ContextMenuDirective, EllipsesPipe, FullscreenService, GraphQLEnum, GraphQLMeta, GraphQLMetaService, GraphQLPlusService, GraphQLRequestType, GraphQLService, GraphQLType, Helper, ImageService, LazyLoadDirective, LoaderService, LogicalOperatorEnum, LogoutGuard, MatchHeightDirective, MustMatch, ResizableDirective, SEOService, SafeHtmlPipe, ScrollService, SortOrderEnum, Standard, StorageService, WsService, apolloOptionsFactory };
-//# sourceMappingURL=lenne.tech-ng-base-src-lib-base.mjs.map