@lenne.tech/ng-base 0.2.1 → 0.2.2

package/bundles/lenne.tech-ng-base-src-lib-base.umd.js

@@ -2606,32 +2606,80 @@
             this.router = router;
             this.moduleConfig = moduleConfig;
             /**
-             * 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;
-            var config = Object.assign({ scrollDetectionOffset: 200, scrollOffset: 100 }, moduleConfig);
+            this.scrollTimer = -1;
+            var 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
          */
         ScrollService.prototype.scrollTo = function (id, options) {
             if (options === void 0) { 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;
-            }
-            var el = document.getElementById(id);
-            var 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 () {
+                var config, el, body, undoOverflowChanges, scrollBodyStyles, cords;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            config = Object.assign({ checkUrl: true, loadImagesBefore: true, resetStyles: false, setOverflow: true, stopPropagation: true }, options);
+                            if (!(config.checkUrl && this.router.url !== '/' && !this.router.url.startsWith('/#'))) return [3 /*break*/, 2];
+                            return [4 /*yield*/, this.router.navigate(['/'], { fragment: id })];
+                        case 1:
+                            _a.sent();
+                            return [2 /*return*/, !config.stopPropagation];
+                        case 2:
+                            el = document.getElementById(id);
+                            if (!el) {
+                                console.error('Missing scroll element with ID:', id);
+                                return [2 /*return*/, !config.stopPropagation];
+                            }
+                            body = document.querySelector('body');
+                            undoOverflowChanges = false;
+                            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;
+                            }
+                            if (!config.loadImagesBefore) return [3 /*break*/, 4];
+                            return [4 /*yield*/, this.preLoadImages()];
+                        case 3:
+                            _a.sent();
+                            _a.label = 4;
+                        case 4:
+                            cords = el.getBoundingClientRect();
+                            // Scroll to element
+                            window.scrollBy({ top: cords.top - this.scrollOffset, behavior: 'smooth' });
+                            return [4 /*yield*/, this.scrollDone({
+                                    doneFunction: function () {
+                                        // 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.');
+                                        }
+                                    },
+                                })];
+                        case 5:
+                            _a.sent();
+                            // Return stop propagation configuration
+                            return [2 /*return*/, !config.stopPropagation];
+                    }
+                });
+            });
         };
         /**
          * Get last active structureElement
@@ -2662,6 +2710,194 @@
             var lastActiveElement = this.getLastActiveElement(list);
             return id === lastActiveElement || (lastActiveElement === null && isFirst);
         };
+        /**
+         * Scroll done promise
+         */
+        ScrollService.prototype.scrollDone = function (options) {
+            var _this = this;
+            if (options === void 0) { options = {}; }
+            // Init configuration
+            var config = Object.assign({ doneFunction: undefined, timeout: undefined }, options);
+            // Return promise for scroll done
+            return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+                var rejected, timeoutId, result;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            rejected = false;
+                            // Set timeout handling if necessary
+                            if (config.timeout) {
+                                timeoutId = window.setTimeout(function () {
+                                    rejected = true;
+                                    reject(new Error('Timeout for scrollDone after:' + config.timeout));
+                                }, config.timeout);
+                            }
+                            // Wait for scroll done
+                            return [4 /*yield*/, this.scrollDoneDetection()];
+                        case 1:
+                            // Wait for scroll done
+                            _a.sent();
+                            if (!!rejected) return [3 /*break*/, 4];
+                            // Stop timeout if set
+                            if (timeoutId) {
+                                window.clearTimeout(timeoutId);
+                            }
+                            result = void 0;
+                            if (!config.doneFunction) return [3 /*break*/, 3];
+                            return [4 /*yield*/, config.doneFunction()];
+                        case 2:
+                            result = _a.sent();
+                            _a.label = 3;
+                        case 3:
+                            // Scroll done
+                            resolve(result);
+                            _a.label = 4;
+                        case 4: return [2 /*return*/];
+                    }
+                });
+            }); });
+        };
+        /**
+         * Scroll done detecton
+         *
+         * @protected
+         */
+        ScrollService.prototype.scrollDoneDetection = function () {
+            var _this = this;
+            // Return current scroll promise (Singelton)
+            if (this.scrollPromise) {
+                return this.scrollPromise;
+            }
+            // Create current scroll promise
+            this.scrollPromise = new Promise(function (resolve) {
+                _this.scrollPromiseResolve = resolve;
+                if (_this.scrollTimer !== -1) {
+                    window.clearTimeout(_this.scrollTimer);
+                }
+                _this.scrollTimer = window.setTimeout(function () {
+                    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;
+        };
+        /**
+         * Preaload images (for lazy handling)
+         *
+         * @param options
+         * @protected
+         */
+        ScrollService.prototype.preLoadImages = function (options) {
+            var _this = this;
+            // Init configuration
+            var config = Object.assign({ doneFunnction: undefined, timeout: undefined }, options);
+            return new Promise(function (resolve) {
+                var e_1, _a;
+                // Init variables
+                var resolved = false;
+                var timeoutId;
+                // Init loading
+                var images = Array.from(document.getElementsByTagName('img'));
+                var promises = [];
+                var _loop_1 = function (image) {
+                    var src = image.getAttribute('src');
+                    // Check if changes are necessary and possible
+                    if ((image.complete && image.naturalHeight !== 0) || image.getAttribute('loading') !== 'lazy' || !src) {
+                        return "continue";
+                    }
+                    var newImage = document.createElement('img');
+                    Array.from(image.attributes).forEach(function (attr) {
+                        if (attr.name !== 'loading' && attr.name !== 'src') {
+                            newImage.setAttribute(attr.name, attr.value);
+                        }
+                    });
+                    image.replaceWith(newImage);
+                    promises.push(_this.loadImage(newImage, src));
+                };
+                try {
+                    // Prepare images
+                    for (var images_1 = __values(images), images_1_1 = images_1.next(); !images_1_1.done; images_1_1 = images_1.next()) {
+                        var image = images_1_1.value;
+                        _loop_1(image);
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (images_1_1 && !images_1_1.done && (_a = images_1.return)) _a.call(images_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                if (config.timeout) {
+                    timeoutId = setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    resolved = true;
+                                    if (!config.doneFunnction) return [3 /*break*/, 2];
+                                    return [4 /*yield*/, config.doneFunction()];
+                                case 1:
+                                    _a.sent();
+                                    _a.label = 2;
+                                case 2:
+                                    resolve(undefined);
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }); });
+                }
+                // Wait until all images loaded
+                Promise.all(promises)
+                    .catch(function (e) { return console.error('Error during image loading', e); })
+                    .finally(function () { return __awaiter(_this, void 0, void 0, function () {
+                    var result;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                // Check if already resolved
+                                if (resolved) {
+                                    return [2 /*return*/];
+                                }
+                                // Stop timeout
+                                if (timeoutId) {
+                                    clearTimeout(timeoutId);
+                                }
+                                if (!config.doneFunnction) return [3 /*break*/, 2];
+                                return [4 /*yield*/, config.doneFunction()];
+                            case 1:
+                                result = _a.sent();
+                                _a.label = 2;
+                            case 2:
+                                resolve(result);
+                                return [2 /*return*/];
+                        }
+                    });
+                }); });
+            });
+        };
+        /**
+         * Load image for image element
+         *
+         * @param imageElement
+         * @param src
+         * @protected
+         */
+        ScrollService.prototype.loadImage = function (imageElement, src) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    src = src || imageElement.src;
+                    return [2 /*return*/, new Promise(function (resolve, reject) {
+                            imageElement.onload = function () { return resolve(imageElement); };
+                            imageElement.onerror = reject;
+                            imageElement.src = src;
+                        })];
+                });
+            });
+        };
         return ScrollService;
     }());
     ScrollService.ɵprov = i0__namespace.ɵɵdefineInjectable({ factory: function ScrollService_Factory() { return new ScrollService(i0__namespace.ɵɵinject(i1__namespace$1.Router), i0__namespace.ɵɵinject(BASE_MODULE_CONFIG)); }, token: ScrollService, providedIn: "root" });