@lenne.tech/ng-base 0.2.1 → 0.3.2

package/esm2015/lib/base/directives/match-height.directive.js

@@ -1,10 +1,15 @@
-import { Directive, ElementRef, HostListener, Input } from '@angular/core';
+import { __awaiter } from "tslib";
+import { Directive, ElementRef, HostListener, Input, NgZone } from '@angular/core';
+import { ImageService } from '../services/image.service';
 /**
  * Set same height (maximum) to different elements
  */
 export class MatchHeightDirective {
-    constructor(el) {
+    constructor(el, imageService, zone) {
         this.el = el;
+        this.imageService = imageService;
+        this.zone = zone;
+        this.loadLazyImages = true;
     }
     onResize() {
         this.matchHeight(this.el.nativeElement, this.ltMatchHeight);
@@ -13,33 +18,41 @@ export class MatchHeightDirective {
         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) {
+        // 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(() => __awaiter(this, void 0, void 0, function* () {
+            if (!parent) {
                 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`));
-        });
+            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((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((element) => (element.style.height = `${maxHeight}px`));
+            }
+        }), 1);
     }
 }
 MatchHeightDirective.decorators = [
@@ -48,10 +61,13 @@ MatchHeightDirective.decorators = [
             },] }
 ];
 MatchHeightDirective.ctorParameters = () => [
-    { type: ElementRef }
+    { type: ElementRef },
+    { type: ImageService },
+    { type: NgZone }
 ];
 MatchHeightDirective.propDecorators = {
     ltMatchHeight: [{ type: Input }],
+    loadLazyImages: [{ type: Input }],
     onResize: [{ type: HostListener, args: ['window:resize',] }]
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/base/interfaces/base-module-config.interface.js

@@ -1,3 +1,3 @@
 import { InjectionToken } from '@angular/core';
 export const BASE_MODULE_CONFIG = new InjectionToken('BASE_MODULE_CONFIG');
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/base/public-api.js

@@ -48,6 +48,7 @@ export * from './services/fullscreen.service';
 export * from './services/graphql.service';
 export * from './services/graphql-meta.service';
 export * from './services/graphql-plus.service';
+export * from './services/image.service';
 export * from './services/loader.service';
 export * from './services/scroll.service';
 export * from './services/seo.service';
@@ -56,4 +57,4 @@ export * from './services/storage.service';
 export * from './types/storage.type';
 // Validators
 export * from './validators/must-match.validator';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/base/services/image.service.js

@@ -0,0 +1,113 @@
+import { __awaiter } from "tslib";
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Image service
+ */
+export 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;
+            // HTMLCollection to array
+            if (config.elements instanceof HTMLCollection) {
+                config.elements = Array.from(config.elements);
+            }
+            // Single element to array
+            if (!Array.isArray(config.elements)) {
+                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',
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"image.service.js","sourceRoot":"","sources":["../../../../../../projects/ng-base/src/lib/base/services/image.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\n\n/**\n * Image service\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class ImageService {\n  /**\n   * Preaload images (for lazy handling)\n   *\n   * @param options\n   * @protected\n   */\n  public preLoadImages(options?: {\n    doneFunction?: () => Promise<any> | any | void;\n    elements?: Element | Element[] | HTMLCollectionOf<Element> | Document | HTMLElement | HTMLElement[];\n    regExp?: RegExp;\n    timeout?: number;\n  }): Promise<any> {\n    // Init configuration\n    const config = {\n      doneFunnction: undefined,\n      elements: document,\n      regExp: undefined,\n      timeout: undefined,\n      ...options,\n    };\n\n    return new Promise((resolve) => {\n      // Init variables\n      let resolved = false;\n      let timeoutId;\n\n      // HTMLCollection to array\n      if (config.elements instanceof HTMLCollection) {\n        config.elements = Array.from(config.elements);\n      }\n\n      // Single element to array\n      if (!Array.isArray(config.elements)) {\n        config.elements = [config.elements] as Element[];\n      }\n\n      // Init loading\n      const promises = [];\n\n      // Get all images\n      let images: HTMLImageElement[] = [];\n      config.elements.forEach((element) => {\n        images = images.concat(Array.from(element.getElementsByTagName('img')));\n      });\n\n      // Prepare images\n      for (const image of images) {\n        const src = image.getAttribute('src');\n\n        // Check if changes are necessary and possible\n        if (\n          (image.complete && image.naturalHeight !== 0) || // already laoded\n          image.getAttribute('loading') !== 'lazy' || // loading attribute !== lazy\n          !src || // Image has no src\n          config.regExp?.test(src) // Test if src matches regular expression\n        ) {\n          continue;\n        }\n\n        // Replace lazy loading image with immediately loading image\n        const newImage = document.createElement('img');\n        Array.from(image.attributes).forEach((attr) => {\n          if (attr.name !== 'loading' && attr.name !== 'src') {\n            newImage.setAttribute(attr.name, attr.value);\n          }\n        });\n        image.replaceWith(newImage);\n\n        // Wait for laoding\n        promises.push(this.loadImage(newImage, src));\n      }\n\n      if (config.timeout) {\n        timeoutId = setTimeout(async () => {\n          resolved = true;\n          if (config.doneFunnction) {\n            await config.doneFunction();\n          }\n          resolve(undefined);\n        });\n      }\n\n      // Wait until all images loaded\n      Promise.all(promises)\n        .catch((e) => console.error('Error during image loading', e))\n        .finally(async () => {\n          // Check if already resolved\n          if (resolved) {\n            return;\n          }\n\n          // Stop timeout\n          if (timeoutId) {\n            clearTimeout(timeoutId);\n          }\n\n          // Return result\n          let result;\n          if (config.doneFunnction) {\n            result = await config.doneFunction();\n          }\n          resolve(result);\n        });\n    });\n  }\n\n  /**\n   * Load image for image element\n   *\n   * @param imageElement\n   * @param src\n   * @protected\n   */\n  public async loadImage(imageElement: HTMLImageElement, src?: string) {\n    src = src || imageElement.src;\n    return new Promise((resolve, reject) => {\n      imageElement.onload = () => resolve(imageElement);\n      imageElement.onerror = reject;\n      imageElement.src = src;\n    });\n  }\n}\n"]}

package/esm2015/lib/base/services/scroll.service.js

@@ -1,9 +1,12 @@
+import { __awaiter } from "tslib";
 import { Inject, Injectable } from '@angular/core';
 import { Router } from '@angular/router';
 import { BASE_MODULE_CONFIG } from '../interfaces/base-module-config.interface';
+import { ImageService } from './image.service';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/router";
 import * as i2 from "../interfaces/base-module-config.interface";
+import * as i3 from "./image.service";
 /**
  * Scroll service for autoscroll to specific fragments
  */
@@ -11,35 +14,78 @@ export class ScrollService {
     /**
      * Initializer
      */
-    constructor(router, moduleConfig) {
+    constructor(router, moduleConfig, imageService) {
         this.router = router;
         this.moduleConfig = moduleConfig;
+        this.imageService = imageService;
         /**
-         * Scroll offset
+         * Is a scroll listener set
+         *
+         * @protected
          */
-        this.scrollOffset = 100;
+        this.scrollListener = false;
         /**
-         * Detection offset
-         * Should be >= scrollOffset
+         * Current scroll timer;
+         *
+         * @protected
          */
-        this.detectionOffset = 200;
-        const config = Object.assign({ scrollDetectionOffset: 200, scrollOffset: 100 }, moduleConfig);
+        this.scrollTimer = -1;
+        const config = Object.assign({ scrollDetectionOffset: 200, scrollOffset: 100, scrollSamplingRate: 100 }, moduleConfig);
         this.detectionOffset = config.scrollDetectionOffset;
         this.scrollOffset = config.scrollOffset;
+        this.scrollSamplingRate = config.scrollSamplingRate;
     }
     /**
      * Scroll to structureElement with specific ID
      */
     scrollTo(id, options = {}) {
-        options = Object.assign({ stopPropagation: true }, options);
-        if (this.router.url !== '/' && !this.router.url.startsWith('/#')) {
-            this.router.navigate(['/'], { fragment: id });
-            return options.stopPropagation ? false : true;
-        }
-        const el = document.getElementById(id);
-        const cords = el.getBoundingClientRect();
-        window.scrollBy({ top: cords.top - this.scrollOffset, behavior: 'smooth' });
-        return options.stopPropagation ? false : true;
+        return __awaiter(this, void 0, void 0, function* () {
+            // Prepare config
+            const config = Object.assign({ checkUrl: true, loadImagesBefore: true, resetStyles: false, setOverflow: true, stopPropagation: true }, options);
+            // Check current URL
+            if (config.checkUrl && this.router.url !== '/' && !this.router.url.startsWith('/#')) {
+                yield this.router.navigate(['/'], { fragment: id });
+                return !config.stopPropagation;
+            }
+            // Check if target element exits
+            const el = document.getElementById(id);
+            if (!el) {
+                console.error('Missing scroll element with ID:', id);
+                return !config.stopPropagation;
+            }
+            // Check if body overflow is visible
+            // This is necessary for scroll handling
+            const body = document.querySelector('body');
+            let undoOverflowChanges = false;
+            const scrollBodyStyles = JSON.parse(JSON.stringify(window.getComputedStyle(body)));
+            if (config.setOverflow && (scrollBodyStyles.overflowX !== 'visible' || scrollBodyStyles.overflowY !== 'visible')) {
+                // Set body overflow to visible
+                console.warn('Style of body element for overflowX and overflowY will be set to "visible" for scrolling!');
+                body.style.overflowX = 'visible';
+                body.style.overflowY = 'visible';
+                undoOverflowChanges = true;
+            }
+            // Load images before scrolling (once)
+            if (config.loadImagesBefore) {
+                yield this.imageService.preLoadImages();
+            }
+            // Get get bounding rect of target element
+            const cords = el.getBoundingClientRect();
+            // Scroll to element
+            window.scrollBy({ top: cords.top - this.scrollOffset, behavior: 'smooth' });
+            yield this.scrollDone({
+                doneFunction: () => {
+                    // Undo changes
+                    if (undoOverflowChanges && config.resetStyles) {
+                        body.style.overflowX = scrollBodyStyles.overflowX;
+                        body.style.overflowY = scrollBodyStyles.overflowY;
+                        console.warn('Original style of body element for overflowX and overflowY is set.');
+                    }
+                },
+            });
+            // Return stop propagation configuration
+            return !config.stopPropagation;
+        });
     }
     /**
      * Get last active structureElement
@@ -69,8 +115,71 @@ export class ScrollService {
         const lastActiveElement = this.getLastActiveElement(list);
         return id === lastActiveElement || (lastActiveElement === null && isFirst);
     }
+    /**
+     * Scroll done promise
+     */
+    scrollDone(options = {}) {
+        // Init configuration
+        const config = Object.assign({ doneFunction: undefined, timeout: undefined }, options);
+        // Return promise for scroll done
+        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            // Init variables
+            let rejected = false;
+            let timeoutId;
+            // Set timeout handling if necessary
+            if (config.timeout) {
+                timeoutId = window.setTimeout(() => {
+                    rejected = true;
+                    reject(new Error('Timeout for scrollDone after:' + config.timeout));
+                }, config.timeout);
+            }
+            // Wait for scroll done
+            yield this.scrollDoneDetection();
+            // Resolve promise if not already rejected
+            if (!rejected) {
+                // Stop timeout if set
+                if (timeoutId) {
+                    window.clearTimeout(timeoutId);
+                }
+                // Get result (if doneFunction is set)
+                let result;
+                if (config.doneFunction) {
+                    result = yield config.doneFunction();
+                }
+                // Scroll done
+                resolve(result);
+            }
+        }));
+    }
+    /**
+     * Scroll done detecton
+     *
+     * @protected
+     */
+    scrollDoneDetection() {
+        // Return current scroll promise (Singelton)
+        if (this.scrollPromise) {
+            return this.scrollPromise;
+        }
+        // Create current scroll promise
+        this.scrollPromise = new Promise((resolve) => {
+            this.scrollPromiseResolve = resolve;
+            if (this.scrollTimer !== -1) {
+                window.clearTimeout(this.scrollTimer);
+            }
+            this.scrollTimer = window.setTimeout(() => {
+                window.removeEventListener('scroll', this.scrollDoneDetection.bind(this));
+                this.scrollPromise = undefined;
+                resolve();
+            }, this.scrollSamplingRate);
+        });
+        // Lisitening to scroll event;
+        window.addEventListener('scroll', this.scrollDoneDetection.bind(this));
+        // Return promise
+        return this.scrollPromise;
+    }
 }
-ScrollService.ɵprov = i0.ɵɵdefineInjectable({ factory: function ScrollService_Factory() { return new ScrollService(i0.ɵɵinject(i1.Router), i0.ɵɵinject(i2.BASE_MODULE_CONFIG)); }, token: ScrollService, providedIn: "root" });
+ScrollService.ɵprov = i0.ɵɵdefineInjectable({ factory: function ScrollService_Factory() { return new ScrollService(i0.ɵɵinject(i1.Router), i0.ɵɵinject(i2.BASE_MODULE_CONFIG), i0.ɵɵinject(i3.ImageService)); }, token: ScrollService, providedIn: "root" });
 ScrollService.decorators = [
     { type: Injectable, args: [{
                 providedIn: 'root',
@@ -78,6 +187,7 @@ 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 }
 ];
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scroll.service.js","sourceRoot":"","sources":["../../../../../../projects/ng-base/src/lib/base/services/scroll.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { Router } from '@angular/router';\nimport { BASE_MODULE_CONFIG, BaseModuleConfig } from '../interfaces/base-module-config.interface';\nimport { ImageService } from './image.service';\n\n/**\n * Scroll service for autoscroll to specific fragments\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class ScrollService {\n  /**\n   * Current scroll promise\n   *\n   * @protected\n   */\n  protected scrollPromise: Promise<void>;\n\n  /**\n   * Resolve function of current scroll promise\n   *\n   * @protected\n   */\n  protected scrollPromiseResolve: (value: void | PromiseLike<void>) => void;\n\n  /**\n   * Is a scroll listener set\n   *\n   * @protected\n   */\n  protected scrollListener = false;\n\n  /**\n   * Current scroll timer;\n   *\n   * @protected\n   */\n  protected scrollTimer = -1;\n\n  /**\n   * Scroll offset\n   */\n  protected readonly scrollOffset: number;\n\n  /**\n   * Detection offset\n   * Should be >= scrollOffset\n   */\n  protected readonly detectionOffset: number;\n\n  /**\n   * Sampling rate for scroll done detection\n   */\n  protected readonly scrollSamplingRate: number;\n\n  /**\n   * Initializer\n   */\n  constructor(\n    protected router: Router,\n    @Inject(BASE_MODULE_CONFIG) protected moduleConfig: BaseModuleConfig,\n    protected imageService: ImageService\n  ) {\n    const config = {\n      scrollDetectionOffset: 200,\n      scrollOffset: 100,\n      scrollSamplingRate: 100,\n      ...moduleConfig,\n    };\n\n    this.detectionOffset = config.scrollDetectionOffset;\n    this.scrollOffset = config.scrollOffset;\n    this.scrollSamplingRate = config.scrollSamplingRate;\n  }\n\n  /**\n   * Scroll to structureElement with specific ID\n   */\n  async scrollTo(\n    id: string,\n    options: {\n      checkUrl?: boolean;\n      loadImagesBefore?: boolean;\n      resetStyles?: boolean;\n      setOverflow?: boolean;\n      stopPropagation?: boolean;\n    } = {}\n  ) {\n    // Prepare config\n    const config = {\n      checkUrl: true,\n      loadImagesBefore: true,\n      resetStyles: false,\n      setOverflow: true,\n      stopPropagation: true,\n      ...options,\n    };\n\n    // Check current URL\n    if (config.checkUrl && this.router.url !== '/' && !this.router.url.startsWith('/#')) {\n      await this.router.navigate(['/'], { fragment: id });\n      return !config.stopPropagation;\n    }\n\n    // Check if target element exits\n    const el = document.getElementById(id);\n    if (!el) {\n      console.error('Missing scroll element with ID:', id);\n      return !config.stopPropagation;\n    }\n\n    // Check if body overflow is visible\n    // This is necessary for scroll handling\n    const body = document.querySelector('body');\n    let undoOverflowChanges = false;\n    const scrollBodyStyles = JSON.parse(JSON.stringify(window.getComputedStyle(body)));\n    if (config.setOverflow && (scrollBodyStyles.overflowX !== 'visible' || scrollBodyStyles.overflowY !== 'visible')) {\n      // Set body overflow to visible\n      console.warn('Style of body element for overflowX and overflowY will be set to \"visible\" for scrolling!');\n      body.style.overflowX = 'visible';\n      body.style.overflowY = 'visible';\n      undoOverflowChanges = true;\n    }\n\n    // Load images before scrolling (once)\n    if (config.loadImagesBefore) {\n      await this.imageService.preLoadImages();\n    }\n\n    // Get get bounding rect of target element\n    const cords = el.getBoundingClientRect();\n\n    // Scroll to element\n    window.scrollBy({ top: cords.top - this.scrollOffset, behavior: 'smooth' });\n    await this.scrollDone({\n      doneFunction: () => {\n        // Undo changes\n        if (undoOverflowChanges && config.resetStyles) {\n          body.style.overflowX = scrollBodyStyles.overflowX;\n          body.style.overflowY = scrollBodyStyles.overflowY;\n          console.warn('Original style of body element for overflowX and overflowY is set.');\n        }\n      },\n    });\n\n    // Return stop propagation configuration\n    return !config.stopPropagation;\n  }\n\n  /**\n   * Get last active structureElement\n   */\n  getLastActiveElement(list?): string {\n    const currentScrollPosition = window.scrollY;\n    const elementsWithId = document.querySelectorAll('[id]');\n    let lastId = null;\n    let lastPosition = 0 - this.detectionOffset - 1;\n    elementsWithId.forEach((element) => {\n      const cords = element.getBoundingClientRect();\n      const top = cords.top + window.pageYOffset - this.detectionOffset;\n      if (\n        (!list || !list.length || list.includes(element.id)) && // In list\n        top < currentScrollPosition && // In active area\n        lastPosition < top // Higher than the last one\n      ) {\n        lastId = element.id;\n        lastPosition = top;\n      }\n    });\n    return lastId;\n  }\n\n  /**\n   * Check if ID is active\n   */\n  isActive(id, list?, isFirst?) {\n    const lastActiveElement = this.getLastActiveElement(list);\n    return id === lastActiveElement || (lastActiveElement === null && isFirst);\n  }\n\n  /**\n   * Scroll done promise\n   */\n  public scrollDone(options: { doneFunction?: () => Promise<any> | any | void; timeout?: number } = {}): Promise<any> {\n    // Init configuration\n    const config = {\n      doneFunction: undefined,\n      timeout: undefined,\n      ...options,\n    };\n\n    // Return promise for scroll done\n    return new Promise(async (resolve, reject) => {\n      // Init variables\n      let rejected = false;\n      let timeoutId: number;\n\n      // Set timeout handling if necessary\n      if (config.timeout) {\n        timeoutId = window.setTimeout(() => {\n          rejected = true;\n          reject(new Error('Timeout for scrollDone after:' + config.timeout));\n        }, config.timeout);\n      }\n\n      // Wait for scroll done\n      await this.scrollDoneDetection();\n\n      // Resolve promise if not already rejected\n      if (!rejected) {\n        // Stop timeout if set\n        if (timeoutId) {\n          window.clearTimeout(timeoutId);\n        }\n\n        // Get result (if doneFunction is set)\n        let result;\n        if (config.doneFunction) {\n          result = await config.doneFunction();\n        }\n\n        // Scroll done\n        resolve(result);\n      }\n    });\n  }\n\n  /**\n   * Scroll done detecton\n   *\n   * @protected\n   */\n  protected scrollDoneDetection(): Promise<void> {\n    // Return current scroll promise (Singelton)\n    if (this.scrollPromise) {\n      return this.scrollPromise;\n    }\n\n    // Create current scroll promise\n    this.scrollPromise = new Promise((resolve) => {\n      this.scrollPromiseResolve = resolve;\n      if (this.scrollTimer !== -1) {\n        window.clearTimeout(this.scrollTimer);\n      }\n      this.scrollTimer = window.setTimeout(() => {\n        window.removeEventListener('scroll', this.scrollDoneDetection.bind(this));\n        this.scrollPromise = undefined;\n        resolve();\n      }, this.scrollSamplingRate);\n    });\n\n    // Lisitening to scroll event;\n    window.addEventListener('scroll', this.scrollDoneDetection.bind(this));\n\n    // Return promise\n    return this.scrollPromise;\n  }\n}\n"]}