@lenne.tech/ng-base 12.1.0 → 13.0.0

package/fesm2020/lenne.tech-ng-base.mjs

@@ -0,0 +1,2526 @@
+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 { 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() {
+        this.client?.close();
+        this.client?.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) {
+        const cm = this.ltContextMenu;
+        if (cm) {
+            // Try to open context menu
+            if (show && event && event instanceof MouseEvent) {
+                // Get valid clicked structureElement
+                const clickedElement = event?.target?.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?.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 = {
+            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 = {
+            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) {
+        if (!parameter) {
+            return parameter;
+        }
+        return parameter?.split('?')?.shift()?.split('#')?.shift();
+    }
+    /**
+     * Get ID of an url parameter
+     */
+    static getParameterId(parameter) {
+        if (!parameter) {
+            return parameter;
+        }
+        return Helper.getPlainParameter(parameter)?.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 = {
+            doneFunnction: undefined,
+            elements: document,
+            regExp: undefined,
+            ...options,
+        };
+        return new Promise((resolve) => {
+            // 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
+                    config.regExp?.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(async () => {
+                // Return result
+                let result;
+                if (config.doneFunnction) {
+                    result = await config.doneFunction();
+                }
+                resolve(result);
+            });
+        });
+    }
+    /**
+     * Load image for image element
+     *
+     * @param imageElement
+     * @param src
+     * @protected
+     */
+    async loadImage(imageElement, src) {
+        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);
+    }
+    async matchHeight(parent, target) {
+        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) {
+                await 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 = {
+            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 } = {
+            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?.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 } = {
+            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 = {
+            ...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 = {
+                        ...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) => {
+            let allowed = false;
+            const opposite = route?.data?.opposite ? route?.data?.opposite : false;
+            const redirectUrl = route?.data?.redirectUrl ? route.data.redirectUrl : this.moduleConfig.authGuardRedirectUrl;
+            if (this.authService.token && !opposite) {
+                if (route.data.allowedRole) {
+                    const user = this.authService.currentUser;
+                    allowed = user?.roles?.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 = {
+            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 = {
+            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 = {
+            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?.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) => {
+                    const data = result?.data?.[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?.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 } = {
+            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?.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 } = {
+            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?.[item]) {
+                    continue;
+                }
+                usedFields.push(currentPath);
+                fieldsString =
+                    fieldsString +
+                        this.prepareFields(item, {
+                            allowed: typeof allowed?.[item] === 'object' && !(allowed?.[item] instanceof GraphQLType) ? 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?.[key] === 'object' && !(allowed?.[key] instanceof GraphQLType) ? 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?.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 = {
+            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
+     */
+    async scrollTo(id, options = {}) {
+        // Prepare config
+        const config = {
+            checkUrl: false,
+            loadImagesBefore: true,
+            resetStyles: false,
+            setOverflow: true,
+            stopPropagation: true,
+            ...options,
+        };
+        // Check current URL
+        if (config.checkUrl && this.router.url !== '/' && !this.router.url.startsWith('/#')) {
+            await 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) {
+            await 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' });
+        await 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
+     */
+    async scrollDone(options = {}) {
+        // Init configuration
+        const config = {
+            doneFunction: undefined,
+            ...options,
+        };
+        // Wait for scroll done
+        await 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
+ */
+
+// Export libs
+
+/**
+ * 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.mjs.map