@lenne.tech/ng-base 12.1.0 → 13.2.0

package/fesm2015/{lenne.tech-ng-base.js → lenne.tech-ng-base.mjs}

@@ -1,8 +1,8 @@
-import * as i1 from 'apollo-angular';
-import { APOLLO_OPTIONS, gql, Apollo } from 'apollo-angular';
+import * as i1$2 from 'apollo-angular';
+import { APOLLO_OPTIONS, gql } from 'apollo-angular';
 import { HttpLink } from 'apollo-angular/http';
 import * as i0 from '@angular/core';
-import { InjectionToken, Injectable, Inject, Directive, ElementRef, Input, Output, HostBinding, PLATFORM_ID, HostListener, Pipe, NgModule } from '@angular/core';
+import { InjectionToken, Injectable, Inject, Directive, Input, Output, HostBinding, PLATFORM_ID, HostListener, Pipe, NgModule } from '@angular/core';
 import { BehaviorSubject, Observable, of, throwError } from 'rxjs';
 import { ApolloLink, split, concat } from '@apollo/client/core';
 import { InMemoryCache } from '@apollo/client/cache';
@@ -10,10 +10,9 @@ import { WebSocketLink } from '@apollo/client/link/ws';
 import { getMainDefinition } from '@apollo/client/utilities';
 import { __awaiter } from 'tslib';
 import { isPlatformBrowser } from '@angular/common';
-import * as i1$2 from '@angular/platform-browser';
-import { DomSanitizer, Title, Meta } from '@angular/platform-browser';
+import * as i1 from '@angular/platform-browser';
 import * as i1$1 from '@angular/router';
-import { Router } from '@angular/router';
+import { FormControl, FormGroup } from '@angular/forms';
 import { buildClientSchema, getIntrospectionQuery } from 'graphql';
 import { map } from 'rxjs/operators';
 
@@ -136,15 +135,19 @@ class StorageService {
         this.storage.clear();
     }
 }
-StorageService.ɵprov = i0.ɵɵdefineInjectable({ factory: function StorageService_Factory() { return new StorageService(i0.ɵɵinject(BASE_MODULE_CONFIG)); }, token: StorageService, providedIn: "root" });
-StorageService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
-StorageService.ctorParameters = () => [
-    { type: undefined, decorators: [{ type: Inject, args: [BASE_MODULE_CONFIG,] }] }
-];
+StorageService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: StorageService, deps: [{ token: BASE_MODULE_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable });
+StorageService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: StorageService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: StorageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: [BASE_MODULE_CONFIG]
+                    }] }];
+    } });
 
 class WsService {
     reconnect() {
@@ -153,12 +156,14 @@ class WsService {
         (_b = this.client) === null || _b === void 0 ? void 0 : _b.connect();
     }
 }
-WsService.ɵprov = i0.ɵɵdefineInjectable({ factory: function WsService_Factory() { return new WsService(); }, token: WsService, providedIn: "root" });
-WsService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
+WsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: WsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+WsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: WsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: WsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
 
 /**
  * Authentication service
@@ -213,17 +218,19 @@ class AuthService {
         return this._token.asObservable();
     }
 }
-AuthService.ɵprov = i0.ɵɵdefineInjectable({ factory: function AuthService_Factory() { return new AuthService(i0.ɵɵinject(BASE_MODULE_CONFIG), i0.ɵɵinject(StorageService), i0.ɵɵinject(WsService)); }, token: AuthService, providedIn: "root" });
-AuthService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
-AuthService.ctorParameters = () => [
-    { type: undefined, decorators: [{ type: Inject, args: [BASE_MODULE_CONFIG,] }] },
-    { type: StorageService },
-    { type: WsService }
-];
+AuthService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: AuthService, deps: [{ token: BASE_MODULE_CONFIG }, { token: StorageService }, { token: WsService }], target: i0.ɵɵFactoryTarget.Injectable });
+AuthService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: AuthService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: AuthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: [BASE_MODULE_CONFIG]
+                    }] }, { type: StorageService }, { type: WsService }];
+    } });
 
 /**
  * Factory for apollo-angular options
@@ -366,24 +373,29 @@ class ContextMenuDirective {
         }
     }
 }
-ContextMenuDirective.decorators = [
-    { type: Directive, args: [{
-                selector: '[ltContextMenu]',
-                exportAs: 'contextMenuData',
-            },] }
-];
-ContextMenuDirective.ctorParameters = () => [
-    { type: ElementRef }
-];
-ContextMenuDirective.propDecorators = {
-    contextMenuData: [{ type: Input }],
-    ltContextMenu: [{ type: Input }],
-    xGap: [{ type: Input }],
-    yGap: [{ type: Input }],
-    overflowSpace: [{ type: Input }],
-    selectors: [{ type: Input }],
-    clickedElement: [{ type: Output }]
-};
+ContextMenuDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: ContextMenuDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+ContextMenuDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.3", type: ContextMenuDirective, selector: "[ltContextMenu]", inputs: { contextMenuData: "contextMenuData", ltContextMenu: "ltContextMenu", xGap: "xGap", yGap: "yGap", overflowSpace: "overflowSpace", selectors: "selectors" }, outputs: { clickedElement: "clickedElement" }, exportAs: ["contextMenuData"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: ContextMenuDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ltContextMenu]',
+                    exportAs: 'contextMenuData',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { contextMenuData: [{
+                type: Input
+            }], ltContextMenu: [{
+                type: Input
+            }], xGap: [{
+                type: Input
+            }], yGap: [{
+                type: Input
+            }], overflowSpace: [{
+                type: Input
+            }], selectors: [{
+                type: Input
+            }], clickedElement: [{
+                type: Output
+            }] } });
 
 /**
  * Directive for lazy loading images
@@ -414,18 +426,19 @@ class LazyLoadDirective {
         this.srcAttr = this.src;
     }
 }
-LazyLoadDirective.decorators = [
-    { type: Directive, args: [{
-                selector: 'img[ltLazyLoad]',
-            },] }
-];
-LazyLoadDirective.ctorParameters = () => [
-    { type: ElementRef }
-];
-LazyLoadDirective.propDecorators = {
-    srcAttr: [{ type: HostBinding, args: ['attr.src',] }],
-    src: [{ type: Input }]
-};
+LazyLoadDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: LazyLoadDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+LazyLoadDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.3", type: LazyLoadDirective, selector: "img[ltLazyLoad]", inputs: { src: "src" }, host: { properties: { "attr.src": "this.srcAttr" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: LazyLoadDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'img[ltLazyLoad]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { srcAttr: [{
+                type: HostBinding,
+                args: ['attr.src']
+            }], src: [{
+                type: Input
+            }] } });
 
 /**
  * Helper class
@@ -715,6 +728,15 @@ class Helper {
             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)}`;
+    }
 }
 
 /**
@@ -805,12 +827,14 @@ class ImageService {
         });
     }
 }
-ImageService.ɵprov = i0.ɵɵdefineInjectable({ factory: function ImageService_Factory() { return new ImageService(); }, token: ImageService, providedIn: "root" });
-ImageService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
+ImageService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: ImageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ImageService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: ImageService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: ImageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
 
 /**
  * Set same height (maximum) to different elements
@@ -870,21 +894,26 @@ class MatchHeightDirective {
         });
     }
 }
-MatchHeightDirective.decorators = [
-    { type: Directive, args: [{
-                selector: '[ltMatchHeight]',
-            },] }
-];
-MatchHeightDirective.ctorParameters = () => [
-    { type: ElementRef },
-    { type: ImageService },
-    { type: String, decorators: [{ type: Inject, args: [PLATFORM_ID,] }] }
-];
-MatchHeightDirective.propDecorators = {
-    ltMatchHeight: [{ type: Input }],
-    loadImages: [{ type: Input }],
-    onResize: [{ type: HostListener, args: ['window:resize',] }]
-};
+MatchHeightDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: MatchHeightDirective, deps: [{ token: i0.ElementRef }, { token: ImageService }, { token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Directive });
+MatchHeightDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.3", type: MatchHeightDirective, selector: "[ltMatchHeight]", inputs: { ltMatchHeight: "ltMatchHeight", loadImages: "loadImages" }, host: { listeners: { "window:resize": "onResize()" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: MatchHeightDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ltMatchHeight]',
+                }]
+        }], ctorParameters: function () {
+        return [{ type: i0.ElementRef }, { type: ImageService }, { type: undefined, decorators: [{
+                        type: Inject,
+                        args: [PLATFORM_ID]
+                    }] }];
+    }, propDecorators: { ltMatchHeight: [{
+                type: Input
+            }], loadImages: [{
+                type: Input
+            }], onResize: [{
+                type: HostListener,
+                args: ['window:resize']
+            }] } });
 
 /**
  * Reszise detection
@@ -961,18 +990,18 @@ class ResizableDirective {
         }, true);
     }
 }
-ResizableDirective.decorators = [
-    { type: Directive, args: [{
-                selector: '[ltResizable]',
-            },] }
-];
-ResizableDirective.ctorParameters = () => [
-    { type: ElementRef }
-];
-ResizableDirective.propDecorators = {
-    resizableGrabWidth: [{ type: Input }],
-    resizableMinWidth: [{ type: Input }]
-};
+ResizableDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: ResizableDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+ResizableDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.3", type: ResizableDirective, selector: "[ltResizable]", inputs: { resizableGrabWidth: "resizableGrabWidth", resizableMinWidth: "resizableMinWidth" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: ResizableDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ltResizable]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { resizableGrabWidth: [{
+                type: Input
+            }], resizableMinWidth: [{
+                type: Input
+            }] } });
 
 /**
  * Truncate string with ellipses
@@ -985,11 +1014,14 @@ class EllipsesPipe {
         return value.length > limit ? value.substring(0, limit) + '...' : value;
     }
 }
-EllipsesPipe.decorators = [
-    { type: Pipe, args: [{
-                name: 'ltEllipses',
-            },] }
-];
+EllipsesPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: EllipsesPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+EllipsesPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: EllipsesPipe, name: "ltEllipses" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: EllipsesPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'ltEllipses',
+                }]
+        }] });
 
 /**
  * Declarate html as safe
@@ -1002,12 +1034,75 @@ class SafeHtmlPipe {
         return this.sanitized.bypassSecurityTrustHtml(value);
     }
 }
-SafeHtmlPipe.decorators = [
-    { type: Pipe, args: [{ name: 'ltSafeHtml' },] }
-];
-SafeHtmlPipe.ctorParameters = () => [
-    { type: DomSanitizer }
-];
+SafeHtmlPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SafeHtmlPipe, deps: [{ token: i1.DomSanitizer }], target: i0.ɵɵFactoryTarget.Pipe });
+SafeHtmlPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SafeHtmlPipe, name: "ltSafeHtml" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SafeHtmlPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'ltSafeHtml' }]
+        }], ctorParameters: function () { return [{ type: i1.DomSanitizer }]; } });
+
+class DateAgoPipe {
+    constructor() {
+        this.intervals = {
+            year: 31536000,
+            month: 2592000,
+            week: 604800,
+            day: 86400,
+            hour: 3600,
+            minute: 60,
+            second: 1,
+        };
+        this.singular = {
+            year: 'Jahr',
+            month: 'Monat',
+            week: 'Woche',
+            day: 'Tag',
+            hour: 'Stunde',
+            minute: 'Minute',
+            second: 'Sekunde',
+        };
+        this.plural = {
+            year: 'Jahren',
+            month: 'Monaten',
+            week: 'Wochen',
+            day: 'Tagen',
+            hour: 'Stunden',
+            minute: 'Minuten',
+            second: 'Sekunden',
+        };
+    }
+    transform(value, currentDate) {
+        const now = currentDate !== null && currentDate !== void 0 ? currentDate : new Date();
+        if (value) {
+            const seconds = Math.floor((+now - +new Date(value)) / 1000);
+            if (seconds < 29) {
+                return 'gerade eben'; // less than 30 seconds ago will show as 'Just now'
+            }
+            let counter;
+            for (const i of Object.keys(this.intervals)) {
+                counter = Math.floor(seconds / this.intervals[i]);
+                if (counter > 0) {
+                    if (counter === 1) {
+                        return 'vor ' + counter + ' ' + this.singular[i]; // singular (1 day ago)
+                    }
+                    else {
+                        return 'vor ' + counter + ' ' + this.plural[i]; // plural (2 days ago)
+                    }
+                }
+            }
+        }
+        return value;
+    }
+}
+DateAgoPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: DateAgoPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+DateAgoPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: DateAgoPipe, name: "dateAgo" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: DateAgoPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'dateAgo',
+                    pure: true,
+                }]
+        }] });
 
 // Imported and exported elements
 const elements = [
@@ -1019,6 +1114,7 @@ const elements = [
     // Pipes
     EllipsesPipe,
     SafeHtmlPipe,
+    DateAgoPipe,
 ];
 /**
  * Base module
@@ -1055,12 +1151,36 @@ class BaseModule {
         };
     }
 }
-BaseModule.decorators = [
-    { type: NgModule, args: [{
-                declarations: elements,
-                exports: elements,
-            },] }
-];
+BaseModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: BaseModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+BaseModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: BaseModule, declarations: [
+        // Directives
+        ContextMenuDirective,
+        LazyLoadDirective,
+        MatchHeightDirective,
+        ResizableDirective,
+        // Pipes
+        EllipsesPipe,
+        SafeHtmlPipe,
+        DateAgoPipe
+    ], exports: [
+        // Directives
+        ContextMenuDirective,
+        LazyLoadDirective,
+        MatchHeightDirective,
+        ResizableDirective,
+        // Pipes
+        EllipsesPipe,
+        SafeHtmlPipe,
+        DateAgoPipe
+    ] });
+BaseModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: BaseModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: BaseModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: elements,
+                    exports: elements,
+                }]
+        }] });
 
 /**
  * Standard class
@@ -1372,14 +1492,16 @@ class AuthGuard {
         return this.canActivate(route, state);
     }
 }
-AuthGuard.decorators = [
-    { type: Injectable }
-];
-AuthGuard.ctorParameters = () => [
-    { type: Router },
-    { type: AuthService },
-    { type: undefined, decorators: [{ type: Inject, args: [BASE_MODULE_CONFIG,] }] }
-];
+AuthGuard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: AuthGuard, deps: [{ token: i1$1.Router }, { token: AuthService }, { token: BASE_MODULE_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable });
+AuthGuard.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: AuthGuard });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: AuthGuard, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () {
+        return [{ type: i1$1.Router }, { type: AuthService }, { type: undefined, decorators: [{
+                        type: Inject,
+                        args: [BASE_MODULE_CONFIG]
+                    }] }];
+    } });
 
 /**
  * Guard to check if a component can be deactivated
@@ -1389,9 +1511,11 @@ class CanDeactivateGuard {
         return component.canDeactivate ? component.canDeactivate() : true;
     }
 }
-CanDeactivateGuard.decorators = [
-    { type: Injectable }
-];
+CanDeactivateGuard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: CanDeactivateGuard, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+CanDeactivateGuard.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: CanDeactivateGuard });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: CanDeactivateGuard, decorators: [{
+            type: Injectable
+        }] });
 
 /**
  * Logout guard
@@ -1414,13 +1538,11 @@ class LogoutGuard {
         return this.canActivate(route, state);
     }
 }
-LogoutGuard.decorators = [
-    { type: Injectable }
-];
-LogoutGuard.ctorParameters = () => [
-    { type: Router },
-    { type: AuthService }
-];
+LogoutGuard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: LogoutGuard, deps: [{ token: i1$1.Router }, { token: AuthService }], target: i0.ɵɵFactoryTarget.Injectable });
+LogoutGuard.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: LogoutGuard });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: LogoutGuard, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1$1.Router }, { type: AuthService }]; } });
 
 /**
  * Comparison operator enum
@@ -1464,6 +1586,29 @@ var SortOrderEnum;
     SortOrderEnum["DESC"] = "DESC";
 })(SortOrderEnum || (SortOrderEnum = {}));
 
+class FormsService {
+    constructor() { }
+    validateAllFormFields(formGroup) {
+        Object.keys(formGroup.controls).forEach((field) => {
+            const control = formGroup.get(field);
+            if (control instanceof FormControl) {
+                control.markAsTouched({ onlySelf: true });
+            }
+            else if (control instanceof FormGroup) {
+                this.validateAllFormFields(control);
+            }
+        });
+    }
+}
+FormsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: FormsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+FormsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: FormsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: FormsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+
 /**
  * Fullscreen service
  */
@@ -1503,13 +1648,14 @@ class FullscreenService {
         });
     }
 }
-FullscreenService.ɵprov = i0.ɵɵdefineInjectable({ factory: function FullscreenService_Factory() { return new FullscreenService(); }, token: FullscreenService, providedIn: "root" });
-FullscreenService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
-FullscreenService.ctorParameters = () => [];
+FullscreenService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: FullscreenService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+FullscreenService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: FullscreenService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: FullscreenService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
 
 /**
  * GraphQL meta service
@@ -1608,15 +1754,14 @@ class GraphQLMetaService {
         return observable;
     }
 }
-GraphQLMetaService.ɵprov = i0.ɵɵdefineInjectable({ factory: function GraphQLMetaService_Factory() { return new GraphQLMetaService(i0.ɵɵinject(i1.Apollo)); }, token: GraphQLMetaService, providedIn: "root" });
-GraphQLMetaService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
-GraphQLMetaService.ctorParameters = () => [
-    { type: Apollo }
-];
+GraphQLMetaService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: GraphQLMetaService, deps: [{ token: i1$2.Apollo }], target: i0.ɵɵFactoryTarget.Injectable });
+GraphQLMetaService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: GraphQLMetaService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: GraphQLMetaService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1$2.Apollo }]; } });
 
 /**
  * GraphQL service
@@ -2020,16 +2165,14 @@ class GraphQLService {
         return { fieldsString, schemaFields, usedFields };
     }
 }
-GraphQLService.ɵprov = i0.ɵɵdefineInjectable({ factory: function GraphQLService_Factory() { return new GraphQLService(i0.ɵɵinject(i1.Apollo), i0.ɵɵinject(GraphQLMetaService)); }, token: GraphQLService, providedIn: "root" });
-GraphQLService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
-GraphQLService.ctorParameters = () => [
-    { type: Apollo },
-    { type: GraphQLMetaService }
-];
+GraphQLService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: GraphQLService, deps: [{ token: i1$2.Apollo }, { token: GraphQLMetaService }], target: i0.ɵɵFactoryTarget.Injectable });
+GraphQLService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: GraphQLService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: GraphQLService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1$2.Apollo }, { type: GraphQLMetaService }]; } });
 
 /**
  * Loader service for loading indication
@@ -2048,12 +2191,14 @@ class LoaderService {
         return this.isLoading.asObservable();
     }
 }
-LoaderService.ɵprov = i0.ɵɵdefineInjectable({ factory: function LoaderService_Factory() { return new LoaderService(); }, token: LoaderService, providedIn: "root" });
-LoaderService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
+LoaderService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: LoaderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+LoaderService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: LoaderService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: LoaderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
 
 /**
  * GraphQL plus service, for extra error handling and loading indication
@@ -2122,17 +2267,14 @@ class GraphQLPlusService extends GraphQLService {
         console.error(error);
     }
 }
-GraphQLPlusService.ɵprov = i0.ɵɵdefineInjectable({ factory: function GraphQLPlusService_Factory() { return new GraphQLPlusService(i0.ɵɵinject(i1.Apollo), i0.ɵɵinject(GraphQLMetaService), i0.ɵɵinject(LoaderService)); }, token: GraphQLPlusService, providedIn: "root" });
-GraphQLPlusService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
-GraphQLPlusService.ctorParameters = () => [
-    { type: Apollo },
-    { type: GraphQLMetaService },
-    { type: LoaderService }
-];
+GraphQLPlusService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: GraphQLPlusService, deps: [{ token: i1$2.Apollo }, { token: GraphQLMetaService }, { token: LoaderService }], target: i0.ɵɵFactoryTarget.Injectable });
+GraphQLPlusService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: GraphQLPlusService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: GraphQLPlusService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1$2.Apollo }, { type: GraphQLMetaService }, { type: LoaderService }]; } });
 
 /**
  * Scroll service for autoscroll to specific fragments
@@ -2285,17 +2427,19 @@ class ScrollService {
         return this.scrollPromise;
     }
 }
-ScrollService.ɵprov = i0.ɵɵdefineInjectable({ factory: function ScrollService_Factory() { return new ScrollService(i0.ɵɵinject(i1$1.Router), i0.ɵɵinject(BASE_MODULE_CONFIG), i0.ɵɵinject(ImageService)); }, token: ScrollService, providedIn: "root" });
-ScrollService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
-ScrollService.ctorParameters = () => [
-    { type: Router },
-    { type: undefined, decorators: [{ type: Inject, args: [BASE_MODULE_CONFIG,] }] },
-    { type: ImageService }
-];
+ScrollService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: ScrollService, deps: [{ token: i1$1.Router }, { token: BASE_MODULE_CONFIG }, { token: ImageService }], target: i0.ɵɵFactoryTarget.Injectable });
+ScrollService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: ScrollService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: ScrollService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () {
+        return [{ type: i1$1.Router }, { type: undefined, decorators: [{
+                        type: Inject,
+                        args: [BASE_MODULE_CONFIG]
+                    }] }, { type: ImageService }];
+    } });
 
 /**
  * SEO service for setting HTML meta data
@@ -2382,48 +2526,83 @@ class SEOService {
         this.metaTagService.updateTag({ name: 'keywords', content: keywords });
     }
 }
-SEOService.ɵprov = i0.ɵɵdefineInjectable({ factory: function SEOService_Factory() { return new SEOService(i0.ɵɵinject(i1$2.Title), i0.ɵɵinject(i1$2.Meta)); }, token: SEOService, providedIn: "root" });
-SEOService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
-SEOService.ctorParameters = () => [
-    { type: Title },
-    { type: Meta }
-];
+SEOService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SEOService, deps: [{ token: i1.Title }, { token: i1.Meta }], target: i0.ɵɵFactoryTarget.Injectable });
+SEOService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SEOService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SEOService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Title }, { type: i1.Meta }]; } });
+
+class ThemeService {
+    constructor(storageService) {
+        this.storageService = storageService;
+        this._theme = new BehaviorSubject('light');
+        // Load from storage
+        this.theme = this.storageService.load('theme');
+        // Use system theme if no theme is set
+        if (!this.theme) {
+            this.checkSystemTheme();
+        }
+    }
+    get theme() {
+        return this._theme.value;
+    }
+    set theme(theme) {
+        this._theme.next(theme);
+        this.storageService.save('theme', theme);
+    }
+    get themeObservable() {
+        return this._theme.asObservable();
+    }
+    /**
+     * Check theme from system
+     */
+    checkSystemTheme() {
+        if (window.matchMedia) {
+            this.theme = window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light';
+        }
+    }
+}
+ThemeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: ThemeService, deps: [{ token: StorageService }], target: i0.ɵɵFactoryTarget.Injectable });
+ThemeService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: ThemeService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: ThemeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: StorageService }]; } });
 
 /**
  * Custom validator to check that two fields match
  * (inspirated by https://jasonwatmore.com/post/2018/11/07/angular-7-reactive-forms-validation-example)
  */
-function MustMatch(controlName, matchingControlName) {
+const MustMatch = (control) => {
     return (formGroup) => {
-        const control = formGroup.controls[controlName];
-        const matchingControl = formGroup.controls[matchingControlName];
+        const baseControl = control.get('password');
+        const matchingControl = control.get('passwordConfirm');
         if (matchingControl.errors && !matchingControl.errors.mustMatch) {
             // return if another validator has already found an error on the matchingControl
-            return;
+            return null;
         }
         // set error on matchingControl if validation fails
-        if (control.value !== matchingControl.value) {
-            matchingControl.setErrors({ mustMatch: true });
+        if (baseControl.value !== matchingControl.value) {
+            return { mustMatch: true };
         }
         else {
-            matchingControl.setErrors(null);
+            return null;
         }
     };
-}
+};
 
 /**
  * Exports for public API
  */
 
-// Export libs
-
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AuthGuard, AuthService, BASE_MODULE_CONFIG, BaseModule, BasicUser, CanDeactivateGuard, ComparisonOperatorEnum, ContextMenuDirective, EllipsesPipe, FullscreenService, GraphQLEnum, GraphQLMeta, GraphQLMetaService, GraphQLPlusService, GraphQLRequestType, GraphQLService, GraphQLType, Helper, ImageService, LazyLoadDirective, LoaderService, LogicalOperatorEnum, LogoutGuard, MatchHeightDirective, MustMatch, ResizableDirective, SEOService, SafeHtmlPipe, ScrollService, SortOrderEnum, Standard, StorageService, WsService, apolloOptionsFactory };
-//# sourceMappingURL=lenne.tech-ng-base.js.map
+export { AuthGuard, AuthService, BASE_MODULE_CONFIG, BaseModule, BasicUser, CanDeactivateGuard, ComparisonOperatorEnum, ContextMenuDirective, DateAgoPipe, EllipsesPipe, FormsService, FullscreenService, GraphQLEnum, GraphQLMeta, GraphQLMetaService, GraphQLPlusService, GraphQLRequestType, GraphQLService, GraphQLType, Helper, ImageService, LazyLoadDirective, LoaderService, LogicalOperatorEnum, LogoutGuard, MatchHeightDirective, MustMatch, ResizableDirective, SEOService, SafeHtmlPipe, ScrollService, SortOrderEnum, Standard, StorageService, ThemeService, WsService, apolloOptionsFactory };
+//# sourceMappingURL=lenne.tech-ng-base.mjs.map