@pepperi-addons/ngx-lib 0.4.2-beta.137 → 0.4.2-beta.139

package/esm2020/list/virtual-scroller.mjs

@@ -0,0 +1,1080 @@
+import { Component, ContentChild, ElementRef, EventEmitter, Inject, Input, NgModule, Optional, Output, ViewChild, } from '@angular/core';
+import { PLATFORM_ID } from '@angular/core';
+import { isPlatformServer } from '@angular/common';
+import { CommonModule } from '@angular/common';
+import * as tween from '@tweenjs/tween.js';
+import * as i0 from "@angular/core";
+export function VIRTUAL_SCROLLER_DEFAULT_OPTIONS_FACTORY() {
+    return {
+        checkResizeInterval: 1000,
+        modifyOverflowStyleOfParentScroll: true,
+        resizeBypassRefreshThreshold: 5,
+        scrollAnimationTime: 750,
+        scrollDebounceTime: 0,
+        scrollThrottlingTime: 0,
+        stripedTable: false
+    };
+}
+export class VirtualScrollerComponent {
+    constructor(element, renderer, zone, changeDetectorRef, platformId, options) {
+        this.element = element;
+        this.renderer = renderer;
+        this.zone = zone;
+        this.changeDetectorRef = changeDetectorRef;
+        this.window = window;
+        this._disable = false;
+        this.executeRefreshOutsideAngularZone = false;
+        this._enableUnequalChildrenSizes = false;
+        this.RTL = false;
+        this.useMarginInsteadOfTranslate = false;
+        this.ssrViewportWidth = 1920;
+        this.ssrViewportHeight = 1080;
+        this._items = [];
+        this.compareItems = (item1, item2) => item1 === item2;
+        // private _lastChildRect: DOMRect = null;
+        this.vsChildRectChange = new EventEmitter();
+        this.vsUpdate = new EventEmitter();
+        this.vsChange = new EventEmitter();
+        this.vsStart = new EventEmitter();
+        this.vsEnd = new EventEmitter();
+        this.calculatedScrollbarWidth = 0;
+        this.calculatedScrollbarHeight = 0;
+        this.padding = 0;
+        this.previousViewPort = {};
+        this.cachedPageSize = 0;
+        this.previousScrollNumberElements = 0;
+        this.isAngularUniversalSSR = isPlatformServer(platformId);
+        const defaultOptions = VIRTUAL_SCROLLER_DEFAULT_OPTIONS_FACTORY();
+        this.checkResizeInterval = options?.checkResizeInterval || defaultOptions.checkResizeInterval;
+        this.modifyOverflowStyleOfParentScroll = options?.modifyOverflowStyleOfParentScroll || defaultOptions.modifyOverflowStyleOfParentScroll;
+        this.resizeBypassRefreshThreshold = options?.resizeBypassRefreshThreshold || defaultOptions.resizeBypassRefreshThreshold;
+        this.scrollAnimationTime = options?.scrollAnimationTime || defaultOptions.scrollAnimationTime;
+        this.scrollDebounceTime = options?.scrollDebounceTime || defaultOptions.scrollDebounceTime;
+        this.scrollThrottlingTime = options?.scrollThrottlingTime || defaultOptions.scrollThrottlingTime;
+        this.scrollbarHeight = options?.scrollbarHeight || defaultOptions.scrollbarHeight;
+        this.scrollbarWidth = options?.scrollbarWidth || defaultOptions.scrollbarWidth;
+        this.stripedTable = options?.stripedTable || defaultOptions.stripedTable;
+        this.horizontal = false;
+        this.resetWrapGroupDimensions();
+    }
+    get viewPortInfo() {
+        const pageInfo = this.previousViewPort || {};
+        return {
+            startIndex: pageInfo.startIndex || 0,
+            endIndex: pageInfo.endIndex || 0,
+            scrollStartPosition: pageInfo.scrollStartPosition || 0,
+            scrollEndPosition: pageInfo.scrollEndPosition || 0,
+            scrollDirection: pageInfo.scrollDirection || 'forward',
+            maxScrollPosition: pageInfo.maxScrollPosition || 0,
+            startIndexWithBuffer: pageInfo.startIndexWithBuffer || 0,
+            endIndexWithBuffer: pageInfo.endIndexWithBuffer || 0,
+        };
+    }
+    get disable() {
+        return this._disable;
+    }
+    set disable(value) {
+        if (this._disable === value) {
+            return;
+        }
+        this._disable = value;
+        if (this._disable) {
+            this.removeScrollEventHandlers();
+        }
+        else {
+            this.addScrollEventHandlers();
+        }
+    }
+    get enableUnequalChildrenSizes() {
+        return this._enableUnequalChildrenSizes;
+    }
+    set enableUnequalChildrenSizes(value) {
+        if (this._enableUnequalChildrenSizes === value) {
+            return;
+        }
+        this._enableUnequalChildrenSizes = value;
+        this.minMeasuredChildWidth = undefined;
+        this.minMeasuredChildHeight = undefined;
+    }
+    get bufferAmount() {
+        if (typeof (this._bufferAmount) === 'number' && this._bufferAmount > 0) {
+            return this._bufferAmount;
+        }
+        else {
+            return this.enableUnequalChildrenSizes ? 5 : 0;
+        }
+    }
+    set bufferAmount(value) {
+        this._bufferAmount = value;
+    }
+    get scrollThrottlingTime() {
+        return this._scrollThrottlingTime;
+    }
+    set scrollThrottlingTime(value) {
+        this._scrollThrottlingTime = value;
+        this.updateOnScrollFunction();
+    }
+    get scrollDebounceTime() {
+        return this._scrollDebounceTime;
+    }
+    set scrollDebounceTime(value) {
+        this._scrollDebounceTime = value;
+        this.updateOnScrollFunction();
+    }
+    updateOnScrollFunction() {
+        if (this.scrollDebounceTime) {
+            this.onScroll = this.debounce(() => {
+                this.refresh_internal(false);
+            }, this.scrollDebounceTime);
+        }
+        else if (this.scrollThrottlingTime) {
+            this.onScroll = this.throttleTrailing(() => {
+                this.refresh_internal(false);
+            }, this.scrollThrottlingTime);
+        }
+        else {
+            this.onScroll = () => {
+                this.refresh_internal(false);
+            };
+        }
+    }
+    get checkResizeInterval() {
+        return this._checkResizeInterval;
+    }
+    set checkResizeInterval(value) {
+        if (this._checkResizeInterval === value) {
+            return;
+        }
+        this._checkResizeInterval = value;
+        this.addScrollEventHandlers();
+    }
+    get items() {
+        return this._items;
+    }
+    set items(value) {
+        if (value === this._items) {
+            return;
+        }
+        this._items = value || [];
+        this.refresh_internal(true);
+    }
+    get horizontal() {
+        return this._horizontal;
+    }
+    set horizontal(value) {
+        this._horizontal = value;
+        this.updateDirection();
+    }
+    revertParentOverscroll() {
+        const scrollElement = this.getScrollElement();
+        if (scrollElement && this.oldParentScrollOverflow) {
+            scrollElement.style['overflow-y'] = this.oldParentScrollOverflow.y;
+            scrollElement.style['overflow-x'] = this.oldParentScrollOverflow.x;
+        }
+        this.oldParentScrollOverflow = undefined;
+    }
+    get parentScroll() {
+        return this._parentScroll;
+    }
+    set parentScroll(value) {
+        if (this._parentScroll === value) {
+            return;
+        }
+        this.revertParentOverscroll();
+        this._parentScroll = value;
+        this.addScrollEventHandlers();
+        const scrollElement = this.getScrollElement();
+        if (this.modifyOverflowStyleOfParentScroll && scrollElement !== this.element.nativeElement) {
+            this.oldParentScrollOverflow = { x: scrollElement.style['overflow-x'], y: scrollElement.style['overflow-y'] };
+            scrollElement.style['overflow-y'] = this.horizontal ? 'visible' : 'auto';
+            scrollElement.style['overflow-x'] = this.horizontal ? 'auto' : 'visible';
+        }
+    }
+    ngOnInit() {
+        this.addScrollEventHandlers();
+    }
+    ngOnDestroy() {
+        this.removeScrollEventHandlers();
+        this.revertParentOverscroll();
+    }
+    ngOnChanges(changes) {
+        const indexLengthChanged = this.cachedItemsLength !== this.items.length;
+        this.cachedItemsLength = this.items.length;
+        const firstRun = !changes.items || !changes.items.previousValue || changes.items.previousValue.length === 0;
+        this.refresh_internal(indexLengthChanged || firstRun);
+    }
+    ngDoCheck() {
+        if (this.cachedItemsLength !== this.items.length) {
+            this.cachedItemsLength = this.items.length;
+            this.refresh_internal(true);
+            return;
+        }
+        if (this.previousViewPort && this.viewPortItems && this.viewPortItems.length > 0) {
+            let itemsArrayChanged = false;
+            for (let i = 0; i < this.viewPortItems.length; ++i) {
+                if (!this.compareItems(this.items[this.previousViewPort.startIndexWithBuffer + i], this.viewPortItems[i])) {
+                    itemsArrayChanged = true;
+                    break;
+                }
+            }
+            if (itemsArrayChanged) {
+                this.refresh_internal(true);
+            }
+        }
+    }
+    refresh(refreshCompletedCallback = undefined) {
+        this.refresh_internal(true, refreshCompletedCallback);
+    }
+    invalidateAllCachedMeasurements() {
+        this.wrapGroupDimensions = {
+            maxChildSizePerWrapGroup: [],
+            numberOfKnownWrapGroupChildSizes: 0,
+            sumOfKnownWrapGroupChildWidths: 0,
+            sumOfKnownWrapGroupChildHeights: 0
+        };
+        this.minMeasuredChildWidth = undefined;
+        this.minMeasuredChildHeight = undefined;
+        this.refresh_internal(false);
+    }
+    invalidateCachedMeasurementForItem(item) {
+        if (this.enableUnequalChildrenSizes) {
+            const index = this.items && this.items.indexOf(item);
+            if (index >= 0) {
+                this.invalidateCachedMeasurementAtIndex(index);
+            }
+        }
+        else {
+            this.minMeasuredChildWidth = undefined;
+            this.minMeasuredChildHeight = undefined;
+        }
+        this.refresh_internal(false);
+    }
+    invalidateCachedMeasurementAtIndex(index) {
+        if (this.enableUnequalChildrenSizes) {
+            const cachedMeasurement = this.wrapGroupDimensions.maxChildSizePerWrapGroup[index];
+            if (cachedMeasurement) {
+                this.wrapGroupDimensions.maxChildSizePerWrapGroup[index] = undefined;
+                --this.wrapGroupDimensions.numberOfKnownWrapGroupChildSizes;
+                this.wrapGroupDimensions.sumOfKnownWrapGroupChildWidths -= cachedMeasurement.childWidth || 0;
+                this.wrapGroupDimensions.sumOfKnownWrapGroupChildHeights -= cachedMeasurement.childHeight || 0;
+            }
+        }
+        else {
+            this.minMeasuredChildWidth = undefined;
+            this.minMeasuredChildHeight = undefined;
+        }
+        this.refresh_internal(false);
+    }
+    scrollInto(item, alignToBeginning = true, additionalOffset = 0, animationMilliseconds = undefined, animationCompletedCallback = undefined) {
+        const index = this.items.indexOf(item);
+        if (index === -1) {
+            return;
+        }
+        this.scrollToIndex(index, alignToBeginning, additionalOffset, animationMilliseconds, animationCompletedCallback);
+    }
+    scrollToIndex(index, alignToBeginning = true, additionalOffset = 0, animationMilliseconds = undefined, animationCompletedCallback = undefined) {
+        let maxRetries = 5;
+        const retryIfNeeded = () => {
+            --maxRetries;
+            if (maxRetries <= 0) {
+                if (animationCompletedCallback) {
+                    animationCompletedCallback();
+                }
+                return;
+            }
+            const dimensions = this.calculateDimensions();
+            const desiredStartIndex = Math.min(Math.max(index, 0), dimensions.itemCount - 1);
+            if (this.previousViewPort.startIndex === desiredStartIndex) {
+                if (animationCompletedCallback) {
+                    animationCompletedCallback();
+                }
+                return;
+            }
+            this.scrollToIndex_internal(index, alignToBeginning, additionalOffset, 0, retryIfNeeded);
+        };
+        this.scrollToIndex_internal(index, alignToBeginning, additionalOffset, animationMilliseconds, retryIfNeeded);
+    }
+    scrollToIndex_internal(index, alignToBeginning = true, additionalOffset = 0, animationMilliseconds = undefined, animationCompletedCallback = undefined) {
+        animationMilliseconds = animationMilliseconds === undefined ? this.scrollAnimationTime : animationMilliseconds;
+        const dimensions = this.calculateDimensions();
+        let scroll = this.calculatePadding(index, dimensions) + additionalOffset;
+        if (!alignToBeginning) {
+            scroll -= dimensions.wrapGroupsPerPage * dimensions[this._childScrollDim];
+        }
+        this.scrollToPosition(scroll, animationMilliseconds, animationCompletedCallback);
+    }
+    scrollToPosition(scrollPosition, animationMilliseconds = undefined, animationCompletedCallback = undefined) {
+        scrollPosition += this.getElementsOffset();
+        animationMilliseconds = animationMilliseconds === undefined ? this.scrollAnimationTime : animationMilliseconds;
+        const scrollElement = this.getScrollElement();
+        let animationRequest;
+        if (this.currentTween) {
+            this.currentTween.stop();
+            this.currentTween = undefined;
+        }
+        if (!animationMilliseconds) {
+            this.renderer.setProperty(scrollElement, this._scrollType, scrollPosition);
+            this.refresh_internal(false, animationCompletedCallback);
+            return;
+        }
+        const tweenConfigObj = { scrollPosition: scrollElement[this._scrollType] };
+        const newTween = new tween.Tween(tweenConfigObj)
+            .to({ scrollPosition }, animationMilliseconds)
+            .easing(tween.Easing.Quadratic.Out)
+            .onUpdate((data) => {
+            if (isNaN(data.scrollPosition)) {
+                return;
+            }
+            this.renderer.setProperty(scrollElement, this._scrollType, data.scrollPosition);
+            this.refresh_internal(false);
+        })
+            .onStop(() => {
+            cancelAnimationFrame(animationRequest);
+        })
+            .start();
+        const animate = (time) => {
+            if (!newTween["isPlaying"]()) {
+                return;
+            }
+            newTween.update(time);
+            if (tweenConfigObj.scrollPosition === scrollPosition) {
+                this.refresh_internal(false, animationCompletedCallback);
+                return;
+            }
+            this.zone.runOutsideAngular(() => {
+                animationRequest = requestAnimationFrame(animate);
+            });
+        };
+        animate();
+        this.currentTween = newTween;
+    }
+    getElementSize(element) {
+        const result = element.getBoundingClientRect();
+        const styles = getComputedStyle(element);
+        const marginTop = parseInt(styles['margin-top'], 10) || 0;
+        const marginBottom = parseInt(styles['margin-bottom'], 10) || 0;
+        const marginLeft = parseInt(styles['margin-left'], 10) || 0;
+        const marginRight = parseInt(styles['margin-right'], 10) || 0;
+        return {
+            top: result.top + marginTop,
+            bottom: result.bottom + marginBottom,
+            left: result.left + marginLeft,
+            right: result.right + marginRight,
+            width: parseFloat((result.width + marginLeft + marginRight).toFixed(3)),
+            height: parseFloat((result.height + marginTop + marginBottom).toFixed(3))
+        };
+    }
+    getContent() {
+        const content = (this.containerElementRef && this.containerElementRef.nativeElement) || this.contentElementRef.nativeElement;
+        return content;
+    }
+    checkScrollElementResized() {
+        const boundingRect = this.getElementSize(this.getScrollElement());
+        let sizeChanged;
+        if (!this.previousScrollBoundingRect) {
+            sizeChanged = true;
+        }
+        else {
+            const widthChange = Math.abs(boundingRect.width - this.previousScrollBoundingRect.width);
+            const heightChange = Math.abs(boundingRect.height - this.previousScrollBoundingRect.height);
+            sizeChanged = widthChange > this.resizeBypassRefreshThreshold || heightChange > this.resizeBypassRefreshThreshold;
+        }
+        if (sizeChanged) {
+            this.previousScrollBoundingRect = boundingRect;
+            if (boundingRect.width > 0 && boundingRect.height > 0) {
+                this.refresh_internal(false);
+            }
+        }
+    }
+    updateDirection() {
+        if (this.horizontal) {
+            this._childScrollDim = 'childWidth';
+            this._invisiblePaddingProperty = 'scaleX';
+            this._marginDir = 'margin-left';
+            this._offsetType = 'offsetLeft';
+            this._pageOffsetType = 'pageXOffset';
+            this._scrollType = 'scrollLeft';
+            this._translateDir = 'translateX';
+        }
+        else {
+            this._childScrollDim = 'childHeight';
+            this._invisiblePaddingProperty = 'scaleY';
+            this._marginDir = 'margin-top';
+            this._offsetType = 'offsetTop';
+            this._pageOffsetType = 'pageYOffset';
+            this._scrollType = 'scrollTop';
+            this._translateDir = 'translateY';
+        }
+    }
+    debounce(func, wait, ...args) {
+        const throttled = this.throttleTrailing(func, wait);
+        const result = function () {
+            throttled['cancel']();
+            throttled.apply(this, args);
+        };
+        result['cancel'] = function () {
+            throttled['cancel']();
+        };
+        return result;
+    }
+    throttleTrailing(func, wait, ...args) {
+        let timeout = undefined;
+        let _arguments = args;
+        const result = function () {
+            const _this = this;
+            _arguments = args;
+            if (timeout) {
+                return;
+            }
+            if (wait <= 0) {
+                func.apply(_this, _arguments);
+            }
+            else {
+                timeout = setTimeout(function () {
+                    timeout = undefined;
+                    func.apply(_this, _arguments);
+                }, wait);
+            }
+        };
+        result['cancel'] = function () {
+            if (timeout) {
+                clearTimeout(timeout);
+                timeout = undefined;
+            }
+        };
+        return result;
+    }
+    refresh_internal(itemsArrayModified, refreshCompletedCallback = undefined, maxRunTimes = 2) {
+        //note: maxRunTimes is to force it to keep recalculating if the previous iteration caused a re-render (different sliced items in viewport or scrollPosition changed).
+        //The default of 2x max will probably be accurate enough without causing too large a performance bottleneck
+        //The code would typically quit out on the 2nd iteration anyways. The main time it'd think more than 2 runs would be necessary would be for vastly different sized child items or if this is the 1st time the items array was initialized.
+        //Without maxRunTimes, If the user is actively scrolling this code would become an infinite loop until they stopped scrolling. This would be okay, except each scroll event would start an additional infinte loop. We want to short-circuit it to prevent this.
+        if (itemsArrayModified && this.previousViewPort && this.previousViewPort.scrollStartPosition > 0) {
+            //if items were prepended, scroll forward to keep same items visible
+            const oldViewPort = this.previousViewPort;
+            const oldViewPortItems = this.viewPortItems;
+            const oldRefreshCompletedCallback = refreshCompletedCallback;
+            refreshCompletedCallback = () => {
+                const scrollLengthDelta = this.previousViewPort.scrollLength - oldViewPort.scrollLength;
+                if (scrollLengthDelta > 0 && this.viewPortItems) {
+                    const oldStartItem = oldViewPortItems[0];
+                    const oldStartItemIndex = this.items.findIndex(x => this.compareItems(oldStartItem, x));
+                    if (oldStartItemIndex > this.previousViewPort.startIndexWithBuffer) {
+                        let itemOrderChanged = false;
+                        for (let i = 1; i < this.viewPortItems.length; ++i) {
+                            if (!this.compareItems(this.items[oldStartItemIndex + i], oldViewPortItems[i])) {
+                                itemOrderChanged = true;
+                                break;
+                            }
+                        }
+                        if (!itemOrderChanged) {
+                            this.scrollToPosition(this.previousViewPort.scrollStartPosition + scrollLengthDelta, 0, oldRefreshCompletedCallback);
+                            return;
+                        }
+                    }
+                }
+                if (oldRefreshCompletedCallback) {
+                    oldRefreshCompletedCallback();
+                }
+            };
+        }
+        this.zone.runOutsideAngular(() => {
+            requestAnimationFrame(() => {
+                if (itemsArrayModified) {
+                    this.resetWrapGroupDimensions();
+                }
+                const viewport = this.calculateViewport();
+                const startChanged = itemsArrayModified || viewport.startIndex !== this.previousViewPort.startIndex;
+                const endChanged = itemsArrayModified || viewport.endIndex !== this.previousViewPort.endIndex;
+                const scrollLengthChanged = viewport.scrollLength !== this.previousViewPort.scrollLength;
+                const paddingChanged = viewport.padding !== this.previousViewPort.padding;
+                const scrollPositionChanged = viewport.scrollStartPosition !== this.previousViewPort.scrollStartPosition || viewport.scrollEndPosition !== this.previousViewPort.scrollEndPosition || viewport.maxScrollPosition !== this.previousViewPort.maxScrollPosition;
+                const scrollDirection = this.previousViewPort.endIndex <= viewport.endIndex ? 'forward' : 'backward';
+                this.previousViewPort = viewport;
+                if (scrollLengthChanged) {
+                    this.renderer.setStyle(this.invisiblePaddingElementRef.nativeElement, 'transform', `${this._invisiblePaddingProperty}(${viewport.scrollLength})`);
+                    this.renderer.setStyle(this.invisiblePaddingElementRef.nativeElement, 'webkitTransform', `${this._invisiblePaddingProperty}(${viewport.scrollLength})`);
+                }
+                if (paddingChanged) {
+                    if (this.useMarginInsteadOfTranslate) {
+                        this.renderer.setStyle(this.contentElementRef.nativeElement, this._marginDir, `${viewport.padding}px`);
+                    }
+                    else {
+                        this.renderer.setStyle(this.contentElementRef.nativeElement, 'transform', `${this._translateDir}(${viewport.padding}px)`);
+                        this.renderer.setStyle(this.contentElementRef.nativeElement, 'webkitTransform', `${this._translateDir}(${viewport.padding}px)`);
+                    }
+                }
+                if (this.headerElementRef) {
+                    const scrollPosition = this.getScrollElement()[this._scrollType];
+                    const containerOffset = this.getElementsOffset();
+                    const offset = Math.max(scrollPosition - viewport.padding - containerOffset + this.headerElementRef.nativeElement.clientHeight, 0);
+                    this.renderer.setStyle(this.headerElementRef.nativeElement, 'transform', `${this._translateDir}(${offset}px)`);
+                    this.renderer.setStyle(this.headerElementRef.nativeElement, 'webkitTransform', `${this._translateDir}(${offset}px)`);
+                }
+                const changeEventArg = (startChanged || endChanged) ? {
+                    startIndex: viewport.startIndex,
+                    endIndex: viewport.endIndex,
+                    scrollStartPosition: viewport.scrollStartPosition,
+                    scrollEndPosition: viewport.scrollEndPosition,
+                    scrollDirection: scrollDirection,
+                    startIndexWithBuffer: viewport.startIndexWithBuffer,
+                    endIndexWithBuffer: viewport.endIndexWithBuffer,
+                    maxScrollPosition: viewport.maxScrollPosition,
+                } : undefined;
+                if (startChanged || endChanged || scrollPositionChanged) {
+                    const handleChanged = () => {
+                        // update the scroll list to trigger re-render of components in viewport
+                        this.viewPortItems = viewport.startIndexWithBuffer >= 0 && viewport.endIndexWithBuffer >= 0 ? this.items.slice(viewport.startIndexWithBuffer, viewport.endIndexWithBuffer + 1) : [];
+                        this.vsUpdate.emit(this.viewPortItems);
+                        if (startChanged) {
+                            this.vsStart.emit(changeEventArg);
+                        }
+                        if (endChanged) {
+                            this.vsEnd.emit(changeEventArg);
+                        }
+                        if (startChanged || endChanged) {
+                            this.changeDetectorRef.markForCheck();
+                            this.vsChange.emit(changeEventArg);
+                        }
+                        if (maxRunTimes > 0) {
+                            this.refresh_internal(false, refreshCompletedCallback, maxRunTimes - 1);
+                            return;
+                        }
+                        if (refreshCompletedCallback) {
+                            refreshCompletedCallback();
+                        }
+                    };
+                    if (this.executeRefreshOutsideAngularZone) {
+                        handleChanged();
+                    }
+                    else {
+                        this.zone.run(handleChanged);
+                    }
+                }
+                else {
+                    if (maxRunTimes > 0 && (scrollLengthChanged || paddingChanged)) {
+                        this.refresh_internal(false, refreshCompletedCallback, maxRunTimes - 1);
+                        return;
+                    }
+                    if (refreshCompletedCallback) {
+                        refreshCompletedCallback();
+                    }
+                }
+            });
+        });
+    }
+    getScrollElement() {
+        return this.parentScroll instanceof Window ? document.scrollingElement || document.documentElement || document.body : this.parentScroll || this.element.nativeElement;
+    }
+    addScrollEventHandlers() {
+        if (this.isAngularUniversalSSR) {
+            return;
+        }
+        const scrollElement = this.getScrollElement();
+        this.removeScrollEventHandlers();
+        this.zone.runOutsideAngular(() => {
+            if (this.parentScroll instanceof Window) {
+                this.disposeScrollHandler = this.renderer.listen('window', 'scroll', this.onScroll);
+                this.disposeResizeHandler = this.renderer.listen('window', 'resize', this.onScroll);
+            }
+            else {
+                this.disposeScrollHandler = this.renderer.listen(scrollElement, 'scroll', this.onScroll);
+                if (this._checkResizeInterval > 0) {
+                    this.checkScrollElementResizedTimer = setInterval(() => { this.checkScrollElementResized(); }, this._checkResizeInterval);
+                }
+            }
+        });
+    }
+    removeScrollEventHandlers() {
+        if (this.checkScrollElementResizedTimer) {
+            clearInterval(this.checkScrollElementResizedTimer);
+        }
+        if (this.disposeScrollHandler) {
+            this.disposeScrollHandler();
+            this.disposeScrollHandler = undefined;
+        }
+        if (this.disposeResizeHandler) {
+            this.disposeResizeHandler();
+            this.disposeResizeHandler = undefined;
+        }
+    }
+    getElementsOffset() {
+        if (this.isAngularUniversalSSR) {
+            return 0;
+        }
+        let offset = 0;
+        if (this.containerElementRef && this.containerElementRef.nativeElement) {
+            offset += this.containerElementRef.nativeElement[this._offsetType];
+        }
+        if (this.parentScroll) {
+            const scrollElement = this.getScrollElement();
+            const elementClientRect = this.getElementSize(this.element.nativeElement);
+            const scrollClientRect = this.getElementSize(scrollElement);
+            if (this.horizontal) {
+                offset += elementClientRect.left - scrollClientRect.left;
+            }
+            else {
+                offset += elementClientRect.top - scrollClientRect.top;
+            }
+            if (!(this.parentScroll instanceof Window)) {
+                offset += scrollElement[this._scrollType];
+            }
+        }
+        return offset;
+    }
+    countItemsPerWrapGroup() {
+        if (this.isAngularUniversalSSR) {
+            return Math.round(this.horizontal ? this.ssrViewportHeight / this.ssrChildHeight : this.ssrViewportWidth / this.ssrChildWidth);
+        }
+        const propertyName = this.horizontal ? 'offsetLeft' : 'offsetTop';
+        const children = this.getContent().children;
+        const childrenLength = children ? children.length : 0;
+        if (childrenLength === 0) {
+            return 1;
+        }
+        const firstOffset = children[0][propertyName];
+        let result = 1;
+        while (result < childrenLength && firstOffset === children[result][propertyName]) {
+            ++result;
+        }
+        return result;
+    }
+    getScrollStartPosition() {
+        let windowScrollValue = undefined;
+        if (this.parentScroll instanceof Window) {
+            windowScrollValue = window[this._pageOffsetType];
+        }
+        return windowScrollValue || this.getScrollElement()[this._scrollType] || 0;
+    }
+    resetWrapGroupDimensions() {
+        const oldWrapGroupDimensions = this.wrapGroupDimensions;
+        this.invalidateAllCachedMeasurements();
+        if (!this.enableUnequalChildrenSizes || !oldWrapGroupDimensions || oldWrapGroupDimensions.numberOfKnownWrapGroupChildSizes === 0) {
+            return;
+        }
+        const itemsPerWrapGroup = this.countItemsPerWrapGroup();
+        for (let wrapGroupIndex = 0; wrapGroupIndex < oldWrapGroupDimensions.maxChildSizePerWrapGroup.length; ++wrapGroupIndex) {
+            const oldWrapGroupDimension = oldWrapGroupDimensions.maxChildSizePerWrapGroup[wrapGroupIndex];
+            if (!oldWrapGroupDimension || !oldWrapGroupDimension.items || !oldWrapGroupDimension.items.length) {
+                continue;
+            }
+            if (oldWrapGroupDimension.items.length !== itemsPerWrapGroup) {
+                return;
+            }
+            let itemsChanged = false;
+            const arrayStartIndex = itemsPerWrapGroup * wrapGroupIndex;
+            for (let i = 0; i < itemsPerWrapGroup; ++i) {
+                if (!this.compareItems(oldWrapGroupDimension.items[i], this.items[arrayStartIndex + i])) {
+                    itemsChanged = true;
+                    break;
+                }
+            }
+            if (!itemsChanged) {
+                ++this.wrapGroupDimensions.numberOfKnownWrapGroupChildSizes;
+                this.wrapGroupDimensions.sumOfKnownWrapGroupChildWidths += oldWrapGroupDimension.childWidth || 0;
+                this.wrapGroupDimensions.sumOfKnownWrapGroupChildHeights += oldWrapGroupDimension.childHeight || 0;
+                this.wrapGroupDimensions.maxChildSizePerWrapGroup[wrapGroupIndex] = oldWrapGroupDimension;
+            }
+        }
+    }
+    calculateDimensions() {
+        const scrollElement = this.getScrollElement();
+        const maxCalculatedScrollBarSize = 25; // Note: Formula to auto-calculate doesn't work for ParentScroll, so we default to this if not set by consuming application
+        this.calculatedScrollbarHeight = Math.max(Math.min(scrollElement.offsetHeight - scrollElement.clientHeight, maxCalculatedScrollBarSize), this.calculatedScrollbarHeight);
+        this.calculatedScrollbarWidth = Math.max(Math.min(scrollElement.offsetWidth - scrollElement.clientWidth, maxCalculatedScrollBarSize), this.calculatedScrollbarWidth);
+        let viewportWidth = scrollElement.offsetWidth - (this.scrollbarWidth || this.calculatedScrollbarWidth || (this.horizontal ? 0 : maxCalculatedScrollBarSize));
+        let viewportHeight = scrollElement.offsetHeight - (this.scrollbarHeight || this.calculatedScrollbarHeight || (this.horizontal ? maxCalculatedScrollBarSize : 0));
+        const content = this.getContent();
+        const itemsPerWrapGroup = this.countItemsPerWrapGroup();
+        let wrapGroupsPerPage;
+        let defaultChildWidth;
+        let defaultChildHeight;
+        if (this.isAngularUniversalSSR) {
+            viewportWidth = this.ssrViewportWidth;
+            viewportHeight = this.ssrViewportHeight;
+            defaultChildWidth = this.ssrChildWidth;
+            defaultChildHeight = this.ssrChildHeight;
+            const itemsPerRow = Math.max(Math.ceil(viewportWidth / defaultChildWidth), 1);
+            const itemsPerCol = Math.max(Math.ceil(viewportHeight / defaultChildHeight), 1);
+            wrapGroupsPerPage = this.horizontal ? itemsPerRow : itemsPerCol;
+        }
+        else if (!this.enableUnequalChildrenSizes) {
+            if (content.children.length > 0) {
+                if (!this.childWidth || !this.childHeight) {
+                    if (!this.minMeasuredChildWidth && viewportWidth > 0) {
+                        this.minMeasuredChildWidth = viewportWidth;
+                    }
+                    if (!this.minMeasuredChildHeight && viewportHeight > 0) {
+                        this.minMeasuredChildHeight = viewportHeight;
+                    }
+                }
+                const child = content.children[0];
+                const clientRect = this.getElementSize(child);
+                this.minMeasuredChildWidth = Math.min(this.minMeasuredChildWidth, clientRect.width);
+                this.minMeasuredChildHeight = Math.min(this.minMeasuredChildHeight, clientRect.height);
+                // Added for getting the child height (for card view, return all the clientRect object).
+                // if (this._lastChildRect === null ||
+                // 	(clientRect?.height !== 0 && (
+                // 		Math.round(this._lastChildRect?.height) !== Math.round(clientRect?.height) || 
+                // 		Math.round(this._lastChildRect?.width) !== Math.round(clientRect?.width))
+                // 	)) {
+                // 	this._lastChildRect = clientRect;
+                // 	this.vsChildRectChange.emit(clientRect);
+                // }
+            }
+            defaultChildWidth = this.childWidth || this.minMeasuredChildWidth || viewportWidth;
+            defaultChildHeight = this.childHeight || this.minMeasuredChildHeight || viewportHeight;
+            const itemsPerRow = Math.max(Math.ceil(viewportWidth / defaultChildWidth), 1);
+            const itemsPerCol = Math.max(Math.ceil(viewportHeight / defaultChildHeight), 1);
+            wrapGroupsPerPage = this.horizontal ? itemsPerRow : itemsPerCol;
+        }
+        else {
+            let scrollOffset = scrollElement[this._scrollType] - (this.previousViewPort ? this.previousViewPort.padding : 0);
+            let arrayStartIndex = this.previousViewPort.startIndexWithBuffer || 0;
+            let wrapGroupIndex = Math.ceil(arrayStartIndex / itemsPerWrapGroup);
+            let maxWidthForWrapGroup = 0;
+            let maxHeightForWrapGroup = 0;
+            let sumOfVisibleMaxWidths = 0;
+            let sumOfVisibleMaxHeights = 0;
+            wrapGroupsPerPage = 0;
+            for (let i = 0; i < content.children.length; ++i) {
+                ++arrayStartIndex;
+                const child = content.children[i];
+                const clientRect = this.getElementSize(child);
+                maxWidthForWrapGroup = Math.max(maxWidthForWrapGroup, clientRect.width);
+                maxHeightForWrapGroup = Math.max(maxHeightForWrapGroup, clientRect.height);
+                if (arrayStartIndex % itemsPerWrapGroup === 0) {
+                    const oldValue = this.wrapGroupDimensions.maxChildSizePerWrapGroup[wrapGroupIndex];
+                    if (oldValue) {
+                        --this.wrapGroupDimensions.numberOfKnownWrapGroupChildSizes;
+                        this.wrapGroupDimensions.sumOfKnownWrapGroupChildWidths -= oldValue.childWidth || 0;
+                        this.wrapGroupDimensions.sumOfKnownWrapGroupChildHeights -= oldValue.childHeight || 0;
+                    }
+                    ++this.wrapGroupDimensions.numberOfKnownWrapGroupChildSizes;
+                    const items = this.items.slice(arrayStartIndex - itemsPerWrapGroup, arrayStartIndex);
+                    this.wrapGroupDimensions.maxChildSizePerWrapGroup[wrapGroupIndex] = {
+                        childWidth: maxWidthForWrapGroup,
+                        childHeight: maxHeightForWrapGroup,
+                        items: items
+                    };
+                    this.wrapGroupDimensions.sumOfKnownWrapGroupChildWidths += maxWidthForWrapGroup;
+                    this.wrapGroupDimensions.sumOfKnownWrapGroupChildHeights += maxHeightForWrapGroup;
+                    if (this.horizontal) {
+                        let maxVisibleWidthForWrapGroup = Math.min(maxWidthForWrapGroup, Math.max(viewportWidth - sumOfVisibleMaxWidths, 0));
+                        if (scrollOffset > 0) {
+                            const scrollOffsetToRemove = Math.min(scrollOffset, maxVisibleWidthForWrapGroup);
+                            maxVisibleWidthForWrapGroup -= scrollOffsetToRemove;
+                            scrollOffset -= scrollOffsetToRemove;
+                        }
+                        sumOfVisibleMaxWidths += maxVisibleWidthForWrapGroup;
+                        if (maxVisibleWidthForWrapGroup > 0 && viewportWidth >= sumOfVisibleMaxWidths) {
+                            ++wrapGroupsPerPage;
+                        }
+                    }
+                    else {
+                        let maxVisibleHeightForWrapGroup = Math.min(maxHeightForWrapGroup, Math.max(viewportHeight - sumOfVisibleMaxHeights, 0));
+                        if (scrollOffset > 0) {
+                            const scrollOffsetToRemove = Math.min(scrollOffset, maxVisibleHeightForWrapGroup);
+                            maxVisibleHeightForWrapGroup -= scrollOffsetToRemove;
+                            scrollOffset -= scrollOffsetToRemove;
+                        }
+                        sumOfVisibleMaxHeights += maxVisibleHeightForWrapGroup;
+                        if (maxVisibleHeightForWrapGroup > 0 && viewportHeight >= sumOfVisibleMaxHeights) {
+                            ++wrapGroupsPerPage;
+                        }
+                    }
+                    ++wrapGroupIndex;
+                    maxWidthForWrapGroup = 0;
+                    maxHeightForWrapGroup = 0;
+                }
+            }
+            const averageChildWidth = this.wrapGroupDimensions.sumOfKnownWrapGroupChildWidths / this.wrapGroupDimensions.numberOfKnownWrapGroupChildSizes;
+            const averageChildHeight = this.wrapGroupDimensions.sumOfKnownWrapGroupChildHeights / this.wrapGroupDimensions.numberOfKnownWrapGroupChildSizes;
+            defaultChildWidth = this.childWidth || averageChildWidth || viewportWidth;
+            defaultChildHeight = this.childHeight || averageChildHeight || viewportHeight;
+            if (this.horizontal) {
+                if (viewportWidth > sumOfVisibleMaxWidths) {
+                    wrapGroupsPerPage += Math.ceil((viewportWidth - sumOfVisibleMaxWidths) / defaultChildWidth);
+                }
+            }
+            else {
+                if (viewportHeight > sumOfVisibleMaxHeights) {
+                    wrapGroupsPerPage += Math.ceil((viewportHeight - sumOfVisibleMaxHeights) / defaultChildHeight);
+                }
+            }
+        }
+        const itemCount = this.items.length;
+        const itemsPerPage = itemsPerWrapGroup * wrapGroupsPerPage;
+        const pageCount_fractional = itemCount / itemsPerPage;
+        const numberOfWrapGroups = Math.ceil(itemCount / itemsPerWrapGroup);
+        let scrollLength = 0;
+        const defaultScrollLengthPerWrapGroup = this.horizontal ? defaultChildWidth : defaultChildHeight;
+        if (this.enableUnequalChildrenSizes) {
+            let numUnknownChildSizes = 0;
+            for (let i = 0; i < numberOfWrapGroups; ++i) {
+                const childSize = this.wrapGroupDimensions.maxChildSizePerWrapGroup[i] && this.wrapGroupDimensions.maxChildSizePerWrapGroup[i][this._childScrollDim];
+                if (childSize) {
+                    scrollLength += childSize;
+                }
+                else {
+                    ++numUnknownChildSizes;
+                }
+            }
+            scrollLength += Math.round(numUnknownChildSizes * defaultScrollLengthPerWrapGroup);
+        }
+        else {
+            scrollLength = numberOfWrapGroups * defaultScrollLengthPerWrapGroup;
+        }
+        if (this.headerElementRef) {
+            scrollLength += this.headerElementRef.nativeElement.clientHeight;
+        }
+        const viewportLength = this.horizontal ? viewportWidth : viewportHeight;
+        const maxScrollPosition = Math.max(scrollLength - viewportLength, 0);
+        return {
+            childHeight: defaultChildHeight,
+            childWidth: defaultChildWidth,
+            itemCount: itemCount,
+            itemsPerPage: itemsPerPage,
+            itemsPerWrapGroup: itemsPerWrapGroup,
+            maxScrollPosition: maxScrollPosition,
+            pageCount_fractional: pageCount_fractional,
+            scrollLength: scrollLength,
+            viewportLength: viewportLength,
+            wrapGroupsPerPage: wrapGroupsPerPage,
+        };
+    }
+    calculatePadding(arrayStartIndexWithBuffer, dimensions) {
+        if (dimensions.itemCount === 0) {
+            return 0;
+        }
+        const defaultScrollLengthPerWrapGroup = dimensions[this._childScrollDim];
+        const startingWrapGroupIndex = Math.floor(arrayStartIndexWithBuffer / dimensions.itemsPerWrapGroup) || 0;
+        if (!this.enableUnequalChildrenSizes) {
+            return defaultScrollLengthPerWrapGroup * startingWrapGroupIndex;
+        }
+        let numUnknownChildSizes = 0;
+        let result = 0;
+        for (let i = 0; i < startingWrapGroupIndex; ++i) {
+            const childSize = this.wrapGroupDimensions.maxChildSizePerWrapGroup[i] && this.wrapGroupDimensions.maxChildSizePerWrapGroup[i][this._childScrollDim];
+            if (childSize) {
+                result += childSize;
+            }
+            else {
+                ++numUnknownChildSizes;
+            }
+        }
+        result += Math.round(numUnknownChildSizes * defaultScrollLengthPerWrapGroup);
+        return result;
+    }
+    calculatePageInfo(scrollPosition, dimensions) {
+        let scrollPercentage = 0;
+        if (this.enableUnequalChildrenSizes) {
+            const numberOfWrapGroups = Math.ceil(dimensions.itemCount / dimensions.itemsPerWrapGroup);
+            let totalScrolledLength = 0;
+            const defaultScrollLengthPerWrapGroup = dimensions[this._childScrollDim];
+            for (let i = 0; i < numberOfWrapGroups; ++i) {
+                const childSize = this.wrapGroupDimensions.maxChildSizePerWrapGroup[i] && this.wrapGroupDimensions.maxChildSizePerWrapGroup[i][this._childScrollDim];
+                if (childSize) {
+                    totalScrolledLength += childSize;
+                }
+                else {
+                    totalScrolledLength += defaultScrollLengthPerWrapGroup;
+                }
+                if (scrollPosition < totalScrolledLength) {
+                    scrollPercentage = i / numberOfWrapGroups;
+                    break;
+                }
+            }
+        }
+        else {
+            scrollPercentage = scrollPosition / dimensions.scrollLength;
+        }
+        const startingArrayIndex_fractional = Math.min(Math.max(scrollPercentage * dimensions.pageCount_fractional, 0), dimensions.pageCount_fractional) * dimensions.itemsPerPage;
+        const maxStart = dimensions.itemCount - dimensions.itemsPerPage - 1;
+        let arrayStartIndex = Math.min(Math.floor(startingArrayIndex_fractional), maxStart);
+        arrayStartIndex -= arrayStartIndex % dimensions.itemsPerWrapGroup; // round down to start of wrapGroup
+        if (this.stripedTable) {
+            const bufferBoundary = 2 * dimensions.itemsPerWrapGroup;
+            if (arrayStartIndex % bufferBoundary !== 0) {
+                arrayStartIndex = Math.max(arrayStartIndex - arrayStartIndex % bufferBoundary, 0);
+            }
+        }
+        let arrayEndIndex = Math.ceil(startingArrayIndex_fractional) + dimensions.itemsPerPage - 1;
+        const endIndexWithinWrapGroup = (arrayEndIndex + 1) % dimensions.itemsPerWrapGroup;
+        if (endIndexWithinWrapGroup > 0) {
+            arrayEndIndex += dimensions.itemsPerWrapGroup - endIndexWithinWrapGroup; // round up to end of wrapGroup
+        }
+        if (isNaN(arrayStartIndex)) {
+            arrayStartIndex = 0;
+        }
+        if (isNaN(arrayEndIndex)) {
+            arrayEndIndex = 0;
+        }
+        arrayStartIndex = Math.min(Math.max(arrayStartIndex, 0), dimensions.itemCount - 1);
+        arrayEndIndex = Math.min(Math.max(arrayEndIndex, 0), dimensions.itemCount - 1);
+        const bufferSize = this.bufferAmount * dimensions.itemsPerWrapGroup;
+        const startIndexWithBuffer = Math.min(Math.max(arrayStartIndex - bufferSize, 0), dimensions.itemCount - 1);
+        const endIndexWithBuffer = Math.min(Math.max(arrayEndIndex + bufferSize, 0), dimensions.itemCount - 1);
+        return {
+            startIndex: arrayStartIndex,
+            endIndex: arrayEndIndex,
+            startIndexWithBuffer: startIndexWithBuffer,
+            endIndexWithBuffer: endIndexWithBuffer,
+            scrollStartPosition: scrollPosition,
+            scrollEndPosition: scrollPosition + dimensions.viewportLength,
+            maxScrollPosition: dimensions.maxScrollPosition
+        };
+    }
+    calculateViewport() {
+        const dimensions = this.calculateDimensions();
+        const offset = this.getElementsOffset();
+        let scrollStartPosition = this.getScrollStartPosition();
+        if (scrollStartPosition > (dimensions.scrollLength + offset) && !(this.parentScroll instanceof Window)) {
+            scrollStartPosition = dimensions.scrollLength;
+        }
+        else {
+            scrollStartPosition -= offset;
+        }
+        scrollStartPosition = Math.max(0, scrollStartPosition);
+        const pageInfo = this.calculatePageInfo(scrollStartPosition, dimensions);
+        const newPadding = this.calculatePadding(pageInfo.startIndexWithBuffer, dimensions);
+        const newScrollLength = dimensions.scrollLength;
+        return {
+            startIndex: pageInfo.startIndex,
+            endIndex: pageInfo.endIndex,
+            startIndexWithBuffer: pageInfo.startIndexWithBuffer,
+            endIndexWithBuffer: pageInfo.endIndexWithBuffer,
+            padding: Math.round(newPadding),
+            scrollLength: Math.round(newScrollLength),
+            scrollStartPosition: pageInfo.scrollStartPosition,
+            scrollEndPosition: pageInfo.scrollEndPosition,
+            maxScrollPosition: pageInfo.maxScrollPosition
+        };
+    }
+}
+VirtualScrollerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: VirtualScrollerComponent, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.NgZone }, { token: i0.ChangeDetectorRef }, { token: PLATFORM_ID }, { token: 'virtual-scroller-default-options', optional: true }], target: i0.ɵɵFactoryTarget.Component });
+VirtualScrollerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.0.2", type: VirtualScrollerComponent, selector: "virtual-scroller,[virtualScroller]", inputs: { disable: "disable", executeRefreshOutsideAngularZone: "executeRefreshOutsideAngularZone", enableUnequalChildrenSizes: "enableUnequalChildrenSizes", RTL: "RTL", useMarginInsteadOfTranslate: "useMarginInsteadOfTranslate", modifyOverflowStyleOfParentScroll: "modifyOverflowStyleOfParentScroll", stripedTable: "stripedTable", scrollbarWidth: "scrollbarWidth", scrollbarHeight: "scrollbarHeight", childWidth: "childWidth", childHeight: "childHeight", ssrChildWidth: "ssrChildWidth", ssrChildHeight: "ssrChildHeight", ssrViewportWidth: "ssrViewportWidth", ssrViewportHeight: "ssrViewportHeight", bufferAmount: "bufferAmount", scrollAnimationTime: "scrollAnimationTime", resizeBypassRefreshThreshold: "resizeBypassRefreshThreshold", scrollThrottlingTime: "scrollThrottlingTime", scrollDebounceTime: "scrollDebounceTime", checkResizeInterval: "checkResizeInterval", items: "items", compareItems: "compareItems", horizontal: "horizontal", parentScroll: "parentScroll" }, outputs: { vsChildRectChange: "vsChildRectChange", vsUpdate: "vsUpdate", vsChange: "vsChange", vsStart: "vsStart", vsEnd: "vsEnd" }, host: { properties: { "class.horizontal": "horizontal", "class.vertical": "!horizontal", "class.selfScroll": "!parentScroll", "class.rtl": "RTL" } }, queries: [{ propertyName: "headerElementRef", first: true, predicate: ["header"], descendants: true, read: ElementRef }, { propertyName: "containerElementRef", first: true, predicate: ["container"], descendants: true, read: ElementRef }], viewQueries: [{ propertyName: "contentElementRef", first: true, predicate: ["content"], descendants: true, read: ElementRef, static: true }, { propertyName: "invisiblePaddingElementRef", first: true, predicate: ["invisiblePadding"], descendants: true, read: ElementRef, static: true }], exportAs: ["virtualScroller"], usesOnChanges: true, ngImport: i0, template: `
+    <div class="total-padding" #invisiblePadding></div>
+    <div class="scrollable-content" #content>
+      <ng-content></ng-content>
+    </div>
+  `, isInline: true, styles: [":host{position:relative;display:block;-webkit-overflow-scrolling:touch}:host.horizontal.selfScroll{overflow-y:visible;overflow-x:auto}:host.horizontal.selfScroll.rtl{transform:scaleX(-1)}:host.vertical.selfScroll{overflow-y:auto;overflow-x:visible}.scrollable-content{top:0;left:0;width:100%;height:100%;max-width:100vw;max-height:100vh;position:absolute}.scrollable-content ::ng-deep>*{box-sizing:border-box}:host.horizontal{white-space:nowrap}:host.horizontal .scrollable-content{display:flex}:host.horizontal .scrollable-content ::ng-deep>*{flex-shrink:0;flex-grow:0;white-space:initial}:host.horizontal.rtl .scrollable-content ::ng-deep>*{transform:scaleX(-1)}.total-padding{position:absolute;top:0;left:0;height:1px;width:1px;transform-origin:0 0;opacity:0}:host.horizontal .total-padding{height:100%}\n"] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: VirtualScrollerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'virtual-scroller,[virtualScroller]', exportAs: 'virtualScroller', template: `
+    <div class="total-padding" #invisiblePadding></div>
+    <div class="scrollable-content" #content>
+      <ng-content></ng-content>
+    </div>
+  `, host: {
+                        '[class.horizontal]': "horizontal",
+                        '[class.vertical]': "!horizontal",
+                        '[class.selfScroll]': "!parentScroll",
+                        '[class.rtl]': "RTL"
+                    }, styles: [":host{position:relative;display:block;-webkit-overflow-scrolling:touch}:host.horizontal.selfScroll{overflow-y:visible;overflow-x:auto}:host.horizontal.selfScroll.rtl{transform:scaleX(-1)}:host.vertical.selfScroll{overflow-y:auto;overflow-x:visible}.scrollable-content{top:0;left:0;width:100%;height:100%;max-width:100vw;max-height:100vh;position:absolute}.scrollable-content ::ng-deep>*{box-sizing:border-box}:host.horizontal{white-space:nowrap}:host.horizontal .scrollable-content{display:flex}:host.horizontal .scrollable-content ::ng-deep>*{flex-shrink:0;flex-grow:0;white-space:initial}:host.horizontal.rtl .scrollable-content ::ng-deep>*{transform:scaleX(-1)}.total-padding{position:absolute;top:0;left:0;height:1px;width:1px;transform-origin:0 0;opacity:0}:host.horizontal .total-padding{height:100%}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i0.NgZone }, { type: i0.ChangeDetectorRef }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: ['virtual-scroller-default-options']
+                }] }]; }, propDecorators: { disable: [{
+                type: Input
+            }], executeRefreshOutsideAngularZone: [{
+                type: Input
+            }], enableUnequalChildrenSizes: [{
+                type: Input
+            }], RTL: [{
+                type: Input
+            }], useMarginInsteadOfTranslate: [{
+                type: Input
+            }], modifyOverflowStyleOfParentScroll: [{
+                type: Input
+            }], stripedTable: [{
+                type: Input
+            }], scrollbarWidth: [{
+                type: Input
+            }], scrollbarHeight: [{
+                type: Input
+            }], childWidth: [{
+                type: Input
+            }], childHeight: [{
+                type: Input
+            }], ssrChildWidth: [{
+                type: Input
+            }], ssrChildHeight: [{
+                type: Input
+            }], ssrViewportWidth: [{
+                type: Input
+            }], ssrViewportHeight: [{
+                type: Input
+            }], bufferAmount: [{
+                type: Input
+            }], scrollAnimationTime: [{
+                type: Input
+            }], resizeBypassRefreshThreshold: [{
+                type: Input
+            }], scrollThrottlingTime: [{
+                type: Input
+            }], scrollDebounceTime: [{
+                type: Input
+            }], checkResizeInterval: [{
+                type: Input
+            }], items: [{
+                type: Input
+            }], compareItems: [{
+                type: Input
+            }], horizontal: [{
+                type: Input
+            }], parentScroll: [{
+                type: Input
+            }], vsChildRectChange: [{
+                type: Output
+            }], vsUpdate: [{
+                type: Output
+            }], vsChange: [{
+                type: Output
+            }], vsStart: [{
+                type: Output
+            }], vsEnd: [{
+                type: Output
+            }], contentElementRef: [{
+                type: ViewChild,
+                args: ['content', { read: ElementRef, static: true }]
+            }], invisiblePaddingElementRef: [{
+                type: ViewChild,
+                args: ['invisiblePadding', { read: ElementRef, static: true }]
+            }], headerElementRef: [{
+                type: ContentChild,
+                args: ['header', { read: ElementRef, static: false }]
+            }], containerElementRef: [{
+                type: ContentChild,
+                args: ['container', { read: ElementRef, static: false }]
+            }] } });
+export class VirtualScrollerModule {
+}
+VirtualScrollerModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: VirtualScrollerModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+VirtualScrollerModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.0.2", ngImport: i0, type: VirtualScrollerModule, declarations: [VirtualScrollerComponent], imports: [CommonModule], exports: [VirtualScrollerComponent] });
+VirtualScrollerModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: VirtualScrollerModule, providers: [
+        {
+            provide: 'virtual-scroller-default-options',
+            useFactory: VIRTUAL_SCROLLER_DEFAULT_OPTIONS_FACTORY
+        }
+    ], imports: [CommonModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: VirtualScrollerModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    exports: [VirtualScrollerComponent],
+                    declarations: [VirtualScrollerComponent],
+                    imports: [CommonModule],
+                    providers: [
+                        {
+                            provide: 'virtual-scroller-default-options',
+                            useFactory: VIRTUAL_SCROLLER_DEFAULT_OPTIONS_FACTORY
+                        }
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"virtual-scroller.js","sourceRoot":"","sources":["../../../../projects/ngx-lib/list/virtual-scroller.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n\tChangeDetectorRef,\r\n\tComponent,\r\n\tContentChild,\r\n\tElementRef,\r\n\tEventEmitter,\r\n\tInject,\r\n\tInput,\r\n\tNgModule,\r\n\tNgZone,\r\n\tOnChanges,\r\n\tOnDestroy,\r\n\tOnInit,\r\n\tOptional,\r\n\tOutput,\r\n\tRenderer2,\r\n\tViewChild,\r\n} from '@angular/core';\r\n\r\nimport { PLATFORM_ID } from '@angular/core';\r\nimport { isPlatformServer } from '@angular/common';\r\n\r\nimport { CommonModule } from '@angular/common';\r\n\r\nimport * as tween from '@tweenjs/tween.js'\r\n\r\nexport interface VirtualScrollerDefaultOptions {\r\n\tcheckResizeInterval: number\r\n\tmodifyOverflowStyleOfParentScroll: boolean,\r\n\tresizeBypassRefreshThreshold: number,\r\n\tscrollAnimationTime: number;\r\n\tscrollDebounceTime: number;\r\n\tscrollThrottlingTime: number;\r\n\tscrollbarHeight?: number;\r\n\tscrollbarWidth?: number;\r\n\tstripedTable: boolean\r\n}\r\n\r\nexport function VIRTUAL_SCROLLER_DEFAULT_OPTIONS_FACTORY(): VirtualScrollerDefaultOptions {\r\n\treturn {\r\n\t\tcheckResizeInterval: 1000,\r\n\t\tmodifyOverflowStyleOfParentScroll: true,\r\n\t\tresizeBypassRefreshThreshold: 5,\r\n\t\tscrollAnimationTime: 750,\r\n\t\tscrollDebounceTime: 0,\r\n\t\tscrollThrottlingTime: 0,\r\n\t\tstripedTable: false\r\n\t};\r\n}\r\n\r\nexport interface WrapGroupDimensions {\r\n\tmaxChildSizePerWrapGroup: WrapGroupDimension[];\r\n\tnumberOfKnownWrapGroupChildSizes: number;\r\n\tsumOfKnownWrapGroupChildHeights: number;\r\n\tsumOfKnownWrapGroupChildWidths: number;\r\n}\r\n\r\nexport interface WrapGroupDimension {\r\n\tchildHeight: number;\r\n\tchildWidth: number;\r\n\titems: any[];\r\n}\r\n\r\nexport interface IDimensions {\r\n\tchildHeight: number;\r\n\tchildWidth: number;\r\n\titemCount: number;\r\n\titemsPerPage: number;\r\n\titemsPerWrapGroup: number;\r\n\tmaxScrollPosition: number;\r\n\tpageCount_fractional: number;\r\n\tscrollLength: number;\r\n\tviewportLength: number;\r\n\twrapGroupsPerPage: number;\r\n}\r\n\r\nexport type ScrollDirectionType = 'backward' | 'forward';\r\n\r\nexport interface IPageInfo {\r\n\tendIndex: number;\r\n\tendIndexWithBuffer: number;\r\n\tmaxScrollPosition: number;\r\n\tscrollEndPosition: number;\r\n\tscrollStartPosition: number;\r\n\tscrollDirection?: ScrollDirectionType;\r\n\tstartIndex: number;\r\n\tstartIndexWithBuffer: number;\r\n}\r\n\r\nexport interface IViewport extends IPageInfo {\r\n\tpadding: number;\r\n\tscrollLength: number;\r\n}\r\n\r\n@Component({\r\n\tselector: 'virtual-scroller,[virtualScroller]',\r\n\texportAs: 'virtualScroller',\r\n\ttemplate: `\r\n    <div class=\"total-padding\" #invisiblePadding></div>\r\n    <div class=\"scrollable-content\" #content>\r\n      <ng-content></ng-content>\r\n    </div>\r\n  `,\r\n\thost: {\r\n\t\t'[class.horizontal]': \"horizontal\",\r\n\t\t'[class.vertical]': \"!horizontal\",\r\n\t\t'[class.selfScroll]': \"!parentScroll\",\r\n\t\t'[class.rtl]': \"RTL\"\r\n\t},\r\n\tstyles: [`\r\n    :host {\r\n      position: relative;\r\n\t  \tdisplay: block;\r\n      -webkit-overflow-scrolling: touch;\r\n    }\r\n\t\t:host.horizontal.selfScroll {\r\n      overflow-y: visible;\r\n      overflow-x: auto;\r\n\t\t}\r\n\t\t:host.horizontal.selfScroll.rtl {\r\n\t\t\ttransform: scaleX(-1);\r\n\t\t}\r\n\t\t:host.vertical.selfScroll {\r\n      overflow-y: auto;\r\n      overflow-x: visible;\r\n\t\t}\r\n    .scrollable-content {\r\n      top: 0;\r\n      left: 0;\r\n      width: 100%;\r\n      height: 100%;\r\n      max-width: 100vw;\r\n      max-height: 100vh;\r\n      position: absolute;\r\n    }\r\n\t\t.scrollable-content ::ng-deep > * {\r\n\t\t\tbox-sizing: border-box;\r\n\t\t}\r\n\t\t:host.horizontal {\r\n\t\t\twhite-space: nowrap;\r\n\t\t}\r\n\t\t:host.horizontal .scrollable-content {\r\n\t\t\tdisplay: flex;\r\n\t\t}\r\n\t\t:host.horizontal .scrollable-content ::ng-deep > * {\r\n\t\t\tflex-shrink: 0;\r\n\t\t\tflex-grow: 0;\r\n\t\t\twhite-space: initial;\r\n\t\t}\r\n\t\t:host.horizontal.rtl .scrollable-content ::ng-deep > * {\r\n\t\t\ttransform:scaleX(-1);\r\n\t\t}\r\n    .total-padding {\r\n      position: absolute;\r\n      top: 0;\r\n      left: 0;\r\n      height: 1px;\r\n      width: 1px;\r\n      transform-origin: 0 0;\r\n      opacity: 0;\r\n    }\r\n    :host.horizontal .total-padding {\r\n      height: 100%;\r\n    }\r\n  `]\r\n})\r\nexport class VirtualScrollerComponent implements OnInit, OnChanges, OnDestroy {\r\n\tpublic viewPortItems: any[];\r\n\tpublic window = window;\r\n\r\n\tpublic get viewPortInfo(): IPageInfo {\r\n\t\tconst pageInfo: IViewport = this.previousViewPort || <any>{};\r\n\t\treturn {\r\n\t\t\tstartIndex: pageInfo.startIndex || 0,\r\n\t\t\tendIndex: pageInfo.endIndex || 0,\r\n\t\t\tscrollStartPosition: pageInfo.scrollStartPosition || 0,\r\n\t\t\tscrollEndPosition: pageInfo.scrollEndPosition || 0,\r\n\t\t\tscrollDirection: pageInfo.scrollDirection || 'forward',\r\n\t\t\tmaxScrollPosition: pageInfo.maxScrollPosition || 0,\r\n\t\t\tstartIndexWithBuffer: pageInfo.startIndexWithBuffer || 0,\r\n\t\t\tendIndexWithBuffer: pageInfo.endIndexWithBuffer || 0,\r\n\t\t};\r\n\t}\r\n\r\n\tprotected _disable = false;\r\n\t@Input()\r\n\tpublic get disable(): boolean {\r\n\t\treturn this._disable;\r\n\t}\r\n\tpublic set disable(value: boolean) {\r\n\t\tif (this._disable === value) {\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tthis._disable = value;\r\n\t\tif (this._disable) {\r\n\t\t\tthis.removeScrollEventHandlers();\r\n\t\t} else {\r\n\t\t\tthis.addScrollEventHandlers();\r\n\t\t}\r\n\t}\r\n\r\n\t@Input()\r\n\tpublic executeRefreshOutsideAngularZone = false;\r\n\r\n\tprotected _enableUnequalChildrenSizes = false;\r\n\t@Input()\r\n\tpublic get enableUnequalChildrenSizes(): boolean {\r\n\t\treturn this._enableUnequalChildrenSizes;\r\n\t}\r\n\tpublic set enableUnequalChildrenSizes(value: boolean) {\r\n\t\tif (this._enableUnequalChildrenSizes === value) {\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tthis._enableUnequalChildrenSizes = value;\r\n\t\tthis.minMeasuredChildWidth = undefined;\r\n\t\tthis.minMeasuredChildHeight = undefined;\r\n\t}\r\n\r\n\t@Input()\r\n\tpublic RTL = false;\r\n\r\n\t@Input()\r\n\tpublic useMarginInsteadOfTranslate = false;\r\n\r\n\t@Input()\r\n\tpublic modifyOverflowStyleOfParentScroll: boolean;\r\n\r\n\t@Input()\r\n\tpublic stripedTable: boolean;\r\n\r\n\t@Input()\r\n\tpublic scrollbarWidth: number;\r\n\r\n\t@Input()\r\n\tpublic scrollbarHeight: number;\r\n\r\n\t@Input()\r\n\tpublic childWidth: number;\r\n\r\n\t@Input()\r\n\tpublic childHeight: number;\r\n\r\n\t@Input()\r\n\tpublic ssrChildWidth: number;\r\n\r\n\t@Input()\r\n\tpublic ssrChildHeight: number;\r\n\r\n\t@Input()\r\n\tpublic ssrViewportWidth = 1920;\r\n\r\n\t@Input()\r\n\tpublic ssrViewportHeight = 1080;\r\n\r\n\tprotected _bufferAmount: number;\r\n\t@Input()\r\n\tpublic get bufferAmount(): number {\r\n\t\tif (typeof (this._bufferAmount) === 'number' && this._bufferAmount > 0) {\r\n\t\t\treturn this._bufferAmount;\r\n\t\t} else {\r\n\t\t\treturn this.enableUnequalChildrenSizes ? 5 : 0;\r\n\t\t}\r\n\t}\r\n\tpublic set bufferAmount(value: number) {\r\n\t\tthis._bufferAmount = value;\r\n\t}\r\n\r\n\t@Input()\r\n\tpublic scrollAnimationTime: number;\r\n\r\n\t@Input()\r\n\tpublic resizeBypassRefreshThreshold: number;\r\n\r\n\tprotected _scrollThrottlingTime: number;\r\n\t@Input()\r\n\tpublic get scrollThrottlingTime(): number {\r\n\t\treturn this._scrollThrottlingTime;\r\n\t}\r\n\tpublic set scrollThrottlingTime(value: number) {\r\n\t\tthis._scrollThrottlingTime = value;\r\n\t\tthis.updateOnScrollFunction();\r\n\t}\r\n\r\n\tprotected _scrollDebounceTime: number;\r\n\t@Input()\r\n\tpublic get scrollDebounceTime(): number {\r\n\t\treturn this._scrollDebounceTime;\r\n\t}\r\n\tpublic set scrollDebounceTime(value: number) {\r\n\t\tthis._scrollDebounceTime = value;\r\n\t\tthis.updateOnScrollFunction();\r\n\t}\r\n\r\n\tprotected onScroll: () => void;\r\n\tprotected updateOnScrollFunction(): void {\r\n\t\tif (this.scrollDebounceTime) {\r\n\t\t\tthis.onScroll = <any>this.debounce(() => {\r\n\t\t\t\tthis.refresh_internal(false);\r\n\t\t\t}, this.scrollDebounceTime);\r\n\t\t}\r\n\t\telse if (this.scrollThrottlingTime) {\r\n\t\t\tthis.onScroll = <any>this.throttleTrailing(() => {\r\n\t\t\t\tthis.refresh_internal(false);\r\n\t\t\t}, this.scrollThrottlingTime);\r\n\t\t}\r\n\t\telse {\r\n\t\t\tthis.onScroll = () => {\r\n\t\t\t\tthis.refresh_internal(false);\r\n\t\t\t};\r\n\t\t}\r\n\t}\r\n\r\n\tprotected checkScrollElementResizedTimer: number;\r\n\tprotected _checkResizeInterval: number;\r\n\t@Input()\r\n\tpublic get checkResizeInterval(): number {\r\n\t\treturn this._checkResizeInterval;\r\n\t}\r\n\tpublic set checkResizeInterval(value: number) {\r\n\t\tif (this._checkResizeInterval === value) {\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tthis._checkResizeInterval = value;\r\n\t\tthis.addScrollEventHandlers();\r\n\t}\r\n\r\n\tprotected _items: any[] = [];\r\n\t@Input()\r\n\tpublic get items(): any[] {\r\n\t\treturn this._items;\r\n\t}\r\n\tpublic set items(value: any[]) {\r\n\t\tif (value === this._items) {\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tthis._items = value || [];\r\n\t\tthis.refresh_internal(true);\r\n\t}\r\n\r\n\t@Input()\r\n\tpublic compareItems: (item1: any, item2: any) => boolean = (item1: any, item2: any) => item1 === item2;\r\n\r\n\tprotected _horizontal: boolean;\r\n\t@Input()\r\n\tpublic get horizontal(): boolean {\r\n\t\treturn this._horizontal;\r\n\t}\r\n\tpublic set horizontal(value: boolean) {\r\n\t\tthis._horizontal = value;\r\n\t\tthis.updateDirection();\r\n\t}\r\n\r\n\tprotected revertParentOverscroll(): void {\r\n\t\tconst scrollElement = this.getScrollElement();\r\n\t\tif (scrollElement && this.oldParentScrollOverflow) {\r\n\t\t\tscrollElement.style['overflow-y'] = this.oldParentScrollOverflow.y;\r\n\t\t\tscrollElement.style['overflow-x'] = this.oldParentScrollOverflow.x;\r\n\t\t}\r\n\r\n\t\tthis.oldParentScrollOverflow = undefined;\r\n\t}\r\n\r\n\tprotected oldParentScrollOverflow: { x: string, y: string };\r\n\tprotected _parentScroll: Element | Window;\r\n\t@Input()\r\n\tpublic get parentScroll(): Element | Window {\r\n\t\treturn this._parentScroll;\r\n\t}\r\n\tpublic set parentScroll(value: Element | Window) {\r\n\t\tif (this._parentScroll === value) {\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tthis.revertParentOverscroll();\r\n\t\tthis._parentScroll = value;\r\n\t\tthis.addScrollEventHandlers();\r\n\r\n\t\tconst scrollElement = this.getScrollElement();\r\n\t\tif (this.modifyOverflowStyleOfParentScroll && scrollElement !== this.element.nativeElement) {\r\n\t\t\tthis.oldParentScrollOverflow = { x: scrollElement.style['overflow-x'], y: scrollElement.style['overflow-y'] };\r\n\t\t\tscrollElement.style['overflow-y'] = this.horizontal ? 'visible' : 'auto';\r\n\t\t\tscrollElement.style['overflow-x'] = this.horizontal ? 'auto' : 'visible';\r\n\t\t}\r\n\t}\r\n\r\n\t// private _lastChildRect: DOMRect = null;\r\n\r\n\t@Output()\r\n\tpublic vsChildRectChange: EventEmitter<DOMRect> = new EventEmitter<DOMRect>();\r\n\r\n\t@Output()\r\n\tpublic vsUpdate: EventEmitter<any[]> = new EventEmitter<any[]>();\r\n\r\n\t@Output()\r\n\tpublic vsChange: EventEmitter<IPageInfo> = new EventEmitter<IPageInfo>();\r\n\r\n\t@Output()\r\n\tpublic vsStart: EventEmitter<IPageInfo> = new EventEmitter<IPageInfo>();\r\n\r\n\t@Output()\r\n\tpublic vsEnd: EventEmitter<IPageInfo> = new EventEmitter<IPageInfo>();\r\n\r\n\t@ViewChild('content', { read: ElementRef, static: true })\r\n\tpublic contentElementRef: ElementRef;\r\n\r\n\t@ViewChild('invisiblePadding', { read: ElementRef, static: true })\r\n\tprotected invisiblePaddingElementRef: ElementRef;\r\n\r\n\t@ContentChild('header', { read: ElementRef, static: false })\r\n\tprotected headerElementRef: ElementRef;\r\n\r\n\t@ContentChild('container', { read: ElementRef, static: false })\r\n\tprotected containerElementRef: ElementRef;\r\n\r\n\tpublic ngOnInit(): void {\r\n\t\tthis.addScrollEventHandlers();\r\n\t}\r\n\r\n\tpublic ngOnDestroy(): void {\r\n\t\tthis.removeScrollEventHandlers();\r\n\t\tthis.revertParentOverscroll();\r\n\t}\r\n\r\n\tpublic ngOnChanges(changes: any): void {\r\n\t\tconst indexLengthChanged = this.cachedItemsLength !== this.items.length;\r\n\t\tthis.cachedItemsLength = this.items.length;\r\n\r\n\t\tconst firstRun: boolean = !changes.items || !changes.items.previousValue || changes.items.previousValue.length === 0;\r\n\t\tthis.refresh_internal(indexLengthChanged || firstRun);\r\n\t}\r\n\r\n\tpublic ngDoCheck(): void {\r\n\t\tif (this.cachedItemsLength !== this.items.length) {\r\n\t\t\tthis.cachedItemsLength = this.items.length;\r\n\t\t\tthis.refresh_internal(true);\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tif (this.previousViewPort && this.viewPortItems && this.viewPortItems.length > 0) {\r\n\t\t\tlet itemsArrayChanged = false;\r\n\t\t\tfor (let i = 0; i < this.viewPortItems.length; ++i) {\r\n\t\t\t\tif (!this.compareItems(this.items[this.previousViewPort.startIndexWithBuffer + i], this.viewPortItems[i])) {\r\n\t\t\t\t\titemsArrayChanged = true;\r\n\t\t\t\t\tbreak;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\tif (itemsArrayChanged) {\r\n\t\t\t\tthis.refresh_internal(true);\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\tpublic refresh(refreshCompletedCallback: () => void = undefined): void {\r\n\t\tthis.refresh_internal(true, refreshCompletedCallback);\r\n\t}\r\n\r\n\tpublic invalidateAllCachedMeasurements(): void {\r\n\t\tthis.wrapGroupDimensions = {\r\n\t\t\tmaxChildSizePerWrapGroup: [],\r\n\t\t\tnumberOfKnownWrapGroupChildSizes: 0,\r\n\t\t\tsumOfKnownWrapGroupChildWidths: 0,\r\n\t\t\tsumOfKnownWrapGroupChildHeights: 0\r\n\t\t};\r\n\r\n\t\tthis.minMeasuredChildWidth = undefined;\r\n\t\tthis.minMeasuredChildHeight = undefined;\r\n\r\n\t\tthis.refresh_internal(false);\r\n\t}\r\n\r\n\tpublic invalidateCachedMeasurementForItem(item: any): void {\r\n\t\tif (this.enableUnequalChildrenSizes) {\r\n\t\t\tconst index = this.items && this.items.indexOf(item);\r\n\t\t\tif (index >= 0) {\r\n\t\t\t\tthis.invalidateCachedMeasurementAtIndex(index);\r\n\t\t\t}\r\n\t\t} else {\r\n\t\t\tthis.minMeasuredChildWidth = undefined;\r\n\t\t\tthis.minMeasuredChildHeight = undefined;\r\n\t\t}\r\n\r\n\t\tthis.refresh_internal(false);\r\n\t}\r\n\r\n\tpublic invalidateCachedMeasurementAtIndex(index: number): void {\r\n\t\tif (this.enableUnequalChildrenSizes) {\r\n\t\t\tconst cachedMeasurement = this.wrapGroupDimensions.maxChildSizePerWrapGroup[index];\r\n\t\t\tif (cachedMeasurement) {\r\n\t\t\t\tthis.wrapGroupDimensions.maxChildSizePerWrapGroup[index] = undefined;\r\n\t\t\t\t--this.wrapGroupDimensions.numberOfKnownWrapGroupChildSizes;\r\n\t\t\t\tthis.wrapGroupDimensions.sumOfKnownWrapGroupChildWidths -= cachedMeasurement.childWidth || 0;\r\n\t\t\t\tthis.wrapGroupDimensions.sumOfKnownWrapGroupChildHeights -= cachedMeasurement.childHeight || 0;\r\n\t\t\t}\r\n\t\t} else {\r\n\t\t\tthis.minMeasuredChildWidth = undefined;\r\n\t\t\tthis.minMeasuredChildHeight = undefined;\r\n\t\t}\r\n\r\n\t\tthis.refresh_internal(false);\r\n\t}\r\n\r\n\tpublic scrollInto(item: any, alignToBeginning = true, additionalOffset = 0, animationMilliseconds: number = undefined, animationCompletedCallback: () => void = undefined): void {\r\n\t\tconst index: number = this.items.indexOf(item);\r\n\t\tif (index === -1) {\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tthis.scrollToIndex(index, alignToBeginning, additionalOffset, animationMilliseconds, animationCompletedCallback);\r\n\t}\r\n\r\n\tpublic scrollToIndex(index: number, alignToBeginning = true, additionalOffset = 0, animationMilliseconds: number = undefined, animationCompletedCallback: () => void = undefined): void {\r\n\t\tlet maxRetries = 5;\r\n\r\n\t\tconst retryIfNeeded = () => {\r\n\t\t\t--maxRetries;\r\n\t\t\tif (maxRetries <= 0) {\r\n\t\t\t\tif (animationCompletedCallback) {\r\n\t\t\t\t\tanimationCompletedCallback();\r\n\t\t\t\t}\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\r\n\t\t\tconst dimensions = this.calculateDimensions();\r\n\t\t\tconst desiredStartIndex = Math.min(Math.max(index, 0), dimensions.itemCount - 1);\r\n\t\t\tif (this.previousViewPort.startIndex === desiredStartIndex) {\r\n\t\t\t\tif (animationCompletedCallback) {\r\n\t\t\t\t\tanimationCompletedCallback();\r\n\t\t\t\t}\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\r\n\t\t\tthis.scrollToIndex_internal(index, alignToBeginning, additionalOffset, 0, retryIfNeeded);\r\n\t\t};\r\n\r\n\t\tthis.scrollToIndex_internal(index, alignToBeginning, additionalOffset, animationMilliseconds, retryIfNeeded);\r\n\t}\r\n\r\n\tprotected scrollToIndex_internal(index: number, alignToBeginning = true, additionalOffset = 0, animationMilliseconds: number = undefined, animationCompletedCallback: () => void = undefined): void {\r\n\t\tanimationMilliseconds = animationMilliseconds === undefined ? this.scrollAnimationTime : animationMilliseconds;\r\n\r\n\t\tconst dimensions = this.calculateDimensions();\r\n\t\tlet scroll = this.calculatePadding(index, dimensions) + additionalOffset;\r\n\t\tif (!alignToBeginning) {\r\n\t\t\tscroll -= dimensions.wrapGroupsPerPage * dimensions[this._childScrollDim];\r\n\t\t}\r\n\r\n\t\tthis.scrollToPosition(scroll, animationMilliseconds, animationCompletedCallback);\r\n\t}\r\n\r\n\tpublic scrollToPosition(scrollPosition: number, animationMilliseconds: number = undefined, animationCompletedCallback: () => void = undefined): void {\r\n\t\tscrollPosition += this.getElementsOffset();\r\n\r\n\t\tanimationMilliseconds = animationMilliseconds === undefined ? this.scrollAnimationTime : animationMilliseconds;\r\n\r\n\t\tconst scrollElement = this.getScrollElement();\r\n\r\n\t\tlet animationRequest: number;\r\n\r\n\t\tif (this.currentTween) {\r\n\t\t\tthis.currentTween.stop();\r\n\t\t\tthis.currentTween = undefined;\r\n\t\t}\r\n\r\n\t\tif (!animationMilliseconds) {\r\n\t\t\tthis.renderer.setProperty(scrollElement, this._scrollType, scrollPosition);\r\n\t\t\tthis.refresh_internal(false, animationCompletedCallback);\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tconst tweenConfigObj = { scrollPosition: scrollElement[this._scrollType] };\r\n\r\n\t\tconst newTween = new tween.Tween(tweenConfigObj)\r\n\t\t\t.to({ scrollPosition }, animationMilliseconds)\r\n\t\t\t.easing(tween.Easing.Quadratic.Out)\r\n\t\t\t.onUpdate((data) => {\r\n\t\t\t\tif (isNaN(data.scrollPosition)) {\r\n\t\t\t\t\treturn;\r\n\t\t\t\t}\r\n\t\t\t\tthis.renderer.setProperty(scrollElement, this._scrollType, data.scrollPosition);\r\n\t\t\t\tthis.refresh_internal(false);\r\n\t\t\t})\r\n\t\t\t.onStop(() => {\r\n\t\t\t\tcancelAnimationFrame(animationRequest);\r\n\t\t\t})\r\n\t\t\t.start();\r\n\r\n\t\tconst animate = (time?: number) => {\r\n\t\t\tif (!newTween[\"isPlaying\"]()) {\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\r\n\t\t\tnewTween.update(time);\r\n\t\t\tif (tweenConfigObj.scrollPosition === scrollPosition) {\r\n\t\t\t\tthis.refresh_internal(false, animationCompletedCallback);\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\r\n\t\t\tthis.zone.runOutsideAngular(() => {\r\n\t\t\t\tanimationRequest = requestAnimationFrame(animate);\r\n\t\t\t});\r\n\t\t};\r\n\r\n\t\tanimate();\r\n\t\tthis.currentTween = newTween;\r\n\t}\r\n\r\n\tprotected isAngularUniversalSSR: boolean;\r\n\r\n\tconstructor(\r\n\t\tprotected readonly element: ElementRef,\r\n\t\tprotected readonly renderer: Renderer2,\r\n\t\tprotected readonly zone: NgZone,\r\n\t\tprotected changeDetectorRef: ChangeDetectorRef,\r\n\t\t@Inject(PLATFORM_ID) platformId: any,\r\n\t\t@Optional() @Inject('virtual-scroller-default-options')\r\n\t\toptions: VirtualScrollerDefaultOptions\r\n\t) {\r\n\r\n\t\tthis.isAngularUniversalSSR = isPlatformServer(platformId);\r\n\r\n\t\tconst defaultOptions = VIRTUAL_SCROLLER_DEFAULT_OPTIONS_FACTORY();\r\n\r\n\t\tthis.checkResizeInterval = options?.checkResizeInterval || defaultOptions.checkResizeInterval;\r\n\t\tthis.modifyOverflowStyleOfParentScroll = options?.modifyOverflowStyleOfParentScroll || defaultOptions.modifyOverflowStyleOfParentScroll;\r\n\t\tthis.resizeBypassRefreshThreshold = options?.resizeBypassRefreshThreshold || defaultOptions.resizeBypassRefreshThreshold;\r\n\t\tthis.scrollAnimationTime = options?.scrollAnimationTime || defaultOptions.scrollAnimationTime;\r\n\t\tthis.scrollDebounceTime = options?.scrollDebounceTime || defaultOptions.scrollDebounceTime;\r\n\t\tthis.scrollThrottlingTime = options?.scrollThrottlingTime || defaultOptions.scrollThrottlingTime;\r\n\t\tthis.scrollbarHeight = options?.scrollbarHeight || defaultOptions.scrollbarHeight;\r\n\t\tthis.scrollbarWidth = options?.scrollbarWidth || defaultOptions.scrollbarWidth;\r\n\t\tthis.stripedTable = options?.stripedTable || defaultOptions.stripedTable;\r\n\r\n\t\tthis.horizontal = false;\r\n\t\tthis.resetWrapGroupDimensions();\r\n\t}\r\n\r\n\tpublic getElementSize(element: HTMLElement): any {\r\n\t\tconst result = element.getBoundingClientRect();\r\n\t\tconst styles = getComputedStyle(element);\r\n\t\tconst marginTop = parseInt(styles['margin-top'], 10) || 0;\r\n\t\tconst marginBottom = parseInt(styles['margin-bottom'], 10) || 0;\r\n\t\tconst marginLeft = parseInt(styles['margin-left'], 10) || 0;\r\n\t\tconst marginRight = parseInt(styles['margin-right'], 10) || 0;\r\n\r\n\t\treturn {\r\n\t\t\ttop: result.top + marginTop,\r\n\t\t\tbottom: result.bottom + marginBottom,\r\n\t\t\tleft: result.left + marginLeft,\r\n\t\t\tright: result.right + marginRight,\r\n\t\t\twidth: parseFloat((result.width + marginLeft + marginRight).toFixed(3)),\r\n\t\t\theight: parseFloat((result.height + marginTop + marginBottom).toFixed(3))\r\n\t\t};\r\n\t}\r\n\r\n\tpublic getContent() {\r\n\t\tconst content = (this.containerElementRef && this.containerElementRef.nativeElement) || this.contentElementRef.nativeElement;\r\n\t\treturn content;\r\n\t}\r\n\r\n\tprotected previousScrollBoundingRect: DOMRect;\r\n\tprotected checkScrollElementResized(): void {\r\n\t\tconst boundingRect = this.getElementSize(this.getScrollElement());\r\n\r\n\t\tlet sizeChanged: boolean;\r\n\t\tif (!this.previousScrollBoundingRect) {\r\n\t\t\tsizeChanged = true;\r\n\t\t} else {\r\n\t\t\tconst widthChange = Math.abs(boundingRect.width - this.previousScrollBoundingRect.width);\r\n\t\t\tconst heightChange = Math.abs(boundingRect.height - this.previousScrollBoundingRect.height);\r\n\t\t\tsizeChanged = widthChange > this.resizeBypassRefreshThreshold || heightChange > this.resizeBypassRefreshThreshold;\r\n\t\t}\r\n\r\n\t\tif (sizeChanged) {\r\n\t\t\tthis.previousScrollBoundingRect = boundingRect;\r\n\t\t\tif (boundingRect.width > 0 && boundingRect.height > 0) {\r\n\t\t\t\tthis.refresh_internal(false);\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\tprotected _invisiblePaddingProperty;\r\n\tprotected _offsetType;\r\n\tprotected _scrollType;\r\n\tprotected _pageOffsetType;\r\n\tprotected _childScrollDim;\r\n\tprotected _translateDir;\r\n\tprotected _marginDir;\r\n\tprotected updateDirection(): void {\r\n\t\tif (this.horizontal) {\r\n\t\t\tthis._childScrollDim = 'childWidth';\r\n\t\t\tthis._invisiblePaddingProperty = 'scaleX';\r\n\t\t\tthis._marginDir = 'margin-left';\r\n\t\t\tthis._offsetType = 'offsetLeft';\r\n\t\t\tthis._pageOffsetType = 'pageXOffset';\r\n\t\t\tthis._scrollType = 'scrollLeft';\r\n\t\t\tthis._translateDir = 'translateX';\r\n\t\t}\r\n\t\telse {\r\n\t\t\tthis._childScrollDim = 'childHeight';\r\n\t\t\tthis._invisiblePaddingProperty = 'scaleY';\r\n\t\t\tthis._marginDir = 'margin-top';\r\n\t\t\tthis._offsetType = 'offsetTop';\r\n\t\t\tthis._pageOffsetType = 'pageYOffset';\r\n\t\t\tthis._scrollType = 'scrollTop';\r\n\t\t\tthis._translateDir = 'translateY';\r\n\t\t}\r\n\t}\r\n\r\n\tprotected debounce(func: () => void, wait: number, ...args): () => void {\r\n\t\tconst throttled = this.throttleTrailing(func, wait);\r\n\t\tconst result = function () {\r\n\t\t\tthrottled['cancel']();\r\n\t\t\tthrottled.apply(this, args);\r\n\t\t};\r\n\t\tresult['cancel'] = function () {\r\n\t\t\tthrottled['cancel']();\r\n\t\t};\r\n\r\n\t\treturn result;\r\n\t}\r\n\r\n\tprotected throttleTrailing(func: () => void, wait: number, ...args): () => void {\r\n\t\tlet timeout = undefined;\r\n\t\tlet _arguments = args;\r\n\t\tconst result = function () {\r\n\t\t\tconst _this = this;\r\n\t\t\t_arguments = args\r\n\r\n\t\t\tif (timeout) {\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\r\n\t\t\tif (wait <= 0) {\r\n\t\t\t\tfunc.apply(_this, _arguments);\r\n\t\t\t} else {\r\n\t\t\t\ttimeout = setTimeout(function () {\r\n\t\t\t\t\ttimeout = undefined;\r\n\t\t\t\t\tfunc.apply(_this, _arguments);\r\n\t\t\t\t}, wait);\r\n\t\t\t}\r\n\t\t};\r\n\t\tresult['cancel'] = function () {\r\n\t\t\tif (timeout) {\r\n\t\t\t\tclearTimeout(timeout);\r\n\t\t\t\ttimeout = undefined;\r\n\t\t\t}\r\n\t\t};\r\n\r\n\t\treturn result;\r\n\t}\r\n\r\n\tprotected calculatedScrollbarWidth = 0;\r\n\tprotected calculatedScrollbarHeight = 0;\r\n\r\n\tprotected padding = 0;\r\n\tprotected previousViewPort: IViewport = <any>{};\r\n\tprotected currentTween: tween.Tween;\r\n\tprotected cachedItemsLength: number;\r\n\r\n\tprotected disposeScrollHandler: () => void | undefined;\r\n\tprotected disposeResizeHandler: () => void | undefined;\r\n\r\n\tprotected refresh_internal(itemsArrayModified: boolean, refreshCompletedCallback: () => void = undefined, maxRunTimes = 2): void {\r\n\t\t//note: maxRunTimes is to force it to keep recalculating if the previous iteration caused a re-render (different sliced items in viewport or scrollPosition changed).\r\n\t\t//The default of 2x max will probably be accurate enough without causing too large a performance bottleneck\r\n\t\t//The code would typically quit out on the 2nd iteration anyways. The main time it'd think more than 2 runs would be necessary would be for vastly different sized child items or if this is the 1st time the items array was initialized.\r\n\t\t//Without maxRunTimes, If the user is actively scrolling this code would become an infinite loop until they stopped scrolling. This would be okay, except each scroll event would start an additional infinte loop. We want to short-circuit it to prevent this.\r\n\r\n\t\tif (itemsArrayModified && this.previousViewPort && this.previousViewPort.scrollStartPosition > 0) {\r\n\t\t\t//if items were prepended, scroll forward to keep same items visible\r\n\t\t\tconst oldViewPort = this.previousViewPort;\r\n\t\t\tconst oldViewPortItems = this.viewPortItems;\r\n\r\n\t\t\tconst oldRefreshCompletedCallback = refreshCompletedCallback;\r\n\t\t\trefreshCompletedCallback = () => {\r\n\t\t\t\tconst scrollLengthDelta = this.previousViewPort.scrollLength - oldViewPort.scrollLength;\r\n\t\t\t\tif (scrollLengthDelta > 0 && this.viewPortItems) {\r\n\t\t\t\t\tconst oldStartItem = oldViewPortItems[0];\r\n\t\t\t\t\tconst oldStartItemIndex = this.items.findIndex(x => this.compareItems(oldStartItem, x));\r\n\t\t\t\t\tif (oldStartItemIndex > this.previousViewPort.startIndexWithBuffer) {\r\n\t\t\t\t\t\tlet itemOrderChanged = false;\r\n\t\t\t\t\t\tfor (let i = 1; i < this.viewPortItems.length; ++i) {\r\n\t\t\t\t\t\t\tif (!this.compareItems(this.items[oldStartItemIndex + i], oldViewPortItems[i])) {\r\n\t\t\t\t\t\t\t\titemOrderChanged = true;\r\n\t\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\tif (!itemOrderChanged) {\r\n\t\t\t\t\t\t\tthis.scrollToPosition(this.previousViewPort.scrollStartPosition + scrollLengthDelta, 0, oldRefreshCompletedCallback);\r\n\t\t\t\t\t\t\treturn;\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\r\n\t\t\t\tif (oldRefreshCompletedCallback) {\r\n\t\t\t\t\toldRefreshCompletedCallback();\r\n\t\t\t\t}\r\n\t\t\t};\r\n\t\t}\r\n\r\n\t\tthis.zone.runOutsideAngular(() => {\r\n\t\t\trequestAnimationFrame(() => {\r\n\r\n\t\t\t\tif (itemsArrayModified) {\r\n\t\t\t\t\tthis.resetWrapGroupDimensions();\r\n\t\t\t\t}\r\n\t\t\t\tconst viewport = this.calculateViewport();\r\n\r\n\t\t\t\tconst startChanged = itemsArrayModified || viewport.startIndex !== this.previousViewPort.startIndex;\r\n\t\t\t\tconst endChanged = itemsArrayModified || viewport.endIndex !== this.previousViewPort.endIndex;\r\n\t\t\t\tconst scrollLengthChanged = viewport.scrollLength !== this.previousViewPort.scrollLength;\r\n\t\t\t\tconst paddingChanged = viewport.padding !== this.previousViewPort.padding;\r\n\t\t\t\tconst scrollPositionChanged = viewport.scrollStartPosition !== this.previousViewPort.scrollStartPosition || viewport.scrollEndPosition !== this.previousViewPort.scrollEndPosition || viewport.maxScrollPosition !== this.previousViewPort.maxScrollPosition;\r\n\r\n\t\t\t\tconst scrollDirection: ScrollDirectionType = this.previousViewPort.endIndex <= viewport.endIndex ? 'forward' : 'backward';\r\n\t\t\t\tthis.previousViewPort = viewport;\r\n\r\n\t\t\t\tif (scrollLengthChanged) {\r\n\t\t\t\t\tthis.renderer.setStyle(this.invisiblePaddingElementRef.nativeElement, 'transform', `${this._invisiblePaddingProperty}(${viewport.scrollLength})`);\r\n\t\t\t\t\tthis.renderer.setStyle(this.invisiblePaddingElementRef.nativeElement, 'webkitTransform', `${this._invisiblePaddingProperty}(${viewport.scrollLength})`);\r\n\t\t\t\t}\r\n\r\n\t\t\t\tif (paddingChanged) {\r\n\t\t\t\t\tif (this.useMarginInsteadOfTranslate) {\r\n\t\t\t\t\t\tthis.renderer.setStyle(this.contentElementRef.nativeElement, this._marginDir, `${viewport.padding}px`);\r\n\t\t\t\t\t}\r\n\t\t\t\t\telse {\r\n\t\t\t\t\t\tthis.renderer.setStyle(this.contentElementRef.nativeElement, 'transform', `${this._translateDir}(${viewport.padding}px)`);\r\n\t\t\t\t\t\tthis.renderer.setStyle(this.contentElementRef.nativeElement, 'webkitTransform', `${this._translateDir}(${viewport.padding}px)`);\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\r\n\t\t\t\tif (this.headerElementRef) {\r\n\t\t\t\t\tconst scrollPosition = this.getScrollElement()[this._scrollType];\r\n\t\t\t\t\tconst containerOffset = this.getElementsOffset();\r\n\t\t\t\t\tconst offset = Math.max(scrollPosition - viewport.padding - containerOffset + this.headerElementRef.nativeElement.clientHeight, 0);\r\n\t\t\t\t\tthis.renderer.setStyle(this.headerElementRef.nativeElement, 'transform', `${this._translateDir}(${offset}px)`);\r\n\t\t\t\t\tthis.renderer.setStyle(this.headerElementRef.nativeElement, 'webkitTransform', `${this._translateDir}(${offset}px)`);\r\n\t\t\t\t}\r\n\r\n\t\t\t\tconst changeEventArg: IPageInfo = (startChanged || endChanged) ? {\r\n\t\t\t\t\tstartIndex: viewport.startIndex,\r\n\t\t\t\t\tendIndex: viewport.endIndex,\r\n\t\t\t\t\tscrollStartPosition: viewport.scrollStartPosition,\r\n\t\t\t\t\tscrollEndPosition: viewport.scrollEndPosition,\r\n\t\t\t\t\tscrollDirection: scrollDirection,\r\n\t\t\t\t\tstartIndexWithBuffer: viewport.startIndexWithBuffer,\r\n\t\t\t\t\tendIndexWithBuffer: viewport.endIndexWithBuffer,\r\n\t\t\t\t\tmaxScrollPosition: viewport.maxScrollPosition,\r\n\t\t\t\t} : undefined;\r\n\r\n\r\n\t\t\t\tif (startChanged || endChanged || scrollPositionChanged) {\r\n\t\t\t\t\tconst handleChanged = () => {\r\n\t\t\t\t\t\t// update the scroll list to trigger re-render of components in viewport\r\n\t\t\t\t\t\tthis.viewPortItems = viewport.startIndexWithBuffer >= 0 && viewport.endIndexWithBuffer >= 0 ? this.items.slice(viewport.startIndexWithBuffer, viewport.endIndexWithBuffer + 1) : [];\r\n\t\t\t\t\t\tthis.vsUpdate.emit(this.viewPortItems);\r\n\r\n\t\t\t\t\t\tif (startChanged) {\r\n\t\t\t\t\t\t\tthis.vsStart.emit(changeEventArg);\r\n\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\tif (endChanged) {\r\n\t\t\t\t\t\t\tthis.vsEnd.emit(changeEventArg);\r\n\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\tif (startChanged || endChanged) {\r\n\t\t\t\t\t\t\tthis.changeDetectorRef.markForCheck();\r\n\t\t\t\t\t\t\tthis.vsChange.emit(changeEventArg);\r\n\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\tif (maxRunTimes > 0) {\r\n\t\t\t\t\t\t\tthis.refresh_internal(false, refreshCompletedCallback, maxRunTimes - 1);\r\n\t\t\t\t\t\t\treturn;\r\n\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\tif (refreshCompletedCallback) {\r\n\t\t\t\t\t\t\trefreshCompletedCallback();\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t};\r\n\r\n\r\n\t\t\t\t\tif (this.executeRefreshOutsideAngularZone) {\r\n\t\t\t\t\t\thandleChanged();\r\n\t\t\t\t\t}\r\n\t\t\t\t\telse {\r\n\t\t\t\t\t\tthis.zone.run(handleChanged);\r\n\t\t\t\t\t}\r\n\t\t\t\t} else {\r\n\t\t\t\t\tif (maxRunTimes > 0 && (scrollLengthChanged || paddingChanged)) {\r\n\t\t\t\t\t\tthis.refresh_internal(false, refreshCompletedCallback, maxRunTimes - 1);\r\n\t\t\t\t\t\treturn;\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\tif (refreshCompletedCallback) {\r\n\t\t\t\t\t\trefreshCompletedCallback();\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t});\r\n\t\t});\r\n\t}\r\n\r\n\tprotected getScrollElement(): HTMLElement {\r\n\t\treturn this.parentScroll instanceof Window ? document.scrollingElement || document.documentElement || document.body : this.parentScroll || this.element.nativeElement;\r\n\t}\r\n\r\n\tprotected addScrollEventHandlers(): void {\r\n\t\tif (this.isAngularUniversalSSR) {\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tconst scrollElement = this.getScrollElement();\r\n\r\n\t\tthis.removeScrollEventHandlers();\r\n\r\n\t\tthis.zone.runOutsideAngular(() => {\r\n\t\t\tif (this.parentScroll instanceof Window) {\r\n\t\t\t\tthis.disposeScrollHandler = this.renderer.listen('window', 'scroll', this.onScroll);\r\n\t\t\t\tthis.disposeResizeHandler = this.renderer.listen('window', 'resize', this.onScroll);\r\n\t\t\t}\r\n\t\t\telse {\r\n\t\t\t\tthis.disposeScrollHandler = this.renderer.listen(scrollElement, 'scroll', this.onScroll);\r\n\t\t\t\tif (this._checkResizeInterval > 0) {\r\n\t\t\t\t\tthis.checkScrollElementResizedTimer = <any>setInterval(() => { this.checkScrollElementResized(); }, this._checkResizeInterval);\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t});\r\n\t}\r\n\r\n\tprotected removeScrollEventHandlers(): void {\r\n\t\tif (this.checkScrollElementResizedTimer) {\r\n\t\t\tclearInterval(this.checkScrollElementResizedTimer);\r\n\t\t}\r\n\r\n\t\tif (this.disposeScrollHandler) {\r\n\t\t\tthis.disposeScrollHandler();\r\n\t\t\tthis.disposeScrollHandler = undefined;\r\n\t\t}\r\n\r\n\t\tif (this.disposeResizeHandler) {\r\n\t\t\tthis.disposeResizeHandler();\r\n\t\t\tthis.disposeResizeHandler = undefined;\r\n\t\t}\r\n\t}\r\n\r\n\tprotected getElementsOffset(): number {\r\n\t\tif (this.isAngularUniversalSSR) {\r\n\t\t\treturn 0;\r\n\t\t}\r\n\r\n\t\tlet offset = 0;\r\n\r\n\t\tif (this.containerElementRef && this.containerElementRef.nativeElement) {\r\n\t\t\toffset += this.containerElementRef.nativeElement[this._offsetType];\r\n\t\t}\r\n\r\n\t\tif (this.parentScroll) {\r\n\t\t\tconst scrollElement = this.getScrollElement();\r\n\t\t\tconst elementClientRect = this.getElementSize(this.element.nativeElement);\r\n\t\t\tconst scrollClientRect = this.getElementSize(scrollElement);\r\n\t\t\tif (this.horizontal) {\r\n\t\t\t\toffset += elementClientRect.left - scrollClientRect.left;\r\n\t\t\t}\r\n\t\t\telse {\r\n\t\t\t\toffset += elementClientRect.top - scrollClientRect.top;\r\n\t\t\t}\r\n\r\n\t\t\tif (!(this.parentScroll instanceof Window)) {\r\n\t\t\t\toffset += scrollElement[this._scrollType];\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\treturn offset;\r\n\t}\r\n\r\n\tprotected countItemsPerWrapGroup(): number {\r\n\t\tif (this.isAngularUniversalSSR) {\r\n\t\t\treturn Math.round(this.horizontal ? this.ssrViewportHeight / this.ssrChildHeight : this.ssrViewportWidth / this.ssrChildWidth);\r\n\t\t}\r\n\r\n\t\tconst propertyName = this.horizontal ? 'offsetLeft' : 'offsetTop';\r\n\t\tconst children = this.getContent().children;\r\n\r\n\t\tconst childrenLength = children ? children.length : 0;\r\n\t\tif (childrenLength === 0) {\r\n\t\t\treturn 1;\r\n\t\t}\r\n\r\n\t\tconst firstOffset = children[0][propertyName];\r\n\t\tlet result = 1;\r\n\t\twhile (result < childrenLength && firstOffset === children[result][propertyName]) {\r\n\t\t\t++result;\r\n\t\t}\r\n\r\n\t\treturn result;\r\n\t}\r\n\r\n\tprotected getScrollStartPosition(): number {\r\n\t\tlet windowScrollValue = undefined;\r\n\t\tif (this.parentScroll instanceof Window) {\r\n\t\t\twindowScrollValue = window[this._pageOffsetType];\r\n\t\t}\r\n\r\n\t\treturn windowScrollValue || this.getScrollElement()[this._scrollType] || 0;\r\n\t}\r\n\r\n\tprotected minMeasuredChildWidth: number;\r\n\tprotected minMeasuredChildHeight: number;\r\n\r\n\tprotected wrapGroupDimensions: WrapGroupDimensions;\r\n\r\n\tprotected resetWrapGroupDimensions(): void {\r\n\t\tconst oldWrapGroupDimensions = this.wrapGroupDimensions;\r\n\t\tthis.invalidateAllCachedMeasurements();\r\n\r\n\t\tif (!this.enableUnequalChildrenSizes || !oldWrapGroupDimensions || oldWrapGroupDimensions.numberOfKnownWrapGroupChildSizes === 0) {\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tconst itemsPerWrapGroup: number = this.countItemsPerWrapGroup();\r\n\t\tfor (let wrapGroupIndex = 0; wrapGroupIndex < oldWrapGroupDimensions.maxChildSizePerWrapGroup.length; ++wrapGroupIndex) {\r\n\t\t\tconst oldWrapGroupDimension: WrapGroupDimension = oldWrapGroupDimensions.maxChildSizePerWrapGroup[wrapGroupIndex];\r\n\t\t\tif (!oldWrapGroupDimension || !oldWrapGroupDimension.items || !oldWrapGroupDimension.items.length) {\r\n\t\t\t\tcontinue;\r\n\t\t\t}\r\n\r\n\t\t\tif (oldWrapGroupDimension.items.length !== itemsPerWrapGroup) {\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\r\n\t\t\tlet itemsChanged = false;\r\n\t\t\tconst arrayStartIndex = itemsPerWrapGroup * wrapGroupIndex;\r\n\t\t\tfor (let i = 0; i < itemsPerWrapGroup; ++i) {\r\n\t\t\t\tif (!this.compareItems(oldWrapGroupDimension.items[i], this.items[arrayStartIndex + i])) {\r\n\t\t\t\t\titemsChanged = true;\r\n\t\t\t\t\tbreak;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n\t\t\tif (!itemsChanged) {\r\n\t\t\t\t++this.wrapGroupDimensions.numberOfKnownWrapGroupChildSizes;\r\n\t\t\t\tthis.wrapGroupDimensions.sumOfKnownWrapGroupChildWidths += oldWrapGroupDimension.childWidth || 0;\r\n\t\t\t\tthis.wrapGroupDimensions.sumOfKnownWrapGroupChildHeights += oldWrapGroupDimension.childHeight || 0;\r\n\t\t\t\tthis.wrapGroupDimensions.maxChildSizePerWrapGroup[wrapGroupIndex] = oldWrapGroupDimension;\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\tprotected calculateDimensions(): IDimensions {\r\n\t\tconst scrollElement = this.getScrollElement();\r\n\r\n\t\tconst maxCalculatedScrollBarSize = 25; // Note: Formula to auto-calculate doesn't work for ParentScroll, so we default to this if not set by consuming application\r\n\t\tthis.calculatedScrollbarHeight = Math.max(Math.min(scrollElement.offsetHeight - scrollElement.clientHeight, maxCalculatedScrollBarSize), this.calculatedScrollbarHeight);\r\n\t\tthis.calculatedScrollbarWidth = Math.max(Math.min(scrollElement.offsetWidth - scrollElement.clientWidth, maxCalculatedScrollBarSize), this.calculatedScrollbarWidth);\r\n\r\n\t\tlet viewportWidth = scrollElement.offsetWidth - (this.scrollbarWidth || this.calculatedScrollbarWidth || (this.horizontal ? 0 : maxCalculatedScrollBarSize));\r\n\t\tlet viewportHeight = scrollElement.offsetHeight - (this.scrollbarHeight || this.calculatedScrollbarHeight || (this.horizontal ? maxCalculatedScrollBarSize : 0));\r\n\r\n\t\tconst content = this.getContent();\r\n\r\n\t\tconst itemsPerWrapGroup = this.countItemsPerWrapGroup();\r\n\t\tlet wrapGroupsPerPage;\r\n\r\n\t\tlet defaultChildWidth;\r\n\t\tlet defaultChildHeight;\r\n\r\n\t\tif (this.isAngularUniversalSSR) {\r\n\t\t\tviewportWidth = this.ssrViewportWidth;\r\n\t\t\tviewportHeight = this.ssrViewportHeight;\r\n\t\t\tdefaultChildWidth = this.ssrChildWidth;\r\n\t\t\tdefaultChildHeight = this.ssrChildHeight;\r\n\t\t\tconst itemsPerRow = Math.max(Math.ceil(viewportWidth / defaultChildWidth), 1);\r\n\t\t\tconst itemsPerCol = Math.max(Math.ceil(viewportHeight / defaultChildHeight), 1);\r\n\t\t\twrapGroupsPerPage = this.horizontal ? itemsPerRow : itemsPerCol;\r\n\t\t}\r\n\t\telse if (!this.enableUnequalChildrenSizes) {\r\n\t\t\tif (content.children.length > 0) {\r\n\t\t\t\tif (!this.childWidth || !this.childHeight) {\r\n\t\t\t\t\tif (!this.minMeasuredChildWidth && viewportWidth > 0) {\r\n\t\t\t\t\t\tthis.minMeasuredChildWidth = viewportWidth;\r\n\t\t\t\t\t}\r\n\t\t\t\t\tif (!this.minMeasuredChildHeight && viewportHeight > 0) {\r\n\t\t\t\t\t\tthis.minMeasuredChildHeight = viewportHeight;\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\r\n\t\t\t\tconst child = content.children[0];\r\n\t\t\t\tconst clientRect = this.getElementSize(child);\r\n\t\t\t\tthis.minMeasuredChildWidth = Math.min(this.minMeasuredChildWidth, clientRect.width);\r\n\t\t\t\tthis.minMeasuredChildHeight = Math.min(this.minMeasuredChildHeight, clientRect.height);\r\n\r\n\t\t\t\t// Added for getting the child height (for card view, return all the clientRect object).\r\n\t\t\t\t// if (this._lastChildRect === null ||\r\n\t\t\t\t// \t(clientRect?.height !== 0 && (\r\n\t\t\t\t// \t\tMath.round(this._lastChildRect?.height) !== Math.round(clientRect?.height) || \r\n\t\t\t\t// \t\tMath.round(this._lastChildRect?.width) !== Math.round(clientRect?.width))\r\n\t\t\t\t// \t)) {\r\n\t\t\t\t// \tthis._lastChildRect = clientRect;\r\n\t\t\t\t// \tthis.vsChildRectChange.emit(clientRect);\r\n\t\t\t\t// }\r\n\t\t\t}\r\n\r\n\t\t\tdefaultChildWidth = this.childWidth || this.minMeasuredChildWidth || viewportWidth;\r\n\t\t\tdefaultChildHeight = this.childHeight || this.minMeasuredChildHeight || viewportHeight;\r\n\t\t\tconst itemsPerRow = Math.max(Math.ceil(viewportWidth / defaultChildWidth), 1);\r\n\t\t\tconst itemsPerCol = Math.max(Math.ceil(viewportHeight / defaultChildHeight), 1);\r\n\t\t\twrapGroupsPerPage = this.horizontal ? itemsPerRow : itemsPerCol;\r\n\t\t} else {\r\n\t\t\tlet scrollOffset = scrollElement[this._scrollType] - (this.previousViewPort ? this.previousViewPort.padding : 0);\r\n\r\n\t\t\tlet arrayStartIndex = this.previousViewPort.startIndexWithBuffer || 0;\r\n\t\t\tlet wrapGroupIndex = Math.ceil(arrayStartIndex / itemsPerWrapGroup);\r\n\r\n\t\t\tlet maxWidthForWrapGroup = 0;\r\n\t\t\tlet maxHeightForWrapGroup = 0;\r\n\t\t\tlet sumOfVisibleMaxWidths = 0;\r\n\t\t\tlet sumOfVisibleMaxHeights = 0;\r\n\t\t\twrapGroupsPerPage = 0;\r\n\r\n\t\t\tfor (let i = 0; i < content.children.length; ++i) {\r\n\t\t\t\t++arrayStartIndex;\r\n\t\t\t\tconst child = content.children[i];\r\n\t\t\t\tconst clientRect = this.getElementSize(child);\r\n\r\n\t\t\t\tmaxWidthForWrapGroup = Math.max(maxWidthForWrapGroup, clientRect.width);\r\n\t\t\t\tmaxHeightForWrapGroup = Math.max(maxHeightForWrapGroup, clientRect.height);\r\n\r\n\t\t\t\tif (arrayStartIndex % itemsPerWrapGroup === 0) {\r\n\t\t\t\t\tconst oldValue = this.wrapGroupDimensions.maxChildSizePerWrapGroup[wrapGroupIndex];\r\n\t\t\t\t\tif (oldValue) {\r\n\t\t\t\t\t\t--this.wrapGroupDimensions.numberOfKnownWrapGroupChildSizes;\r\n\t\t\t\t\t\tthis.wrapGroupDimensions.sumOfKnownWrapGroupChildWidths -= oldValue.childWidth || 0;\r\n\t\t\t\t\t\tthis.wrapGroupDimensions.sumOfKnownWrapGroupChildHeights -= oldValue.childHeight || 0;\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\t++this.wrapGroupDimensions.numberOfKnownWrapGroupChildSizes;\r\n\t\t\t\t\tconst items = this.items.slice(arrayStartIndex - itemsPerWrapGroup, arrayStartIndex);\r\n\t\t\t\t\tthis.wrapGroupDimensions.maxChildSizePerWrapGroup[wrapGroupIndex] = {\r\n\t\t\t\t\t\tchildWidth: maxWidthForWrapGroup,\r\n\t\t\t\t\t\tchildHeight: maxHeightForWrapGroup,\r\n\t\t\t\t\t\titems: items\r\n\t\t\t\t\t};\r\n\t\t\t\t\tthis.wrapGroupDimensions.sumOfKnownWrapGroupChildWidths += maxWidthForWrapGroup;\r\n\t\t\t\t\tthis.wrapGroupDimensions.sumOfKnownWrapGroupChildHeights += maxHeightForWrapGroup;\r\n\r\n\t\t\t\t\tif (this.horizontal) {\r\n\t\t\t\t\t\tlet maxVisibleWidthForWrapGroup = Math.min(maxWidthForWrapGroup, Math.max(viewportWidth - sumOfVisibleMaxWidths, 0));\r\n\t\t\t\t\t\tif (scrollOffset > 0) {\r\n\t\t\t\t\t\t\tconst scrollOffsetToRemove = Math.min(scrollOffset, maxVisibleWidthForWrapGroup);\r\n\t\t\t\t\t\t\tmaxVisibleWidthForWrapGroup -= scrollOffsetToRemove;\r\n\t\t\t\t\t\t\tscrollOffset -= scrollOffsetToRemove;\r\n\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\tsumOfVisibleMaxWidths += maxVisibleWidthForWrapGroup;\r\n\t\t\t\t\t\tif (maxVisibleWidthForWrapGroup > 0 && viewportWidth >= sumOfVisibleMaxWidths) {\r\n\t\t\t\t\t\t\t++wrapGroupsPerPage;\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\tlet maxVisibleHeightForWrapGroup = Math.min(maxHeightForWrapGroup, Math.max(viewportHeight - sumOfVisibleMaxHeights, 0));\r\n\t\t\t\t\t\tif (scrollOffset > 0) {\r\n\t\t\t\t\t\t\tconst scrollOffsetToRemove = Math.min(scrollOffset, maxVisibleHeightForWrapGroup);\r\n\t\t\t\t\t\t\tmaxVisibleHeightForWrapGroup -= scrollOffsetToRemove;\r\n\t\t\t\t\t\t\tscrollOffset -= scrollOffsetToRemove;\r\n\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\tsumOfVisibleMaxHeights += maxVisibleHeightForWrapGroup;\r\n\t\t\t\t\t\tif (maxVisibleHeightForWrapGroup > 0 && viewportHeight >= sumOfVisibleMaxHeights) {\r\n\t\t\t\t\t\t\t++wrapGroupsPerPage;\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\t++wrapGroupIndex;\r\n\r\n\t\t\t\t\tmaxWidthForWrapGroup = 0;\r\n\t\t\t\t\tmaxHeightForWrapGroup = 0;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n\t\t\tconst averageChildWidth = this.wrapGroupDimensions.sumOfKnownWrapGroupChildWidths / this.wrapGroupDimensions.numberOfKnownWrapGroupChildSizes;\r\n\t\t\tconst averageChildHeight = this.wrapGroupDimensions.sumOfKnownWrapGroupChildHeights / this.wrapGroupDimensions.numberOfKnownWrapGroupChildSizes;\r\n\t\t\tdefaultChildWidth = this.childWidth || averageChildWidth || viewportWidth;\r\n\t\t\tdefaultChildHeight = this.childHeight || averageChildHeight || viewportHeight;\r\n\r\n\t\t\tif (this.horizontal) {\r\n\t\t\t\tif (viewportWidth > sumOfVisibleMaxWidths) {\r\n\t\t\t\t\twrapGroupsPerPage += Math.ceil((viewportWidth - sumOfVisibleMaxWidths) / defaultChildWidth);\r\n\t\t\t\t}\r\n\t\t\t} else {\r\n\t\t\t\tif (viewportHeight > sumOfVisibleMaxHeights) {\r\n\t\t\t\t\twrapGroupsPerPage += Math.ceil((viewportHeight - sumOfVisibleMaxHeights) / defaultChildHeight);\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tconst itemCount = this.items.length;\r\n\t\tconst itemsPerPage = itemsPerWrapGroup * wrapGroupsPerPage;\r\n\t\tconst pageCount_fractional = itemCount / itemsPerPage;\r\n\t\tconst numberOfWrapGroups = Math.ceil(itemCount / itemsPerWrapGroup);\r\n\r\n\t\tlet scrollLength = 0;\r\n\r\n\t\tconst defaultScrollLengthPerWrapGroup = this.horizontal ? defaultChildWidth : defaultChildHeight;\r\n\t\tif (this.enableUnequalChildrenSizes) {\r\n\t\t\tlet numUnknownChildSizes = 0;\r\n\t\t\tfor (let i = 0; i < numberOfWrapGroups; ++i) {\r\n\t\t\t\tconst childSize = this.wrapGroupDimensions.maxChildSizePerWrapGroup[i] && this.wrapGroupDimensions.maxChildSizePerWrapGroup[i][this._childScrollDim];\r\n\t\t\t\tif (childSize) {\r\n\t\t\t\t\tscrollLength += childSize;\r\n\t\t\t\t} else {\r\n\t\t\t\t\t++numUnknownChildSizes;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n\t\t\tscrollLength += Math.round(numUnknownChildSizes * defaultScrollLengthPerWrapGroup);\r\n\t\t} else {\r\n\t\t\tscrollLength = numberOfWrapGroups * defaultScrollLengthPerWrapGroup;\r\n\t\t}\r\n\r\n\t\tif (this.headerElementRef) {\r\n\t\t\tscrollLength += this.headerElementRef.nativeElement.clientHeight;\r\n\t\t}\r\n\r\n\t\tconst viewportLength = this.horizontal ? viewportWidth : viewportHeight;\r\n\t\tconst maxScrollPosition = Math.max(scrollLength - viewportLength, 0);\r\n\r\n\t\treturn {\r\n\t\t\tchildHeight: defaultChildHeight,\r\n\t\t\tchildWidth: defaultChildWidth,\r\n\t\t\titemCount: itemCount,\r\n\t\t\titemsPerPage: itemsPerPage,\r\n\t\t\titemsPerWrapGroup: itemsPerWrapGroup,\r\n\t\t\tmaxScrollPosition: maxScrollPosition,\r\n\t\t\tpageCount_fractional: pageCount_fractional,\r\n\t\t\tscrollLength: scrollLength,\r\n\t\t\tviewportLength: viewportLength,\r\n\t\t\twrapGroupsPerPage: wrapGroupsPerPage,\r\n\t\t};\r\n\t}\r\n\r\n\tprotected cachedPageSize = 0;\r\n\tprotected previousScrollNumberElements = 0;\r\n\r\n\tprotected calculatePadding(arrayStartIndexWithBuffer: number, dimensions: IDimensions): number {\r\n\t\tif (dimensions.itemCount === 0) {\r\n\t\t\treturn 0;\r\n\t\t}\r\n\r\n\t\tconst defaultScrollLengthPerWrapGroup = dimensions[this._childScrollDim];\r\n\t\tconst startingWrapGroupIndex = Math.floor(arrayStartIndexWithBuffer / dimensions.itemsPerWrapGroup) || 0;\r\n\r\n\t\tif (!this.enableUnequalChildrenSizes) {\r\n\t\t\treturn defaultScrollLengthPerWrapGroup * startingWrapGroupIndex;\r\n\t\t}\r\n\r\n\t\tlet numUnknownChildSizes = 0;\r\n\t\tlet result = 0;\r\n\t\tfor (let i = 0; i < startingWrapGroupIndex; ++i) {\r\n\t\t\tconst childSize = this.wrapGroupDimensions.maxChildSizePerWrapGroup[i] && this.wrapGroupDimensions.maxChildSizePerWrapGroup[i][this._childScrollDim];\r\n\t\t\tif (childSize) {\r\n\t\t\t\tresult += childSize;\r\n\t\t\t} else {\r\n\t\t\t\t++numUnknownChildSizes;\r\n\t\t\t}\r\n\t\t}\r\n\t\tresult += Math.round(numUnknownChildSizes * defaultScrollLengthPerWrapGroup);\r\n\r\n\t\treturn result;\r\n\t}\r\n\r\n\tprotected calculatePageInfo(scrollPosition: number, dimensions: IDimensions): IPageInfo {\r\n\t\tlet scrollPercentage = 0;\r\n\t\tif (this.enableUnequalChildrenSizes) {\r\n\t\t\tconst numberOfWrapGroups = Math.ceil(dimensions.itemCount / dimensions.itemsPerWrapGroup);\r\n\t\t\tlet totalScrolledLength = 0;\r\n\t\t\tconst defaultScrollLengthPerWrapGroup = dimensions[this._childScrollDim];\r\n\t\t\tfor (let i = 0; i < numberOfWrapGroups; ++i) {\r\n\t\t\t\tconst childSize = this.wrapGroupDimensions.maxChildSizePerWrapGroup[i] && this.wrapGroupDimensions.maxChildSizePerWrapGroup[i][this._childScrollDim];\r\n\t\t\t\tif (childSize) {\r\n\t\t\t\t\ttotalScrolledLength += childSize;\r\n\t\t\t\t} else {\r\n\t\t\t\t\ttotalScrolledLength += defaultScrollLengthPerWrapGroup;\r\n\t\t\t\t}\r\n\r\n\t\t\t\tif (scrollPosition < totalScrolledLength) {\r\n\t\t\t\t\tscrollPercentage = i / numberOfWrapGroups;\r\n\t\t\t\t\tbreak;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t} else {\r\n\t\t\tscrollPercentage = scrollPosition / dimensions.scrollLength;\r\n\t\t}\r\n\r\n\t\tconst startingArrayIndex_fractional = Math.min(Math.max(scrollPercentage * dimensions.pageCount_fractional, 0), dimensions.pageCount_fractional) * dimensions.itemsPerPage;\r\n\r\n\t\tconst maxStart = dimensions.itemCount - dimensions.itemsPerPage - 1;\r\n\t\tlet arrayStartIndex = Math.min(Math.floor(startingArrayIndex_fractional), maxStart);\r\n\t\tarrayStartIndex -= arrayStartIndex % dimensions.itemsPerWrapGroup; // round down to start of wrapGroup\r\n\r\n\t\tif (this.stripedTable) {\r\n\t\t\tconst bufferBoundary = 2 * dimensions.itemsPerWrapGroup;\r\n\t\t\tif (arrayStartIndex % bufferBoundary !== 0) {\r\n\t\t\t\tarrayStartIndex = Math.max(arrayStartIndex - arrayStartIndex % bufferBoundary, 0);\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tlet arrayEndIndex = Math.ceil(startingArrayIndex_fractional) + dimensions.itemsPerPage - 1;\r\n\t\tconst endIndexWithinWrapGroup = (arrayEndIndex + 1) % dimensions.itemsPerWrapGroup;\r\n\t\tif (endIndexWithinWrapGroup > 0) {\r\n\t\t\tarrayEndIndex += dimensions.itemsPerWrapGroup - endIndexWithinWrapGroup; // round up to end of wrapGroup\r\n\t\t}\r\n\r\n\t\tif (isNaN(arrayStartIndex)) {\r\n\t\t\tarrayStartIndex = 0;\r\n\t\t}\r\n\t\tif (isNaN(arrayEndIndex)) {\r\n\t\t\tarrayEndIndex = 0;\r\n\t\t}\r\n\r\n\t\tarrayStartIndex = Math.min(Math.max(arrayStartIndex, 0), dimensions.itemCount - 1);\r\n\t\tarrayEndIndex = Math.min(Math.max(arrayEndIndex, 0), dimensions.itemCount - 1);\r\n\r\n\t\tconst bufferSize = this.bufferAmount * dimensions.itemsPerWrapGroup;\r\n\t\tconst startIndexWithBuffer = Math.min(Math.max(arrayStartIndex - bufferSize, 0), dimensions.itemCount - 1);\r\n\t\tconst endIndexWithBuffer = Math.min(Math.max(arrayEndIndex + bufferSize, 0), dimensions.itemCount - 1);\r\n\r\n\t\treturn {\r\n\t\t\tstartIndex: arrayStartIndex,\r\n\t\t\tendIndex: arrayEndIndex,\r\n\t\t\tstartIndexWithBuffer: startIndexWithBuffer,\r\n\t\t\tendIndexWithBuffer: endIndexWithBuffer,\r\n\t\t\tscrollStartPosition: scrollPosition,\r\n\t\t\tscrollEndPosition: scrollPosition + dimensions.viewportLength,\r\n\t\t\tmaxScrollPosition: dimensions.maxScrollPosition\r\n\t\t};\r\n\t}\r\n\r\n\tprotected calculateViewport(): IViewport {\r\n\t\tconst dimensions = this.calculateDimensions();\r\n\t\tconst offset = this.getElementsOffset();\r\n\r\n\t\tlet scrollStartPosition = this.getScrollStartPosition();\r\n\t\tif (scrollStartPosition > (dimensions.scrollLength + offset) && !(this.parentScroll instanceof Window)) {\r\n\t\t\tscrollStartPosition = dimensions.scrollLength;\r\n\t\t} else {\r\n\t\t\tscrollStartPosition -= offset;\r\n\t\t}\r\n\t\tscrollStartPosition = Math.max(0, scrollStartPosition);\r\n\r\n\t\tconst pageInfo = this.calculatePageInfo(scrollStartPosition, dimensions);\r\n\t\tconst newPadding = this.calculatePadding(pageInfo.startIndexWithBuffer, dimensions);\r\n\t\tconst newScrollLength = dimensions.scrollLength;\r\n\r\n\t\treturn {\r\n\t\t\tstartIndex: pageInfo.startIndex,\r\n\t\t\tendIndex: pageInfo.endIndex,\r\n\t\t\tstartIndexWithBuffer: pageInfo.startIndexWithBuffer,\r\n\t\t\tendIndexWithBuffer: pageInfo.endIndexWithBuffer,\r\n\t\t\tpadding: Math.round(newPadding),\r\n\t\t\tscrollLength: Math.round(newScrollLength),\r\n\t\t\tscrollStartPosition: pageInfo.scrollStartPosition,\r\n\t\t\tscrollEndPosition: pageInfo.scrollEndPosition,\r\n\t\t\tmaxScrollPosition: pageInfo.maxScrollPosition\r\n\t\t};\r\n\t}\r\n}\r\n\r\n@NgModule({\r\n\texports: [VirtualScrollerComponent],\r\n\tdeclarations: [VirtualScrollerComponent],\r\n\timports: [CommonModule],\r\n\tproviders: [\r\n\t\t{\r\n\t\t\tprovide: 'virtual-scroller-default-options',\r\n\t\t\tuseFactory: VIRTUAL_SCROLLER_DEFAULT_OPTIONS_FACTORY\r\n\t\t}\r\n\t]\r\n})\r\nexport class VirtualScrollerModule { }"]}