@lenne.tech/ng-base 13.6.3 → 13.6.6

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

@@ -1,239 +1,26 @@
-import * as i1$2 from 'apollo-angular';
-import { APOLLO_OPTIONS, gql } from 'apollo-angular';
+import { APOLLO_OPTIONS, ApolloModule } 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 { Directive, Input, Output, HostBinding, PLATFORM_ID, Inject, HostListener, Pipe, NgModule, Injectable } from '@angular/core';
 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 * as i2 from '@lenne.tech/ng-base/shared';
+import { createRestartableClient, BASE_MODULE_CONFIG, AuthService, WsService } from '@lenne.tech/ng-base/shared';
+import { GraphQLWsLink } from '@apollo/client/link/subscriptions';
 import { isPlatformBrowser } from '@angular/common';
 import * as i1 from '@angular/platform-browser';
+import { HttpClientModule } from '@angular/common/http';
+import { Observable, BehaviorSubject } from 'rxjs';
 import * as i1$1 from '@angular/router';
-import { FormControl, FormGroup } from '@angular/forms';
-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.3", ngImport: i0, type: StorageService, deps: [{ token: BASE_MODULE_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable });
-StorageService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: StorageService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", 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.3", ngImport: i0, type: WsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-WsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: WsService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", 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.3", 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.3", ngImport: i0, type: AuthService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", 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,
+        uri: baseModuleConfig.apiUrl,
     });
     const authMiddleware = new ApolloLink((operation, forward) => {
         const headers = {};
@@ -246,18 +33,20 @@ function apolloOptionsFactory(baseModuleConfig, httpLink, authService, wsService
         }
         return forward(operation);
     });
+    if (baseModuleConfig.logging) {
+        console.log(baseModuleConfig);
+    }
     if (baseModuleConfig.wsUrl) {
-        const wsLink = new WebSocketLink({
-            uri: baseModuleConfig.wsUrl,
-            options: {
-                reconnect: true,
-                connectionParams: () => ({
+        const wsLink = new GraphQLWsLink(createRestartableClient({
+            url: baseModuleConfig.wsUrl,
+            connectionParams: () => {
+                return {
                     Authorization: authService.token ? 'Bearer ' + authService.token : undefined,
-                }),
+                };
             },
-        });
+        }));
         // Set client for reconnection on logout/login
-        wsService.client = wsLink.subscriptionClient;
+        wsService.client = wsLink.client;
         // 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(
@@ -433,409 +222,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImpor
                 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;
-        }
-    }
-    static arrayBufferToBase64(buffer) {
-        let binary = '';
-        const bytes = new Uint8Array(buffer);
-        const len = bytes.byteLength;
-        for (let i = 0; i < len; i++) {
-            binary += String.fromCharCode(bytes[i]);
-        }
-        return `data:image/*;base64, ${window.btoa(binary)}`;
-    }
-}
-
-/**
- * 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.3", ngImport: i0, type: ImageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-ImageService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: ImageService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: ImageService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }] });
-
 /**
  * Set same height (maximum) to different elements
  */
@@ -892,14 +278,14 @@ class MatchHeightDirective {
         }
     }
 }
-MatchHeightDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: MatchHeightDirective, deps: [{ token: i0.ElementRef }, { token: ImageService }, { token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Directive });
+MatchHeightDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: MatchHeightDirective, deps: [{ token: i0.ElementRef }, { token: i2.ImageService }, { token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Directive });
 MatchHeightDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.3", 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.3", ngImport: i0, type: MatchHeightDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: '[ltMatchHeight]',
                 }]
-        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: ImageService }, { type: undefined, decorators: [{
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i2.ImageService }, { type: undefined, decorators: [{
                     type: Inject,
                     args: [PLATFORM_ID]
                 }] }]; }, propDecorators: { ltMatchHeight: [{
@@ -1122,7 +508,7 @@ class BaseModule {
     static forRoot(baseModuleConfig = {}, AppAuthService) {
         // Default config
         const config = {
-            apiUrl: 'localhost:3000',
+            apiUrl: '',
             authGuardRedirectUrl: '/auth',
             logging: false,
             version: null,
@@ -1132,11 +518,14 @@ class BaseModule {
             storageType: 'local',
             ...baseModuleConfig,
         };
+        if (config.logging) {
+            console.log('Config:', config);
+        }
         // Prepare providers
         const providers = [
             {
                 provide: BASE_MODULE_CONFIG,
-                useValue: baseModuleConfig,
+                useValue: config,
             },
         ];
         // Add apollo features if API URL is set
@@ -1167,7 +556,7 @@ BaseModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13
         // Pipes
         EllipsesPipe,
         SafeHtmlPipe,
-        DateAgoPipe], exports: [
+        DateAgoPipe], imports: [ApolloModule, HttpClientModule], exports: [
         // Directives
         ContextMenuDirective,
         LazyLoadDirective,
@@ -1176,320 +565,43 @@ BaseModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13
         // Pipes
         EllipsesPipe,
         SafeHtmlPipe,
-        DateAgoPipe] });
-BaseModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: BaseModule });
+        DateAgoPipe, ApolloModule, HttpClientModule] });
+BaseModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: BaseModule, imports: [[ApolloModule, HttpClientModule], ApolloModule, HttpClientModule] });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: BaseModule, decorators: [{
             type: NgModule,
             args: [{
+                    imports: [ApolloModule, HttpClientModule],
                     declarations: elements,
-                    exports: elements,
+                    exports: [...elements, ApolloModule, HttpClientModule],
                 }]
         }] });
 
+function debounce(delay = 300) {
+    return function (target, propertyKey, descriptor) {
+        let timeout = null;
+        const original = descriptor.value;
+        descriptor.value = function (...args) {
+            clearTimeout(timeout);
+            timeout = setTimeout(() => original.apply(this, args), delay);
+        };
+        return descriptor;
+    };
+}
+
 /**
- * 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
+ * Authentication guard
  */
-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);
-    }
+class AuthGuard {
     /**
-     * Clone object (and map additional data)
+     * Imports
      */
-    clone(mapData) {
-        const current = JSON.parse(JSON.stringify(this));
-        if (mapData) {
-            Object.assign(current, mapData);
-        }
-        return new this.constructor().map(current);
+    constructor(router, authService, moduleConfig) {
+        this.router = router;
+        this.authService = authService;
+        this.moduleConfig = moduleConfig;
     }
     /**
-     * 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;
-    }
-}
-
-function debounce(delay = 300) {
-    return function (target, propertyKey, descriptor) {
-        let timeout = null;
-        const original = descriptor.value;
-        descriptor.value = function (...args) {
-            clearTimeout(timeout);
-            timeout = setTimeout(() => original.apply(this, args), delay);
-        };
-        return descriptor;
-    };
-}
-
-/**
- * Authentication guard
- */
-class AuthGuard {
-    /**
-     * Imports
-     */
-    constructor(router, authService, moduleConfig) {
-        this.router = router;
-        this.authService = authService;
-        this.moduleConfig = moduleConfig;
-    }
-    /**
-     * Can activate main route
+     * Can activate main route
      */
     canActivate(route, state) {
         return new Observable((subscriber) => {
@@ -1522,11 +634,11 @@ class AuthGuard {
         return this.canActivate(route, state);
     }
 }
-AuthGuard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: AuthGuard, deps: [{ token: i1$1.Router }, { token: AuthService }, { token: BASE_MODULE_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable });
+AuthGuard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: AuthGuard, deps: [{ token: i1$1.Router }, { token: i2.AuthService }, { token: BASE_MODULE_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable });
 AuthGuard.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: AuthGuard });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: AuthGuard, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: i1$1.Router }, { type: AuthService }, { type: undefined, decorators: [{
+        }], ctorParameters: function () { return [{ type: i1$1.Router }, { type: i2.AuthService }, { type: undefined, decorators: [{
                     type: Inject,
                     args: [BASE_MODULE_CONFIG]
                 }] }]; } });
@@ -1566,76 +678,11 @@ class LogoutGuard {
         return this.canActivate(route, state);
     }
 }
-LogoutGuard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: LogoutGuard, deps: [{ token: i1$1.Router }, { token: AuthService }], target: i0.ɵɵFactoryTarget.Injectable });
+LogoutGuard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: LogoutGuard, deps: [{ token: i1$1.Router }, { token: i2.AuthService }], target: i0.ɵɵFactoryTarget.Injectable });
 LogoutGuard.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: LogoutGuard });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", 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 = {}));
-
-class FormsService {
-    constructor() { }
-    validateAllFormFields(formGroup) {
-        Object.keys(formGroup.controls).forEach((field) => {
-            const control = formGroup.get(field);
-            if (control instanceof FormControl) {
-                control.markAsTouched({ onlySelf: true });
-            }
-            else if (control instanceof FormGroup) {
-                this.validateAllFormFields(control);
-            }
-        });
-    }
-}
-FormsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: FormsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-FormsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: FormsService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: FormsService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: function () { return []; } });
+        }], ctorParameters: function () { return [{ type: i1$1.Router }, { type: i2.AuthService }]; } });
 
 /**
  * Fullscreen service
@@ -1685,828 +732,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImpor
                 }]
         }], 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.3", ngImport: i0, type: GraphQLMetaService, deps: [{ token: i1$2.Apollo }], target: i0.ɵɵFactoryTarget.Injectable });
-GraphQLMetaService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: GraphQLMetaService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", 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.3", 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.3", ngImport: i0, type: GraphQLService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", 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.3", ngImport: i0, type: LoaderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-LoaderService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: LoaderService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", 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.3", 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.3", ngImport: i0, type: GraphQLPlusService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", 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.3", 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.3", ngImport: i0, type: ScrollService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", 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
  */
@@ -2631,36 +856,14 @@ class ThemeService {
         }
     }
 }
-ThemeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: ThemeService, deps: [{ token: StorageService }], target: i0.ɵɵFactoryTarget.Injectable });
+ThemeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: ThemeService, deps: [{ token: i2.StorageService }], target: i0.ɵɵFactoryTarget.Injectable });
 ThemeService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: ThemeService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: ThemeService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: function () { return [{ type: StorageService }]; } });
-
-/**
- * Custom validator to check that two fields match
- * (inspirated by https://jasonwatmore.com/post/2018/11/07/angular-7-reactive-forms-validation-example)
- */
-const MustMatch = (control) => {
-    return (formGroup) => {
-        const baseControl = control.get('password');
-        const matchingControl = control.get('passwordConfirm');
-        if (matchingControl.errors && !matchingControl.errors.mustMatch) {
-            // return if another validator has already found an error on the matchingControl
-            return null;
-        }
-        // set error on matchingControl if validation fails
-        if (baseControl.value !== matchingControl.value) {
-            return { mustMatch: true };
-        }
-        else {
-            return null;
-        }
-    };
-};
+        }], ctorParameters: function () { return [{ type: i2.StorageService }]; } });
 
 /**
  * Exports for public API
@@ -2670,5 +873,5 @@ const MustMatch = (control) => {
  * Generated bundle index. Do not edit.
  */
 
-export { AuthGuard, AuthService, BASE_MODULE_CONFIG, BaseModule, BasicUser, CanDeactivateGuard, ComparisonOperatorEnum, ContextMenuDirective, DateAgoPipe, EllipsesPipe, FormsService, FullscreenService, GraphQLEnum, GraphQLMeta, GraphQLMetaService, GraphQLPlusService, GraphQLRequestType, GraphQLService, GraphQLType, Helper, ImageService, LazyLoadDirective, LoaderService, LogicalOperatorEnum, LogoutGuard, MatchHeightDirective, MustMatch, ResizableDirective, SEOService, SafeHtmlPipe, ScrollService, SortOrderEnum, Standard, StorageService, ThemeService, WsService, apolloOptionsFactory, debounce };
+export { AuthGuard, BaseModule, CanDeactivateGuard, ContextMenuDirective, DateAgoPipe, EllipsesPipe, FullscreenService, LazyLoadDirective, LogoutGuard, MatchHeightDirective, ResizableDirective, SEOService, SafeHtmlPipe, ThemeService, apolloOptionsFactory, debounce };
 //# sourceMappingURL=lenne.tech-ng-base.mjs.map