@lenne.tech/ng-base 18.1.3 → 22.0.1

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

@@ -1,2863 +0,0 @@
-import { GraphQLInputObjectType, GraphQLScalarType, GraphQLEnumType, GraphQLNonNull, GraphQLList, buildClientSchema, getIntrospectionQuery } from 'graphql';
-import * as i0 from '@angular/core';
-import { InjectionToken, Injectable, Inject, PLATFORM_ID } from '@angular/core';
-import { of, throwError, Observable, BehaviorSubject, map as map$1, filter } from 'rxjs';
-import * as i1 from 'apollo-angular';
-import { gql } from 'apollo-angular';
-import { sha256 } from 'js-sha256';
-import { map } from 'rxjs/operators';
-import * as i2 from '@angular/common';
-import { isPlatformBrowser, DOCUMENT } from '@angular/common';
-import * as i1$1 from '@angular/router';
-import { NavigationEnd } from '@angular/router';
-import { UntypedFormControl, UntypedFormGroup } from '@angular/forms';
-import Compressor from 'compressorjs';
-import * as i2$1 from '@angular/common/http';
-import { HttpHeaders } from '@angular/common/http';
-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 double characters
-            str = str.replace('---', '-');
-            str = str.replace('--', '-');
-            // 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 a specific length
-     */
-    static getUID(length = 24) {
-        let dt = new Date().getTime();
-        const uuid = 'x'.repeat(length).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 {
-    id = undefined;
-    email = undefined;
-    avatar = undefined;
-    firstName = undefined;
-    lastName = undefined;
-    roles = [];
-    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 {
-    value;
-    constructor(value) {
-        this.value = value;
-    }
-}
-
-/**
- * GraphQL type
- */
-class GraphQLType extends Standard {
-    type = '';
-    fields = {};
-    isRequired = false;
-    isItemRequired = false;
-    isList = false;
-    isEnum = false;
-    validEnums = [];
-}
-
-/**
- * GraphQL meta
- */
-class GraphQLMeta {
-    schema;
-    // Frozen caches
-    args = {};
-    fields = {};
-    /**
-     * Integrate schema
-     */
-    constructor(schema) {
-        this.schema = schema;
-        if (!schema) {
-            throw Error('Missing schema');
-        }
-    }
-    /**
-     * Get an object with GraphQLRequestType (operation type) as keys and method (fields) names as value
-     */
-    getMethodNames() {
-        return {
-            query: Object.keys(this.schema.getQueryType()?.getFields() || {}),
-            mutation: Object.keys(this.schema.getMutationType()?.getFields() || {}),
-            subscription: Object.keys(this.schema.getSubscriptionType()?.getFields() || {}),
-        };
-    }
-    /**
-     * Get GraphQLRequestTypes (operation types) via method (field) name
-     */
-    getRequestTypesViaMethod(methodName) {
-        const result = [];
-        const methodNames = this.getMethodNames();
-        for (const [key, value] of Object.entries(methodNames)) {
-            if (value.includes(methodName)) {
-                result.push(key);
-            }
-        }
-        return result;
-    }
-    /**
-     * We're going to get the query and mutation types from the schema, then we're going to loop through the fields of each
-     * type and check if the field name starts with `find`, `create`, `update`, or `delete`. If it does, we're going to add
-     * the model name to the `possibleTypes` array
-     *
-     * @returns An array of objects with the name of the model, and the CRUD operations that are available for that model.
-     */
-    getTypes(logging = false) {
-        const possibleTypes = [];
-        const mutationType = this.schema.getMutationType();
-        const queryType = this.schema.getQueryType();
-        if (logging) {
-            console.log('GraphQLMeta::getTypes->queryTypeFields', queryType.getFields());
-        }
-        for (const [key, value] of Object.entries(queryType.getFields())) {
-            if (key.startsWith('find')) {
-                possibleTypes.push({
-                    name: key.split('find').pop().slice(0, -1),
-                    create: false,
-                    update: false,
-                    delete: false,
-                    duplicate: false,
-                });
-            }
-        }
-        if (logging) {
-            console.log('GraphQLMeta::getTypes->mutationTypeFields', mutationType.getFields());
-            console.log('GraphQLMeta::getTypes->possibleTypes', possibleTypes);
-        }
-        for (const [key, value] of Object.entries(mutationType.getFields())) {
-            if (key.startsWith('create')) {
-                const model = key.split('create').pop();
-                if (possibleTypes.find((e) => e.name === model)) {
-                    possibleTypes.find((item) => item.name === model).create = true;
-                }
-            }
-            if (key.startsWith('update')) {
-                const model = key.split('update').pop();
-                if (possibleTypes.find((e) => e.name === model)) {
-                    possibleTypes.find((item) => item.name === model).update = true;
-                }
-            }
-            if (key.startsWith('delete')) {
-                const model = key.split('delete').pop();
-                if (possibleTypes.find((e) => e.name === model)) {
-                    possibleTypes.find((item) => item.name === model).delete = true;
-                }
-            }
-            if (key.startsWith('duplicate')) {
-                const model = key.split('duplicate').pop();
-                if (possibleTypes.find((e) => e.name === model)) {
-                    possibleTypes.find((item) => item.name === model).duplicate = true;
-                }
-            }
-        }
-        if (logging) {
-            console.log('GraphQLMeta::getTypes->possibleTypes', possibleTypes);
-            console.log('GraphQLMeta::getTypes->filteredPossibleTypes', possibleTypes.filter((e) => e.create || e.update));
-        }
-        return possibleTypes.filter((e) => e.create || e.update);
-    }
-    /**
-     * 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 = new GraphQLType();
-        if (func?.args) {
-            func.args.forEach((item) => {
-                result.fields[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 name
-     */
-    getTypeName(type) {
-        if (type instanceof GraphQLInputObjectType ||
-            type instanceof GraphQLScalarType ||
-            type instanceof GraphQLEnumType) {
-            return type.name;
-        }
-        else if (type.type) {
-            return this.getTypeName(type.type);
-        }
-        else if (type.ofType) {
-            return this.getTypeName(type.ofType);
-        }
-        else {
-            return type.name;
-        }
-    }
-    /**
-     * Get deep type data
-     */
-    getDeepType(type, prepared = {}, setMetaData = false) {
-        // Check type
-        if (!type) {
-            return type;
-        }
-        // Infinite regress protection
-        const typeName = this.getTypeName(type);
-        const graphQLType = GraphQLType.map({
-            type: this.getTypeName(type),
-        });
-        // Check prepared
-        if (typeof type === 'object') {
-            const preparedType = prepared[typeName];
-            // Work with cached type
-            if (preparedType) {
-                // Create a new object to protect own isXXX information
-                const clone = Object.assign({}, preparedType);
-                // But use fields as reference to get future changes via prepared caching
-                clone.fields = preparedType.fields;
-                // Disable meta flags for sub objects
-                if (type?.type instanceof GraphQLInputObjectType ||
-                    (type?.type instanceof GraphQLNonNull && type?.type?.ofType instanceof GraphQLInputObjectType && setMetaData)) {
-                    setMetaData = false;
-                }
-                // Check for meta flags
-                if (type.type && setMetaData) {
-                    if (type.type instanceof GraphQLNonNull) {
-                        clone.isRequired = true;
-                        if (type.type.ofType instanceof GraphQLList) {
-                            clone.isList = true;
-                            clone.isItemRequired = type.type.ofType.ofType instanceof GraphQLNonNull;
-                        }
-                        else {
-                            clone.isList = false;
-                            clone.isItemRequired = false;
-                        }
-                    }
-                    else {
-                        clone.isRequired = false;
-                        // List first
-                        if (type.type instanceof GraphQLList) {
-                            clone.isList = true;
-                            clone.isItemRequired = type.ofType instanceof GraphQLNonNull;
-                        }
-                        else {
-                            clone.isList = false;
-                            clone.isItemRequired = false;
-                        }
-                    }
-                }
-                return clone;
-            }
-            // Set prepared cache for GraphQL types
-            // (type names start with uppercase letters as opposed to property names that start with lowercase letters)
-            if (type.name && type.name[0].toUpperCase() === type.name[0] && !prepared[type.name]) {
-                prepared[type.name] = graphQLType;
-            }
-        }
-        // Search deeper
-        if (type.ofType) {
-            const ofTypeResult = this.getDeepType(type.ofType, prepared, setMetaData);
-            Object.assign(graphQLType, ofTypeResult);
-            return graphQLType;
-        }
-        // Process fields
-        if (type._fields) {
-            const fields = {};
-            for (const [key, value] of Object.entries(type._fields)) {
-                fields[key] = this.getDeepType(value, prepared, true);
-            }
-            // Assign and not replace to preserve updates in the cache
-            Object.assign(graphQLType.fields, fields);
-            return graphQLType;
-        }
-        // Process type
-        if (type.type) {
-            const typeResult = this.getDeepType(type.type, prepared, setMetaData);
-            // Disable meta flags for sub objects
-            if (type?.type instanceof GraphQLInputObjectType ||
-                (type?.type instanceof GraphQLNonNull && type?.type?.ofType instanceof GraphQLInputObjectType && setMetaData)) {
-                setMetaData = false;
-            }
-            // Check for meta flags
-            if (setMetaData) {
-                if (type.type instanceof GraphQLNonNull) {
-                    typeResult.isRequired = true;
-                    if (type.type.ofType instanceof GraphQLList) {
-                        typeResult.isList = true;
-                        typeResult.isItemRequired = type.type.ofType.ofType instanceof GraphQLNonNull;
-                    }
-                    else {
-                        typeResult.isList = false;
-                        typeResult.isItemRequired = false;
-                    }
-                }
-                else {
-                    typeResult.isRequired = false;
-                    // List first
-                    if (type.type instanceof GraphQLList) {
-                        typeResult.isList = true;
-                        typeResult.isItemRequired = type.ofType instanceof GraphQLNonNull;
-                    }
-                    else {
-                        typeResult.isList = false;
-                        typeResult.isItemRequired = false;
-                    }
-                }
-            }
-            Object.assign(graphQLType, typeResult);
-            return graphQLType;
-        }
-        // 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
-        return graphQLType;
-    }
-}
-
-class Auth extends Standard {
-    refreshToken = undefined;
-    token = undefined;
-    user = undefined;
-    map(data) {
-        Helper.map(data, this);
-        this.user = data?.user ? BasicUser.map(data.user) : this.user;
-        return this;
-    }
-}
-
-class Sort {
-    sortOrder = 1;
-    collator = new Intl.Collator(undefined, { numeric: true, sensitivity: 'base' });
-    /**
-     * Sorts clicked column
-     */
-    startSort(property, order, type = '') {
-        if (order === 'desc') {
-            this.sortOrder = -1;
-        }
-        return (a, b) => {
-            if (type === 'date') {
-                return this.sortDate(new Date(a.latestStep[property]), new Date(b.latestStep[property]));
-            }
-            else if (type === 'position') {
-                return this.collator.compare(a.position.Value[property], b.position.Value[property]) * this.sortOrder;
-            }
-            else {
-                return this.collator.compare(a[property], b[property]) * this.sortOrder;
-            }
-        };
-    }
-    /**
-     * Sorts dates
-     */
-    sortDate(a, b) {
-        if (a < b) {
-            return -1 * this.sortOrder;
-        }
-        else if (a > b) {
-            return 1 * this.sortOrder;
-        }
-        else {
-            return 0 * this.sortOrder;
-        }
-    }
-}
-
-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;
-    };
-}
-
-/**
- * GraphQL request type enum
- */
-var GraphQLRequestType;
-(function (GraphQLRequestType) {
-    GraphQLRequestType["QUERY"] = "query";
-    GraphQLRequestType["MUTATION"] = "mutation";
-    GraphQLRequestType["SUBSCRIPTION"] = "subscription";
-})(GraphQLRequestType || (GraphQLRequestType = {}));
-
-const BASE_MODULE_CONFIG = new InjectionToken('BASE_MODULE_CONFIG');
-
-/**
- * GraphQL meta service
- *
- * For collecting meta information of the GraphQL API
- */
-class GraphQLMetaService {
-    apollo;
-    // Caches
-    _frozenSchema;
-    _frozenSchemaObservable;
-    _meta;
-    _metaObservable;
-    _schemaObservable;
-    // Private caches
-    _introspectionQuery;
-    /**
-     * 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;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: GraphQLMetaService, deps: [{ token: i1.Apollo }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: GraphQLMetaService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: GraphQLMetaService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: i1.Apollo }] });
-
-/**
- * GraphQL service
- */
-class GraphQLService {
-    apollo;
-    graphQLMetaService;
-    moduleConfig;
-    /**
-     * Include services
-     */
-    constructor(apollo, graphQLMetaService, moduleConfig) {
-        this.apollo = apollo;
-        this.graphQLMetaService = graphQLMetaService;
-        this.moduleConfig = moduleConfig;
-    }
-    /**
-     * GraphQL request
-     */
-    graphQl(graphqlMethodName, options = {}) {
-        // Check parameters
-        if (!graphqlMethodName) {
-            throwError(() => new Error('Missing graphql method name'));
-        }
-        // Get config
-        const config = {
-            arguments: null,
-            fields: null,
-            log: false,
-            model: null,
-            ...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) => {
-                // Set GraphQLRequestType automatically
-                if (!config.type) {
-                    const types = meta.getRequestTypesViaMethod(graphqlMethodName);
-                    if (!types?.length) {
-                        throwError(() => new Error('No GraphQLRequestType detected'));
-                    }
-                    config.type = types[0];
-                    if (config.type) {
-                        throwError(() => new Error('No GraphQLRequestType detected'));
-                    }
-                    if (types.length > 1) {
-                        // eslint-disable-next-line no-console
-                        console.debug('GraphQLRequestType ' + config.type + ' used for ' + graphqlMethodName, types);
-                    }
-                }
-                // Prepare fields
-                let fields;
-                let allowedFields;
-                // Log meta
-                if (config.log) {
-                    console.log({ meta });
-                }
-                if (config.fields) {
-                    allowedFields = meta.getFields(graphqlMethodName, { type: config.type });
-                    // Log meta
-                    if (config.log) {
-                        console.log({ allowedFields });
-                    }
-                    const fieldsData = this.prepareFields(config.fields, {
-                        allowed: allowedFields,
-                    });
-                    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(graphqlMethodName, { 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.graphQLTypeToStringArray(allowedArgs)
-                        .sort()
-                        .filter((field) => !argsData.usedArgs.includes(field));
-                    console.log({ argsData, filtered, unused });
-                }
-                let args = argsData?.argsString || '';
-                if (args === '{}') {
-                    args = '';
-                }
-                // Log
-                if (config.log) {
-                    console.log({ graphQL: graphqlMethodName, args, fields, type: config.type });
-                }
-                // Prepare request
-                const request = {};
-                // Prepare GraphQL
-                const gQlFuncBody = fields
-                    ? ' {\n' + graphqlMethodName + args + fields + '\n}'
-                    : ' {\n' + graphqlMethodName + args + '\n}';
-                let gQlBody = config.type + gQlFuncBody;
-                // Handling for variables (e.g. for file uploads)
-                if (Object.keys(argsData.variables).length) {
-                    // Preparations
-                    request.variables = {};
-                    let multipart = false;
-                    // Add surrounding
-                    gQlBody = config.type + ' Request(';
-                    for (const [key, item] of Object.entries(argsData.variables)) {
-                        gQlBody += '\n$' + key + ':' + item.type + ',';
-                        request.variables[key] = item.value;
-                        if (item.type.startsWith('Upload')) {
-                            multipart = true;
-                        }
-                    }
-                    gQlBody = gQlBody.slice(0, -1) + '\n)' + gQlFuncBody;
-                    // Set Multipart
-                    if (multipart) {
-                        request.context = {
-                            useMultipart: true,
-                        };
-                    }
-                }
-                const documentNode = gql(gQlBody);
-                // Log
-                if (config.log) {
-                    console.log({ documentNode });
-                }
-                // Set document node
-                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?.[graphqlMethodName] !== undefined ? result.data[graphqlMethodName] : 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
-     */
-    graphQLTypeToStringArray(graphQLType, current = '', result = [], cacheNode = []) {
-        if (!graphQLType) {
-            return result;
-        }
-        if (current?.includes('.')) {
-            cacheNode.push(current.split('.')[1]);
-        }
-        else if (current) {
-            cacheNode.push(current);
-        }
-        for (const key of Object.keys(graphQLType.fields)) {
-            if (current === key || cacheNode.includes(key)) {
-                continue;
-            }
-            this.graphQLTypeToStringArray(graphQLType.fields[key], current ? current + '.' + key : key, result, cacheNode);
-        }
-        return result;
-    }
-    /**
-     * Prepare arguments for GraphQL request
-     */
-    prepareArguments(args, options = {}) {
-        // Init config variables
-        const { allowed, levelKey, level, parent, schemaArgs, usedArgs, variables } = {
-            allowed: null,
-            levelKey: '',
-            level: 1,
-            parent: '',
-            schemaArgs: [],
-            usedArgs: [],
-            variables: {},
-            ...options,
-        };
-        // Check args
-        if (args === undefined || args === null) {
-            return { argsString: '', schemaArgs, usedArgs, variables };
-        }
-        // Init args
-        const result = [];
-        // Process array
-        if (Array.isArray(args)) {
-            const allowedKeys = allowed ? Object.keys(allowed.fields) : null;
-            for (const item of args) {
-                let key = null;
-                if (allowed) {
-                    if (!allowedKeys || allowedKeys.length < 1) {
-                        break;
-                    }
-                    key = allowedKeys.shift();
-                }
-                // Process value
-                result.push(this.prepareArguments(item, {
-                    allowed: key ? allowed.fields[key] : null,
-                    levelKey: key,
-                    level: level + 1,
-                    parent: parent + key + '.',
-                    schemaArgs,
-                    usedArgs,
-                    variables,
-                }).argsString);
-            }
-            // Encapsulation of the array result
-            if (result.length) {
-                // Complete result, encapsulated via round brackets
-                if (level === 1) {
-                    return { argsString: '(' + result.join(', ') + ')', schemaArgs, usedArgs, variables };
-                }
-                // Deeper result part, encapsulated via square brackets
-                else {
-                    return { argsString: '[' + result.join(', ') + ']', schemaArgs, usedArgs, variables };
-                }
-            }
-        }
-        // Process object
-        else if (typeof args === 'object') {
-            // Check for Upload type for variable handling
-            if (allowed?.type === 'Upload') {
-                const name = levelKey + '_' + Helper.getUID(6);
-                variables[name] = { type: allowed.type + (allowed.isRequired ? '!' : ''), value: args };
-                return { argsString: '$' + name, schemaArgs, usedArgs, variables };
-            }
-            // Check object is empty
-            if (args && Object.keys(args).length === 0 && Object.getPrototypeOf(args) === Object.prototype) {
-                return { argsString: '{}', schemaArgs, usedArgs, variables };
-            }
-            // 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.fields[key]) {
-                    continue;
-                }
-                // Skip value if not exists
-                if (value === undefined) {
-                    continue;
-                }
-                // Set null e.g. for resetting
-                if (value === null) {
-                    result.push(key + ':' + null);
-                    continue;
-                }
-                // Add current key to metadata
-                usedArgs.push(currentKey);
-                // Process GraphQLEnum
-                if (value instanceof GraphQLEnum) {
-                    result.push(key + ':' + value.value);
-                    continue;
-                }
-                if (this.moduleConfig.securePasswordTransfer && key === 'password') {
-                    result.push(key + ':' + `"${sha256(value)}"`);
-                    continue;
-                }
-                // Process array
-                else if (Array.isArray(value)) {
-                    result.push(key +
-                        ': [' +
-                        value.map((item) => this.prepareArguments(item, {
-                            allowed: allowed.fields[key],
-                            levelKey: key,
-                            level: level + 1,
-                            parent: currentKey + '.',
-                            schemaArgs,
-                            usedArgs,
-                            variables,
-                        }).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.fields[key].isEnum) {
-                        additionalResult += value;
-                    }
-                    // String
-                    else {
-                        additionalResult += `"${value.replace(/"/g, '\\"').replace(/\n/g, '\\n')}"`;
-                    }
-                }
-                // Value is a simple boolean or a number
-                else if (typeof value === 'boolean' || typeof value === 'number') {
-                    additionalResult += value;
-                }
-                // Others
-                else {
-                    const prepareOptions = {
-                        allowed: allowed.fields[key],
-                        levelKey: key,
-                        level: level + 1,
-                        parent: currentKey + '.',
-                        schemaArgs,
-                        usedArgs,
-                        variables,
-                    };
-                    try {
-                        additionalResult += this.prepareArguments(value, prepareOptions).argsString;
-                    }
-                    catch (e) {
-                        console.error('Error during preparing arguments', value, prepareOptions);
-                        throw e;
-                    }
-                }
-                // 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, variables };
-                }
-                // Deeper result part, encapsulated via curly brackets
-                else {
-                    return { argsString: '{' + result.join(', ') + '}', schemaArgs, usedArgs, variables };
-                }
-            }
-        }
-        // Prepare and process other / unknown values as JSON
-        else {
-            return { argsString: JSON.stringify(args), schemaArgs, usedArgs, variables };
-        }
-    }
-    /**
-     * 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 && !allowed.fields[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, // item is object or array
-                                parent,
-                                spaces,
-                                schemaFields,
-                                tab: tab + 1,
-                                usedFields,
-                            }).fieldsString;
-                    continue;
-                }
-                const currentPath = parent + item;
-                schemaFields.push(currentPath);
-                if (allowed && !allowed.fields[item]) {
-                    continue;
-                }
-                usedFields.push(currentPath);
-                fieldsString =
-                    fieldsString +
-                        this.prepareFields(item, {
-                            allowed: null, // item is string
-                            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.fields[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: allowed.fields[key], // val is object or array
-                                parent: currentPath + '.',
-                                spaces,
-                                schemaFields,
-                                tab: tab + 1,
-                                usedFields,
-                            }).fieldsString +
-                            '\n' +
-                            ' '.repeat(spaces).repeat(tab) +
-                            '}';
-                }
-            }
-        }
-        // Return result
-        return { fieldsString, schemaFields, usedFields };
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: GraphQLService, deps: [{ token: i1.Apollo }, { token: GraphQLMetaService }, { token: BASE_MODULE_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: GraphQLService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: GraphQLService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: i1.Apollo }, { type: GraphQLMetaService }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: [BASE_MODULE_CONFIG]
-                }] }] });
-
-/**
- * Storage service for local data storage
- */
-class StorageService {
-    moduleConfig;
-    platformId;
-    /**
-     * Storage
-     */
-    storage = null;
-    /**
-     * Prefix for storage keys
-     */
-    prefix = '';
-    /**
-     * Initializations
-     */
-    constructor(moduleConfig, platformId) {
-        this.moduleConfig = moduleConfig;
-        this.platformId = platformId;
-        // Set storage
-        const type = moduleConfig.storageType ? moduleConfig.storageType : 'local';
-        if (isPlatformBrowser(this.platformId)) {
-            if (type === 'session') {
-                this.storage = sessionStorage;
-            }
-            else {
-                if (localStorage) {
-                    this.storage = localStorage;
-                }
-                else {
-                    this.storage = null;
-                }
-            }
-        }
-        // 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();
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: StorageService, deps: [{ token: BASE_MODULE_CONFIG }, { token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: StorageService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: StorageService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: undefined, decorators: [{
-                    type: Inject,
-                    args: [BASE_MODULE_CONFIG]
-                }] }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: [PLATFORM_ID]
-                }] }] });
-
-class WsService {
-    client;
-    reconnect() {
-        this.client?.restart();
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: WsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: WsService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: WsService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }] });
-
-/**
- * Authentication service
- */
-class AuthService {
-    storageService;
-    wsService;
-    injector;
-    router;
-    // Subjects
-    _currentUser = new BehaviorSubject(null);
-    _token = new BehaviorSubject(null);
-    _refreshToken = new BehaviorSubject(null);
-    /**
-     * Constructor
-     */
-    constructor(storageService, wsService, injector, router) {
-        this.storageService = storageService;
-        this.wsService = wsService;
-        this.injector = injector;
-        this.router = router;
-        this.loadFromStorage();
-    }
-    requestNewToken() {
-        return new Observable((subscriber) => {
-            this.injector
-                .get(GraphQLService)
-                .graphQl('refreshToken', {
-                fields: ['token', 'refreshToken'],
-            })
-                .subscribe({
-                next: (response) => {
-                    this.token = response.token;
-                    this.refreshToken = response.refreshToken;
-                    subscriber.next(response);
-                    subscriber.complete();
-                },
-                error: (err) => {
-                    subscriber.error(err);
-                },
-            });
-        });
-    }
-    loadFromStorage() {
-        if (localStorage) {
-            this.token = this.storageService.load('token');
-            this.refreshToken = this.storageService.load('refreshToken');
-            this.currentUser = this.storageService.load('currentUser');
-        }
-    }
-    /**
-     * Logout
-     */
-    logout(redirect = true) {
-        return new Observable((subscriber) => {
-            this.injector
-                .get(GraphQLService)
-                .graphQl('logout', {
-                fields: [],
-            })
-                .subscribe({
-                next: () => {
-                    this.clearSession(redirect);
-                    subscriber.next(true);
-                    subscriber.complete();
-                },
-                error: (err) => {
-                    subscriber.error(err);
-                },
-            });
-        });
-    }
-    clearSession(redirect = true) {
-        this.storageService.remove(['token', 'refreshToken', 'currentUser']);
-        this.currentUser = null;
-        this.token = null;
-        this.refreshToken = null;
-        if (redirect) {
-            this.router.navigate(['/auth']);
-        }
-    }
-    // #################################################################
-    // Current User
-    // #################################################################
-    get currentUser() {
-        if (!localStorage) {
-            return undefined;
-        }
-        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() {
-        if (!localStorage) {
-            return undefined;
-        }
-        return this._token.value;
-    }
-    set token(token) {
-        this._token.next(token);
-        this.storageService.save('token', token);
-        this.wsService.reconnect();
-    }
-    get tokenObservable() {
-        if (!this._token.value) {
-            this.loadFromStorage();
-        }
-        return this._token.asObservable();
-    }
-    // #################################################################
-    // refreshToken
-    // #################################################################
-    get refreshToken() {
-        if (!localStorage) {
-            return undefined;
-        }
-        return this._refreshToken.value;
-    }
-    set refreshToken(refreshToken) {
-        this._refreshToken.next(refreshToken);
-        this.storageService.save('refreshToken', refreshToken);
-    }
-    get refreshTokenObservable() {
-        if (!this._refreshToken.value) {
-            this.loadFromStorage();
-        }
-        return this._refreshToken.asObservable();
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AuthService, deps: [{ token: StorageService }, { token: WsService }, { token: i0.Injector }, { token: i1$1.Router }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AuthService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AuthService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: StorageService }, { type: WsService }, { type: i0.Injector }, { type: i1$1.Router }] });
-
-/**
- * Loader service for loading indication
- */
-class LoaderService {
-    isLoading = new BehaviorSubject(false);
-    lastStartTime;
-    /**
-     * Start loading manually
-     */
-    start() {
-        if (!this.isLoading.value) {
-            this.isLoading.next(true);
-            this.lastStartTime = new Date().getTime();
-        }
-    }
-    /**
-     * Stop loading manually
-     *
-     * @param duration
-     */
-    stop(duration = 1800) {
-        const diffMs = new Date().getTime() - this.lastStartTime;
-        if (diffMs >= duration) {
-            this.isLoading.next(false);
-            return;
-        }
-        setTimeout(() => {
-            this.isLoading.next(false);
-        }, duration - diffMs);
-    }
-    /**
-     * Get loader as observable
-     */
-    getAsObservable() {
-        return this.isLoading.asObservable();
-    }
-    /**
-     * Load until observable done
-     *
-     * @param observable
-     * @param duration
-     */
-    loadUntilObservable(observable, duration = 1800) {
-        return new Observable((subscriber) => {
-            const startFrom = new Date().getTime();
-            this.isLoading.next(true);
-            observable.subscribe({
-                next: (value) => {
-                    const diffMs = new Date().getTime() - startFrom;
-                    if (diffMs >= duration) {
-                        subscriber.next(value);
-                        subscriber.complete();
-                        this.isLoading.next(false);
-                        return;
-                    }
-                    setTimeout(() => {
-                        subscriber.next(value);
-                        subscriber.complete();
-                        this.isLoading.next(false);
-                    }, duration - diffMs);
-                },
-                error: (error) => subscriber.error(error),
-            });
-        });
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: LoaderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: LoaderService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: LoaderService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }] });
-
-/**
- * GraphQL plus service, for extra error handling and loading indication
- */
-class GraphQLPlusService extends GraphQLService {
-    apollo;
-    graphqlMetaService;
-    loaderService;
-    moduleConfig;
-    /**
-     * Include services
-     */
-    constructor(apollo, graphqlMetaService, loaderService, moduleConfig) {
-        super(apollo, graphqlMetaService, moduleConfig);
-        this.apollo = apollo;
-        this.graphqlMetaService = graphqlMetaService;
-        this.loaderService = loaderService;
-        this.moduleConfig = moduleConfig;
-    }
-    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);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: GraphQLPlusService, deps: [{ token: i1.Apollo }, { token: GraphQLMetaService }, { token: LoaderService }, { token: BASE_MODULE_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: GraphQLPlusService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: GraphQLPlusService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: i1.Apollo }, { type: GraphQLMetaService }, { type: LoaderService }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: [BASE_MODULE_CONFIG]
-                }] }] });
-
-/**
- * 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;
-        });
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: ImageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: ImageService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: ImageService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }] });
-
-/**
- * Scroll service for autoscroll to specific fragments
- */
-class ScrollService {
-    router;
-    moduleConfig;
-    imageService;
-    /**
-     * Current scroll promise
-     *
-     * @protected
-     */
-    scrollPromise;
-    /**
-     * Resolve function of current scroll promise
-     *
-     * @protected
-     */
-    scrollPromiseResolve;
-    /**
-     * Is a scroll listener set
-     *
-     * @protected
-     */
-    scrollListener = false;
-    /**
-     * Current scroll timer;
-     *
-     * @protected
-     */
-    scrollTimer = -1;
-    /**
-     * Scroll offset
-     */
-    scrollOffset;
-    /**
-     * Detection offset
-     * Should be >= scrollOffset
-     */
-    detectionOffset;
-    /**
-     * Sampling rate for scroll done detection
-     */
-    scrollSamplingRate;
-    /**
-     * Initializer
-     */
-    constructor(router, moduleConfig, imageService) {
-        this.router = router;
-        this.moduleConfig = moduleConfig;
-        this.imageService = imageService;
-        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;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: ScrollService, deps: [{ token: i1$1.Router }, { token: BASE_MODULE_CONFIG }, { token: ImageService }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: ScrollService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: ScrollService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: i1$1.Router }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: [BASE_MODULE_CONFIG]
-                }] }, { type: ImageService }] });
-
-class FormsService {
-    document;
-    scrollService;
-    constructor(document, scrollService) {
-        this.document = document;
-        this.scrollService = scrollService;
-    }
-    validateAllFormFields(formGroup) {
-        Object.keys(formGroup.controls).forEach((field) => {
-            const control = formGroup.get(field);
-            if (control instanceof UntypedFormControl) {
-                control.markAsTouched({ onlySelf: true });
-            }
-            else if (control instanceof UntypedFormGroup) {
-                this.validateAllFormFields(control);
-            }
-        });
-    }
-    findInvalidControls(formGroup) {
-        return this.getInvalidControl(formGroup);
-    }
-    getInvalidControl(formGroup, invalid, parents = []) {
-        let result = invalid ? [...invalid] : [];
-        let nestedParents = [...[], ...parents];
-        const controls = formGroup.controls;
-        Object.keys(formGroup.controls).forEach((name) => {
-            if (controls[name].invalid) {
-                if (controls[name]?.controls) {
-                    nestedParents.push(name);
-                    result = this.getInvalidControl(controls[name], result, nestedParents);
-                    nestedParents = [];
-                }
-                else {
-                    result.push(nestedParents.length ? nestedParents.join('.') + '.' + name : name);
-                }
-            }
-        });
-        return result;
-    }
-    scrollToInvalidControl(form) {
-        const invalidForm = this.findInvalidControls(form)[0];
-        this.scrollService.scrollTo(invalidForm);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: FormsService, deps: [{ token: DOCUMENT }, { token: ScrollService }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: FormsService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: FormsService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: Document, decorators: [{
-                    type: Inject,
-                    args: [DOCUMENT]
-                }] }, { type: ScrollService }] });
-
-class UserService extends GraphQLPlusService {
-    apollo;
-    graphqlMetaService;
-    loaderService;
-    authService;
-    moduleConfig;
-    constructor(apollo, graphqlMetaService, loaderService, authService, moduleConfig) {
-        super(apollo, graphqlMetaService, loaderService, moduleConfig);
-        this.apollo = apollo;
-        this.graphqlMetaService = graphqlMetaService;
-        this.loaderService = loaderService;
-        this.authService = authService;
-        this.moduleConfig = moduleConfig;
-    }
-    /**
-     * Login
-     *
-     * @param input
-     */
-    login(input) {
-        return this.graphQl('signIn', {
-            arguments: { input: { ...input, deviceDescription: navigator?.userAgent } },
-            fields: ['refreshToken', 'token', { user: ['id', 'firstName', 'lastName', 'email', 'roles', 'avatar'] }],
-            loading: true,
-        }).pipe(map$1((response) => {
-            this.authService.token = response.token;
-            this.authService.refreshToken = response.refreshToken;
-            this.authService.currentUser = response.user;
-            return Auth.map({
-                token: response.token,
-                refreshToken: response.refreshToken,
-                user: BasicUser.map(response.user),
-            });
-        }));
-    }
-    /**
-     * Register
-     *
-     * @param input
-     */
-    register(input) {
-        return this.graphQl('signUp', {
-            arguments: { input: { ...input, deviceDescription: navigator?.userAgent } },
-            fields: ['refreshToken', 'token', { user: ['id', 'firstName', 'lastName', 'email', 'roles', 'avatar'] }],
-            loading: true,
-        }).pipe(map$1((response) => {
-            this.authService.token = response.token;
-            this.authService.refreshToken = response.refreshToken;
-            this.authService.currentUser = response.user;
-            return Auth.map({
-                token: response.token,
-                refreshToken: response.refreshToken,
-                user: BasicUser.map(response.user),
-            });
-        }));
-    }
-    /**
-     * This function will make a GraphQL query to the server, and return the result
-     *
-     * @param id - The id of the user you want to get
-     * @returns A GraphQLRequest object.
-     */
-    get(id) {
-        return this.graphQl('getUser', {
-            arguments: { id },
-            fields: ['id', 'firstName', 'lastName', 'email', 'roles', 'avatar'],
-            type: GraphQLRequestType.QUERY,
-            loading: true,
-        });
-    }
-    /**
-     * Request password reset mail
-     *
-     * @param email
-     */
-    requestPasswordResetMail(email) {
-        return this.graphQl('requestPasswordResetMail', {
-            arguments: { email },
-            fields: [],
-            type: GraphQLRequestType.QUERY,
-            loading: true,
-        });
-    }
-    /**
-     * Change password of current user
-     *
-     * @param id
-     * @param password
-     */
-    changePassword(id, password) {
-        return this.graphQl('updateUser', {
-            arguments: { id, input: { password } },
-            fields: ['id'],
-            type: GraphQLRequestType.MUTATION,
-            loading: true,
-        });
-    }
-    /**
-     * Set new password by token
-     *
-     * @param token
-     * @param password
-     */
-    resetPassword(token, password) {
-        return this.graphQl('resetPassword', {
-            arguments: { token, password },
-            type: GraphQLRequestType.MUTATION,
-            loading: true,
-        });
-    }
-    /**
-     * Delete user by id
-     *
-     * @param id
-     */
-    delete(id) {
-        return this.graphQl('deleteUser', {
-            arguments: { id },
-            fields: ['id'],
-            type: GraphQLRequestType.MUTATION,
-            loading: true,
-        });
-    }
-    /**
-     * Verify user by token
-     *
-     * @param token
-     */
-    verifyUser(token) {
-        return this.graphQl('verifyUser', {
-            arguments: { token },
-            type: GraphQLRequestType.MUTATION,
-            loading: true,
-        });
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: UserService, deps: [{ token: i1.Apollo }, { token: GraphQLMetaService }, { token: LoaderService }, { token: AuthService }, { token: BASE_MODULE_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: UserService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: UserService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: i1.Apollo }, { type: GraphQLMetaService }, { type: LoaderService }, { type: AuthService }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: [BASE_MODULE_CONFIG]
-                }] }] });
-
-class ToastService {
-    toastsObservables = new BehaviorSubject([]);
-    get toastsAsObservable() {
-        return this.toastsObservables.asObservable();
-    }
-    /**
-     * Show new toast
-     *
-     * @param toast
-     * @param duration
-     */
-    show(toast, duration = 2300) {
-        const value = this.toastsObservables.value;
-        value.push(toast);
-        this.toastsObservables.next(value);
-        if (duration) {
-            setTimeout(() => {
-                const currentToasts = this.toastsObservables.value;
-                const foundIndex = currentToasts.findIndex((e) => e.id === toast.id);
-                if (foundIndex > -1) {
-                    currentToasts.splice(foundIndex, 1);
-                    this.toastsObservables.next(currentToasts);
-                }
-            }, duration);
-        }
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: ToastService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: ToastService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: ToastService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }] });
-
-class BreadcrumbService {
-    router;
-    _breadcrumbs = new BehaviorSubject([]);
-    set breadcrumbs(value) {
-        this._breadcrumbs.next(value);
-    }
-    get breadcrumbsObservable() {
-        return this._breadcrumbs.asObservable();
-    }
-    constructor(router) {
-        this.router = router;
-        this.subscribeToRouteChanges();
-    }
-    /**
-     * Subscribe to route changes and add element to breadcrumb
-     */
-    subscribeToRouteChanges() {
-        this.router.events.pipe(filter((event) => event instanceof NavigationEnd)).subscribe((event) => {
-            const root = this.router.routerState.snapshot.root;
-            const breadcrumbs = [];
-            this.addBreadcrumb(root, [], breadcrumbs);
-            this.breadcrumbs = breadcrumbs;
-        });
-    }
-    /**
-     * Add element to breadcrumb
-     *
-     * @param route
-     * @param parentUrl
-     * @param breadcrumbs
-     * @private
-     */
-    addBreadcrumb(route, parentUrl, breadcrumbs) {
-        if (route) {
-            const routeUrl = parentUrl.concat(route.url.map((url) => url.path));
-            if (route.data?.breadcrumb) {
-                const breadcrumb = {
-                    label: this.getLabel(route.data),
-                    url: '/' + routeUrl.join('/'),
-                };
-                breadcrumbs.push(breadcrumb);
-            }
-            this.addBreadcrumb(route.firstChild, routeUrl, breadcrumbs);
-        }
-    }
-    /**
-     * Get label for breadcrumb
-     *
-     * @param data
-     * @private
-     */
-    getLabel(data) {
-        return typeof data.breadcrumb === 'function' ? data.breadcrumb(data) : data.breadcrumb;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: BreadcrumbService, deps: [{ token: i1$1.Router }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: BreadcrumbService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: BreadcrumbService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: i1$1.Router }] });
-
-class NavigationService {
-    router;
-    location;
-    history = [];
-    constructor(router, location) {
-        this.router = router;
-        this.location = location;
-        this.router.events.subscribe((event) => {
-            if (event instanceof NavigationEnd) {
-                this.history.push(event.urlAfterRedirects);
-            }
-        });
-    }
-    /**
-     * If the history stack is empty, navigate to the home page, otherwise go back to the previous page
-     */
-    back() {
-        this.history.pop();
-        if (this.history.length > 0) {
-            this.location.back();
-        }
-        else {
-            this.router.navigateByUrl('/');
-        }
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: NavigationService, deps: [{ token: i1$1.Router }, { token: i2.Location }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: NavigationService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: NavigationService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [{ type: i1$1.Router }, { type: i2.Location }] });
-
-class CmsService {
-    graphQLService;
-    constructor(graphQLService) {
-        this.graphQLService = graphQLService;
-    }
-    /**
-     * It calls the graphQLService to delete the object with the id of the object that is currently being edited
-     */
-    deleteObject(id, modelName) {
-        return new Promise((resolve, reject) => {
-            if (confirm('Möchtest du das Objekt wirklich löschen?')) {
-                this.graphQLService
-                    .graphQl('delete' + this.capitalizeFirstLetter(modelName), {
-                    arguments: { id },
-                    fields: ['id'],
-                    type: GraphQLRequestType.MUTATION,
-                })
-                    .subscribe({
-                    next: (value) => {
-                        resolve(value);
-                    },
-                    error: (err) => {
-                        reject(err);
-                        console.error('Error on delete object', err);
-                    },
-                });
-            }
-        });
-    }
-    /**
-     * It sends a GraphQL mutation to the server to duplicate the object
-     */
-    async duplicateObject(id, modelName) {
-        return new Promise((resolve, reject) => {
-            if (confirm('Möchtest du das Objekt wirklich duplizieren?')) {
-                this.graphQLService
-                    .graphQl('duplicate' + this.capitalizeFirstLetter(modelName), {
-                    arguments: { id },
-                    fields: ['id'],
-                    type: GraphQLRequestType.MUTATION,
-                })
-                    .subscribe({
-                    next: (value) => {
-                        resolve(value);
-                    },
-                    error: (err) => {
-                        reject(err);
-                        console.error('Error on duplicate object', err);
-                    },
-                });
-            }
-        });
-    }
-    /**
-     * It takes a string, capitalizes the first letter, and returns the modified string
-     *
-     * @param value - The string to capitalize.
-     * @returns The first letter of the string is being capitalized and the rest of the string is being returned.
-     */
-    capitalizeFirstLetter(value) {
-        return value.charAt(0).toUpperCase() + value.slice(1);
-    }
-    /**
-     * Transform first letter to lowercase
-     */
-    lowerCaseFirstLetter(value) {
-        return value.charAt(0).toLowerCase() + value.slice(1);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: CmsService, deps: [{ token: GraphQLService }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: CmsService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: CmsService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: GraphQLService }] });
-
-class FileService {
-    authService;
-    httpClient;
-    constructor(authService, httpClient) {
-        this.authService = authService;
-        this.httpClient = httpClient;
-    }
-    /**
-     * Compress file with options and return file
-     */
-    compress(file, options) {
-        const config = {
-            quality: 0.6,
-            checkOrientation: false,
-            ...options,
-        };
-        return new Promise((resolve, reject) => {
-            new Compressor(file, {
-                success(result) {
-                    // Check if result is blob for convert to file
-                    if (result instanceof Blob) {
-                        resolve(new File([result], result.name));
-                    }
-                    else {
-                        resolve(result);
-                    }
-                },
-                error(err) {
-                    reject(err.message);
-                },
-                ...config,
-            });
-        });
-    }
-    /**
-     * Upload file to server
-     */
-    async upload(url, path, file, compressOptions) {
-        return new Promise(async (resolve, reject) => {
-            if (compressOptions) {
-                file = await this.compress(file, compressOptions);
-            }
-            const data = new FormData();
-            data.append('file', file);
-            const httpOptions = {
-                headers: new HttpHeaders({
-                    Authorization: 'Bearer ' + this.authService.token,
-                }),
-            };
-            this.httpClient.post(url + path, data, httpOptions).subscribe((result) => {
-                resolve(result);
-            }, (err) => {
-                reject(err);
-            });
-        });
-    }
-    delete(url, path, id) {
-        return new Promise(async (resolve, reject) => {
-            const httpOptions = {
-                headers: new HttpHeaders({
-                    Authorization: 'Bearer ' + this.authService.token,
-                }),
-            };
-            this.httpClient.delete(url + path + id, httpOptions).subscribe((result) => {
-                resolve(result);
-            }, (err) => {
-                reject(err);
-            });
-        });
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: FileService, deps: [{ token: AuthService }, { token: i2$1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: FileService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: FileService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: AuthService }, { type: i2$1.HttpClient }] });
-
-/**
- * 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 = {}));
-
-var ToastType;
-(function (ToastType) {
-    ToastType["ERROR"] = "error";
-    ToastType["WARNING"] = "warning";
-    ToastType["INFO"] = "info";
-    ToastType["SUCCESS"] = "success";
-})(ToastType || (ToastType = {}));
-
-var SkeletonType;
-(function (SkeletonType) {
-    SkeletonType["LINE"] = "LINE";
-    SkeletonType["RECTANGLE"] = "RECTANGLE";
-    SkeletonType["AVATAR"] = "AVATAR";
-})(SkeletonType || (SkeletonType = {}));
-
-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 {
-                if (controls.get(checkControlName)?.errors && controls.get(checkControlName)?.errors['matching']) {
-                    delete controls.get(checkControlName)?.errors['matching'];
-                }
-                return null;
-            }
-        };
-    }
-}
-
-function fullEmail() {
-    return (control) => {
-        const EMAIL_REGEXP = /^(([^<>()\[\]\.,;:\s@\"]+(\.[^<>()\[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i;
-        return !EMAIL_REGEXP.test(control.value) ? { invalidEmail: true } : null;
-    };
-}
-
-function securePasswordValidator() {
-    return (control) => {
-        const PASSWORD_REGEX = /^(?=.*?[A-Z])(?=.*?[a-z])(?=.*?[0-9])(?=.*?[^a-zA-Z0-9]).{8,}$/i;
-        return !PASSWORD_REGEX.test(control.value) ? { invalidSecurePassword: true } : 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
- */
-// Classes
-
-/**
- * Generated bundle index. Do not edit.
- */
-
-export { Auth, AuthService, BASE_MODULE_CONFIG, BasicUser, BreadcrumbService, CmsService, ComparisonOperatorEnum, FileService, FormsService, GraphQLEnum, GraphQLMeta, GraphQLMetaService, GraphQLPlusService, GraphQLRequestType, GraphQLService, GraphQLType, Helper, ImageService, LoaderService, LogicalOperatorEnum, NavigationService, ScrollService, SkeletonType, Sort, SortOrderEnum, Standard, StorageService, ToastService, ToastType, UserService, Validation, WsService, createRestartableClient, debounce, fullEmail, securePasswordValidator };
-//# sourceMappingURL=lenne.tech-ng-base-shared.mjs.map