@lenne.tech/ng-base 13.6.3 → 13.6.6

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

@@ -0,0 +1,1939 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, Injectable, Inject } from '@angular/core';
+import { BehaviorSubject, of, throwError, Observable, map as map$1 } from 'rxjs';
+import * as i1 from 'apollo-angular';
+import { gql } from 'apollo-angular';
+import { buildClientSchema, getIntrospectionQuery } from 'graphql';
+import { map } from 'rxjs/operators';
+import { FormControl, FormGroup } from '@angular/forms';
+import * as i1$1 from '@angular/router';
+import { createClient } from 'graphql-ws';
+
+/**
+ * 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)}`;
+    }
+}
+
+/**
+ * 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;
+    }
+}
+
+class Auth extends Standard {
+    constructor() {
+        super(...arguments);
+        this.token = undefined;
+        this.user = undefined;
+    }
+    map(data) {
+        Helper.map(data, this);
+        this.user = data?.user ? BasicUser.map(data.user) : this.user;
+        return this;
+    }
+}
+
+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?.restart();
+    }
+}
+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 }]; } });
+
+/**
+ * GraphQL request type enum
+ */
+var GraphQLRequestType;
+(function (GraphQLRequestType) {
+    GraphQLRequestType["QUERY"] = "query";
+    GraphQLRequestType["MUTATION"] = "mutation";
+    GraphQLRequestType["SUBSCRIPTION"] = "subscription";
+})(GraphQLRequestType || (GraphQLRequestType = {}));
+
+/**
+ * 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.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.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.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.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.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.Apollo }, { type: GraphQLMetaService }, { type: LoaderService }]; } });
+
+class FormsService {
+    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',
+                }]
+        }] });
+
+class UserService extends GraphQLPlusService {
+    constructor(apollo, graphqlMetaService, loaderService, authService) {
+        super(apollo, graphqlMetaService, loaderService);
+        this.apollo = apollo;
+        this.graphqlMetaService = graphqlMetaService;
+        this.loaderService = loaderService;
+        this.authService = authService;
+    }
+    /**
+     * Login
+     *
+     * @param input
+     */
+    login(input) {
+        return this.graphQl('signIn', {
+            arguments: { input },
+            fields: ['token', { user: ['id', 'firstName', 'lastName', 'email', 'roles'] }],
+            type: GraphQLRequestType.QUERY,
+            loading: true,
+        }).pipe(map$1((response) => {
+            this.authService.token = response.token;
+            this.authService.currentUser = BasicUser.map(response.user);
+            return Auth.map({
+                token: response.token,
+                user: BasicUser.map(response.user),
+            });
+        }));
+    }
+    /**
+     * Register
+     *
+     * @param input
+     */
+    register(input) {
+        return this.graphQl('signUp', {
+            arguments: { input },
+            fields: ['token', { user: ['id', 'firstName', 'lastName', 'email', 'roles'] }],
+            type: GraphQLRequestType.MUTATION,
+            loading: true,
+        }).pipe(map$1((response) => {
+            this.authService.token = response.token;
+            this.authService.currentUser = BasicUser.map(response.user);
+            return Auth.map({
+                token: response.token,
+                user: BasicUser.map(response.user),
+            });
+        }));
+    }
+    /**
+     * Request password reset mail
+     *
+     * @param email
+     */
+    requestPasswordResetMail(email) {
+        return this.graphQl('requestPasswordResetMail', {
+            arguments: { email },
+            fields: [],
+            type: GraphQLRequestType.QUERY,
+            loading: true,
+        });
+    }
+}
+UserService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: UserService, deps: [{ token: i1.Apollo }, { token: GraphQLMetaService }, { token: LoaderService }, { token: AuthService }], target: i0.ɵɵFactoryTarget.Injectable });
+UserService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: UserService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: UserService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Apollo }, { type: GraphQLMetaService }, { type: LoaderService }, { type: AuthService }]; } });
+
+/**
+ * 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',
+                }]
+        }] });
+
+/**
+ * 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 }]; } });
+
+/**
+ * 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 = {}));
+
+/**
+ * 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 Validation {
+    static match(controlName, checkControlName) {
+        return (controls) => {
+            const control = controls.get(controlName);
+            const checkControl = controls.get(checkControlName);
+            if (checkControl?.errors && !checkControl.errors?.matching) {
+                return null;
+            }
+            if (control?.value !== checkControl?.value) {
+                controls.get(checkControlName)?.setErrors({ matching: true });
+                return { matching: true };
+            }
+            else {
+                return null;
+            }
+        };
+    }
+}
+
+function createRestartableClient(options) {
+    let restartRequested = false;
+    let restart = () => {
+        restartRequested = true;
+    };
+    const { on = undefined } = options;
+    const client = createClient({
+        ...options,
+        on: {
+            ...on,
+            connected: (socket) => {
+                // @ts-ignore
+                on?.connected?.(socket);
+                restart = () => {
+                    if (socket.readyState === WebSocket.OPEN) {
+                        // if the socket is still open for the restart, do the restart
+                        socket.close(4205, 'Client Restart');
+                    }
+                    else {
+                        // otherwise the socket might've closed, indicate that you want
+                        // a restart on the next connected event
+                        restartRequested = true;
+                    }
+                };
+                // just in case you were eager to restart
+                if (restartRequested) {
+                    restartRequested = false;
+                    restart();
+                }
+            },
+        },
+    });
+    return {
+        ...client,
+        restart: () => restart(),
+    };
+}
+
+/**
+ * Exports for public API
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { Auth, AuthService, BASE_MODULE_CONFIG, BasicUser, ComparisonOperatorEnum, FormsService, GraphQLEnum, GraphQLMeta, GraphQLMetaService, GraphQLPlusService, GraphQLRequestType, GraphQLService, GraphQLType, Helper, ImageService, LoaderService, LogicalOperatorEnum, ScrollService, SortOrderEnum, Standard, StorageService, UserService, Validation, WsService, createRestartableClient };
+//# sourceMappingURL=lenne.tech-ng-base-shared.mjs.map