@lenne.tech/ng-base 14.0.4 → 14.1.1

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

@@ -1,17 +1,15 @@
-import { GraphQLInputObjectType, GraphQLNonNull, GraphQLList, buildClientSchema, getIntrospectionQuery } from 'graphql';
-import { cloneDeep } from '@apollo/client/utilities';
+import { GraphQLInputObjectType, GraphQLScalarType, GraphQLEnumType, GraphQLNonNull, GraphQLList, buildClientSchema, getIntrospectionQuery } from 'graphql';
 import * as i0 from '@angular/core';
-import { Directive, Inject, Input, HostListener, Injectable, InjectionToken } from '@angular/core';
-import * as i2 from '@angular/common';
-import { DOCUMENT } from '@angular/common';
-import * as i1 from '@angular/router';
-import { NavigationEnd } from '@angular/router';
+import { InjectionToken, Injectable, Inject } from '@angular/core';
 import { BehaviorSubject, of, throwError, Observable, map as map$1, filter } from 'rxjs';
-import * as i1$1 from 'apollo-angular';
+import * as i1 from 'apollo-angular';
 import { gql } from 'apollo-angular';
 import { sha256 } from 'js-sha256';
 import { map } from 'rxjs/operators';
 import { UntypedFormControl, UntypedFormGroup } from '@angular/forms';
+import * as i1$1 from '@angular/router';
+import { NavigationEnd } from '@angular/router';
+import * as i2 from '@angular/common';
 import { createClient } from 'graphql-ws';
 
 /**
@@ -423,6 +421,7 @@ class GraphQLType extends Standard {
     constructor() {
         super(...arguments);
         this.type = '';
+        this.fields = {};
         this.isRequired = false;
         this.isItemRequired = false;
         this.isList = false;
@@ -515,10 +514,10 @@ class GraphQLMeta {
             }
         }
         const func = this.getFunction(functionName, { type });
-        const result = {};
+        const result = new GraphQLType();
         if (func?.args) {
             func.args.forEach((item) => {
-                result[item.name] = this.getDeepType(item.type);
+                result.fields[item.name] = this.getDeepType(item.type);
             });
         }
         // Set cache
@@ -591,21 +590,47 @@ class GraphQLMeta {
     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 = new WeakMap(), setMetaData = false) {
+    getDeepType(type, prepared = {}, setMetaData = false) {
         // Check type
         if (!type) {
             return type;
         }
         // Infinite regress protection
-        const preparedObject = {};
+        const typeName = this.getTypeName(type);
+        const graphQLType = GraphQLType.map({
+            type: this.getTypeName(type),
+        });
         // Check prepared
         if (typeof type === 'object') {
-            const preparedType = prepared.get(type);
+            const preparedType = prepared[typeName];
+            // Work with cached type
             if (preparedType) {
-                const clone = cloneDeep(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)) {
@@ -639,25 +664,29 @@ class GraphQLMeta {
                 }
                 return clone;
             }
-            // Set prepared
-            prepared.set(type, preparedObject);
+            // 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(preparedObject, ofTypeResult);
-            return ofTypeResult;
+            Object.assign(graphQLType, ofTypeResult);
+            return graphQLType;
         }
         // Process fields
         if (type._fields) {
-            const result = {};
+            const fields = {};
             for (const [key, value] of Object.entries(type._fields)) {
-                result[key] = this.getDeepType(value, prepared, true);
+                fields[key] = this.getDeepType(value, prepared, true);
             }
-            Object.assign(preparedObject, result);
-            return result;
+            // Assign and not replace to preserve updates in the cache
+            Object.assign(graphQLType.fields, fields);
+            return graphQLType;
         }
-        // Get type name
+        // Process type
         if (type.type) {
             const typeResult = this.getDeepType(type.type, prepared, setMetaData);
             // Disable meta flags for sub objects
@@ -691,25 +720,20 @@ class GraphQLMeta {
                     }
                 }
             }
-            Object.assign(preparedObject, typeResult);
-            return typeResult;
+            Object.assign(graphQLType, typeResult);
+            return graphQLType;
         }
-        // Initialize GraphQLType
-        const graphqlType = GraphQLType.map({
-            type: type.name,
-        });
         // Set enum values
         if (!!type._values) {
-            graphqlType.isEnum = true;
+            graphQLType.isEnum = true;
             for (const [key, value] of Object.entries(type._nameLookup)) {
                 if (!value.isDeprecated) {
-                    graphqlType.validEnums.push(key);
+                    graphQLType.validEnums.push(key);
                 }
             }
         }
         // Finish
-        prepared.set(type, graphqlType);
-        return graphqlType;
+        return graphQLType;
     }
 }
 
@@ -733,10 +757,6 @@ class Sort {
     }
     /**
      * Sorts clicked column
-     *
-     * @param property
-     * @param order
-     * @param type
      */
     startSort(property, order, type = '') {
         if (order === 'desc') {
@@ -756,9 +776,6 @@ class Sort {
     }
     /**
      * Sorts dates
-     *
-     * @param a
-     * @param b
      */
     sortDate(a, b) {
         if (a < b) {
@@ -773,107 +790,6 @@ class Sort {
     }
 }
 
-class SortDirective {
-    constructor(renderer, targetElem, document) {
-        this.renderer = renderer;
-        this.targetElem = targetElem;
-    }
-    /**
-     * Sorts columns on click
-     */
-    sortColumn() {
-        const items = document.getElementsByTagName('th');
-        for (let i = 0; i < items.length; i++) {
-            items[i].classList.remove('asc');
-            items[i].classList.remove('desc');
-        }
-        const sort = new Sort();
-        const elem = this.targetElem.nativeElement;
-        const order = elem.getAttribute('data-order');
-        const type = elem.getAttribute('data-type');
-        const property = elem.getAttribute('data-name');
-        if (order === 'desc') {
-            this.lcSort.sort(sort.startSort(property, order, type));
-            elem.setAttribute('data-order', 'asc');
-            elem.classList.remove('desc');
-            elem.classList.add('asc');
-        }
-        else {
-            this.lcSort.sort(sort.startSort(property, order, type));
-            elem.setAttribute('data-order', 'desc');
-            elem.classList.remove('asc');
-            elem.classList.add('desc');
-        }
-    }
-}
-SortDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: SortDirective, deps: [{ token: i0.Renderer2 }, { token: i0.ElementRef }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Directive });
-SortDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.1.0", type: SortDirective, selector: "[baseSort]", inputs: { lcSort: "lcSort" }, host: { listeners: { "click": "sortColumn()" } }, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: SortDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[baseSort]',
-                }]
-        }], ctorParameters: function () { return [{ type: i0.Renderer2 }, { type: i0.ElementRef }, { type: Document, decorators: [{
-                    type: Inject,
-                    args: [DOCUMENT]
-                }] }]; }, propDecorators: { lcSort: [{
-                type: Input
-            }], sortColumn: [{
-                type: HostListener,
-                args: ['click']
-            }] } });
-
-class NavigationService {
-    constructor(router, location) {
-        this.router = router;
-        this.location = location;
-        this.history = [];
-        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('/');
-        }
-    }
-}
-NavigationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: NavigationService, deps: [{ token: i1.Router }, { token: i2.Location }], target: i0.ɵɵFactoryTarget.Injectable });
-NavigationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: NavigationService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: NavigationService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: function () { return [{ type: i1.Router }, { type: i2.Location }]; } });
-
-class BackButtonDirective {
-    constructor(navigation) {
-        this.navigation = navigation;
-    }
-    onClick() {
-        this.navigation.back();
-    }
-}
-BackButtonDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: BackButtonDirective, deps: [{ token: NavigationService }], target: i0.ɵɵFactoryTarget.Directive });
-BackButtonDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.1.0", type: BackButtonDirective, selector: "[baseBackButton]", host: { listeners: { "click": "onClick()" } }, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: BackButtonDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[baseBackButton]',
-                }]
-        }], ctorParameters: function () { return [{ type: NavigationService }]; }, propDecorators: { onClick: [{
-                type: HostListener,
-                args: ['click']
-            }] } });
-
 function debounce(delay = 300) {
     return function (target, propertyKey, descriptor) {
         let timeout = null;
@@ -1060,6 +976,9 @@ class AuthService {
     // Current User
     // #################################################################
     get currentUser() {
+        if (!localStorage) {
+            return undefined;
+        }
         return this._currentUser.value;
     }
     set currentUser(user) {
@@ -1073,6 +992,9 @@ class AuthService {
     // Token
     // #################################################################
     get token() {
+        if (!localStorage) {
+            return undefined;
+        }
         return this._token.value;
     }
     set token(token) {
@@ -1211,14 +1133,14 @@ class GraphQLMetaService {
         return observable;
     }
 }
-GraphQLMetaService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: GraphQLMetaService, deps: [{ token: i1$1.Apollo }], target: i0.ɵɵFactoryTarget.Injectable });
+GraphQLMetaService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: GraphQLMetaService, deps: [{ token: i1.Apollo }], target: i0.ɵɵFactoryTarget.Injectable });
 GraphQLMetaService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: GraphQLMetaService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: GraphQLMetaService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: function () { return [{ type: i1$1.Apollo }]; } });
+        }], ctorParameters: function () { return [{ type: i1.Apollo }]; } });
 
 /**
  * GraphQL service
@@ -1285,7 +1207,7 @@ class GraphQLService {
                         fieldsData.usedFields.sort();
                         fieldsData.schemaFields.sort();
                         const filtered = fieldsData.schemaFields.filter((field) => !fieldsData.usedFields.includes(field));
-                        const unused = this.graphQLTypeCollectionToStringArray(allowedFields).filter((field) => !fieldsData.usedFields.includes(field));
+                        const unused = this.graphQLTypeToStringArray(allowedFields).filter((field) => !fieldsData.usedFields.includes(field));
                         console.log({ fieldsData, filtered, unused });
                     }
                     fields = fieldsData.fieldsString;
@@ -1311,7 +1233,7 @@ class GraphQLService {
                     argsData.usedArgs.sort();
                     argsData.schemaArgs.sort();
                     const filtered = argsData.schemaArgs.filter((field) => !argsData.usedArgs.includes(field));
-                    const unused = this.graphQLTypeCollectionToStringArray(allowedArgs)
+                    const unused = this.graphQLTypeToStringArray(allowedArgs)
                         .sort()
                         .filter((field) => !argsData.usedArgs.includes(field));
                     console.log({ argsData, filtered, unused });
@@ -1378,25 +1300,21 @@ class GraphQLService {
     /**
      * Get fields / args from IGraphQLTypeCollection
      */
-    graphQLTypeCollectionToStringArray(collection, current = '', result = [], cacheNode = []) {
-        if (collection) {
-            if (collection instanceof GraphQLType) {
-                result.push(current);
-            }
-            else {
-                if (current?.includes('.')) {
-                    cacheNode.push(current.split('.')[1]);
-                }
-                else if (current) {
-                    cacheNode.push(current);
-                }
-                for (const key of Object.keys(collection)) {
-                    if (current === key || cacheNode.includes(key)) {
-                        continue;
-                    }
-                    this.graphQLTypeCollectionToStringArray(collection[key], current ? current + '.' + key : key, result, cacheNode);
-                }
+    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;
     }
@@ -1421,18 +1339,18 @@ class GraphQLService {
         const result = [];
         // Process array
         if (Array.isArray(args)) {
-            const allowedKeys = allowed ? Object.keys(allowed) : null;
+            const allowedKeys = allowed ? Object.keys(allowed.fields) : null;
             for (const item of args) {
                 let key = null;
                 if (allowed) {
-                    if (allowed.length < 1) {
+                    if (!allowedKeys || allowedKeys.length < 1) {
                         break;
                     }
-                    key = allowedKeys?.shift();
+                    key = allowedKeys.shift();
                 }
                 // Process value
                 result.push(this.prepareArguments(item, {
-                    allowed: key ? allowed[key] : null,
+                    allowed: key ? allowed.fields[key] : null,
                     level: level + 1,
                     parent: parent + key + '.',
                     schemaArgs,
@@ -1464,7 +1382,7 @@ class GraphQLService {
                 schemaArgs.push(currentKey);
                 // If the allowed key handling is enabled and the current key is not included in the list of allowed keys,
                 // the current key will be skipped
-                if (allowed && !allowed[key]) {
+                if (allowed && !allowed.fields[key]) {
                     continue;
                 }
                 // Skip value if not exists
@@ -1487,7 +1405,7 @@ class GraphQLService {
                     result.push(key +
                         ': [' +
                         value.map((item) => this.prepareArguments(item, {
-                            allowed: allowed[key],
+                            allowed: allowed.fields[key],
                             level: level + 1,
                             parent: currentKey + '.',
                             schemaArgs,
@@ -1505,7 +1423,7 @@ class GraphQLService {
                 // Value is a string
                 else if (typeof value === 'string') {
                     // Enum (doesn't need quotation marks)
-                    if (allowed[key].isEnum) {
+                    if (allowed.fields[key].isEnum) {
                         additionalResult += value;
                     }
                     // String
@@ -1520,7 +1438,7 @@ class GraphQLService {
                 // Others
                 else {
                     additionalResult += this.prepareArguments(value, {
-                        allowed: allowed[key],
+                        allowed: allowed.fields[key],
                         level: level + 1,
                         parent: currentKey + '.',
                         schemaArgs,
@@ -1569,8 +1487,7 @@ class GraphQLService {
         }
         // Process string
         if (typeof fields === 'string') {
-            if (allowed &&
-                ((typeof allowed === 'string' && allowed !== fields) || (typeof allowed === 'object' && !allowed[fields]))) {
+            if (allowed && !allowed.fields[fields]) {
                 return { fieldsString, schemaFields, usedFields };
             }
             return { fieldsString: '\n' + ' '.repeat(spaces).repeat(tab) + fields, schemaFields, usedFields };
@@ -1593,14 +1510,14 @@ class GraphQLService {
                 }
                 const currentPath = parent + item;
                 schemaFields.push(currentPath);
-                if (allowed && !allowed?.[item]) {
+                if (allowed && !allowed.fields[item]) {
                     continue;
                 }
                 usedFields.push(currentPath);
                 fieldsString =
                     fieldsString +
                         this.prepareFields(item, {
-                            allowed: typeof allowed?.[item] === 'object' && !(allowed?.[item] instanceof GraphQLType) ? allowed?.[item] : item,
+                            allowed: null,
                             parent: currentPath + '.',
                             spaces,
                             schemaFields,
@@ -1614,7 +1531,7 @@ class GraphQLService {
             for (const [key, val] of Object.entries(fields)) {
                 const currentPath = parent + key;
                 schemaFields.push(currentPath);
-                if (allowed && !allowed[key]) {
+                if (allowed && !allowed.fields[key]) {
                     continue;
                 }
                 usedFields.push(currentPath);
@@ -1630,7 +1547,7 @@ class GraphQLService {
                             ' ' +
                             '{' +
                             this.prepareFields(val, {
-                                allowed: typeof allowed?.[key] === 'object' && !(allowed?.[key] instanceof GraphQLType) ? allowed?.[key] : key,
+                                allowed: allowed.fields[key],
                                 parent: currentPath + '.',
                                 spaces,
                                 schemaFields,
@@ -1647,14 +1564,14 @@ class GraphQLService {
         return { fieldsString, schemaFields, usedFields };
     }
 }
-GraphQLService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: GraphQLService, deps: [{ token: i1$1.Apollo }, { token: GraphQLMetaService }], target: i0.ɵɵFactoryTarget.Injectable });
+GraphQLService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: GraphQLService, deps: [{ token: i1.Apollo }, { token: GraphQLMetaService }], target: i0.ɵɵFactoryTarget.Injectable });
 GraphQLService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: GraphQLService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: GraphQLService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: function () { return [{ type: i1$1.Apollo }, { type: GraphQLMetaService }]; } });
+        }], ctorParameters: function () { return [{ type: i1.Apollo }, { type: GraphQLMetaService }]; } });
 
 /**
  * Loader service for loading indication
@@ -1749,14 +1666,14 @@ class GraphQLPlusService extends GraphQLService {
         console.error(error);
     }
 }
-GraphQLPlusService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: GraphQLPlusService, deps: [{ token: i1$1.Apollo }, { token: GraphQLMetaService }, { token: LoaderService }], target: i0.ɵɵFactoryTarget.Injectable });
+GraphQLPlusService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: GraphQLPlusService, deps: [{ token: i1.Apollo }, { token: GraphQLMetaService }, { token: LoaderService }], target: i0.ɵɵFactoryTarget.Injectable });
 GraphQLPlusService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: GraphQLPlusService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: GraphQLPlusService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: function () { return [{ type: i1$1.Apollo }, { type: GraphQLMetaService }, { type: LoaderService }]; } });
+        }], ctorParameters: function () { return [{ type: i1.Apollo }, { type: GraphQLMetaService }, { type: LoaderService }]; } });
 
 class FormsService {
     validateAllFormFields(formGroup) {
@@ -1856,14 +1773,14 @@ class UserService extends GraphQLPlusService {
         });
     }
 }
-UserService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: UserService, deps: [{ token: i1$1.Apollo }, { token: GraphQLMetaService }, { token: LoaderService }, { token: AuthService }], target: i0.ɵɵFactoryTarget.Injectable });
+UserService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: UserService, deps: [{ token: i1.Apollo }, { token: GraphQLMetaService }, { token: LoaderService }, { token: AuthService }], target: i0.ɵɵFactoryTarget.Injectable });
 UserService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: UserService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: UserService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: function () { return [{ type: i1$1.Apollo }, { type: GraphQLMetaService }, { type: LoaderService }, { type: AuthService }]; } });
+        }], ctorParameters: function () { return [{ type: i1.Apollo }, { type: GraphQLMetaService }, { type: LoaderService }, { type: AuthService }]; } });
 
 /**
  * Image service
@@ -2126,14 +2043,14 @@ class ScrollService {
         return this.scrollPromise;
     }
 }
-ScrollService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: ScrollService, deps: [{ token: i1.Router }, { token: BASE_MODULE_CONFIG }, { token: ImageService }], target: i0.ɵɵFactoryTarget.Injectable });
+ScrollService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: ScrollService, deps: [{ token: i1$1.Router }, { token: BASE_MODULE_CONFIG }, { token: ImageService }], target: i0.ɵɵFactoryTarget.Injectable });
 ScrollService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: ScrollService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: ScrollService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: function () { return [{ type: i1.Router }, { type: undefined, decorators: [{
+        }], ctorParameters: function () { return [{ type: i1$1.Router }, { type: undefined, decorators: [{
                     type: Inject,
                     args: [BASE_MODULE_CONFIG]
                 }] }, { type: ImageService }]; } });
@@ -2230,14 +2147,116 @@ class BreadcrumbService {
         return typeof data.breadcrumb === 'function' ? data.breadcrumb(data) : data.breadcrumb;
     }
 }
-BreadcrumbService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: BreadcrumbService, deps: [{ token: i1.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+BreadcrumbService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: BreadcrumbService, deps: [{ token: i1$1.Router }], target: i0.ɵɵFactoryTarget.Injectable });
 BreadcrumbService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: BreadcrumbService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: BreadcrumbService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: function () { return [{ type: i1.Router }]; } });
+        }], ctorParameters: function () { return [{ type: i1$1.Router }]; } });
+
+class NavigationService {
+    constructor(router, location) {
+        this.router = router;
+        this.location = location;
+        this.history = [];
+        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('/');
+        }
+    }
+}
+NavigationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: NavigationService, deps: [{ token: i1$1.Router }, { token: i2.Location }], target: i0.ɵɵFactoryTarget.Injectable });
+NavigationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: NavigationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: NavigationService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1$1.Router }, { type: i2.Location }]; } });
+
+class CmsService {
+    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);
+    }
+}
+CmsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: CmsService, deps: [{ token: GraphQLService }], target: i0.ɵɵFactoryTarget.Injectable });
+CmsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: CmsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.0", ngImport: i0, type: CmsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: GraphQLService }]; } });
 
 /**
  * Comparison operator enum
@@ -2351,5 +2370,5 @@ function createRestartableClient(options) {
  * Generated bundle index. Do not edit.
  */
 
-export { Auth, AuthService, BASE_MODULE_CONFIG, BackButtonDirective, BasicUser, BreadcrumbService, ComparisonOperatorEnum, FormsService, GraphQLEnum, GraphQLMeta, GraphQLMetaService, GraphQLPlusService, GraphQLRequestType, GraphQLService, GraphQLType, Helper, ImageService, LoaderService, LogicalOperatorEnum, NavigationService, ScrollService, SkeletonType, Sort, SortDirective, SortOrderEnum, Standard, StorageService, ToastService, ToastType, UserService, Validation, WsService, createRestartableClient, debounce };
+export { Auth, AuthService, BASE_MODULE_CONFIG, BasicUser, BreadcrumbService, CmsService, ComparisonOperatorEnum, 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 };
 //# sourceMappingURL=lenne.tech-ng-base-shared.mjs.map