@lenne.tech/ng-base 0.3.0 → 0.3.4

package/fesm2015/lenne.tech-ng-base.js

@@ -2,19 +2,20 @@ import * as i1 from 'apollo-angular';
 import { APOLLO_OPTIONS, gql, Apollo } from 'apollo-angular';
 import { HttpLink } from 'apollo-angular/http';
 import * as i0 from '@angular/core';
-import { InjectionToken, Injectable, Inject, Directive, ElementRef, Input, Output, HostBinding, HostListener, Pipe, NgModule } from '@angular/core';
+import { InjectionToken, Injectable, Inject, Directive, ElementRef, 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';
 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$1 from '@angular/router';
 import { Router } from '@angular/router';
 import { buildClientSchema, getIntrospectionQuery } from 'graphql';
 import { map } from 'rxjs/operators';
-import { __awaiter } from 'tslib';
 
 const BASE_MODULE_CONFIG = new InjectionToken('BASE_MODULE_CONFIG');
 
@@ -212,8 +213,9 @@ AuthService.ctorParameters = () => [
  */
 function apolloOptionsFactory(baseModuleConfig, httpLink, authService) {
     const links = [];
+    const defaultUrl = 'api.' + window.location.href + '/graphql';
     const http = httpLink.create({
-        uri: baseModuleConfig.apiUrl,
+        uri: baseModuleConfig.apiUrl ? baseModuleConfig.apiUrl : 'https://' + defaultUrl,
     });
     const authMiddleware = new ApolloLink((operation, forward) => {
         const headers = {};
@@ -418,238 +420,6 @@ LazyLoadDirective.propDecorators = {
     src: [{ type: Input }]
 };
 
-/**
- * Set same height (maximum) to different elements
- */
-class MatchHeightDirective {
-    constructor(el) {
-        this.el = el;
-    }
-    onResize() {
-        this.matchHeight(this.el.nativeElement, this.ltMatchHeight);
-    }
-    ngAfterViewChecked() {
-        this.matchHeight(this.el.nativeElement, this.ltMatchHeight);
-    }
-    matchHeight(parent, target) {
-        if (!parent) {
-            return;
-        }
-        let classNames;
-        if (!Array.isArray(target)) {
-            classNames = [target];
-        }
-        else {
-            classNames = target;
-        }
-        classNames.forEach((className) => {
-            // find all child structureElements with the selected class name
-            const children = parent.getElementsByClassName(className);
-            if (!children) {
-                return;
-            }
-            // reset all children height
-            Array.from(children).forEach((x) => {
-                x.style.height = 'initial';
-            });
-            // get all the child structureElements heights
-            const itemHeights = Array.from(children).map((x) => x.getBoundingClientRect().height);
-            // find out the tallest one
-            const maxHeight = itemHeights.reduce((prev, curr) => (curr > prev ? curr : prev), 0);
-            // update the child structureElements height to the tallest one
-            Array.from(children).forEach((x) => (x.style.height = `${maxHeight}px`));
-        });
-    }
-}
-MatchHeightDirective.decorators = [
-    { type: Directive, args: [{
-                selector: '[ltMatchHeight]',
-            },] }
-];
-MatchHeightDirective.ctorParameters = () => [
-    { type: ElementRef }
-];
-MatchHeightDirective.propDecorators = {
-    ltMatchHeight: [{ type: Input }],
-    onResize: [{ type: HostListener, args: ['window:resize',] }]
-};
-
-/**
- * Reszise detection
- * (inpsired by: https://stackblitz.com/edit/angular-resizable)
- */
-class ResizableDirective {
-    constructor(el) {
-        this.el = el;
-        this.resizableGrabWidth = 8;
-        this.resizableMinWidth = 10;
-        this.dragging = false;
-    }
-    ngOnInit() {
-        this.addListenerToDocument();
-        this.addListenerToElement();
-    }
-    mouseMoveG(evt) {
-        if (!this.dragging) {
-            return;
-        }
-        this.newWidth(evt.clientX - this.el.nativeElement.offsetLeft);
-        evt.stopPropagation();
-    }
-    newWidth(wid) {
-        const result = Math.max(this.resizableMinWidth, wid);
-        this.el.nativeElement.style.width = result + 'px';
-    }
-    mouseDown(evt) {
-        if (this.inDragRegion(evt)) {
-            this.dragging = true;
-            this.preventGlobalMouseEvents();
-            evt.stopPropagation();
-        }
-    }
-    restoreGlobalMouseEvents() {
-        document.body.style['pointer-events'] = 'auto';
-    }
-    mouseUpG(evt) {
-        if (!this.dragging) {
-            return;
-        }
-        this.restoreGlobalMouseEvents();
-        this.dragging = false;
-        evt.stopPropagation();
-    }
-    mouseMove(evt) {
-        if (this.inDragRegion(evt) || this.dragging) {
-            this.el.nativeElement.style.cursor = 'col-resize';
-        }
-        else {
-            this.el.nativeElement.style.cursor = 'default';
-        }
-    }
-    preventGlobalMouseEvents() {
-        document.body.style['pointer-events'] = 'none';
-    }
-    inDragRegion(evt) {
-        return this.el.nativeElement.clientWidth - evt.clientX + this.el.nativeElement.offsetLeft < this.resizableGrabWidth;
-    }
-    addListenerToDocument() {
-        document.addEventListener('mousemove', (e) => {
-            this.mouseMoveG(e);
-        }, true);
-        document.addEventListener('mouseup', (e) => {
-            this.mouseUpG(e);
-        }, true);
-    }
-    addListenerToElement() {
-        this.el.nativeElement.addEventListener('mousedown', (e) => {
-            this.mouseDown(e);
-        }, true);
-        this.el.nativeElement.addEventListener('mousemove', (e) => {
-            this.mouseMove(e);
-        }, true);
-    }
-}
-ResizableDirective.decorators = [
-    { type: Directive, args: [{
-                selector: '[ltResizable]',
-            },] }
-];
-ResizableDirective.ctorParameters = () => [
-    { type: ElementRef }
-];
-ResizableDirective.propDecorators = {
-    resizableGrabWidth: [{ type: Input }],
-    resizableMinWidth: [{ type: Input }]
-};
-
-/**
- * Truncate string with ellipses
- */
-class EllipsesPipe {
-    transform(value, limit) {
-        if (!value) {
-            return null;
-        }
-        return value.length > limit ? value.substring(0, limit) + '...' : value;
-    }
-}
-EllipsesPipe.decorators = [
-    { type: Pipe, args: [{
-                name: 'ltEllipses',
-            },] }
-];
-
-/**
- * Declarate html as safe
- */
-class SafeHtmlPipe {
-    constructor(sanitized) {
-        this.sanitized = sanitized;
-    }
-    transform(value) {
-        return this.sanitized.bypassSecurityTrustHtml(value);
-    }
-}
-SafeHtmlPipe.decorators = [
-    { type: Pipe, args: [{ name: 'ltSafeHtml' },] }
-];
-SafeHtmlPipe.ctorParameters = () => [
-    { type: DomSanitizer }
-];
-
-// Imported and exported elements
-const elements = [
-    // Directives
-    ContextMenuDirective,
-    LazyLoadDirective,
-    MatchHeightDirective,
-    ResizableDirective,
-    // Pipes
-    EllipsesPipe,
-    SafeHtmlPipe,
-];
-/**
- * Base module
- */
-class BaseModule {
-    /**
-     * Set configuration of base module in root module of the app
-     */
-    static forRoot(baseModuleConfig = {}) {
-        // Default config
-        const config = Object.assign({ apiUrl: 'localhost:3000', authGuardRedirectUrl: '/auth', logging: false, version: null, prefix: null, scrollDetectionOffset: 200, scrollOffset: 100, storageType: 'local' }, baseModuleConfig);
-        // Prepare providers
-        const providers = [
-            {
-                provide: BASE_MODULE_CONFIG,
-                useValue: baseModuleConfig,
-            },
-        ];
-        // Add apollo features if API URL is set
-        if (baseModuleConfig.apiUrl) {
-            providers.push({
-                provide: APOLLO_OPTIONS,
-                useFactory: apolloOptionsFactory,
-                deps: [BASE_MODULE_CONFIG, HttpLink, AuthService],
-            });
-        }
-        else if (config.logging) {
-            console.log('apiUrl is missing, ApolloLink is not initialized');
-        }
-        // Return root module
-        return {
-            ngModule: BaseModule,
-            providers,
-        };
-    }
-}
-BaseModule.decorators = [
-    { type: NgModule, args: [{
-                declarations: elements,
-                exports: elements,
-            },] }
-];
-
 /**
  * Helper class
  */
@@ -872,55 +642,448 @@ class Helper {
         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 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;
+        }
+    }
+}
+
+/**
+ * Image service
+ */
+class ImageService {
+    /**
+     * Preaload images (for lazy handling)
+     *
+     * @param options
+     * @protected
+     */
+    preLoadImages(options) {
+        // Init configuration
+        const config = Object.assign({ doneFunnction: undefined, elements: document, regExp: undefined, timeout: undefined }, options);
+        return new Promise((resolve) => {
+            var _a;
+            // Init variables
+            let resolved = false;
+            let timeoutId;
+            // 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 (const image of images) {
+                const src = image.getAttribute('src');
+                // Check if changes are necessary and possible
+                if ((image.complete && image.naturalHeight !== 0) || // already laoded
+                    image.getAttribute('loading') !== 'lazy' || // loading attribute !== lazy
+                    !src || // Image has no src
+                    ((_a = config.regExp) === null || _a === void 0 ? void 0 : _a.test(src)) // Test if src matches regular expression
+                ) {
+                    continue;
+                }
+                // Replace lazy loading image with immediately loading image
+                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);
+                // Wait for laoding
+                promises.push(this.loadImage(newImage, src));
+            }
+            if (config.timeout) {
+                timeoutId = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                    resolved = true;
+                    if (config.doneFunnction) {
+                        yield config.doneFunction();
+                    }
+                    resolve(undefined);
+                }));
+            }
+            // Wait until all images loaded
+            Promise.all(promises)
+                .catch((e) => console.error('Error during image loading', e))
+                .finally(() => __awaiter(this, void 0, void 0, function* () {
+                // Check if already resolved
+                if (resolved) {
+                    return;
+                }
+                // Stop timeout
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                }
+                // Return result
+                let result;
+                if (config.doneFunnction) {
+                    result = yield config.doneFunction();
+                }
+                resolve(result);
+            }));
+        });
+    }
+    /**
+     * Load image for image element
+     *
+     * @param imageElement
+     * @param src
+     * @protected
+     */
+    loadImage(imageElement, src) {
+        return __awaiter(this, void 0, void 0, function* () {
+            src = src || imageElement.src;
+            return new Promise((resolve, reject) => {
+                imageElement.onload = () => resolve(imageElement);
+                imageElement.onerror = reject;
+                imageElement.src = src;
+            });
+        });
+    }
+}
+ImageService.ɵprov = i0.ɵɵdefineInjectable({ factory: function ImageService_Factory() { return new ImageService(); }, token: ImageService, providedIn: "root" });
+ImageService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+
+/**
+ * Set same height (maximum) to different elements
+ */
+class MatchHeightDirective {
+    constructor(el, imageService, platformId) {
+        this.el = el;
+        this.imageService = imageService;
+        // Replace lazy loading images with immediate loading images
+        this.loadLazyImages = true;
+        this.isBrowser = isPlatformBrowser(platformId);
+    }
+    onResize() {
+        this.matchHeight(this.el.nativeElement, this.ltMatchHeight);
+    }
+    ngAfterViewChecked() {
+        this.matchHeight(this.el.nativeElement, this.ltMatchHeight);
+    }
+    matchHeight(parent, target) {
+        if (this.isBrowser) {
+            // Timeout is set to force Angular to wait for all actions and only continue once the process has run through.
+            // Otherwise, an infinite loop will occur.
+            setTimeout(() => {
+                this.matchHeightHelper(parent, target);
+            }, 1);
+        }
+        else {
+            this.matchHeightHelper(parent, target);
+        }
+    }
+    matchHeightHelper(parent, target) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!parent) {
+                return;
+            }
+            let classNames;
+            if (!Array.isArray(target)) {
+                classNames = [target];
+            }
+            else {
+                classNames = target;
+            }
+            for (const className of classNames) {
+                // find all child structureElements with the selected class name
+                const children = parent.getElementsByClassName(className);
+                if (!children || children.length < 2) {
+                    continue;
+                }
+                // Load images of children
+                if (this.loadLazyImages) {
+                    yield this.imageService.preLoadImages({ elements: children });
+                }
+                // reset all children height
+                Array.from(children).forEach((element) => {
+                    element.style.height = 'initial';
+                });
+                // get all the child structureElements heights
+                const itemHeights = Array.from(children).map((element) => {
+                    if (element.getBoundingClientRect) {
+                        return element.getBoundingClientRect().height;
+                    }
+                    return 0;
+                });
+                // find out the tallest one
+                const maxHeight = itemHeights.reduce((prev, curr) => (curr > prev ? curr : prev), 0);
+                // update the child structureElements height to the tallest one
+                Array.from(children).forEach((element) => (element.style.height = `${maxHeight}px`));
+            }
+        });
+    }
+}
+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 }],
+    loadLazyImages: [{ type: Input }],
+    onResize: [{ type: HostListener, args: ['window:resize',] }]
+};
+
+/**
+ * Reszise detection
+ * (inpsired by: https://stackblitz.com/edit/angular-resizable)
+ */
+class ResizableDirective {
+    constructor(el) {
+        this.el = el;
+        this.resizableGrabWidth = 8;
+        this.resizableMinWidth = 10;
+        this.dragging = false;
+    }
+    ngOnInit() {
+        this.addListenerToDocument();
+        this.addListenerToElement();
+    }
+    mouseMoveG(evt) {
+        if (!this.dragging) {
+            return;
+        }
+        this.newWidth(evt.clientX - this.el.nativeElement.offsetLeft);
+        evt.stopPropagation();
+    }
+    newWidth(wid) {
+        const result = Math.max(this.resizableMinWidth, wid);
+        this.el.nativeElement.style.width = result + 'px';
+    }
+    mouseDown(evt) {
+        if (this.inDragRegion(evt)) {
+            this.dragging = true;
+            this.preventGlobalMouseEvents();
+            evt.stopPropagation();
+        }
+    }
+    restoreGlobalMouseEvents() {
+        document.body.style['pointer-events'] = 'auto';
+    }
+    mouseUpG(evt) {
+        if (!this.dragging) {
+            return;
+        }
+        this.restoreGlobalMouseEvents();
+        this.dragging = false;
+        evt.stopPropagation();
+    }
+    mouseMove(evt) {
+        if (this.inDragRegion(evt) || this.dragging) {
+            this.el.nativeElement.style.cursor = 'col-resize';
+        }
+        else {
+            this.el.nativeElement.style.cursor = 'default';
         }
-        // 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;
+    }
+    preventGlobalMouseEvents() {
+        document.body.style['pointer-events'] = 'none';
+    }
+    inDragRegion(evt) {
+        return this.el.nativeElement.clientWidth - evt.clientX + this.el.nativeElement.offsetLeft < this.resizableGrabWidth;
+    }
+    addListenerToDocument() {
+        document.addEventListener('mousemove', (e) => {
+            this.mouseMoveG(e);
+        }, true);
+        document.addEventListener('mouseup', (e) => {
+            this.mouseUpG(e);
+        }, true);
+    }
+    addListenerToElement() {
+        this.el.nativeElement.addEventListener('mousedown', (e) => {
+            this.mouseDown(e);
+        }, true);
+        this.el.nativeElement.addEventListener('mousemove', (e) => {
+            this.mouseMove(e);
+        }, true);
+    }
+}
+ResizableDirective.decorators = [
+    { type: Directive, args: [{
+                selector: '[ltResizable]',
+            },] }
+];
+ResizableDirective.ctorParameters = () => [
+    { type: ElementRef }
+];
+ResizableDirective.propDecorators = {
+    resizableGrabWidth: [{ type: Input }],
+    resizableMinWidth: [{ type: Input }]
+};
+
+/**
+ * Truncate string with ellipses
+ */
+class EllipsesPipe {
+    transform(value, limit) {
+        if (!value) {
+            return null;
         }
-        // Else
-        return true;
+        return value.length > limit ? value.substring(0, limit) + '...' : value;
     }
-    /**
-     * 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);
+}
+EllipsesPipe.decorators = [
+    { type: Pipe, args: [{
+                name: 'ltEllipses',
+            },] }
+];
+
+/**
+ * Declarate html as safe
+ */
+class SafeHtmlPipe {
+    constructor(sanitized) {
+        this.sanitized = sanitized;
+    }
+    transform(value) {
+        return this.sanitized.bypassSecurityTrustHtml(value);
     }
+}
+SafeHtmlPipe.decorators = [
+    { type: Pipe, args: [{ name: 'ltSafeHtml' },] }
+];
+SafeHtmlPipe.ctorParameters = () => [
+    { type: DomSanitizer }
+];
+
+// Imported and exported elements
+const elements = [
+    // Directives
+    ContextMenuDirective,
+    LazyLoadDirective,
+    MatchHeightDirective,
+    ResizableDirective,
+    // Pipes
+    EllipsesPipe,
+    SafeHtmlPipe,
+];
+/**
+ * Base module
+ */
+class BaseModule {
     /**
-     * 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
+     * Set configuration of base module in root module of the app
      */
-    static getDiff(a, b, clone = true) {
-        const result = {};
-        let firstObject = a;
-        if (clone) {
-            firstObject = JSON.parse(JSON.stringify(a));
+    static forRoot(baseModuleConfig = {}) {
+        // Default config
+        const config = Object.assign({ apiUrl: 'localhost:3000', authGuardRedirectUrl: '/auth', logging: false, version: null, prefix: null, scrollDetectionOffset: 200, scrollOffset: 100, storageType: 'local' }, baseModuleConfig);
+        // Prepare providers
+        const providers = [
+            {
+                provide: BASE_MODULE_CONFIG,
+                useValue: baseModuleConfig,
+            },
+        ];
+        // Add apollo features if API URL is set
+        if (baseModuleConfig.apiUrl) {
+            providers.push({
+                provide: APOLLO_OPTIONS,
+                useFactory: apolloOptionsFactory,
+                deps: [BASE_MODULE_CONFIG, HttpLink, AuthService],
+            });
         }
-        for (const [key, value] of Object.entries(firstObject)) {
-            if (!Helper.isSubset(value, b[key])) {
-                result[key] = value;
-            }
+        else if (config.logging) {
+            console.log('apiUrl is missing, ApolloLink is not initialized');
         }
-        return result;
+        // Return root module
+        return {
+            ngModule: BaseModule,
+            providers,
+        };
     }
 }
+BaseModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: elements,
+                exports: elements,
+            },] }
+];
 
 /**
  * Standard class
@@ -2001,9 +2164,10 @@ class ScrollService {
     /**
      * Initializer
      */
-    constructor(router, moduleConfig) {
+    constructor(router, moduleConfig, imageService) {
         this.router = router;
         this.moduleConfig = moduleConfig;
+        this.imageService = imageService;
         /**
          * Is a scroll listener set
          *
@@ -2053,7 +2217,7 @@ class ScrollService {
             }
             // Load images before scrolling (once)
             if (config.loadImagesBefore) {
-                yield this.preLoadImages();
+                yield this.imageService.preLoadImages();
             }
             // Get get bounding rect of target element
             const cords = el.getBoundingClientRect();
@@ -2164,87 +2328,8 @@ class ScrollService {
         // Return promise
         return this.scrollPromise;
     }
-    /**
-     * Preaload images (for lazy handling)
-     *
-     * @param options
-     * @protected
-     */
-    preLoadImages(options) {
-        // Init configuration
-        const config = Object.assign({ doneFunnction: undefined, timeout: undefined }, options);
-        return new Promise((resolve) => {
-            // Init variables
-            let resolved = false;
-            let timeoutId;
-            // Init loading
-            const images = Array.from(document.getElementsByTagName('img'));
-            const promises = [];
-            // Prepare images
-            for (const image of images) {
-                const src = image.getAttribute('src');
-                // Check if changes are necessary and possible
-                if ((image.complete && image.naturalHeight !== 0) || image.getAttribute('loading') !== 'lazy' || !src) {
-                    continue;
-                }
-                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);
-                promises.push(this.loadImage(newImage, src));
-            }
-            if (config.timeout) {
-                timeoutId = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
-                    resolved = true;
-                    if (config.doneFunnction) {
-                        yield config.doneFunction();
-                    }
-                    resolve(undefined);
-                }));
-            }
-            // Wait until all images loaded
-            Promise.all(promises)
-                .catch((e) => console.error('Error during image loading', e))
-                .finally(() => __awaiter(this, void 0, void 0, function* () {
-                // Check if already resolved
-                if (resolved) {
-                    return;
-                }
-                // Stop timeout
-                if (timeoutId) {
-                    clearTimeout(timeoutId);
-                }
-                // Return result
-                let result;
-                if (config.doneFunnction) {
-                    result = yield config.doneFunction();
-                }
-                resolve(result);
-            }));
-        });
-    }
-    /**
-     * Load image for image element
-     *
-     * @param imageElement
-     * @param src
-     * @protected
-     */
-    loadImage(imageElement, src) {
-        return __awaiter(this, void 0, void 0, function* () {
-            src = src || imageElement.src;
-            return new Promise((resolve, reject) => {
-                imageElement.onload = () => resolve(imageElement);
-                imageElement.onerror = reject;
-                imageElement.src = src;
-            });
-        });
-    }
 }
-ScrollService.ɵprov = i0.ɵɵdefineInjectable({ factory: function ScrollService_Factory() { return new ScrollService(i0.ɵɵinject(i1$1.Router), i0.ɵɵinject(BASE_MODULE_CONFIG)); }, token: ScrollService, providedIn: "root" });
+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',
@@ -2252,7 +2337,8 @@ ScrollService.decorators = [
 ];
 ScrollService.ctorParameters = () => [
     { type: Router },
-    { type: undefined, decorators: [{ type: Inject, args: [BASE_MODULE_CONFIG,] }] }
+    { type: undefined, decorators: [{ type: Inject, args: [BASE_MODULE_CONFIG,] }] },
+    { type: ImageService }
 ];
 
 /**
@@ -2263,23 +2349,79 @@ class SEOService {
         this.titleService = titleService;
         this.metaTagService = metaTagService;
     }
-    initPageForSEO(title, description, keywords) {
-        this.setPageTitle(title);
-        this.setPageDescription(description);
-        if (keywords) {
-            this.setPageKeywords(keywords);
+    initPageForSEO(input) {
+        this.setGeneralData(input);
+        this.setTwitterData(input);
+        this.setTwitterData(input);
+        this.setFacebookData(input);
+        if (input.keywords) {
+            this.setPageKeywords(input.keywords);
         }
     }
-    setPageTitle(title) {
-        this.titleService.setTitle(title);
-        this.metaTagService.updateTag({ property: 'og:title', content: title });
-        this.metaTagService.updateTag({ name: 'twitter:title', content: title });
+    /**
+     * Set general metadata
+     *
+     * @param data
+     * @private
+     */
+    setGeneralData(data) {
+        this.titleService.setTitle(data.title);
+        this.metaTagService.updateTag({ name: 'description', content: data.description });
+    }
+    /**
+     * Set metadata for twitter
+     *
+     * @param data
+     * @private
+     */
+    setTwitterData(data) {
+        this.metaTagService.updateTag({ name: 'twitter:title', content: data.title });
+        this.metaTagService.updateTag({ name: 'twitter:description', content: data.description });
+        this.metaTagService.updateTag({
+            property: 'twitter:url',
+            content: data.url ? data.url : window.location.href,
+        });
+        if (data.image) {
+            this.metaTagService.updateTag({
+                property: 'twitter:image',
+                content: data.image,
+            });
+            this.metaTagService.updateTag({
+                property: 'twitter:card',
+                content: 'summary_large_image',
+            });
+        }
     }
-    setPageDescription(description) {
-        this.metaTagService.updateTag({ name: 'description', content: description });
-        this.metaTagService.updateTag({ property: 'og:description', content: description });
-        this.metaTagService.updateTag({ name: 'twitter:description', content: description });
+    /**
+     * Set metadata for facebook
+     *
+     * @param data
+     * @private
+     */
+    setFacebookData(data) {
+        this.metaTagService.updateTag({ property: 'og:title', content: data.title });
+        this.metaTagService.updateTag({ property: 'og:description', content: data.description });
+        this.metaTagService.updateTag({
+            property: 'og:type',
+            content: 'website',
+        });
+        this.metaTagService.updateTag({
+            property: 'og:url',
+            content: data.url ? data.url : window.location.href,
+        });
+        if (data.image) {
+            this.metaTagService.updateTag({
+                property: 'og:image',
+                content: data.image,
+            });
+        }
     }
+    /**
+     * Set page keywords
+     *
+     * @param keywords
+     * @private
+     */
     setPageKeywords(keywords) {
         this.metaTagService.updateTag({ name: 'keywords', content: keywords });
     }
@@ -2327,5 +2469,5 @@ function MustMatch(controlName, matchingControlName) {
  * 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, LazyLoadDirective, LoaderService, LogicalOperatorEnum, LogoutGuard, MatchHeightDirective, MustMatch, ResizableDirective, SEOService, SafeHtmlPipe, ScrollService, SortOrderEnum, Standard, StorageService, apolloOptionsFactory };
+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, apolloOptionsFactory };
 //# sourceMappingURL=lenne.tech-ng-base.js.map