ng-virtual-list 14.12.0 → 14.12.2

package/esm2020/lib/core/track-box.mjs

@@ -0,0 +1,1352 @@
+import { CACHE_BOX_CHANGE_EVENT_NAME, CacheMap } from "./cache-map";
+import { Tracker } from "./tracker";
+import { DEFAULT_DIVIDES, HEIGHT_PROP_NAME, SERVICE_PROP_DUMMY, SERVICE_PROP_DUMMY_ENABLED, TRACK_BY_PROPERTY_NAME, WIDTH_PROP_NAME, X_PROP_NAME, Y_PROP_NAME, } from "../const";
+import { debounce } from "../utils";
+import { bufferInterpolation } from "../utils/buffer-interpolation";
+import { objectAsReadonly } from "../utils/object";
+import { getServiceIdProp } from "./utils";
+import { DEFAULT_BUFFER_EXTREMUM_THRESHOLD, DEFAULT_MAX_BUFFER_SEQUENCE_LENGTH, DEFAULT_RESET_BUFFER_SIZE_TIMEOUT, END_COLLECTION_PREFIX_ID, IS_NEW, START_COLLECTION_PREFIX_ID, } from "./const";
+import { Z_INDEX_0, Z_INDEX_1, Z_INDEX_2, Z_INDEX_3, } from '../const';
+import { TrackBoxEvents } from "./events";
+import { ItemDisplayMethods } from "./enums";
+import { Alignments } from "../enums";
+/**
+ * An object that performs tracking, calculations and caching.
+ * @link https://github.com/DjonnyX/ng-virtual-list/blob/14.x/projects/ng-virtual-list/src/lib/core/track-box.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+export class TrackBox extends CacheMap {
+    constructor(trackingPropertyName) {
+        super();
+        this._scrollDirection = 0;
+        this._trackBy = TRACK_BY_PROPERTY_NAME;
+        this._divides = DEFAULT_DIVIDES;
+        this._isInfinity = false;
+        this._isSnappingMethodAdvanced = false;
+        this._isLazy = false;
+        this._trackingPropertyName = TRACK_BY_PROPERTY_NAME;
+        this._isScrollStart = false;
+        this._isScrollEnd = false;
+        this._isScrollSnapToStart = false;
+        this._isScrollSnapToEnd = false;
+        this._scrollStartOffset = 0;
+        this._scrollEndOffset = 0;
+        this._deletedItemsMap = {};
+        this._crudDetected = false;
+        this._previousTotalSize = 0;
+        this._deltaOfNewItems = 0;
+        this.isAdaptiveBuffer = true;
+        this._bufferSequenceExtraThreshold = DEFAULT_BUFFER_EXTREMUM_THRESHOLD;
+        this._maxBufferSequenceLength = DEFAULT_MAX_BUFFER_SEQUENCE_LENGTH;
+        this._bufferSizeSequence = [];
+        this._bufferSize = 0;
+        this._defaultBufferSize = 0;
+        this._maxBufferSize = this._defaultBufferSize;
+        this._resetBufferSizeTimeout = DEFAULT_RESET_BUFFER_SIZE_TIMEOUT;
+        this._isReseted = true;
+        this._prerenderedCache = null;
+        this._newItems = [];
+        this._previousScrollSize = 0;
+        this._debouncedIsScrollStartOff = debounce(() => {
+            this._isScrollStart = false;
+        });
+        this._trackingPropertyName = trackingPropertyName;
+        this.initialize();
+    }
+    set items(v) {
+        if (this._items === v) {
+            return;
+        }
+        this._items = v;
+    }
+    set displayComponents(v) {
+        if (this._displayComponents === v) {
+            return;
+        }
+        this._displayComponents = v;
+    }
+    set snappedDisplayComponents(v) {
+        if (this._snappedDisplayComponents === v) {
+            return;
+        }
+        this._snappedDisplayComponents = v;
+    }
+    set scrollDirection(v) {
+        if (this._scrollDirection === v) {
+            return;
+        }
+        this._scrollDirection = v;
+    }
+    get scrollDirection() { return this._scrollDirection; }
+    set trackBy(v) {
+        if (this._trackBy === v) {
+            return;
+        }
+        this._trackBy = v;
+    }
+    get trackBy() { return this._trackBy; }
+    set divides(v) {
+        if (this._divides === v) {
+            return;
+        }
+        this._divides = v;
+    }
+    set isInfinity(v) {
+        if (this._isInfinity === v) {
+            return;
+        }
+        this._isInfinity = v;
+    }
+    set isSnappingMethodAdvanced(v) {
+        if (this._isSnappingMethodAdvanced === v) {
+            return;
+        }
+        this._isSnappingMethodAdvanced = v;
+    }
+    set isLazy(v) {
+        if (this._isLazy === v) {
+            return;
+        }
+        this._isLazy = v;
+    }
+    /**
+     * Set the trackBy property
+     */
+    set trackingPropertyName(v) {
+        this._trackingPropertyName = this._tracker.trackingPropertyName = v;
+    }
+    set isScrollStart(v) {
+        this._isScrollStart = v;
+        if (v) {
+            this._isScrollSnapToStart = true;
+        }
+    }
+    set isScrollEnd(v) {
+        this._isScrollEnd = v;
+        if (v) {
+            this._isScrollSnapToEnd = true;
+        }
+    }
+    get isSnappedToStart() {
+        return this._isScrollStart || this._isScrollSnapToStart;
+    }
+    get isSnappedToEnd() {
+        return this._isScrollEnd || this._isScrollSnapToEnd;
+    }
+    set scrollStartOffset(v) {
+        this._scrollStartOffset = v;
+    }
+    get scrollStartOffset() {
+        return this._scrollStartOffset;
+    }
+    set scrollEndOffset(v) {
+        this._scrollEndOffset = v;
+    }
+    get scrollEndOffset() {
+        return this._scrollEndOffset;
+    }
+    initialize() {
+        this._tracker = new Tracker(this._trackingPropertyName);
+    }
+    set(id, cache) {
+        if (this._map.has(id)) {
+            const b = this._map.get(id);
+            if (b?.width === cache.width && b?.height === cache.height) {
+                return this._map;
+            }
+        }
+        const v = this._map.set(id, cache);
+        this.bumpVersion();
+        return v;
+    }
+    get crudDetected() { return this._crudDetected; }
+    fireChangeIfNeed() {
+        if (this.changesDetected()) {
+            this.dispatch(TrackBoxEvents.CHANGE, this._version);
+        }
+    }
+    fireTick() {
+        this.dispatch(TrackBoxEvents.TICK);
+    }
+    get deltaOfNewItems() { return this._deltaOfNewItems; }
+    get bufferSize() { return this._bufferSize; }
+    lifeCircle() {
+        this.fireChangeIfNeed();
+        this.fireTick();
+        this.lifeCircleDo();
+    }
+    /**
+     * Scans the collection for deleted items and flushes the deleted item cache.
+     */
+    resetCollection(currentCollection, itemSize) {
+        if (currentCollection !== undefined && currentCollection !== null &&
+            currentCollection === this._previousCollection) {
+            console.warn('Attention! The collection must be immutable.');
+            return;
+        }
+        const reseted = ((!this._previousCollection || this._previousCollection.length === 0) &&
+            (!!currentCollection && currentCollection.length > 0));
+        this._isReseted = reseted;
+        this.updateCache(this._previousCollection, currentCollection, itemSize);
+        this._previousCollection = [...(currentCollection || [])];
+    }
+    /**
+     * Update the cache of items from the list
+     */
+    updateCache(previousCollection, currentCollection, itemSize) {
+        const trackBy = this._trackingPropertyName;
+        let crudDetected = false;
+        this._newItems = [];
+        if (!currentCollection || currentCollection.length === 0) {
+            if (previousCollection) {
+                // deleted
+                for (let i = 0, l = previousCollection.length; i < l; i++) {
+                    const item = previousCollection[i], id = item?.[trackBy];
+                    crudDetected = true;
+                    if (!!item && this._map.has(id)) {
+                        this._map.delete(id);
+                    }
+                }
+            }
+            return;
+        }
+        if (!previousCollection || previousCollection.length === 0) {
+            if (currentCollection) {
+                // added
+                for (let i = 0, l = currentCollection.length; i < l; i++) {
+                    crudDetected = true;
+                    const item = currentCollection[i], id = item?.[trackBy];
+                    if (!!item) {
+                        this._map.set(id, { width: itemSize, height: itemSize, method: ItemDisplayMethods.CREATE });
+                    }
+                }
+            }
+            return;
+        }
+        const collectionDict = {};
+        for (let i = 0, l = currentCollection.length; i < l; i++) {
+            const item = currentCollection[i];
+            if (!!item) {
+                collectionDict[item[trackBy]] = item;
+            }
+        }
+        const notChangedMap = {}, deletedMap = {}, deletedItemsMap = {}, updatedMap = {};
+        for (let i = 0, l = previousCollection.length; i < l; i++) {
+            const item = previousCollection[i], id = item?.[trackBy];
+            if (!!item) {
+                if (collectionDict.hasOwnProperty(id)) {
+                    if (item === collectionDict[id]) {
+                        // not changed
+                        notChangedMap[item[trackBy]] = item;
+                        this._map.set(id, {
+                            ...(this._map.get(id) || { width: itemSize, height: itemSize }),
+                            method: ItemDisplayMethods.NOT_CHANGED
+                        });
+                        continue;
+                    }
+                    else {
+                        // updated
+                        crudDetected = true;
+                        updatedMap[item[trackBy]] = item;
+                        this._map.set(id, {
+                            ...(this._map.get(id) || { width: itemSize, height: itemSize }),
+                            method: ItemDisplayMethods.UPDATE
+                        });
+                        continue;
+                    }
+                }
+                // deleted
+                crudDetected = true;
+                deletedMap[id] = item;
+                deletedItemsMap[i] = this._map.get(id);
+                this._map.delete(id);
+            }
+        }
+        for (let i = 0, l = currentCollection.length; i < l; i++) {
+            const item = currentCollection[i], id = item?.[trackBy];
+            if (!!item && !deletedMap.hasOwnProperty(id) && !updatedMap.hasOwnProperty(id) &&
+                !notChangedMap.hasOwnProperty(id)) {
+                this._newItems.push(id);
+                // added
+                crudDetected = true;
+                this._map.set(id, { width: itemSize, height: itemSize, method: ItemDisplayMethods.CREATE });
+            }
+        }
+        this._crudDetected = crudDetected;
+        this._deletedItemsMap = deletedItemsMap;
+    }
+    /**
+     * Finds the position of a collection element by the given Id
+     */
+    getItemPosition(id, itemConfigMap, options) {
+        const opt = { fromItemId: id ?? options.fromItemId, itemConfigMap, ...options };
+        this._defaultBufferSize = opt.bufferSize;
+        this._maxBufferSize = opt.maxBufferSize;
+        const { scrollSize, isFromItemIdFound } = this.recalculateMetrics({
+            ...opt,
+            dynamicSize: this._crudDetected || opt.dynamicSize,
+            previousTotalSize: this._previousTotalSize,
+            crudDetected: this._crudDetected,
+            deletedItemsMap: this._deletedItemsMap,
+        });
+        return isFromItemIdFound ? scrollSize : -1;
+    }
+    preventScrollSnapping(clearBuffer = false) {
+        this._isScrollStart = this._isScrollEnd = false;
+        if (clearBuffer) {
+            this._isScrollSnapToStart = this._isScrollSnapToEnd = false;
+        }
+    }
+    /**
+     * Updates the collection of display objects
+     */
+    getMetrics(items, itemConfigMap, options) {
+        const opt = { itemConfigMap, ...options }, crudDetected = this._crudDetected, deletedItemsMap = this._deletedItemsMap;
+        this._defaultBufferSize = opt.bufferSize;
+        this._maxBufferSize = opt.maxBufferSize;
+        const metrics = this.recalculateMetrics({
+            ...opt,
+            collection: items,
+            previousTotalSize: this._previousTotalSize,
+            crudDetected: this._crudDetected,
+            deletedItemsMap,
+        });
+        return { totalSize: metrics.totalSize, delta: metrics.delta, crudDetected };
+    }
+    /**
+     * Updates the collection of display objects
+     */
+    updateCollection(items, itemConfigMap, options) {
+        const opt = { itemConfigMap, ...options }, dynamicSize = opt.dynamicSize, crudDetected = this._crudDetected, deletedItemsMap = this._deletedItemsMap;
+        if (dynamicSize) {
+            this.cacheElements(opt.isVertical, opt.itemSize);
+        }
+        this._defaultBufferSize = opt.bufferSize;
+        this._maxBufferSize = opt.maxBufferSize;
+        const metrics = this.recalculateMetrics({
+            ...opt,
+            collection: items,
+            previousTotalSize: this._previousTotalSize,
+            crudDetected: this._crudDetected,
+            deletedItemsMap,
+        });
+        this._delta += metrics.delta;
+        this.updateAdaptiveBufferParams(metrics, items.length);
+        this._previousTotalSize = metrics.totalSize;
+        this._deletedItemsMap = {};
+        this._crudDetected = false;
+        if (opt.dynamicSize) {
+            this.snapshot();
+        }
+        const displayItems = this.generateDisplayCollection(metrics.items, items, itemConfigMap, { ...metrics, });
+        return { displayItems, totalSize: metrics.totalSize, delta: metrics.delta, crudDetected, leftLayoutOffset: metrics.leftLayoutOffset };
+    }
+    updateAdaptiveBufferParams(metrics, totalItemsLength) {
+        this.disposeClearBufferSizeTimer();
+        const scrollSize = metrics.scrollSize + this._delta, delta = Math.abs(this._previousScrollSize - scrollSize);
+        this._previousScrollSize = scrollSize;
+        const bufferRawSize = Math.min(Math.floor(metrics.typicalItemSize !== 0 ? delta / metrics.typicalItemSize : 0) * 5, totalItemsLength), minBufferSize = bufferRawSize < this._defaultBufferSize ? this._defaultBufferSize : bufferRawSize, bufferValue = minBufferSize > this._maxBufferSize ? this._maxBufferSize : minBufferSize;
+        this._bufferSize = bufferInterpolation(this._bufferSize, this._bufferSizeSequence, bufferValue, {
+            extremumThreshold: this._bufferSequenceExtraThreshold,
+            bufferSize: this._maxBufferSequenceLength,
+        });
+        this.startResetBufferSizeTimer();
+    }
+    startResetBufferSizeTimer() {
+        this._resetBufferSizeTimer = setTimeout(() => {
+            this._bufferSize = this._defaultBufferSize;
+            this._bufferSizeSequence = [];
+        }, this._resetBufferSizeTimeout);
+    }
+    disposeClearBufferSizeTimer() {
+        clearTimeout(this._resetBufferSizeTimer);
+    }
+    /**
+     * Calculates the entry into the overscroll area and returns the number of overscroll elements
+     */
+    getElementNumToEnd(i, collection, map, typicalItemSize, size, isVertical, indexOffset = 0, reverse = false) {
+        const trackBy = this._trackingPropertyName, sizeProperty = isVertical ? HEIGHT_PROP_NAME : WIDTH_PROP_NAME;
+        let offset = 0, num = 0;
+        for (let j = collection.length - indexOffset - 1; reverse ? j >= 0 : j >= i; j--) {
+            const item = collection[j], id = item[trackBy];
+            let itemSize = 0;
+            if (map.has(id)) {
+                const cache = map.get(id);
+                itemSize = cache && cache[sizeProperty] > 0 ? cache[sizeProperty] : typicalItemSize;
+            }
+            else {
+                itemSize = typicalItemSize;
+            }
+            if (offset + itemSize > size) {
+                return { num, offset };
+            }
+            offset += itemSize;
+            num++;
+        }
+        return { num, offset };
+    }
+    /**
+     * Calculates list metrics
+     */
+    recalculateMetrics(options) {
+        const { alignment, fromItemId, bounds, collection, dynamicSize, isVertical, itemSize, minItemSize, maxItemSize, bufferSize: minBufferSize, scrollSize, stickyEnabled, itemConfigMap, enabledBufferOptimization, previousTotalSize, snapToItem, snapToItemAlign, deletedItemsMap, itemTransform } = options, roundedScrollSize = Math.round(scrollSize);
+        const trackBy = this._trackingPropertyName, bufferSize = Math.max(minBufferSize, this._bufferSize), { width, height } = bounds, sizeProperty = isVertical ? HEIGHT_PROP_NAME : WIDTH_PROP_NAME, size = isVertical ? height : width, totalLength = collection.length, typicalItemSize = itemSize, w = isVertical ? width : typicalItemSize, h = isVertical ? typicalItemSize : height, map = this._map, snapshot = this._snapshot, divides = this._divides, stickyPos = Math.floor(scrollSize) + this._scrollStartOffset, leftItemsOrRowsWeights = [], isFromId = fromItemId !== undefined && (typeof fromItemId === 'number' && fromItemId > -1)
+            || (typeof fromItemId === 'string' && fromItemId > '-1');
+        let leftItemsOffset = 0, rightItemsOffset = 0;
+        if (enabledBufferOptimization) {
+            switch (this._scrollDirection) {
+                case 1: {
+                    leftItemsOffset = 0;
+                    rightItemsOffset = bufferSize * divides;
+                    break;
+                }
+                case -1: {
+                    leftItemsOffset = bufferSize * divides;
+                    rightItemsOffset = 0;
+                    break;
+                }
+                case 0:
+                default: {
+                    leftItemsOffset = rightItemsOffset = bufferSize * divides;
+                }
+            }
+        }
+        else {
+            leftItemsOffset = rightItemsOffset = bufferSize * divides;
+        }
+        let itemsFromStartToScrollEnd = -1, itemsFromDisplayEndToOffsetEnd = 0, itemsFromStartToDisplayEnd = -1, leftItemLength = 0, rightItemLength = 0, leftItemsWeight = 0, rightItemsWeight = 0, leftHiddenItemsWeight = 0, totalItemsToDisplayEndWeight = 0, deltaOfNewItems = 0, leftSizeOfAddedItems = 0, leftSizeOfUpdatedItems = 0, leftSizeOfDeletedItems = 0, itemById = null, itemByIdPos = this._scrollStartOffset, isTargetInOverscroll = false, actualScrollSize = itemByIdPos, totalSize = this._scrollStartOffset + this._scrollEndOffset, startIndex, isFromItemIdFound = false, deltaFromStartCreation = 0, isUpdating = false, leftYOffset = 0, leftLayoutOffset = 0, leftLayoutIndexOffset = 0, rightLayoutIndexOffset = 0;
+        const isStart = ((roundedScrollSize === 0) || this.isSnappedToStart);
+        let stickyItemId, isNew = false;
+        let items;
+        // If the list is dynamic or there are new elements in the collection, then it switches to the long algorithm.
+        if (dynamicSize) {
+            items = [];
+            const serviceIdProp = getServiceIdProp(trackBy);
+            if (isFromId) {
+                for (let stickyId = undefined, i = 0, l = collection.length; i < l; i++) {
+                    const item = collection[i], id = item?.[trackBy];
+                    if (itemConfigMap[id]?.sticky === 1) {
+                        stickyId = id;
+                    }
+                    if (!itemConfigMap[id]?.sticky) {
+                        stickyItemId = stickyId;
+                    }
+                    if (id == fromItemId) {
+                        break;
+                    }
+                }
+            }
+            let y = this._scrollStartOffset, stickyComponentSize = 0, row = {
+                startItemIndex: 0,
+                endItemIndex: 0,
+                size: 0,
+                snapshotSize: 0,
+                deltaFromStartCreation: 0,
+                leftSizeOfAddedItems: 0,
+                leftSizeOfUpdatedItems: 0,
+                leftSizeOfDeletedItems: 0,
+                deltaOfNewItems: 0,
+                leftItemsOrRowsWeights: null,
+                rightItemsWeight: 0,
+                leftHiddenItemsWeight: 0,
+                totalItemsToDisplayEndWeight: 0,
+            };
+            const calculate = (i, l, li, isPrecollection = false, idPrefix = null) => {
+                const ii = i + 1;
+                if (ii > l) {
+                    return false;
+                }
+                const collectionItem = collection[i], id = collectionItem[trackBy], sticky = itemConfigMap?.[id]?.sticky ?? 0, isNewRow = i % divides === 0, isLastItemInRow = ii % divides === 0, isLastItem = i === li, isRowEnd = (isLastItemInRow || (!isLastItemInRow && isLastItem));
+                items.push(isPrecollection ? { ...collectionItem, [serviceIdProp]: `_${idPrefix}-${id}_` } : collectionItem);
+                if (isNewRow || row === null) {
+                    row = {
+                        startItemIndex: i + 1,
+                        endItemIndex: i + divides,
+                        size: 0,
+                        snapshotSize: 0,
+                        deltaFromStartCreation: 0,
+                        leftSizeOfAddedItems: 0,
+                        leftSizeOfUpdatedItems: 0,
+                        leftSizeOfDeletedItems: 0,
+                        deltaOfNewItems: 0,
+                        leftItemsOrRowsWeights: null,
+                        rightItemsWeight: 0,
+                        leftHiddenItemsWeight: 0,
+                        totalItemsToDisplayEndWeight: 0,
+                    };
+                }
+                let componentSize = 0, rowSizeDelta = 0, itemDisplayMethod = ItemDisplayMethods.NOT_CHANGED;
+                if (map.has(id)) {
+                    const cache = map.get(id);
+                    componentSize = cache[sizeProperty] > 0 ? cache[sizeProperty] : typicalItemSize;
+                    itemDisplayMethod = cache?.method ?? ItemDisplayMethods.UPDATE;
+                    const isItemNew = this._newItems.indexOf(id) > -1 || (this._isLazy && isStart && !this._isReseted);
+                    isNew = isItemNew;
+                    if (isNew) {
+                        isUpdating = true;
+                    }
+                    const snapshotBounds = snapshot.get(id), snapshotSize = snapshotBounds ? snapshotBounds[sizeProperty] : typicalItemSize;
+                    row.size = Math.max(row.size, componentSize);
+                    row.snapshotSize = Math.max(row.snapshotSize, snapshotSize);
+                    rowSizeDelta = row.size - row.snapshotSize;
+                    switch (itemDisplayMethod) {
+                        case ItemDisplayMethods.UPDATE: {
+                            map.set(id, { ...cache, method: isNew ? ItemDisplayMethods.UPDATE : ItemDisplayMethods.NOT_CHANGED, [IS_NEW]: isNew });
+                            if (isRowEnd && isNew && y <= (scrollSize + size + deltaFromStartCreation + componentSize)) {
+                                row.deltaFromStartCreation = rowSizeDelta;
+                                rowSizeDelta = 0;
+                            }
+                            break;
+                        }
+                        case ItemDisplayMethods.CREATE: {
+                            rowSizeDelta = typicalItemSize;
+                            map.set(id, { ...cache, method: ItemDisplayMethods.UPDATE, [IS_NEW]: isNew });
+                            if (isRowEnd && isNew && y <= (scrollSize + size + deltaFromStartCreation + componentSize)) {
+                                row.deltaFromStartCreation = rowSizeDelta;
+                                rowSizeDelta = 0;
+                            }
+                            break;
+                        }
+                    }
+                }
+                else {
+                    componentSize = typicalItemSize;
+                    row.size = Math.max(row.size, componentSize);
+                    row.snapshotSize = row.size;
+                    rowSizeDelta = row.size - row.snapshotSize;
+                }
+                if (deletedItemsMap.hasOwnProperty(i)) {
+                    const cache = deletedItemsMap[i], size = cache?.[sizeProperty] ?? typicalItemSize;
+                    if (y < scrollSize + this._scrollStartOffset - size) {
+                        row.leftSizeOfDeletedItems = Math.max(row.leftSizeOfDeletedItems, size);
+                    }
+                }
+                if (isFromId) {
+                    if (itemById === null) {
+                        if (id != fromItemId && id === stickyItemId && sticky === 1) {
+                            stickyComponentSize = componentSize;
+                            y -= stickyComponentSize;
+                        }
+                        if (id == fromItemId) {
+                            isFromItemIdFound = true;
+                            if (alignment !== Alignments.CENTER) {
+                                const { num, offset } = this.getElementNumToEnd(i, collection, map, typicalItemSize, size, isVertical), leftViewportSize = size - offset;
+                                if (leftViewportSize > 0) {
+                                    const { num: num1, offset: offset1 } = this.getElementNumToEnd(i + num, collection, map, typicalItemSize, size, isVertical, 0, true), deltaNum = (num1 - num), deltaOffset = (offset1 - offset);
+                                    totalItemsToDisplayEndWeight += offset;
+                                    itemsFromStartToScrollEnd -= deltaNum;
+                                    rightItemsWeight = rightItemLength = 0;
+                                    leftHiddenItemsWeight -= deltaOffset;
+                                    leftItemsOrRowsWeights.splice(leftItemsOrRowsWeights.length - deltaNum, deltaNum);
+                                    y -= deltaOffset;
+                                }
+                            }
+                            itemById = collectionItem;
+                            itemByIdPos = y;
+                        }
+                        else {
+                            leftItemsOrRowsWeights.push(componentSize);
+                            leftHiddenItemsWeight += componentSize;
+                            itemsFromStartToScrollEnd = row.startItemIndex;
+                        }
+                    }
+                }
+                else if (y <= scrollSize - componentSize) {
+                    if (row.leftItemsOrRowsWeights === null) {
+                        row.leftItemsOrRowsWeights = 0;
+                    }
+                    row.leftItemsOrRowsWeights = Math.max(row.leftItemsOrRowsWeights, componentSize);
+                    row.leftHiddenItemsWeight = Math.max(row.leftHiddenItemsWeight, componentSize);
+                    if (!isPrecollection) {
+                        itemsFromStartToScrollEnd = row.startItemIndex;
+                    }
+                }
+                if (isFromId) {
+                    if (itemById === null || y < itemByIdPos + size + componentSize) {
+                        itemsFromStartToDisplayEnd = row.endItemIndex;
+                        totalItemsToDisplayEndWeight += componentSize;
+                        itemsFromDisplayEndToOffsetEnd = itemsFromStartToDisplayEnd + rightItemsOffset;
+                    }
+                }
+                else if (y <= scrollSize + size + componentSize) {
+                    if (!isPrecollection) {
+                        itemsFromStartToDisplayEnd = row.endItemIndex;
+                        itemsFromDisplayEndToOffsetEnd = itemsFromStartToDisplayEnd + rightItemsOffset;
+                    }
+                    row.totalItemsToDisplayEndWeight = Math.max(row.totalItemsToDisplayEndWeight, componentSize);
+                    if (isRowEnd && y <= scrollSize + componentSize) {
+                        switch (itemDisplayMethod) {
+                            case ItemDisplayMethods.CREATE: {
+                                row.leftSizeOfAddedItems = rowSizeDelta;
+                                break;
+                            }
+                            case ItemDisplayMethods.UPDATE:
+                            case ItemDisplayMethods.NOT_CHANGED: {
+                                row.leftSizeOfUpdatedItems = rowSizeDelta;
+                                break;
+                            }
+                            case ItemDisplayMethods.DELETE: {
+                                row.leftSizeOfDeletedItems = rowSizeDelta;
+                                break;
+                            }
+                        }
+                    }
+                    if (isRowEnd && itemDisplayMethod === ItemDisplayMethods.CREATE) {
+                        row.deltaOfNewItems = rowSizeDelta;
+                    }
+                }
+                else {
+                    if (isRowEnd && i < itemsFromDisplayEndToOffsetEnd) {
+                        row.rightItemsWeight = Math.max(row.rightItemsWeight, componentSize);
+                    }
+                }
+                if (isRowEnd) {
+                    if (!isPrecollection) {
+                        deltaFromStartCreation += row.deltaFromStartCreation;
+                        leftSizeOfAddedItems += row.leftSizeOfAddedItems;
+                        leftSizeOfUpdatedItems += row.leftSizeOfUpdatedItems;
+                        leftSizeOfDeletedItems += row.leftSizeOfDeletedItems;
+                        deltaOfNewItems += row.deltaOfNewItems;
+                        rightItemsWeight += row.rightItemsWeight;
+                        totalItemsToDisplayEndWeight += row.totalItemsToDisplayEndWeight;
+                        leftHiddenItemsWeight += row.leftHiddenItemsWeight;
+                        if (row.leftItemsOrRowsWeights !== null) {
+                            leftItemsOrRowsWeights.push(row.leftItemsOrRowsWeights);
+                        }
+                    }
+                    totalSize += row.size;
+                    y += row.size;
+                }
+                return true;
+            };
+            if (this._isInfinity) {
+                const viewportSize = isVertical ? height : width;
+                let buffSize = -1;
+                if (scrollSize <= viewportSize) {
+                    let i = 0, l = collection.length, li = l > 0 ? (l - 1) : 0;
+                    if (l > 0) {
+                        const limit = viewportSize;
+                        while (y <= limit || buffSize > -1) {
+                            const ii = i + 1;
+                            if (buffSize === -1) {
+                                buffSize = leftItemsOffset;
+                            }
+                            if (y >= limit) {
+                                buffSize--;
+                            }
+                            if (!calculate(li - i, l, li, true, START_COLLECTION_PREFIX_ID)) {
+                                break;
+                            }
+                            if (ii === l) {
+                                i = 0;
+                            }
+                            else {
+                                i++;
+                            }
+                        }
+                        items.reverse();
+                        leftYOffset = y;
+                        leftLayoutOffset = viewportSize * .5;
+                        leftLayoutIndexOffset = i;
+                        y = this._scrollStartOffset;
+                        totalSize = this._scrollStartOffset + this._scrollEndOffset;
+                        itemsFromStartToDisplayEnd = itemsFromDisplayEndToOffsetEnd = 0;
+                        row = null;
+                    }
+                }
+            }
+            for (let i = 0, l = collection.length, li = l - 1; i < l; i++) {
+                if (!calculate(i, l, li)) {
+                    break;
+                }
+            }
+            if (this._isInfinity) {
+                row = null;
+                const yy = y, currentTotalSize = totalSize, viewportSize = isVertical ? height : width, normalizedTotalSize = totalSize + viewportSize;
+                row = {
+                    startItemIndex: 0,
+                    endItemIndex: 0,
+                    size: 0,
+                    snapshotSize: 0,
+                    deltaFromStartCreation: 0,
+                    leftSizeOfAddedItems: 0,
+                    leftSizeOfUpdatedItems: 0,
+                    leftSizeOfDeletedItems: 0,
+                    deltaOfNewItems: 0,
+                    leftItemsOrRowsWeights: null,
+                    rightItemsWeight: 0,
+                    leftHiddenItemsWeight: 0,
+                    totalItemsToDisplayEndWeight: 0,
+                };
+                const l = collection.length, li = l - 1;
+                let i = 0, count = 0;
+                while (y < normalizedTotalSize) {
+                    const ii = i + 1;
+                    if (!calculate(i, l, li, true, END_COLLECTION_PREFIX_ID)) {
+                        break;
+                    }
+                    if (ii === l) {
+                        i = 0;
+                    }
+                    else {
+                        i++;
+                    }
+                    count++;
+                }
+                y = yy;
+                totalSize = currentTotalSize;
+                rightLayoutIndexOffset = count;
+            }
+            actualScrollSize = (isFromId ? itemByIdPos : scrollSize);
+            if (itemsFromStartToScrollEnd <= -1) {
+                itemsFromStartToScrollEnd = 0;
+            }
+            if (itemsFromStartToDisplayEnd <= -1) {
+                itemsFromStartToDisplayEnd = 0;
+            }
+            leftItemsOrRowsWeights.splice(0, leftItemsOrRowsWeights.length - bufferSize);
+            leftItemsOrRowsWeights.forEach(v => {
+                leftItemsWeight += v;
+            });
+            leftItemLength = Math.min(itemsFromStartToScrollEnd, leftItemsOffset);
+            rightItemLength = itemsFromStartToDisplayEnd + rightItemsOffset > totalLength
+                ? totalLength - itemsFromStartToDisplayEnd : rightItemsOffset;
+            startIndex = (Math.ceil(Math.min(itemsFromStartToScrollEnd - leftItemLength, totalLength > 0 ? totalLength - 1 : 0) / divides) * divides);
+        }
+        else 
+        // Buffer optimization does not work on fast linear algorithm
+        {
+            const dividedTypicalItemSize = typicalItemSize / divides, bufferItemNumbers = bufferSize * divides;
+            itemsFromStartToScrollEnd = Math.floor(dividedTypicalItemSize !== 0 ? (scrollSize / dividedTypicalItemSize) : 0);
+            itemsFromStartToDisplayEnd = Math.ceil(dividedTypicalItemSize !== 0 ? ((scrollSize + size) / dividedTypicalItemSize) : 0);
+            leftItemLength = Math.min(itemsFromStartToScrollEnd, bufferSize * divides);
+            rightItemLength = (itemsFromStartToDisplayEnd + bufferItemNumbers) > totalLength
+                ? totalLength - itemsFromStartToDisplayEnd : bufferItemNumbers;
+            leftItemsWeight = Math.floor(leftItemLength * dividedTypicalItemSize / typicalItemSize) * typicalItemSize;
+            rightItemsWeight = Math.floor(rightItemLength * dividedTypicalItemSize / typicalItemSize) * typicalItemSize;
+            leftHiddenItemsWeight = Math.floor(itemsFromStartToScrollEnd * dividedTypicalItemSize / typicalItemSize) * typicalItemSize;
+            totalItemsToDisplayEndWeight = Math.floor(itemsFromStartToDisplayEnd * dividedTypicalItemSize / typicalItemSize) * typicalItemSize;
+            totalSize = (Math.ceil(totalLength / divides) * divides * dividedTypicalItemSize) + this._scrollStartOffset + this._scrollEndOffset;
+            const k = totalSize !== 0 ? previousTotalSize / totalSize : 0;
+            if (isFromId) {
+                const index = collection.findIndex(item => item[trackBy] == fromItemId);
+                if (index > -1) {
+                    itemByIdPos = this._scrollStartOffset + Math.floor(index * dividedTypicalItemSize / divides);
+                    isFromItemIdFound = true;
+                }
+            }
+            actualScrollSize = (isFromId ? itemByIdPos : scrollSize * k);
+            items = [];
+            if (this._isInfinity) {
+                const viewportSize = isVertical ? height : width;
+                let buffSize = -1, y = this._scrollStartOffset;
+                if (scrollSize <= viewportSize) {
+                    let i = 0, l = collection.length, li = l > 0 ? (l - 1) : 0;
+                    if (l > 0) {
+                        const limit = viewportSize;
+                        while (y <= limit || buffSize > -1) {
+                            const ii = i + 1;
+                            if (buffSize === -1) {
+                                buffSize = leftItemsOffset;
+                            }
+                            if (y >= limit) {
+                                buffSize--;
+                            }
+                            const itemIndex = li - i;
+                            if (collection.length > itemIndex) {
+                                items.push(collection[itemIndex]);
+                            }
+                            else {
+                                break;
+                            }
+                            const isLastItemInRow = ii % divides === 0, isLastItem = i === li;
+                            if (isLastItemInRow || (!isLastItemInRow && isLastItem)) {
+                                y += dividedTypicalItemSize;
+                            }
+                            if (ii === l) {
+                                i = 0;
+                            }
+                            else {
+                                i++;
+                            }
+                        }
+                        items.reverse();
+                        leftYOffset = y;
+                        leftLayoutOffset = viewportSize * .5;
+                        leftLayoutIndexOffset = i;
+                    }
+                }
+            }
+            items.push(...collection);
+            if (this._isInfinity) {
+                let y = Math.floor(totalSize / dividedTypicalItemSize) * dividedTypicalItemSize;
+                const viewportSize = isVertical ? height : width, normalizedTotalSize = totalSize + viewportSize;
+                const l = collection.length, li = l - 1;
+                let i = 0, count = 0;
+                while (y < normalizedTotalSize) {
+                    const ii = i + 1;
+                    if (collection.length <= i) {
+                        break;
+                    }
+                    items.push(collection[i]);
+                    const isLastItemInRow = ii % divides === 0, isLastItem = i === li;
+                    if (isLastItemInRow || (!isLastItemInRow && isLastItem)) {
+                        y += dividedTypicalItemSize;
+                    }
+                    if (ii === l) {
+                        i = 0;
+                    }
+                    else {
+                        i++;
+                    }
+                    count++;
+                }
+                rightLayoutIndexOffset = count;
+                leftItemLength = Math.min(itemsFromStartToScrollEnd, leftItemsOffset);
+                rightItemLength = itemsFromStartToDisplayEnd + rightItemsOffset > totalLength
+                    ? totalLength - itemsFromStartToDisplayEnd : rightItemsOffset;
+                startIndex = (Math.ceil(Math.min(itemsFromStartToScrollEnd - leftItemLength, totalLength > 0 ? totalLength - 1 : 0) / divides) * divides);
+            }
+            else {
+                startIndex = Math.min(itemsFromStartToScrollEnd - leftItemLength, totalLength > 0 ? totalLength - 1 : 0);
+            }
+        }
+        const itemsOnDisplayWeight = totalItemsToDisplayEndWeight - leftItemsWeight, itemsOnDisplayLength = itemsFromStartToDisplayEnd - itemsFromStartToScrollEnd, startPosition = this._scrollStartOffset + leftHiddenItemsWeight - leftItemsWeight - leftYOffset, renderItems = (Math.ceil((itemsOnDisplayLength + leftItemLength + rightItemLength) / divides) * divides) + rightLayoutIndexOffset, startCreationDelta = deltaFromStartCreation > 0 ? deltaFromStartCreation : 0, delta = leftSizeOfUpdatedItems + leftSizeOfAddedItems - leftSizeOfDeletedItems + startCreationDelta;
+        this._deltaOfNewItems = deltaOfNewItems;
+        if (isFromId && !isTargetInOverscroll) {
+            actualScrollSize -= this._scrollStartOffset;
+        }
+        const metrics = {
+            delta,
+            normalizedItemWidth: w,
+            normalizedItemHeight: h,
+            width,
+            height,
+            dynamicSize,
+            divides,
+            itemSize,
+            minItemSize,
+            maxItemSize,
+            items,
+            itemsFromStartToScrollEnd,
+            itemsFromStartToDisplayEnd,
+            itemsOnDisplayWeight,
+            itemsOnDisplayLength,
+            isVertical,
+            leftHiddenItemsWeight,
+            leftItemLength,
+            leftItemsWeight,
+            leftLayoutOffset,
+            leftLayoutIndexOffset,
+            renderItems,
+            rightItemLength,
+            rightItemsWeight,
+            scrollSize: actualScrollSize,
+            leftSizeOfAddedItems,
+            sizeProperty,
+            stickyEnabled,
+            stickyPos,
+            startIndex,
+            startPosition,
+            totalItemsToDisplayEndWeight,
+            totalLength,
+            totalSize,
+            typicalItemSize,
+            isFromItemIdFound,
+            isUpdating,
+            snapToItem,
+            snapToItemAlign,
+            itemTransform,
+        };
+        return metrics;
+    }
+    refreshCache(cache) {
+        this._prerenderedCache = cache;
+    }
+    clearDelta() {
+        this._delta = this._deltaOfNewItems = 0;
+    }
+    changes(immediately = false, force = false) {
+        if (immediately) {
+            if (force) {
+                this.bumpVersion();
+            }
+            this._previousVersion = this._version;
+            this.dispatch(CACHE_BOX_CHANGE_EVENT_NAME, this.version);
+        }
+        else {
+            if (force) {
+                this.bumpVersion();
+                return;
+            }
+            if (this.changesDetected()) {
+                return;
+            }
+            this.bumpVersion();
+        }
+    }
+    /**
+     * Returns true if the bounds of at least one screen object have changed.
+     */
+    checkBoundsOfElements() {
+        if (!this._displayComponents) {
+            return false;
+        }
+        for (let i = 0, l = this._displayComponents.length; i < l; i++) {
+            const component = this._displayComponents[i], itemId = component.instance.itemId;
+            if (itemId === undefined) {
+                continue;
+            }
+            const bounds = component.instance.getBounds(), cache = this.get(itemId);
+            if (!!bounds && !!cache) {
+                if (bounds.width !== cache.width || bounds.height !== cache.height) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    generateDisplayCollection(items, actualItems, itemConfigMap, metrics) {
+        const { width, height, normalizedItemWidth, normalizedItemHeight, dynamicSize, divides, itemsOnDisplayLength, itemsFromStartToScrollEnd, isVertical, leftLayoutOffset: layoutOffset, leftLayoutIndexOffset: layoutIndexOffset, renderItems: renderItemsLength, scrollSize, sizeProperty, stickyEnabled, stickyPos, startPosition, totalLength, startIndex, typicalItemSize, minItemSize, maxItemSize, snapToItem, snapToItemAlign, itemTransform, } = metrics, displayItems = [];
+        if (items.length) {
+            const trackBy = this._trackingPropertyName, actualSnippedPosition = stickyPos, isSnappingMethodAdvanced = this._isSnappingMethodAdvanced, deltaOffet = (isSnappingMethodAdvanced ? scrollSize : 0), scrollDirection = this._scrollDirection, boundsSize = isVertical ? height : width, actualEndSnippedPosition = scrollSize + boundsSize - this._scrollEndOffset;
+            let pos = startPosition, renderItems = renderItemsLength, stickyItem, nextSticky, stickyItemIndex = -1, stickyItemSize = 0, endStickyItem, nextEndSticky, endStickyItemIndex = -1, endStickyItemSize = 0;
+            const li = layoutIndexOffset + actualItems.length - 1;
+            if (stickyEnabled) {
+                for (let i = Math.min(itemsFromStartToScrollEnd > 0 ? (divides > 1 ? (itemsFromStartToScrollEnd - 1) : itemsFromStartToScrollEnd) : 0, totalLength - 1); i >= 0; i--) {
+                    const collectionItem = items[i], isDummy = collectionItem?.[SERVICE_PROP_DUMMY] && (collectionItem?.[SERVICE_PROP_DUMMY] === SERVICE_PROP_DUMMY_ENABLED);
+                    if (!collectionItem || isDummy) {
+                        continue;
+                    }
+                    const rowIndex = Math.floor(((items.length - layoutIndexOffset + i) + 1) / divides), id = collectionItem[trackBy], cache = this.get(id), sticky = itemConfigMap[id]?.sticky ?? 0, selectable = itemConfigMap[id]?.selectable ?? true, collapsable = itemConfigMap[id]?.collapsable ?? false, size = dynamicSize ? cache?.[sizeProperty] > 0 ? cache?.[sizeProperty] : typicalItemSize : typicalItemSize, absoluteStartPosition = pos - (scrollSize - size) - size, ratio = size !== 0 ? boundsSize / size : 0, absoluteStartPositionPercent = -(boundsSize !== 0 ? absoluteStartPosition / boundsSize : 0) * ratio, absoluteEndPosition = boundsSize - (absoluteStartPositionPercent + size), absoluteEndPositionPercent = (absoluteStartPositionPercent + (boundsSize !== 0 ? (absoluteEndPosition + size) / boundsSize : 0) * ratio), x = isVertical ? 0 : actualSnippedPosition, y = isVertical ? actualSnippedPosition : 0;
+                    if (sticky === 1) {
+                        const isOdd = (items.length - layoutIndexOffset + i) % 2 != 0, measures = {
+                            x,
+                            y,
+                            transformedX: x,
+                            transformedY: y,
+                            z: 0,
+                            rotationX: 0,
+                            rotationY: 0,
+                            rotationZ: 0,
+                            scaleX: 1,
+                            scaleY: 1,
+                            scaleZ: 1,
+                            width: isVertical ? normalizedItemWidth : size,
+                            height: isVertical ? size : normalizedItemHeight,
+                            minWidth: minItemSize,
+                            minHeight: minItemSize,
+                            maxWidth: maxItemSize,
+                            maxHeight: maxItemSize,
+                            size,
+                            row: {
+                                size,
+                                odd: rowIndex % 2 != 0,
+                                even: rowIndex % 2 == 0,
+                            },
+                            position: pos,
+                            boundsSize,
+                            scrollSize,
+                            absoluteStartPosition,
+                            absoluteStartPositionPercent,
+                            absoluteEndPosition,
+                            absoluteEndPositionPercent,
+                            scrollDirection,
+                            delta: sticky === 1 ? this._scrollStartOffset : sticky === 2 ? actualEndSnippedPosition - deltaOffet - size : 0,
+                        }, config = {
+                            fullSize: true,
+                            isFirst: i === layoutIndexOffset,
+                            isLast: i === li,
+                            new: cache?.[IS_NEW] === true,
+                            odd: isOdd,
+                            even: !isOdd,
+                            isVertical,
+                            collapsable,
+                            selectable,
+                            sticky,
+                            snap: stickyEnabled,
+                            snapped: true,
+                            snappedOut: false,
+                            dynamic: dynamicSize,
+                            isSnappingMethodAdvanced,
+                            layoutOffset,
+                            layoutIndexOffset,
+                            totalItems: items.length,
+                            snapToItem,
+                            snapToItemAlign,
+                            tabIndex: i - layoutIndexOffset,
+                            divides,
+                            opacity: 1,
+                            zIndex: Z_INDEX_1,
+                        };
+                        const itemData = collectionItem;
+                        stickyItem = {
+                            index: i, id, measures, data: itemData, previouseData: i > 0 ? items[i - 1] : null,
+                            nextData: i < totalLength ? items[i + 1] : null, config,
+                        };
+                        stickyItemIndex = i;
+                        stickyItemSize = size;
+                        displayItems.push(stickyItem);
+                        break;
+                    }
+                }
+            }
+            if (stickyEnabled) {
+                const si = itemsFromStartToScrollEnd + itemsOnDisplayLength - 1, startIndex = si < 0 ? si : si;
+                for (let i = Math.min(startIndex, totalLength > 0 ? totalLength - 1 : 0), rowIndex = Math.floor(((items.length - layoutIndexOffset + i) + 1) / divides), l = totalLength; i < l; i++) {
+                    const collectionItem = items[i], isDummy = collectionItem?.[SERVICE_PROP_DUMMY] && (collectionItem?.[SERVICE_PROP_DUMMY] === SERVICE_PROP_DUMMY_ENABLED);
+                    if (!collectionItem || isDummy) {
+                        continue;
+                    }
+                    const id = collectionItem[trackBy], cache = this.get(id), sticky = itemConfigMap[id]?.sticky ?? 0, selectable = itemConfigMap[id]?.selectable ?? true, collapsable = itemConfigMap[id]?.collapsable ?? false, size = dynamicSize
+                        ? cache?.[sizeProperty] || typicalItemSize
+                        : typicalItemSize;
+                    if (sticky === 2) {
+                        const isOdd = (items.length - layoutIndexOffset + i) % 2 != 0, w = isVertical ? normalizedItemWidth : size, h = isVertical ? size : normalizedItemHeight, absoluteStartPosition = pos - (scrollSize - size) - size, ratio = size !== 0 ? boundsSize / size : 0, absoluteStartPositionPercent = -(boundsSize !== 0 ? absoluteStartPosition / boundsSize : 0) * ratio, absoluteEndPosition = boundsSize - (absoluteStartPositionPercent + size), absoluteEndPositionPercent = (absoluteStartPositionPercent + (boundsSize !== 0 ? (absoluteEndPosition + size) / boundsSize : 0) * ratio), x = isVertical ? 0 : actualEndSnippedPosition - w, y = isVertical ? actualEndSnippedPosition - h : 0, measures = {
+                            x,
+                            y,
+                            transformedX: x,
+                            transformedY: y,
+                            z: 0,
+                            rotationX: 0,
+                            rotationY: 0,
+                            rotationZ: 0,
+                            scaleX: 1,
+                            scaleY: 1,
+                            scaleZ: 1,
+                            size,
+                            row: {
+                                size,
+                                odd: rowIndex % 2 != 0,
+                                even: rowIndex % 2 == 0,
+                            },
+                            position: pos,
+                            boundsSize,
+                            scrollSize,
+                            absoluteStartPosition,
+                            absoluteStartPositionPercent,
+                            absoluteEndPosition,
+                            absoluteEndPositionPercent,
+                            width: w,
+                            height: h,
+                            minWidth: minItemSize,
+                            minHeight: minItemSize,
+                            maxWidth: maxItemSize,
+                            maxHeight: maxItemSize,
+                            scrollDirection,
+                            delta: actualEndSnippedPosition - deltaOffet - size,
+                        }, config = {
+                            fullSize: true,
+                            isFirst: i === layoutIndexOffset,
+                            isLast: i === li,
+                            new: cache?.[IS_NEW] === true,
+                            odd: isOdd,
+                            even: !isOdd,
+                            isVertical,
+                            collapsable,
+                            selectable,
+                            sticky,
+                            snap: stickyEnabled,
+                            snapped: true,
+                            snappedOut: false,
+                            dynamic: dynamicSize,
+                            isSnappingMethodAdvanced,
+                            layoutOffset,
+                            layoutIndexOffset,
+                            totalItems: items.length,
+                            snapToItem,
+                            snapToItemAlign,
+                            tabIndex: i - layoutIndexOffset,
+                            divides,
+                            opacity: 1,
+                            zIndex: Z_INDEX_1,
+                        };
+                        const itemData = collectionItem;
+                        endStickyItem = {
+                            index: i, id, measures, data: itemData, previouseData: i > 0 ? items[i - 1] : null,
+                            nextData: i < totalLength ? items[i + 1] : null, config,
+                        };
+                        endStickyItemIndex = i;
+                        endStickyItemSize = size;
+                        displayItems.push(endStickyItem);
+                        break;
+                    }
+                }
+            }
+            const collectionLength = items.length;
+            let i = startIndex, ci = 0, row = {
+                size: 0,
+                odd: false,
+                even: false,
+            };
+            while (renderItems > 0) {
+                if (i >= collectionLength) {
+                    break;
+                }
+                const collectionItem = items[i];
+                if (!collectionItem) {
+                    break;
+                }
+                const isDummy = collectionItem?.[SERVICE_PROP_DUMMY] && (collectionItem?.[SERVICE_PROP_DUMMY] === SERVICE_PROP_DUMMY_ENABLED), ii = i + 1, rowIndex = Math.floor(((items.length - layoutIndexOffset + i) + 1) / divides), id = collectionItem[trackBy], cache = this.get(id), size = isDummy ? typicalItemSize : (dynamicSize ? cache?.[sizeProperty] || typicalItemSize : typicalItemSize), divSize = (isVertical ? normalizedItemWidth : normalizedItemHeight) / divides;
+                if (i % divides === 0) {
+                    ci = 0;
+                    row = {
+                        size,
+                        odd: rowIndex % 2 !== 0,
+                        even: rowIndex % 2 === 0,
+                    };
+                }
+                else {
+                    row.size = Math.max(row.size, size);
+                    ci++;
+                }
+                if (!isDummy) {
+                    if ((isSnappingMethodAdvanced || id !== stickyItem?.id) && id !== endStickyItem?.id) {
+                        const isOdd = (items.length - layoutIndexOffset + i) % 2 != 0, sticky = itemConfigMap[id]?.sticky ?? 0, fullSize = itemConfigMap[id]?.fullSize ?? false, selectable = itemConfigMap[id]?.selectable ?? true, collapsable = itemConfigMap[id]?.collapsable ?? false, snapped = stickyEnabled && ((sticky === 1 && (pos <= scrollSize + this._scrollStartOffset)) || (sticky === 2 && (pos >= scrollSize + boundsSize - size))), absoluteStartPosition = pos - scrollSize, ratio = size !== 0 ? boundsSize / size : 0, absoluteStartPositionPercent = -(boundsSize !== 0 ? absoluteStartPosition / boundsSize : 0) * ratio, absoluteEndPosition = boundsSize - (absoluteStartPositionPercent + size), absoluteEndPositionPercent = (absoluteStartPositionPercent + (boundsSize !== 0 ? (absoluteEndPosition + size) / boundsSize : 0) * ratio), x = isVertical ? divSize * ((sticky || fullSize) ? 0 : ci) : pos, y = isVertical ? pos : divSize * ((sticky || fullSize) ? 0 : ci), measures = {
+                            x,
+                            y,
+                            transformedX: x,
+                            transformedY: y,
+                            z: 0,
+                            rotationX: 0,
+                            rotationY: 0,
+                            rotationZ: 0,
+                            scaleX: 1,
+                            scaleY: 1,
+                            scaleZ: 1,
+                            size,
+                            row,
+                            position: pos,
+                            boundsSize,
+                            scrollSize,
+                            absoluteStartPosition,
+                            absoluteStartPositionPercent,
+                            absoluteEndPosition,
+                            absoluteEndPositionPercent,
+                            width: isVertical ? ((sticky || fullSize) ? normalizedItemWidth : (normalizedItemWidth / divides)) : size,
+                            height: isVertical ? size : ((sticky || fullSize) ? normalizedItemHeight : (normalizedItemHeight / divides)),
+                            minWidth: minItemSize,
+                            minHeight: minItemSize,
+                            maxWidth: maxItemSize,
+                            maxHeight: maxItemSize,
+                            scrollDirection,
+                            delta: sticky === 1 ? actualSnippedPosition : (sticky === 2 ? (actualEndSnippedPosition - deltaOffet - size) : 0),
+                        }, config = {
+                            isFirst: i === layoutIndexOffset,
+                            isLast: i === li,
+                            new: cache?.[IS_NEW] === true,
+                            odd: isOdd,
+                            even: !isOdd,
+                            isVertical,
+                            collapsable,
+                            selectable,
+                            sticky,
+                            snap: stickyEnabled,
+                            snapped: false,
+                            snappedOut: false,
+                            dynamic: dynamicSize,
+                            isSnappingMethodAdvanced,
+                            layoutOffset,
+                            layoutIndexOffset,
+                            totalItems: items.length,
+                            snapToItem,
+                            snapToItemAlign,
+                            tabIndex: i - layoutIndexOffset,
+                            isStub: (isSnappingMethodAdvanced && id === stickyItem?.id),
+                            divides,
+                            opacity: 1,
+                            zIndex: Z_INDEX_0,
+                            fullSize,
+                        };
+                        if (snapped) {
+                            config.zIndex = Z_INDEX_2;
+                        }
+                        const itemData = collectionItem;
+                        const item = {
+                            index: i, id, measures, data: itemData, previouseData: i > 0 ? items[i - 1] : null,
+                            nextData: i < totalLength ? items[i + 1] : null, config,
+                        };
+                        if (!nextSticky && stickyItemIndex < i && sticky === 1 && (pos <= scrollSize + this._scrollStartOffset + size + stickyItemSize)) {
+                            item.measures.x = isVertical ? 0 : snapped ? actualSnippedPosition : pos;
+                            item.measures.y = isVertical ? snapped ? actualSnippedPosition : pos : 0;
+                            nextSticky = item;
+                            nextSticky.config.snapped = snapped;
+                            nextSticky.measures.delta = (isVertical ? item.measures.y : item.measures.x) - scrollSize;
+                            nextSticky.config.zIndex = Z_INDEX_3;
+                        }
+                        if (!nextEndSticky && endStickyItemIndex > i && sticky === 2 &&
+                            (pos >= actualEndSnippedPosition - size - endStickyItemSize)) {
+                            item.measures.x = isVertical ? 0 : snapped ? actualEndSnippedPosition - size : pos;
+                            item.measures.y = isVertical ? snapped ? actualEndSnippedPosition - size : pos : 0;
+                            nextEndSticky = item;
+                            nextEndSticky.config.zIndex = Z_INDEX_3;
+                            nextEndSticky.config.snapped = snapped;
+                            nextEndSticky.measures.delta = (isVertical ? item.measures.y : item.measures.x) - scrollSize;
+                        }
+                        displayItems.push(item);
+                    }
+                }
+                renderItems--;
+                if (ii % divides === 0 || renderItems <= 0) {
+                    pos += row.size;
+                }
+                i++;
+            }
+            const axis = isVertical ? Y_PROP_NAME : X_PROP_NAME;
+            if (!!nextSticky && !!stickyItem && nextSticky.measures[axis] <= actualSnippedPosition + stickyItem.measures[sizeProperty]) {
+                if (nextSticky.measures[axis] > actualSnippedPosition) {
+                    stickyItem.measures[axis] = nextSticky.measures[axis] - stickyItem.measures[sizeProperty];
+                    stickyItem.config.snapped = nextSticky.config.snapped = false;
+                    stickyItem.config.snappedOut = true;
+                    stickyItem.config.sticky = 1;
+                    stickyItem.measures.delta = (isVertical ? stickyItem.measures.y : stickyItem.measures.x) - scrollSize;
+                }
+                else {
+                    nextSticky.config.snapped = true;
+                    nextSticky.measures.delta = (isVertical ? nextSticky.measures.y : nextSticky.measures.x) - scrollSize;
+                    stickyItem.measures[axis] = nextSticky.measures[axis] - stickyItem.measures[sizeProperty];
+                    stickyItem.measures.delta = (isVertical ? stickyItem.measures.y : stickyItem.measures.x) - scrollSize;
+                }
+            }
+            if (!!nextEndSticky && !!endStickyItem &&
+                (nextEndSticky.measures[axis] >= actualEndSnippedPosition - endStickyItemSize - nextEndSticky.measures[sizeProperty])) {
+                if (nextEndSticky.measures[axis] < actualEndSnippedPosition - nextEndSticky.measures[sizeProperty]) {
+                    endStickyItem.measures[axis] = nextEndSticky.measures[axis] + nextEndSticky.measures[sizeProperty];
+                    endStickyItem.config.snapped = nextEndSticky.config.snapped = false;
+                    endStickyItem.config.snappedOut = true;
+                    endStickyItem.config.sticky = 2;
+                    endStickyItem.measures.delta = (isVertical ? endStickyItem.measures.y : endStickyItem.measures.x) - scrollSize;
+                }
+                else {
+                    nextEndSticky.config.snapped = true;
+                    nextEndSticky.measures[axis] = actualEndSnippedPosition - nextEndSticky.measures[sizeProperty];
+                    nextEndSticky.measures.delta = (isVertical ? nextEndSticky.measures.y : nextEndSticky.measures.x) - scrollSize;
+                    endStickyItem.measures[axis] = nextEndSticky.measures[axis] + nextEndSticky.measures[sizeProperty];
+                    endStickyItem.measures.delta = (isVertical ? endStickyItem.measures.y : endStickyItem.measures.x) - scrollSize;
+                }
+            }
+            if (itemTransform !== null) {
+                for (let i = 0, l = displayItems.length; i < l; i++) {
+                    const item = displayItems[i];
+                    if (!!item) {
+                        const transformation = itemTransform(item.index, objectAsReadonly(item.measures), objectAsReadonly(item.config));
+                        item.measures.transformedX = transformation.x;
+                        item.measures.transformedY = transformation.y;
+                        item.measures.z = transformation.z;
+                        item.measures.rotationX = transformation.rotationX;
+                        item.measures.rotationY = transformation.rotationY;
+                        item.measures.rotationZ = transformation.rotationZ;
+                        item.measures.scaleX = transformation.scaleX;
+                        item.measures.scaleY = transformation.scaleY;
+                        item.measures.scaleZ = transformation.scaleZ;
+                        item.config.opacity = transformation.opacity;
+                        item.config.filter = transformation.filter;
+                        item.config.blendColor = transformation.blendColor;
+                        item.config.zIndex = String(transformation.zIndex);
+                    }
+                }
+            }
+        }
+        return displayItems;
+    }
+    resetPositions() {
+        this._tracker.clearTrackMap();
+        this.track();
+    }
+    /**
+     * tracking by propName
+     */
+    track() {
+        if (!this._items || !this._displayComponents) {
+            return;
+        }
+        this._tracker.track(this._items, this._displayComponents, this._snappedDisplayComponents, this._scrollDirection, this._trackBy);
+    }
+    setDisplayObjectIndexMapById(v) {
+        this._tracker.displayObjectIndexMapById = v;
+    }
+    untrackComponentByIdProperty(component) {
+        this._tracker.untrackComponentByIdProperty(component);
+    }
+    getItemBounds(id) {
+        if (this.has(id)) {
+            return this.get(id) ?? null;
+        }
+        return null;
+    }
+    getComponentBoundsByIntersectionPosition(position, maxPosition = null) {
+        const components = this._displayComponents;
+        let first = null, last = null;
+        if (!!components) {
+            for (const comp of components) {
+                const id = comp.instance.itemId ?? null, isVertical = comp.instance.item?.config?.isVertical, x = comp.instance.item?.measures?.x ?? 0, y = comp.instance.item?.measures?.y ?? 0, isFirst = comp.instance.item?.config?.isFirst ?? false, isLast = comp.instance.item?.config?.isLast ?? false, { width, height } = comp.instance.getBounds(), pos = position;
+                if (isVertical && (pos >= y && pos < y + height)) {
+                    return { id, x, y, width, height, isFirst, isLast };
+                }
+                else if (!isVertical && (pos >= x && pos < x + width)) {
+                    return { id, x, y, width, height, isFirst, isLast };
+                }
+                if (isFirst) {
+                    first = { id, x, y, width, height, isFirst, isLast };
+                }
+                else if (isLast) {
+                    last = { id, x, y, width, height, isFirst, isLast };
+                }
+            }
+        }
+        if (position < 0) {
+            return first;
+        }
+        if (maxPosition !== null && position > maxPosition) {
+            return last;
+        }
+        return null;
+    }
+    cacheElements(isVertical, itemSize) {
+        if (!this._displayComponents) {
+            return;
+        }
+        for (let i = 0, l = this._displayComponents.length; i < l; i++) {
+            const component = this._displayComponents[i], itemId = component.instance.itemId;
+            if (itemId === undefined) {
+                continue;
+            }
+            const bounds = component.instance.getBounds();
+            this.set(itemId, {
+                ...this.get(itemId), ...bounds,
+                width: bounds.width || (isVertical ? 0 : itemSize),
+                height: bounds.height || (isVertical ? itemSize : 0),
+            });
+            if (this._isLazy && (this._isScrollStart)) {
+                this._debouncedIsScrollStartOff.execute();
+            }
+        }
+        const cache = this._prerenderedCache;
+        if (!!cache) {
+            for (const id in cache) {
+                const cacheItem = cache[id];
+                this.set(id, { ...(this.get(id) || {}), ...cacheItem });
+            }
+            this._prerenderedCache = null;
+        }
+    }
+    resetCacheChunkInfo() {
+        this._newItems = [];
+    }
+    cacheClean() {
+        this._map.clear();
+        this._snapshot.clear();
+    }
+    dispose() {
+        super.dispose();
+        this.disposeClearBufferSizeTimer();
+        if (!!this._debouncedIsScrollStartOff) {
+            this._debouncedIsScrollStartOff.dispose();
+        }
+        if (!!this._tracker) {
+            this._tracker.dispose();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"track-box.js","sourceRoot":"","sources":["../../../../../projects/ng-virtual-list/src/lib/core/track-box.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentRef } from \"@angular/core\";\r\nimport { IRenderVirtualListCollection, } from \"../models/render-collection.model\";\r\nimport { IRenderVirtualListItem } from \"../models/render-item.model\";\r\nimport { Id } from \"../types/id\";\r\nimport { CACHE_BOX_CHANGE_EVENT_NAME, CacheMap } from \"./cache-map\";\r\nimport { Tracker } from \"./tracker\";\r\nimport { IRect, ISize } from \"../interfaces\";\r\nimport {\r\n    DEFAULT_DIVIDES, HEIGHT_PROP_NAME, SERVICE_PROP_DUMMY, SERVICE_PROP_DUMMY_ENABLED, TRACK_BY_PROPERTY_NAME, WIDTH_PROP_NAME,\r\n    X_PROP_NAME, Y_PROP_NAME,\r\n} from \"../const\";\r\nimport { IRenderVirtualListItemConfig, IRenderVirtualListItemMeasures, IVirtualListItemConfigMap } from \"../models\";\r\nimport { debounce } from \"../utils\";\r\nimport { CMap } from '../utils/cmap';\r\nimport { bufferInterpolation } from \"../utils/buffer-interpolation\";\r\nimport { BaseVirtualListItemComponent } from \"../components/ng-list-item/base\";\r\nimport { PrerenderCache } from \"../components/ng-prerender-container/types/cache\";\r\nimport { ScrollDirection } from \"../types\";\r\nimport { objectAsReadonly } from \"../utils/object\";\r\nimport { getServiceIdProp } from \"./utils\";\r\nimport {\r\n    DEFAULT_BUFFER_EXTREMUM_THRESHOLD, DEFAULT_MAX_BUFFER_SEQUENCE_LENGTH, DEFAULT_RESET_BUFFER_SIZE_TIMEOUT, END_COLLECTION_PREFIX_ID,\r\n    IS_NEW, START_COLLECTION_PREFIX_ID,\r\n} from \"./const\";\r\nimport { Z_INDEX_0, Z_INDEX_1, Z_INDEX_2, Z_INDEX_3, } from '../const';\r\nimport {\r\n    IGetItemPositionOptions, IGetMetricsReturns, IItem, IMetrics, IRecalculateMetricsOptions, IUpdateCollectionOptions,\r\n    IUpdateCollectionReturns,\r\n} from \"./interfaces\";\r\nimport { TrackBoxEvents } from \"./events\";\r\nimport { Cache, CacheMapEvents, CacheMapListeners } from \"./types\";\r\nimport { ItemDisplayMethods } from \"./enums\";\r\nimport { Alignments } from \"../enums\";\r\n\r\n/**\r\n * An object that performs tracking, calculations and caching.\r\n * @link https://github.com/DjonnyX/ng-virtual-list/blob/14.x/projects/ng-virtual-list/src/lib/core/track-box.ts\r\n * @author Evgenii Alexandrovich Grebennikov\r\n * @email djonnyx@gmail.com\r\n */\r\nexport class TrackBox<C extends BaseVirtualListItemComponent = any>\r\n    extends CacheMap<Id, Cache, CacheMapEvents, CacheMapListeners> {\r\n\r\n    protected _tracker!: Tracker<C>;\r\n\r\n    protected _items: IRenderVirtualListCollection | null | undefined;\r\n\r\n    set items(v: IRenderVirtualListCollection | null | undefined) {\r\n        if (this._items === v) {\r\n            return;\r\n        }\r\n\r\n        this._items = v;\r\n    }\r\n\r\n    protected _displayComponents: Array<ComponentRef<C>> | null | undefined;\r\n\r\n    set displayComponents(v: Array<ComponentRef<C>> | null | undefined) {\r\n        if (this._displayComponents === v) {\r\n            return;\r\n        }\r\n\r\n        this._displayComponents = v;\r\n    }\r\n\r\n    protected _snappedDisplayComponents: Array<ComponentRef<C>> | null | undefined;\r\n\r\n    set snappedDisplayComponents(v: Array<ComponentRef<C>> | null | undefined) {\r\n        if (this._snappedDisplayComponents === v) {\r\n            return;\r\n        }\r\n\r\n        this._snappedDisplayComponents = v;\r\n    }\r\n\r\n    protected _scrollDirection: ScrollDirection = 0;\r\n    set scrollDirection(v: ScrollDirection) {\r\n        if (this._scrollDirection === v) {\r\n            return;\r\n        }\r\n\r\n        this._scrollDirection = v;\r\n    }\r\n    get scrollDirection() { return this._scrollDirection; }\r\n\r\n    protected _trackBy: string = TRACK_BY_PROPERTY_NAME;\r\n    set trackBy(v: string) {\r\n        if (this._trackBy === v) {\r\n            return;\r\n        }\r\n\r\n        this._trackBy = v;\r\n    }\r\n    get trackBy() { return this._trackBy; }\r\n\r\n    protected _divides: number = DEFAULT_DIVIDES;\r\n\r\n    set divides(v: number) {\r\n        if (this._divides === v) {\r\n            return;\r\n        }\r\n\r\n        this._divides = v;\r\n    }\r\n\r\n    protected _isInfinity: boolean = false;\r\n\r\n    set isInfinity(v: boolean) {\r\n        if (this._isInfinity === v) {\r\n            return;\r\n        }\r\n\r\n        this._isInfinity = v;\r\n    }\r\n\r\n    protected _isSnappingMethodAdvanced: boolean = false;\r\n\r\n    set isSnappingMethodAdvanced(v: boolean) {\r\n        if (this._isSnappingMethodAdvanced === v) {\r\n            return;\r\n        }\r\n\r\n        this._isSnappingMethodAdvanced = v;\r\n    }\r\n\r\n    protected _isLazy: boolean = false;\r\n\r\n    set isLazy(v: boolean) {\r\n        if (this._isLazy === v) {\r\n            return;\r\n        }\r\n\r\n        this._isLazy = v;\r\n    }\r\n\r\n    /**\r\n     * Set the trackBy property\r\n     */\r\n    set trackingPropertyName(v: string) {\r\n        this._trackingPropertyName = this._tracker.trackingPropertyName = v;\r\n    }\r\n\r\n    protected _trackingPropertyName: string = TRACK_BY_PROPERTY_NAME;\r\n\r\n    protected _isScrollStart: boolean = false;\r\n\r\n    set isScrollStart(v: boolean) {\r\n        this._isScrollStart = v;\r\n        if (v) {\r\n            this._isScrollSnapToStart = true;\r\n        }\r\n    }\r\n\r\n    protected _isScrollEnd: boolean = false;\r\n\r\n    set isScrollEnd(v: boolean) {\r\n        this._isScrollEnd = v;\r\n        if (v) {\r\n            this._isScrollSnapToEnd = true;\r\n        }\r\n    }\r\n\r\n    protected _isScrollSnapToStart: boolean = false;\r\n\r\n    get isSnappedToStart() {\r\n        return this._isScrollStart || this._isScrollSnapToStart;\r\n    }\r\n\r\n    protected _isScrollSnapToEnd: boolean = false;\r\n\r\n    get isSnappedToEnd() {\r\n        return this._isScrollEnd || this._isScrollSnapToEnd;\r\n    }\r\n\r\n    protected _scrollStartOffset: number = 0;\r\n    set scrollStartOffset(v: number) {\r\n        this._scrollStartOffset = v;\r\n    }\r\n    get scrollStartOffset() {\r\n        return this._scrollStartOffset;\r\n    }\r\n\r\n    protected _scrollEndOffset: number = 0;\r\n    set scrollEndOffset(v: number) {\r\n        this._scrollEndOffset = v;\r\n    }\r\n    get scrollEndOffset() {\r\n        return this._scrollEndOffset;\r\n    }\r\n\r\n    constructor(trackingPropertyName: string) {\r\n        super();\r\n\r\n        this._trackingPropertyName = trackingPropertyName;\r\n\r\n        this.initialize();\r\n    }\r\n\r\n    protected initialize() {\r\n        this._tracker = new Tracker(this._trackingPropertyName);\r\n    }\r\n\r\n    override set(id: Id, cache: Cache): CMap<Id, ISize> {\r\n        if (this._map.has(id)) {\r\n            const b = this._map.get(id);\r\n            if (b?.width === cache.width && b?.height === cache.height) {\r\n                return this._map;\r\n            }\r\n        }\r\n\r\n        const v = this._map.set(id, cache);\r\n\r\n        this.bumpVersion();\r\n        return v;\r\n    }\r\n\r\n    protected _previousCollection: Array<IItem> | null | undefined;\r\n\r\n    protected _deletedItemsMap: { [index: number]: ISize } = {};\r\n\r\n    protected _crudDetected = false;\r\n    get crudDetected() { return this._crudDetected; }\r\n\r\n    protected override fireChangeIfNeed() {\r\n        if (this.changesDetected()) {\r\n            this.dispatch(TrackBoxEvents.CHANGE, this._version);\r\n        }\r\n    }\r\n\r\n    protected fireTick() {\r\n        this.dispatch(TrackBoxEvents.TICK);\r\n    }\r\n\r\n    protected _previousTotalSize = 0;\r\n\r\n    protected _deltaOfNewItems: number = 0;\r\n    get deltaOfNewItems() { return this._deltaOfNewItems; }\r\n\r\n    isAdaptiveBuffer = true;\r\n\r\n    protected _bufferSequenceExtraThreshold = DEFAULT_BUFFER_EXTREMUM_THRESHOLD;\r\n\r\n    protected _maxBufferSequenceLength = DEFAULT_MAX_BUFFER_SEQUENCE_LENGTH;\r\n\r\n    protected _bufferSizeSequence: Array<number> = [];\r\n\r\n    protected _bufferSize: number = 0;\r\n    get bufferSize() { return this._bufferSize; }\r\n\r\n    protected _defaultBufferSize: number = 0;\r\n\r\n    protected _maxBufferSize: number = this._defaultBufferSize;\r\n\r\n    protected _resetBufferSizeTimeout: number = DEFAULT_RESET_BUFFER_SIZE_TIMEOUT;\r\n\r\n    protected _resetBufferSizeTimer: number | undefined;\r\n\r\n    protected _isReseted: boolean = true;\r\n\r\n    private _prerenderedCache: PrerenderCache | null = null;\r\n\r\n    private _newItems: Array<Id> = [];\r\n\r\n    protected override lifeCircle() {\r\n        this.fireChangeIfNeed();\r\n\r\n        this.fireTick();\r\n\r\n        this.lifeCircleDo();\r\n    }\r\n\r\n    /**\r\n     * Scans the collection for deleted items and flushes the deleted item cache.\r\n     */\r\n    resetCollection<I extends IItem, C extends Array<I>>(currentCollection: C | null | undefined,\r\n        itemSize: number): void {\r\n        if (currentCollection !== undefined && currentCollection !== null &&\r\n            currentCollection === this._previousCollection) {\r\n            console.warn('Attention! The collection must be immutable.');\r\n            return;\r\n        }\r\n\r\n        const reseted = ((!this._previousCollection || this._previousCollection.length === 0) &&\r\n            (!!currentCollection && currentCollection.length > 0));\r\n\r\n        this._isReseted = reseted;\r\n\r\n        this.updateCache(this._previousCollection, currentCollection, itemSize);\r\n\r\n        this._previousCollection = [...(currentCollection || [])];\r\n    }\r\n\r\n    /**\r\n     * Update the cache of items from the list\r\n     */\r\n    protected updateCache<I extends IItem, C extends Array<I>>(previousCollection: C | null | undefined,\r\n        currentCollection: C | null | undefined,\r\n        itemSize: number): void {\r\n        const trackBy = this._trackingPropertyName;\r\n        let crudDetected = false;\r\n        this._newItems = [];\r\n\r\n        if (!currentCollection || currentCollection.length === 0) {\r\n            if (previousCollection) {\r\n                // deleted\r\n                for (let i = 0, l = previousCollection.length; i < l; i++) {\r\n                    const item = previousCollection[i], id = item?.[trackBy];\r\n                    crudDetected = true;\r\n                    if (!!item && this._map.has(id)) {\r\n                        this._map.delete(id);\r\n                    }\r\n                }\r\n            }\r\n            return;\r\n        }\r\n        if (!previousCollection || previousCollection.length === 0) {\r\n            if (currentCollection) {\r\n                // added\r\n                for (let i = 0, l = currentCollection.length; i < l; i++) {\r\n                    crudDetected = true;\r\n                    const item = currentCollection[i], id = item?.[trackBy];\r\n                    if (!!item) {\r\n                        this._map.set(id, { width: itemSize, height: itemSize, method: ItemDisplayMethods.CREATE });\r\n                    }\r\n                }\r\n            }\r\n            return;\r\n        }\r\n        const collectionDict: IItem<I> = {};\r\n        for (let i = 0, l = currentCollection.length; i < l; i++) {\r\n            const item = currentCollection[i];\r\n            if (!!item) {\r\n                collectionDict[item[trackBy]] = item;\r\n            }\r\n        }\r\n        const notChangedMap: IItem<I> = {}, deletedMap: IItem<I> = {}, deletedItemsMap: { [index: number]: ISize } = {},\r\n            updatedMap: IItem<I> = {};\r\n        for (let i = 0, l = previousCollection.length; i < l; i++) {\r\n            const item = previousCollection[i], id = item?.[trackBy];\r\n            if (!!item) {\r\n                if (collectionDict.hasOwnProperty(id)) {\r\n                    if (item === collectionDict[id]) {\r\n                        // not changed\r\n                        notChangedMap[item[trackBy]] = item;\r\n                        this._map.set(id, {\r\n                            ...(this._map.get(id) || { width: itemSize, height: itemSize }),\r\n                            method: ItemDisplayMethods.NOT_CHANGED\r\n                        });\r\n                        continue;\r\n                    } else {\r\n                        // updated\r\n                        crudDetected = true;\r\n                        updatedMap[item[trackBy]] = item;\r\n                        this._map.set(id, {\r\n                            ...(this._map.get(id) || { width: itemSize, height: itemSize }),\r\n                            method: ItemDisplayMethods.UPDATE\r\n                        });\r\n                        continue;\r\n                    }\r\n                }\r\n\r\n                // deleted\r\n                crudDetected = true;\r\n                deletedMap[id] = item;\r\n                deletedItemsMap[i] = this._map.get(id);\r\n                this._map.delete(id);\r\n            }\r\n        }\r\n\r\n        for (let i = 0, l = currentCollection.length; i < l; i++) {\r\n            const item = currentCollection[i], id = item?.[trackBy];\r\n            if (!!item && !deletedMap.hasOwnProperty(id) && !updatedMap.hasOwnProperty(id) &&\r\n                !notChangedMap.hasOwnProperty(id)) {\r\n                this._newItems.push(id);\r\n                // added\r\n                crudDetected = true;\r\n                this._map.set(id, { width: itemSize, height: itemSize, method: ItemDisplayMethods.CREATE });\r\n            }\r\n        }\r\n        this._crudDetected = crudDetected;\r\n        this._deletedItemsMap = deletedItemsMap;\r\n    }\r\n\r\n    /**\r\n     * Finds the position of a collection element by the given Id\r\n     */\r\n    getItemPosition<I extends IItem, C extends Array<I>>(id: Id, itemConfigMap: IVirtualListItemConfigMap,\r\n        options: IGetItemPositionOptions<I, C>): number {\r\n        const opt = { fromItemId: id ?? options.fromItemId, itemConfigMap, ...options };\r\n        this._defaultBufferSize = opt.bufferSize;\r\n        this._maxBufferSize = opt.maxBufferSize;\r\n\r\n        const { scrollSize, isFromItemIdFound } = this.recalculateMetrics({\r\n            ...opt,\r\n            dynamicSize: this._crudDetected || opt.dynamicSize,\r\n            previousTotalSize: this._previousTotalSize,\r\n            crudDetected: this._crudDetected,\r\n            deletedItemsMap: this._deletedItemsMap,\r\n        });\r\n        return isFromItemIdFound ? scrollSize : -1;\r\n    }\r\n\r\n    preventScrollSnapping(clearBuffer: boolean = false) {\r\n        this._isScrollStart = this._isScrollEnd = false;\r\n\r\n        if (clearBuffer) {\r\n            this._isScrollSnapToStart = this._isScrollSnapToEnd = false;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Updates the collection of display objects\r\n     */\r\n    getMetrics<I extends IItem, C extends Array<I>>(items: C, itemConfigMap: IVirtualListItemConfigMap,\r\n        options: IUpdateCollectionOptions<I, C>): IGetMetricsReturns {\r\n        const opt = { itemConfigMap, ...options }, crudDetected = this._crudDetected,\r\n            deletedItemsMap = this._deletedItemsMap;\r\n        this._defaultBufferSize = opt.bufferSize;\r\n        this._maxBufferSize = opt.maxBufferSize;\r\n\r\n        const metrics = this.recalculateMetrics({\r\n            ...opt,\r\n            collection: items,\r\n            previousTotalSize: this._previousTotalSize,\r\n            crudDetected: this._crudDetected,\r\n            deletedItemsMap,\r\n        });\r\n\r\n        return { totalSize: metrics.totalSize, delta: metrics.delta, crudDetected };\r\n    }\r\n\r\n    /**\r\n     * Updates the collection of display objects\r\n     */\r\n    updateCollection<I extends IItem, C extends Array<I>>(items: C, itemConfigMap: IVirtualListItemConfigMap,\r\n        options: IUpdateCollectionOptions<I, C>): IUpdateCollectionReturns {\r\n        const opt = { itemConfigMap, ...options }, dynamicSize = opt.dynamicSize, crudDetected = this._crudDetected,\r\n            deletedItemsMap = this._deletedItemsMap;\r\n        if (dynamicSize) {\r\n            this.cacheElements(opt.isVertical, opt.itemSize);\r\n        }\r\n        this._defaultBufferSize = opt.bufferSize;\r\n        this._maxBufferSize = opt.maxBufferSize;\r\n\r\n        const metrics = this.recalculateMetrics({\r\n            ...opt,\r\n            collection: items,\r\n            previousTotalSize: this._previousTotalSize,\r\n            crudDetected: this._crudDetected,\r\n            deletedItemsMap,\r\n        });\r\n\r\n        this._delta += metrics.delta;\r\n\r\n        this.updateAdaptiveBufferParams(metrics, items.length);\r\n\r\n        this._previousTotalSize = metrics.totalSize;\r\n\r\n        this._deletedItemsMap = {};\r\n\r\n        this._crudDetected = false;\r\n\r\n        if (opt.dynamicSize) {\r\n            this.snapshot();\r\n        }\r\n\r\n        const displayItems = this.generateDisplayCollection(metrics.items, items, itemConfigMap, { ...metrics, });\r\n        return { displayItems, totalSize: metrics.totalSize, delta: metrics.delta, crudDetected, leftLayoutOffset: metrics.leftLayoutOffset };\r\n    }\r\n\r\n    protected _previousScrollSize = 0;\r\n\r\n    protected updateAdaptiveBufferParams<I extends IItem>(metrics: IMetrics<I>, totalItemsLength: number) {\r\n        this.disposeClearBufferSizeTimer();\r\n\r\n        const scrollSize = metrics.scrollSize + this._delta, delta = Math.abs(this._previousScrollSize - scrollSize);\r\n        this._previousScrollSize = scrollSize;\r\n        const bufferRawSize = Math.min(Math.floor(metrics.typicalItemSize !== 0 ? delta / metrics.typicalItemSize : 0) * 5, totalItemsLength),\r\n            minBufferSize = bufferRawSize < this._defaultBufferSize ? this._defaultBufferSize : bufferRawSize,\r\n            bufferValue = minBufferSize > this._maxBufferSize ? this._maxBufferSize : minBufferSize;\r\n\r\n        this._bufferSize = bufferInterpolation(this._bufferSize, this._bufferSizeSequence, bufferValue, {\r\n            extremumThreshold: this._bufferSequenceExtraThreshold,\r\n            bufferSize: this._maxBufferSequenceLength,\r\n        });\r\n\r\n        this.startResetBufferSizeTimer();\r\n    }\r\n\r\n    protected startResetBufferSizeTimer() {\r\n        this._resetBufferSizeTimer = setTimeout(() => {\r\n            this._bufferSize = this._defaultBufferSize;\r\n            this._bufferSizeSequence = [];\r\n        }, this._resetBufferSizeTimeout) as unknown as number;\r\n    }\r\n\r\n    protected disposeClearBufferSizeTimer() {\r\n        clearTimeout(this._resetBufferSizeTimer);\r\n    }\r\n\r\n    /**\r\n     * Calculates the entry into the overscroll area and returns the number of overscroll elements\r\n     */\r\n    protected getElementNumToEnd<I extends IItem, C extends Array<I>>(i: number, collection: C, map: CMap<Id, ISize>, typicalItemSize: number,\r\n        size: number, isVertical: boolean, indexOffset: number = 0, reverse: boolean = false): { num: number, offset: number } {\r\n        const trackBy = this._trackingPropertyName, sizeProperty = isVertical ? HEIGHT_PROP_NAME : WIDTH_PROP_NAME;\r\n        let offset = 0, num = 0;\r\n        for (let j = collection.length - indexOffset - 1; reverse ? j >= 0 : j >= i; j--) {\r\n            const item = collection[j], id = item[trackBy];\r\n            let itemSize = 0;\r\n            if (map.has(id)) {\r\n                const cache = map.get(id);\r\n                itemSize = cache && cache[sizeProperty] > 0 ? cache[sizeProperty] : typicalItemSize;\r\n            } else {\r\n                itemSize = typicalItemSize;\r\n            }\r\n            if (offset + itemSize > size) {\r\n                return { num, offset };\r\n            }\r\n            offset += itemSize;\r\n            num++;\r\n        }\r\n        return { num, offset };\r\n    }\r\n\r\n    /**\r\n     * Calculates list metrics\r\n     */\r\n    protected recalculateMetrics<I extends IItem, C extends Array<I>>(options: IRecalculateMetricsOptions<I, C>): IMetrics<I> {\r\n        const { alignment, fromItemId, bounds, collection, dynamicSize, isVertical, itemSize, minItemSize, maxItemSize, bufferSize: minBufferSize,\r\n            scrollSize, stickyEnabled, itemConfigMap, enabledBufferOptimization, previousTotalSize, snapToItem, snapToItemAlign,\r\n            deletedItemsMap, itemTransform } = options as IRecalculateMetricsOptions<I, C> & {\r\n                itemConfigMap: IVirtualListItemConfigMap,\r\n            }, roundedScrollSize = Math.round(scrollSize);\r\n\r\n        const trackBy = this._trackingPropertyName, bufferSize = Math.max(minBufferSize, this._bufferSize),\r\n            { width, height } = bounds, sizeProperty = isVertical ? HEIGHT_PROP_NAME : WIDTH_PROP_NAME,\r\n            size = isVertical ? height : width, totalLength = collection.length, typicalItemSize = itemSize,\r\n            w = isVertical ? width : typicalItemSize, h = isVertical ? typicalItemSize : height,\r\n            map = this._map, snapshot = this._snapshot, divides = this._divides,\r\n            stickyPos = Math.floor(scrollSize) + this._scrollStartOffset, leftItemsOrRowsWeights: Array<number> = [],\r\n            isFromId = fromItemId !== undefined && (typeof fromItemId === 'number' && fromItemId > -1)\r\n                || (typeof fromItemId === 'string' && fromItemId > '-1');\r\n\r\n        let leftItemsOffset = 0, rightItemsOffset = 0;\r\n        if (enabledBufferOptimization) {\r\n            switch (this._scrollDirection) {\r\n                case 1: {\r\n                    leftItemsOffset = 0;\r\n                    rightItemsOffset = bufferSize * divides;\r\n                    break;\r\n                }\r\n                case -1: {\r\n                    leftItemsOffset = bufferSize * divides;\r\n                    rightItemsOffset = 0;\r\n                    break;\r\n                }\r\n                case 0:\r\n                default: {\r\n                    leftItemsOffset = rightItemsOffset = bufferSize * divides;\r\n                }\r\n            }\r\n        } else {\r\n            leftItemsOffset = rightItemsOffset = bufferSize * divides;\r\n        }\r\n\r\n        let itemsFromStartToScrollEnd: number = -1,\r\n            itemsFromDisplayEndToOffsetEnd = 0,\r\n            itemsFromStartToDisplayEnd = -1,\r\n            leftItemLength = 0, rightItemLength = 0,\r\n            leftItemsWeight = 0, rightItemsWeight = 0,\r\n            leftHiddenItemsWeight = 0,\r\n            totalItemsToDisplayEndWeight = 0,\r\n            deltaOfNewItems = 0,\r\n            leftSizeOfAddedItems = 0,\r\n            leftSizeOfUpdatedItems = 0,\r\n            leftSizeOfDeletedItems = 0,\r\n            itemById: I | null = null,\r\n            itemByIdPos: number = this._scrollStartOffset,\r\n            isTargetInOverscroll: boolean = false,\r\n            actualScrollSize = itemByIdPos,\r\n            totalSize = this._scrollStartOffset + this._scrollEndOffset,\r\n            startIndex: number,\r\n            isFromItemIdFound = false,\r\n            deltaFromStartCreation = 0,\r\n            isUpdating = false,\r\n            leftYOffset = 0,\r\n            leftLayoutOffset = 0,\r\n            leftLayoutIndexOffset = 0,\r\n            rightLayoutIndexOffset = 0;\r\n\r\n        const isStart = ((roundedScrollSize === 0) || this.isSnappedToStart);\r\n        let stickyItemId: Id | undefined, isNew = false;\r\n\r\n        let items: Array<I>;\r\n\r\n        // If the list is dynamic or there are new elements in the collection, then it switches to the long algorithm.\r\n        if (dynamicSize) {\r\n            items = [];\r\n            const serviceIdProp = getServiceIdProp(trackBy);\r\n            if (isFromId) {\r\n                for (let stickyId: Id | undefined = undefined, i = 0, l = collection.length; i < l; i++) {\r\n                    const item = collection[i], id = item?.[trackBy];\r\n                    if (itemConfigMap[id]?.sticky === 1) {\r\n                        stickyId = id;\r\n                    }\r\n                    if (!itemConfigMap[id]?.sticky) {\r\n                        stickyItemId = stickyId;\r\n                    }\r\n                    if (id == fromItemId) {\r\n                        break;\r\n                    }\r\n                }\r\n            }\r\n\r\n            let y = this._scrollStartOffset,\r\n                stickyComponentSize = 0,\r\n                row: {\r\n                    startItemIndex: number;\r\n                    endItemIndex: number;\r\n                    size: number;\r\n                    snapshotSize: number;\r\n                    deltaFromStartCreation: number;\r\n                    leftSizeOfAddedItems: number;\r\n                    leftSizeOfUpdatedItems: number;\r\n                    leftSizeOfDeletedItems: number;\r\n                    deltaOfNewItems: number;\r\n                    leftItemsOrRowsWeights: number | null;\r\n                    rightItemsWeight: number;\r\n                    leftHiddenItemsWeight: number;\r\n                    totalItemsToDisplayEndWeight: number;\r\n                } = {\r\n                    startItemIndex: 0,\r\n                    endItemIndex: 0,\r\n                    size: 0,\r\n                    snapshotSize: 0,\r\n                    deltaFromStartCreation: 0,\r\n                    leftSizeOfAddedItems: 0,\r\n                    leftSizeOfUpdatedItems: 0,\r\n                    leftSizeOfDeletedItems: 0,\r\n                    deltaOfNewItems: 0,\r\n                    leftItemsOrRowsWeights: null,\r\n                    rightItemsWeight: 0,\r\n                    leftHiddenItemsWeight: 0,\r\n                    totalItemsToDisplayEndWeight: 0,\r\n                };\r\n            const calculate = (i: number, l: number, li: number, isPrecollection: boolean = false, idPrefix: string | null = null) => {\r\n                const ii = i + 1;\r\n                if (ii > l) {\r\n                    return false;\r\n                }\r\n                const collectionItem = collection[i],\r\n                    id = collectionItem[trackBy],\r\n                    sticky = itemConfigMap?.[id]?.sticky ?? 0,\r\n                    isNewRow = i % divides === 0,\r\n                    isLastItemInRow = ii % divides === 0,\r\n                    isLastItem = i === li,\r\n                    isRowEnd = (isLastItemInRow || (!isLastItemInRow && isLastItem));\r\n                items.push(isPrecollection ? { ...collectionItem, [serviceIdProp]: `_${idPrefix}-${id}_` } : collectionItem);\r\n                if (isNewRow || row === null) {\r\n                    row = {\r\n                        startItemIndex: i + 1,\r\n                        endItemIndex: i + divides,\r\n                        size: 0,\r\n                        snapshotSize: 0,\r\n                        deltaFromStartCreation: 0,\r\n                        leftSizeOfAddedItems: 0,\r\n                        leftSizeOfUpdatedItems: 0,\r\n                        leftSizeOfDeletedItems: 0,\r\n                        deltaOfNewItems: 0,\r\n                        leftItemsOrRowsWeights: null,\r\n                        rightItemsWeight: 0,\r\n                        leftHiddenItemsWeight: 0,\r\n                        totalItemsToDisplayEndWeight: 0,\r\n                    };\r\n                }\r\n                let componentSize = 0, rowSizeDelta = 0, itemDisplayMethod: ItemDisplayMethods = ItemDisplayMethods.NOT_CHANGED;\r\n                if (map.has(id)) {\r\n                    const cache = map.get(id);\r\n                    componentSize = cache[sizeProperty] > 0 ? cache[sizeProperty] : typicalItemSize;\r\n                    itemDisplayMethod = cache?.method ?? ItemDisplayMethods.UPDATE;\r\n                    const isItemNew = this._newItems.indexOf(id) > -1 || (this._isLazy && isStart && !this._isReseted);\r\n                    isNew = isItemNew;\r\n                    if (isNew) {\r\n                        isUpdating = true;\r\n                    }\r\n                    const snapshotBounds = snapshot.get(id),\r\n                        snapshotSize = snapshotBounds ? snapshotBounds[sizeProperty] : typicalItemSize;\r\n\r\n                    row.size = Math.max(row.size, componentSize);\r\n                    row.snapshotSize = Math.max(row.snapshotSize, snapshotSize);\r\n\r\n                    rowSizeDelta = row.size - row.snapshotSize;\r\n\r\n                    switch (itemDisplayMethod) {\r\n                        case ItemDisplayMethods.UPDATE: {\r\n                            map.set(id, { ...cache, method: isNew ? ItemDisplayMethods.UPDATE : ItemDisplayMethods.NOT_CHANGED, [IS_NEW]: isNew });\r\n                            if (isRowEnd && isNew && y <= (scrollSize + size + deltaFromStartCreation + componentSize)) {\r\n                                row.deltaFromStartCreation = rowSizeDelta;\r\n                                rowSizeDelta = 0;\r\n                            }\r\n                            break;\r\n                        }\r\n                        case ItemDisplayMethods.CREATE: {\r\n                            rowSizeDelta = typicalItemSize;\r\n                            map.set(id, { ...cache, method: ItemDisplayMethods.UPDATE, [IS_NEW]: isNew });\r\n                            if (isRowEnd && isNew && y <= (scrollSize + size + deltaFromStartCreation + componentSize)) {\r\n                                row.deltaFromStartCreation = rowSizeDelta;\r\n                                rowSizeDelta = 0;\r\n                            }\r\n                            break;\r\n                        }\r\n                    }\r\n                } else {\r\n                    componentSize = typicalItemSize;\r\n                    row.size = Math.max(row.size, componentSize);\r\n                    row.snapshotSize = row.size;\r\n                    rowSizeDelta = row.size - row.snapshotSize;\r\n                }\r\n\r\n                if (deletedItemsMap.hasOwnProperty(i)) {\r\n                    const cache = deletedItemsMap[i], size = cache?.[sizeProperty] ?? typicalItemSize;\r\n                    if (y < scrollSize + this._scrollStartOffset - size) {\r\n                        row.leftSizeOfDeletedItems = Math.max(row.leftSizeOfDeletedItems, size);\r\n                    }\r\n                }\r\n\r\n                if (isFromId) {\r\n                    if (itemById === null) {\r\n                        if (id != fromItemId && id === stickyItemId && sticky === 1) {\r\n                            stickyComponentSize = componentSize;\r\n                            y -= stickyComponentSize;\r\n                        }\r\n\r\n                        if (id == fromItemId) {\r\n                            isFromItemIdFound = true;\r\n\r\n                            if (alignment !== Alignments.CENTER) {\r\n                                const { num, offset } = this.getElementNumToEnd(i, collection, map, typicalItemSize, size, isVertical),\r\n                                    leftViewportSize = size - offset;\r\n                                if (leftViewportSize > 0) {\r\n                                    const { num: num1, offset: offset1 } = this.getElementNumToEnd(i + num, collection, map, typicalItemSize, size, isVertical, 0, true),\r\n                                        deltaNum = (num1 - num), deltaOffset = (offset1 - offset);\r\n                                    totalItemsToDisplayEndWeight += offset;\r\n                                    itemsFromStartToScrollEnd -= deltaNum;\r\n                                    rightItemsWeight = rightItemLength = 0;\r\n                                    leftHiddenItemsWeight -= deltaOffset;\r\n                                    leftItemsOrRowsWeights.splice(leftItemsOrRowsWeights.length - deltaNum, deltaNum);\r\n                                    y -= deltaOffset;\r\n                                }\r\n                            }\r\n\r\n                            itemById = collectionItem;\r\n                            itemByIdPos = y;\r\n                        } else {\r\n                            leftItemsOrRowsWeights.push(componentSize);\r\n                            leftHiddenItemsWeight += componentSize;\r\n                            itemsFromStartToScrollEnd = row.startItemIndex;\r\n                        }\r\n                    }\r\n                } else if (y <= scrollSize - componentSize) {\r\n                    if (row.leftItemsOrRowsWeights === null) {\r\n                        row.leftItemsOrRowsWeights = 0;\r\n                    }\r\n                    row.leftItemsOrRowsWeights = Math.max(row.leftItemsOrRowsWeights, componentSize);\r\n                    row.leftHiddenItemsWeight = Math.max(row.leftHiddenItemsWeight, componentSize);\r\n                    if (!isPrecollection) {\r\n                        itemsFromStartToScrollEnd = row.startItemIndex;\r\n                    }\r\n                }\r\n\r\n                if (isFromId) {\r\n                    if (itemById === null || y < itemByIdPos + size + componentSize) {\r\n                        itemsFromStartToDisplayEnd = row.endItemIndex;\r\n                        totalItemsToDisplayEndWeight += componentSize;\r\n                        itemsFromDisplayEndToOffsetEnd = itemsFromStartToDisplayEnd + rightItemsOffset;\r\n                    }\r\n                } else if (y <= scrollSize + size + componentSize) {\r\n                    if (!isPrecollection) {\r\n                        itemsFromStartToDisplayEnd = row.endItemIndex;\r\n                        itemsFromDisplayEndToOffsetEnd = itemsFromStartToDisplayEnd + rightItemsOffset;\r\n                    }\r\n                    row.totalItemsToDisplayEndWeight = Math.max(row.totalItemsToDisplayEndWeight, componentSize);\r\n\r\n                    if (isRowEnd && y <= scrollSize + componentSize) {\r\n                        switch (itemDisplayMethod) {\r\n                            case ItemDisplayMethods.CREATE: {\r\n                                row.leftSizeOfAddedItems = rowSizeDelta;\r\n                                break;\r\n                            }\r\n                            case ItemDisplayMethods.UPDATE:\r\n                            case ItemDisplayMethods.NOT_CHANGED: {\r\n                                row.leftSizeOfUpdatedItems = rowSizeDelta;\r\n                                break;\r\n                            }\r\n                            case ItemDisplayMethods.DELETE: {\r\n                                row.leftSizeOfDeletedItems = rowSizeDelta;\r\n                                break;\r\n                            }\r\n                        }\r\n                    }\r\n\r\n                    if (isRowEnd && itemDisplayMethod === ItemDisplayMethods.CREATE) {\r\n                        row.deltaOfNewItems = rowSizeDelta;\r\n                    }\r\n                } else {\r\n                    if (isRowEnd && i < itemsFromDisplayEndToOffsetEnd) {\r\n                        row.rightItemsWeight = Math.max(row.rightItemsWeight, componentSize);\r\n                    }\r\n                }\r\n\r\n                if (isRowEnd) {\r\n                    if (!isPrecollection) {\r\n                        deltaFromStartCreation += row.deltaFromStartCreation;\r\n                        leftSizeOfAddedItems += row.leftSizeOfAddedItems;\r\n                        leftSizeOfUpdatedItems += row.leftSizeOfUpdatedItems;\r\n                        leftSizeOfDeletedItems += row.leftSizeOfDeletedItems;\r\n                        deltaOfNewItems += row.deltaOfNewItems;\r\n                        rightItemsWeight += row.rightItemsWeight;\r\n                        totalItemsToDisplayEndWeight += row.totalItemsToDisplayEndWeight;\r\n                        leftHiddenItemsWeight += row.leftHiddenItemsWeight;\r\n                        if (row.leftItemsOrRowsWeights !== null) {\r\n                            leftItemsOrRowsWeights.push(row.leftItemsOrRowsWeights);\r\n                        }\r\n                    }\r\n                    totalSize += row.size;\r\n                    y += row.size;\r\n                }\r\n                return true;\r\n            }\r\n\r\n            if (this._isInfinity) {\r\n                const viewportSize = isVertical ? height : width;\r\n                let buffSize = -1;\r\n                if (scrollSize <= viewportSize) {\r\n                    let i = 0, l = collection.length, li = l > 0 ? (l - 1) : 0;\r\n                    if (l > 0) {\r\n                        const limit = viewportSize;\r\n                        while (y <= limit || buffSize > -1) {\r\n                            const ii = i + 1;\r\n                            if (buffSize === -1) {\r\n                                buffSize = leftItemsOffset;\r\n                            }\r\n                            if (y >= limit) {\r\n                                buffSize--;\r\n                            }\r\n                            if (!calculate(li - i, l, li, true, START_COLLECTION_PREFIX_ID)) {\r\n                                break;\r\n                            }\r\n                            if (ii === l) {\r\n                                i = 0;\r\n                            } else {\r\n                                i++;\r\n                            }\r\n                        }\r\n\r\n                        items.reverse();\r\n                        leftYOffset = y;\r\n                        leftLayoutOffset = viewportSize * .5;\r\n                        leftLayoutIndexOffset = i;\r\n                        y = this._scrollStartOffset;\r\n                        totalSize = this._scrollStartOffset + this._scrollEndOffset;\r\n                        itemsFromStartToDisplayEnd = itemsFromDisplayEndToOffsetEnd = 0;\r\n\r\n                        (row as any) = null;\r\n                    }\r\n                }\r\n            }\r\n\r\n            for (let i = 0, l = collection.length, li = l - 1; i < l; i++) {\r\n                if (!calculate(i, l, li)) {\r\n                    break;\r\n                }\r\n            }\r\n\r\n            if (this._isInfinity) {\r\n                (row as any) = null;\r\n\r\n                const yy = y, currentTotalSize = totalSize, viewportSize = isVertical ? height : width,\r\n                    normalizedTotalSize = totalSize + viewportSize;\r\n                row = {\r\n                    startItemIndex: 0,\r\n                    endItemIndex: 0,\r\n                    size: 0,\r\n                    snapshotSize: 0,\r\n                    deltaFromStartCreation: 0,\r\n                    leftSizeOfAddedItems: 0,\r\n                    leftSizeOfUpdatedItems: 0,\r\n                    leftSizeOfDeletedItems: 0,\r\n                    deltaOfNewItems: 0,\r\n                    leftItemsOrRowsWeights: null,\r\n                    rightItemsWeight: 0,\r\n                    leftHiddenItemsWeight: 0,\r\n                    totalItemsToDisplayEndWeight: 0,\r\n                };\r\n                const l = collection.length, li = l - 1;\r\n                let i = 0, count = 0;\r\n                while (y < normalizedTotalSize) {\r\n                    const ii = i + 1;\r\n                    if (!calculate(i, l, li, true, END_COLLECTION_PREFIX_ID)) {\r\n                        break;\r\n                    }\r\n                    if (ii === l) {\r\n                        i = 0;\r\n                    } else {\r\n                        i++;\r\n                    }\r\n                    count++;\r\n                }\r\n                y = yy;\r\n                totalSize = currentTotalSize;\r\n                rightLayoutIndexOffset = count;\r\n            }\r\n\r\n            actualScrollSize = (isFromId ? itemByIdPos : scrollSize);\r\n\r\n            if (itemsFromStartToScrollEnd <= -1) {\r\n                itemsFromStartToScrollEnd = 0;\r\n            }\r\n            if (itemsFromStartToDisplayEnd <= -1) {\r\n                itemsFromStartToDisplayEnd = 0;\r\n            }\r\n\r\n            leftItemsOrRowsWeights.splice(0, leftItemsOrRowsWeights.length - bufferSize);\r\n            leftItemsOrRowsWeights.forEach(v => {\r\n                leftItemsWeight += v;\r\n            });\r\n\r\n            leftItemLength = Math.min(itemsFromStartToScrollEnd, leftItemsOffset);\r\n            rightItemLength = itemsFromStartToDisplayEnd + rightItemsOffset > totalLength\r\n                ? totalLength - itemsFromStartToDisplayEnd : rightItemsOffset;\r\n\r\n            startIndex = (Math.ceil(Math.min(itemsFromStartToScrollEnd - leftItemLength, totalLength > 0 ? totalLength - 1 : 0) / divides) * divides);\r\n        } else\r\n        // Buffer optimization does not work on fast linear algorithm\r\n        {\r\n            const dividedTypicalItemSize = typicalItemSize / divides, bufferItemNumbers = bufferSize * divides;\r\n            itemsFromStartToScrollEnd = Math.floor(dividedTypicalItemSize !== 0 ? (scrollSize / dividedTypicalItemSize) : 0);\r\n            itemsFromStartToDisplayEnd = Math.ceil(dividedTypicalItemSize !== 0 ? ((scrollSize + size) / dividedTypicalItemSize) : 0);\r\n            leftItemLength = Math.min(itemsFromStartToScrollEnd, bufferSize * divides);\r\n            rightItemLength = (itemsFromStartToDisplayEnd + bufferItemNumbers) > totalLength\r\n                ? totalLength - itemsFromStartToDisplayEnd : bufferItemNumbers;\r\n            leftItemsWeight = Math.floor(leftItemLength * dividedTypicalItemSize / typicalItemSize) * typicalItemSize;\r\n            rightItemsWeight = Math.floor(rightItemLength * dividedTypicalItemSize / typicalItemSize) * typicalItemSize;\r\n            leftHiddenItemsWeight = Math.floor(itemsFromStartToScrollEnd * dividedTypicalItemSize / typicalItemSize) * typicalItemSize;\r\n            totalItemsToDisplayEndWeight = Math.floor(itemsFromStartToDisplayEnd * dividedTypicalItemSize / typicalItemSize) * typicalItemSize;\r\n            totalSize = (Math.ceil(totalLength / divides) * divides * dividedTypicalItemSize) + this._scrollStartOffset + this._scrollEndOffset;\r\n            const k = totalSize !== 0 ? previousTotalSize / totalSize : 0;\r\n\r\n            if (isFromId) {\r\n                const index = collection.findIndex(item => item[trackBy] == fromItemId);\r\n                if (index > -1) {\r\n                    itemByIdPos = this._scrollStartOffset + Math.floor(index * dividedTypicalItemSize / divides);\r\n                    isFromItemIdFound = true;\r\n                }\r\n            }\r\n\r\n            actualScrollSize = (isFromId ? itemByIdPos : scrollSize * k);\r\n\r\n            items = [];\r\n\r\n            if (this._isInfinity) {\r\n                const viewportSize = isVertical ? height : width;\r\n                let buffSize = -1, y = this._scrollStartOffset;\r\n                if (scrollSize <= viewportSize) {\r\n                    let i = 0, l = collection.length, li = l > 0 ? (l - 1) : 0;\r\n                    if (l > 0) {\r\n                        const limit = viewportSize;\r\n                        while (y <= limit || buffSize > -1) {\r\n                            const ii = i + 1;\r\n                            if (buffSize === -1) {\r\n                                buffSize = leftItemsOffset;\r\n                            }\r\n                            if (y >= limit) {\r\n                                buffSize--;\r\n                            }\r\n                            const itemIndex = li - i;\r\n                            if (collection.length > itemIndex) {\r\n                                items.push(collection[itemIndex] as I);\r\n                            } else {\r\n                                break;\r\n                            }\r\n                            const isLastItemInRow = ii % divides === 0,\r\n                                isLastItem = i === li;\r\n                            if (isLastItemInRow || (!isLastItemInRow && isLastItem)) {\r\n                                y += dividedTypicalItemSize;\r\n                            }\r\n                            if (ii === l) {\r\n                                i = 0;\r\n                            } else {\r\n                                i++;\r\n                            }\r\n                        }\r\n\r\n                        items.reverse();\r\n                        leftYOffset = y;\r\n                        leftLayoutOffset = viewportSize * .5;\r\n                        leftLayoutIndexOffset = i;\r\n                    }\r\n                }\r\n            }\r\n\r\n            items.push(...collection);\r\n\r\n            if (this._isInfinity) {\r\n                let y = Math.floor(totalSize / dividedTypicalItemSize) * dividedTypicalItemSize;\r\n                const viewportSize = isVertical ? height : width,\r\n                    normalizedTotalSize = totalSize + viewportSize;\r\n                const l = collection.length, li = l - 1;\r\n                let i = 0, count = 0;\r\n                while (y < normalizedTotalSize) {\r\n                    const ii = i + 1;\r\n                    if (collection.length <= i) {\r\n                        break;\r\n                    }\r\n                    items.push(collection[i]);\r\n                    const isLastItemInRow = ii % divides === 0,\r\n                        isLastItem = i === li;\r\n                    if (isLastItemInRow || (!isLastItemInRow && isLastItem)) {\r\n                        y += dividedTypicalItemSize;\r\n                    }\r\n                    if (ii === l) {\r\n                        i = 0;\r\n                    } else {\r\n                        i++;\r\n                    }\r\n                    count++;\r\n                }\r\n                rightLayoutIndexOffset = count;\r\n                leftItemLength = Math.min(itemsFromStartToScrollEnd, leftItemsOffset);\r\n                rightItemLength = itemsFromStartToDisplayEnd + rightItemsOffset > totalLength\r\n                    ? totalLength - itemsFromStartToDisplayEnd : rightItemsOffset;\r\n\r\n                startIndex = (Math.ceil(Math.min(itemsFromStartToScrollEnd - leftItemLength, totalLength > 0 ? totalLength - 1 : 0) / divides) * divides);\r\n            } else {\r\n                startIndex = Math.min(itemsFromStartToScrollEnd - leftItemLength, totalLength > 0 ? totalLength - 1 : 0);\r\n            }\r\n        }\r\n\r\n        const itemsOnDisplayWeight = totalItemsToDisplayEndWeight - leftItemsWeight,\r\n            itemsOnDisplayLength = itemsFromStartToDisplayEnd - itemsFromStartToScrollEnd,\r\n            startPosition = this._scrollStartOffset + leftHiddenItemsWeight - leftItemsWeight - leftYOffset,\r\n            renderItems = (Math.ceil((itemsOnDisplayLength + leftItemLength + rightItemLength) / divides) * divides) + rightLayoutIndexOffset,\r\n            startCreationDelta = deltaFromStartCreation > 0 ? deltaFromStartCreation : 0,\r\n            delta = leftSizeOfUpdatedItems + leftSizeOfAddedItems - leftSizeOfDeletedItems + startCreationDelta;\r\n        this._deltaOfNewItems = deltaOfNewItems;\r\n\r\n        if (isFromId && !isTargetInOverscroll) {\r\n            actualScrollSize -= this._scrollStartOffset;\r\n        }\r\n\r\n        const metrics: IMetrics<I> = {\r\n            delta,\r\n            normalizedItemWidth: w,\r\n            normalizedItemHeight: h,\r\n            width,\r\n            height,\r\n            dynamicSize,\r\n            divides,\r\n            itemSize,\r\n            minItemSize,\r\n            maxItemSize,\r\n            items,\r\n            itemsFromStartToScrollEnd,\r\n            itemsFromStartToDisplayEnd,\r\n            itemsOnDisplayWeight,\r\n            itemsOnDisplayLength,\r\n            isVertical,\r\n            leftHiddenItemsWeight,\r\n            leftItemLength,\r\n            leftItemsWeight,\r\n            leftLayoutOffset,\r\n            leftLayoutIndexOffset,\r\n            renderItems,\r\n            rightItemLength,\r\n            rightItemsWeight,\r\n            scrollSize: actualScrollSize,\r\n            leftSizeOfAddedItems,\r\n            sizeProperty,\r\n            stickyEnabled,\r\n            stickyPos,\r\n            startIndex,\r\n            startPosition,\r\n            totalItemsToDisplayEndWeight,\r\n            totalLength,\r\n            totalSize,\r\n            typicalItemSize,\r\n            isFromItemIdFound,\r\n            isUpdating,\r\n            snapToItem,\r\n            snapToItemAlign,\r\n            itemTransform,\r\n        };\r\n\r\n        return metrics;\r\n    }\r\n\r\n    refreshCache(cache: PrerenderCache) {\r\n        this._prerenderedCache = cache;\r\n    }\r\n\r\n    clearDelta(): void {\r\n        this._delta = this._deltaOfNewItems = 0;\r\n    }\r\n\r\n    changes(immediately: boolean = false, force: boolean = false): void {\r\n        if (immediately) {\r\n            if (force) {\r\n                this.bumpVersion();\r\n            }\r\n            this._previousVersion = this._version;\r\n            this.dispatch(CACHE_BOX_CHANGE_EVENT_NAME as CacheMapEvents, this.version);\r\n        } else {\r\n            if (force) {\r\n                this.bumpVersion();\r\n                return;\r\n            }\r\n            if (this.changesDetected()) {\r\n                return;\r\n            }\r\n            this.bumpVersion();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Returns true if the bounds of at least one screen object have changed.\r\n     */\r\n    checkBoundsOfElements(): boolean {\r\n        if (!this._displayComponents) {\r\n            return false;\r\n        }\r\n\r\n        for (let i = 0, l = this._displayComponents.length; i < l; i++) {\r\n            const component = this._displayComponents[i], itemId = component.instance.itemId;\r\n            if (itemId === undefined) {\r\n                continue;\r\n            }\r\n            const bounds = component.instance.getBounds(), cache = this.get(itemId);\r\n            if (!!bounds && !!cache) {\r\n                if (bounds.width !== cache.width || bounds.height !== cache.height) {\r\n                    return true;\r\n                }\r\n            }\r\n        }\r\n        return false;\r\n    }\r\n\r\n    protected generateDisplayCollection<I extends IItem, C extends Array<I>>(items: C, actualItems: C, itemConfigMap: IVirtualListItemConfigMap,\r\n        metrics: IMetrics<I>): IRenderVirtualListCollection {\r\n        const {\r\n            width,\r\n            height,\r\n            normalizedItemWidth,\r\n            normalizedItemHeight,\r\n            dynamicSize,\r\n            divides,\r\n            itemsOnDisplayLength,\r\n            itemsFromStartToScrollEnd,\r\n            isVertical,\r\n            leftLayoutOffset: layoutOffset,\r\n            leftLayoutIndexOffset: layoutIndexOffset,\r\n            renderItems: renderItemsLength,\r\n            scrollSize,\r\n            sizeProperty,\r\n            stickyEnabled,\r\n            stickyPos,\r\n            startPosition,\r\n            totalLength,\r\n            startIndex,\r\n            typicalItemSize,\r\n            minItemSize,\r\n            maxItemSize,\r\n            snapToItem,\r\n            snapToItemAlign,\r\n            itemTransform,\r\n        } = metrics,\r\n            displayItems: IRenderVirtualListCollection = [];\r\n\r\n        if (items.length) {\r\n            const trackBy = this._trackingPropertyName, actualSnippedPosition = stickyPos,\r\n                isSnappingMethodAdvanced = this._isSnappingMethodAdvanced,\r\n                deltaOffet = (isSnappingMethodAdvanced ? scrollSize : 0),\r\n                scrollDirection = this._scrollDirection,\r\n                boundsSize = isVertical ? height : width, actualEndSnippedPosition = scrollSize + boundsSize - this._scrollEndOffset;\r\n            let pos = startPosition,\r\n                renderItems = renderItemsLength,\r\n                stickyItem: IRenderVirtualListItem | undefined, nextSticky: IRenderVirtualListItem | undefined, stickyItemIndex = -1,\r\n                stickyItemSize = 0, endStickyItem: IRenderVirtualListItem | undefined, nextEndSticky: IRenderVirtualListItem | undefined,\r\n                endStickyItemIndex = -1, endStickyItemSize = 0;\r\n\r\n            const li = layoutIndexOffset + actualItems.length - 1;\r\n            if (stickyEnabled) {\r\n                for (let i = Math.min(itemsFromStartToScrollEnd > 0 ? (divides > 1 ? (itemsFromStartToScrollEnd - 1) : itemsFromStartToScrollEnd) : 0, totalLength - 1); i >= 0; i--) {\r\n                    const collectionItem = items[i],\r\n                        isDummy = collectionItem?.[SERVICE_PROP_DUMMY] && (collectionItem?.[SERVICE_PROP_DUMMY] === SERVICE_PROP_DUMMY_ENABLED);\r\n                    if (!collectionItem || isDummy) {\r\n                        continue;\r\n                    }\r\n                    const rowIndex = Math.floor(((items.length - layoutIndexOffset + i) + 1) / divides), id = collectionItem[trackBy], cache = this.get(id)!, sticky = itemConfigMap[id]?.sticky ?? 0,\r\n                        selectable = itemConfigMap[id]?.selectable ?? true,\r\n                        collapsable = itemConfigMap[id]?.collapsable ?? false,\r\n                        size = dynamicSize ? cache?.[sizeProperty] > 0 ? cache?.[sizeProperty] : typicalItemSize : typicalItemSize,\r\n                        absoluteStartPosition = pos - (scrollSize - size) - size,\r\n                        ratio = size !== 0 ? boundsSize / size : 0, absoluteStartPositionPercent = -(boundsSize !== 0 ? absoluteStartPosition / boundsSize : 0) * ratio,\r\n                        absoluteEndPosition = boundsSize - (absoluteStartPositionPercent + size),\r\n                        absoluteEndPositionPercent = (absoluteStartPositionPercent + (boundsSize !== 0 ? (absoluteEndPosition + size) / boundsSize : 0) * ratio),\r\n                        x = isVertical ? 0 : actualSnippedPosition,\r\n                        y = isVertical ? actualSnippedPosition : 0;\r\n                    if (sticky === 1) {\r\n                        const isOdd = (items.length - layoutIndexOffset + i) % 2 != 0,\r\n                            measures: IRenderVirtualListItemMeasures = {\r\n                                x,\r\n                                y,\r\n                                transformedX: x,\r\n                                transformedY: y,\r\n                                z: 0,\r\n                                rotationX: 0,\r\n                                rotationY: 0,\r\n                                rotationZ: 0,\r\n                                scaleX: 1,\r\n                                scaleY: 1,\r\n                                scaleZ: 1,\r\n                                width: isVertical ? normalizedItemWidth : size,\r\n                                height: isVertical ? size : normalizedItemHeight,\r\n                                minWidth: minItemSize,\r\n                                minHeight: minItemSize,\r\n                                maxWidth: maxItemSize,\r\n                                maxHeight: maxItemSize,\r\n                                size,\r\n                                row: {\r\n                                    size,\r\n                                    odd: rowIndex % 2 != 0,\r\n                                    even: rowIndex % 2 == 0,\r\n                                },\r\n                                position: pos,\r\n                                boundsSize,\r\n                                scrollSize,\r\n                                absoluteStartPosition,\r\n                                absoluteStartPositionPercent,\r\n                                absoluteEndPosition,\r\n                                absoluteEndPositionPercent,\r\n                                scrollDirection,\r\n                                delta: sticky === 1 ? this._scrollStartOffset : sticky === 2 ? actualEndSnippedPosition - deltaOffet - size : 0,\r\n                            }, config: IRenderVirtualListItemConfig = {\r\n                                fullSize: true,\r\n                                isFirst: i === layoutIndexOffset,\r\n                                isLast: i === li,\r\n                                new: (cache as Cache)?.[IS_NEW] === true,\r\n                                odd: isOdd,\r\n                                even: !isOdd,\r\n                                isVertical,\r\n                                collapsable,\r\n                                selectable,\r\n                                sticky,\r\n                                snap: stickyEnabled,\r\n                                snapped: true,\r\n                                snappedOut: false,\r\n                                dynamic: dynamicSize,\r\n                                isSnappingMethodAdvanced,\r\n                                layoutOffset,\r\n                                layoutIndexOffset,\r\n                                totalItems: items.length,\r\n                                snapToItem,\r\n                                snapToItemAlign,\r\n                                tabIndex: i - layoutIndexOffset,\r\n                                divides,\r\n                                opacity: 1,\r\n                                zIndex: Z_INDEX_1,\r\n                            };\r\n\r\n                        const itemData: I = collectionItem;\r\n\r\n                        stickyItem = {\r\n                            index: i, id, measures, data: itemData, previouseData: i > 0 ? items[i - 1] : null,\r\n                            nextData: i < totalLength ? items[i + 1] : null, config,\r\n                        };\r\n                        stickyItemIndex = i;\r\n                        stickyItemSize = size;\r\n\r\n                        displayItems.push(stickyItem);\r\n                        break;\r\n                    }\r\n                }\r\n            }\r\n\r\n            if (stickyEnabled) {\r\n                const si = itemsFromStartToScrollEnd + itemsOnDisplayLength - 1, startIndex = si < 0 ? si : si;\r\n                for (let i = Math.min(startIndex, totalLength > 0 ? totalLength - 1 : 0),\r\n                    rowIndex = Math.floor(((items.length - layoutIndexOffset + i) + 1) / divides),\r\n                    l = totalLength; i < l; i++) {\r\n                    const collectionItem = items[i],\r\n                        isDummy = collectionItem?.[SERVICE_PROP_DUMMY] && (collectionItem?.[SERVICE_PROP_DUMMY] === SERVICE_PROP_DUMMY_ENABLED);\r\n                    if (!collectionItem || isDummy) {\r\n                        continue;\r\n                    }\r\n                    const id = collectionItem[trackBy], cache = this.get(id)!, sticky = itemConfigMap[id]?.sticky ?? 0,\r\n                        selectable = itemConfigMap[id]?.selectable ?? true,\r\n                        collapsable = itemConfigMap[id]?.collapsable ?? false,\r\n                        size = dynamicSize\r\n                            ? cache?.[sizeProperty] || typicalItemSize\r\n                            : typicalItemSize;\r\n                    if (sticky === 2) {\r\n                        const isOdd = (items.length - layoutIndexOffset + i) % 2 != 0,\r\n                            w = isVertical ? normalizedItemWidth : size, h = isVertical ? size : normalizedItemHeight,\r\n                            absoluteStartPosition = pos - (scrollSize - size) - size, ratio = size !== 0 ? boundsSize / size : 0, absoluteStartPositionPercent = -(boundsSize !== 0 ? absoluteStartPosition / boundsSize : 0) * ratio,\r\n                            absoluteEndPosition = boundsSize - (absoluteStartPositionPercent + size),\r\n                            absoluteEndPositionPercent = (absoluteStartPositionPercent + (boundsSize !== 0 ? (absoluteEndPosition + size) / boundsSize : 0) * ratio),\r\n                            x = isVertical ? 0 : actualEndSnippedPosition - w,\r\n                            y = isVertical ? actualEndSnippedPosition - h : 0,\r\n                            measures: IRenderVirtualListItemMeasures = {\r\n                                x,\r\n                                y,\r\n                                transformedX: x,\r\n                                transformedY: y,\r\n                                z: 0,\r\n                                rotationX: 0,\r\n                                rotationY: 0,\r\n                                rotationZ: 0,\r\n                                scaleX: 1,\r\n                                scaleY: 1,\r\n                                scaleZ: 1,\r\n                                size,\r\n                                row: {\r\n                                    size,\r\n                                    odd: rowIndex % 2 != 0,\r\n                                    even: rowIndex % 2 == 0,\r\n                                },\r\n                                position: pos,\r\n                                boundsSize,\r\n                                scrollSize,\r\n                                absoluteStartPosition,\r\n                                absoluteStartPositionPercent,\r\n                                absoluteEndPosition,\r\n                                absoluteEndPositionPercent,\r\n                                width: w,\r\n                                height: h,\r\n                                minWidth: minItemSize,\r\n                                minHeight: minItemSize,\r\n                                maxWidth: maxItemSize,\r\n                                maxHeight: maxItemSize,\r\n                                scrollDirection,\r\n                                delta: actualEndSnippedPosition - deltaOffet - size,\r\n                            }, config: IRenderVirtualListItemConfig = {\r\n                                fullSize: true,\r\n                                isFirst: i === layoutIndexOffset,\r\n                                isLast: i === li,\r\n                                new: (cache as Cache)?.[IS_NEW] === true,\r\n                                odd: isOdd,\r\n                                even: !isOdd,\r\n                                isVertical,\r\n                                collapsable,\r\n                                selectable,\r\n                                sticky,\r\n                                snap: stickyEnabled,\r\n                                snapped: true,\r\n                                snappedOut: false,\r\n                                dynamic: dynamicSize,\r\n                                isSnappingMethodAdvanced,\r\n                                layoutOffset,\r\n                                layoutIndexOffset,\r\n                                totalItems: items.length,\r\n                                snapToItem,\r\n                                snapToItemAlign,\r\n                                tabIndex: i - layoutIndexOffset,\r\n                                divides,\r\n                                opacity: 1,\r\n                                zIndex: Z_INDEX_1,\r\n                            };\r\n\r\n                        const itemData: I = collectionItem;\r\n\r\n                        endStickyItem = {\r\n                            index: i, id, measures, data: itemData, previouseData: i > 0 ? items[i - 1] : null,\r\n                            nextData: i < totalLength ? items[i + 1] : null, config,\r\n                        };\r\n                        endStickyItemIndex = i;\r\n                        endStickyItemSize = size;\r\n\r\n                        displayItems.push(endStickyItem);\r\n                        break;\r\n                    }\r\n                }\r\n            }\r\n\r\n            const collectionLength = items.length;\r\n            let i = startIndex,\r\n                ci = 0,\r\n                row: {\r\n                    size: number;\r\n                    odd: boolean;\r\n                    even: boolean;\r\n                } = {\r\n                    size: 0,\r\n                    odd: false,\r\n                    even: false,\r\n                };\r\n            while (renderItems > 0) {\r\n                if (i >= collectionLength) {\r\n                    break;\r\n                }\r\n                const collectionItem = items[i];\r\n                if (!collectionItem) {\r\n                    break;\r\n                }\r\n\r\n                const isDummy = collectionItem?.[SERVICE_PROP_DUMMY] && (collectionItem?.[SERVICE_PROP_DUMMY] === SERVICE_PROP_DUMMY_ENABLED),\r\n                    ii = i + 1,\r\n                    rowIndex = Math.floor(((items.length - layoutIndexOffset + i) + 1) / divides),\r\n                    id = collectionItem[trackBy],\r\n                    cache = this.get(id)!,\r\n                    size = isDummy ? typicalItemSize : (dynamicSize ? cache?.[sizeProperty] || typicalItemSize : typicalItemSize),\r\n                    divSize = (isVertical ? normalizedItemWidth : normalizedItemHeight) / divides;\r\n\r\n                if (i % divides === 0) {\r\n                    ci = 0;\r\n                    row = {\r\n                        size,\r\n                        odd: rowIndex % 2 !== 0,\r\n                        even: rowIndex % 2 === 0,\r\n                    };\r\n                } else {\r\n                    row.size = Math.max(row.size, size);\r\n                    ci++;\r\n                }\r\n\r\n                if (!isDummy) {\r\n                    if ((isSnappingMethodAdvanced || id !== stickyItem?.id) && id !== endStickyItem?.id) {\r\n                        const isOdd = (items.length - layoutIndexOffset + i) % 2 != 0,\r\n                            sticky = itemConfigMap[id]?.sticky ?? 0,\r\n                            fullSize = itemConfigMap[id]?.fullSize ?? false,\r\n                            selectable = itemConfigMap[id]?.selectable ?? true,\r\n                            collapsable = itemConfigMap[id]?.collapsable ?? false,\r\n                            snapped = stickyEnabled && ((sticky === 1 && (pos <= scrollSize + this._scrollStartOffset)) || (sticky === 2 && (pos >= scrollSize + boundsSize - size))),\r\n                            absoluteStartPosition = pos - scrollSize, ratio = size !== 0 ? boundsSize / size : 0, absoluteStartPositionPercent = -(boundsSize !== 0 ? absoluteStartPosition / boundsSize : 0) * ratio,\r\n                            absoluteEndPosition = boundsSize - (absoluteStartPositionPercent + size),\r\n                            absoluteEndPositionPercent = (absoluteStartPositionPercent + (boundsSize !== 0 ? (absoluteEndPosition + size) / boundsSize : 0) * ratio),\r\n                            x = isVertical ? divSize * ((sticky || fullSize) ? 0 : ci) : pos,\r\n                            y = isVertical ? pos : divSize * ((sticky || fullSize) ? 0 : ci),\r\n                            measures: IRenderVirtualListItemMeasures = {\r\n                                x,\r\n                                y,\r\n                                transformedX: x,\r\n                                transformedY: y,\r\n                                z: 0,\r\n                                rotationX: 0,\r\n                                rotationY: 0,\r\n                                rotationZ: 0,\r\n                                scaleX: 1,\r\n                                scaleY: 1,\r\n                                scaleZ: 1,\r\n                                size,\r\n                                row,\r\n                                position: pos,\r\n                                boundsSize,\r\n                                scrollSize,\r\n                                absoluteStartPosition,\r\n                                absoluteStartPositionPercent,\r\n                                absoluteEndPosition,\r\n                                absoluteEndPositionPercent,\r\n                                width: isVertical ? ((sticky || fullSize) ? normalizedItemWidth : (normalizedItemWidth / divides)) : size,\r\n                                height: isVertical ? size : ((sticky || fullSize) ? normalizedItemHeight : (normalizedItemHeight / divides)),\r\n                                minWidth: minItemSize,\r\n                                minHeight: minItemSize,\r\n                                maxWidth: maxItemSize,\r\n                                maxHeight: maxItemSize,\r\n                                scrollDirection,\r\n                                delta: sticky === 1 ? actualSnippedPosition : (sticky === 2 ? (actualEndSnippedPosition - deltaOffet - size) : 0),\r\n                            }, config: IRenderVirtualListItemConfig = {\r\n                                isFirst: i === layoutIndexOffset,\r\n                                isLast: i === li,\r\n                                new: (cache as Cache)?.[IS_NEW] === true,\r\n                                odd: isOdd,\r\n                                even: !isOdd,\r\n                                isVertical,\r\n                                collapsable,\r\n                                selectable,\r\n                                sticky,\r\n                                snap: stickyEnabled,\r\n                                snapped: false,\r\n                                snappedOut: false,\r\n                                dynamic: dynamicSize,\r\n                                isSnappingMethodAdvanced,\r\n                                layoutOffset,\r\n                                layoutIndexOffset,\r\n                                totalItems: items.length,\r\n                                snapToItem,\r\n                                snapToItemAlign,\r\n                                tabIndex: i - layoutIndexOffset,\r\n                                isStub: (isSnappingMethodAdvanced && id === stickyItem?.id),\r\n                                divides,\r\n                                opacity: 1,\r\n                                zIndex: Z_INDEX_0,\r\n                                fullSize,\r\n                            };\r\n\r\n                        if (snapped) {\r\n                            config.zIndex = Z_INDEX_2;\r\n                        }\r\n\r\n                        const itemData: I = collectionItem;\r\n\r\n                        const item: IRenderVirtualListItem = {\r\n                            index: i, id, measures, data: itemData, previouseData: i > 0 ? items[i - 1] : null,\r\n                            nextData: i < totalLength ? items[i + 1] : null, config,\r\n                        };\r\n                        if (!nextSticky && stickyItemIndex < i && sticky === 1 && (pos <= scrollSize + this._scrollStartOffset + size + stickyItemSize)) {\r\n                            item.measures.x = isVertical ? 0 : snapped ? actualSnippedPosition : pos;\r\n                            item.measures.y = isVertical ? snapped ? actualSnippedPosition : pos : 0;\r\n                            nextSticky = item;\r\n                            nextSticky.config.snapped = snapped;\r\n                            nextSticky.measures.delta = (isVertical ? item.measures.y : item.measures.x) - scrollSize;\r\n                            nextSticky.config.zIndex = Z_INDEX_3;\r\n                        }\r\n                        if (!nextEndSticky && endStickyItemIndex > i && sticky === 2 &&\r\n                            (pos >= actualEndSnippedPosition - size - endStickyItemSize)) {\r\n                            item.measures.x = isVertical ? 0 : snapped ? actualEndSnippedPosition - size : pos;\r\n                            item.measures.y = isVertical ? snapped ? actualEndSnippedPosition - size : pos : 0;\r\n                            nextEndSticky = item;\r\n                            nextEndSticky.config.zIndex = Z_INDEX_3;\r\n                            nextEndSticky.config.snapped = snapped;\r\n                            nextEndSticky.measures.delta = (isVertical ? item.measures.y : item.measures.x) - scrollSize;\r\n                        }\r\n\r\n                        displayItems.push(item);\r\n                    }\r\n                }\r\n\r\n                renderItems--;\r\n\r\n                if (ii % divides === 0 || renderItems <= 0) {\r\n                    pos += row.size;\r\n                }\r\n                i++;\r\n            }\r\n\r\n            const axis = isVertical ? Y_PROP_NAME : X_PROP_NAME;\r\n\r\n            if (!!nextSticky && !!stickyItem && nextSticky.measures[axis] <= actualSnippedPosition + stickyItem.measures[sizeProperty]) {\r\n                if (nextSticky.measures[axis] > actualSnippedPosition) {\r\n                    stickyItem.measures[axis] = nextSticky.measures[axis] - stickyItem.measures[sizeProperty];\r\n                    stickyItem.config.snapped = nextSticky.config.snapped = false;\r\n                    stickyItem.config.snappedOut = true;\r\n                    stickyItem.config.sticky = 1;\r\n                    stickyItem.measures.delta = (isVertical ? stickyItem.measures.y : stickyItem.measures.x) - scrollSize;\r\n                } else {\r\n                    nextSticky.config.snapped = true;\r\n                    nextSticky.measures.delta = (isVertical ? nextSticky.measures.y : nextSticky.measures.x) - scrollSize;\r\n                    stickyItem.measures[axis] = nextSticky.measures[axis] - stickyItem.measures[sizeProperty];\r\n                    stickyItem.measures.delta = (isVertical ? stickyItem.measures.y : stickyItem.measures.x) - scrollSize;\r\n                }\r\n            }\r\n\r\n            if (!!nextEndSticky && !!endStickyItem &&\r\n                (nextEndSticky.measures[axis] >= actualEndSnippedPosition - endStickyItemSize - nextEndSticky.measures[sizeProperty])) {\r\n                if (nextEndSticky.measures[axis] < actualEndSnippedPosition - nextEndSticky.measures[sizeProperty]) {\r\n                    endStickyItem.measures[axis] = nextEndSticky.measures[axis] + nextEndSticky.measures[sizeProperty];\r\n                    endStickyItem.config.snapped = nextEndSticky.config.snapped = false;\r\n                    endStickyItem.config.snappedOut = true;\r\n                    endStickyItem.config.sticky = 2;\r\n                    endStickyItem.measures.delta = (isVertical ? endStickyItem.measures.y : endStickyItem.measures.x) - scrollSize;\r\n                } else {\r\n                    nextEndSticky.config.snapped = true;\r\n                    nextEndSticky.measures[axis] = actualEndSnippedPosition - nextEndSticky.measures[sizeProperty];\r\n                    nextEndSticky.measures.delta = (isVertical ? nextEndSticky.measures.y : nextEndSticky.measures.x) - scrollSize;\r\n                    endStickyItem.measures[axis] = nextEndSticky.measures[axis] + nextEndSticky.measures[sizeProperty];\r\n                    endStickyItem.measures.delta = (isVertical ? endStickyItem.measures.y : endStickyItem.measures.x) - scrollSize;\r\n                }\r\n            }\r\n\r\n            if (itemTransform !== null) {\r\n                for (let i = 0, l = displayItems.length; i < l; i++) {\r\n                    const item = displayItems[i];\r\n                    if (!!item) {\r\n                        const transformation = itemTransform(item.index, objectAsReadonly(item.measures), objectAsReadonly(item.config));\r\n                        item.measures.transformedX = transformation.x;\r\n                        item.measures.transformedY = transformation.y;\r\n                        item.measures.z = transformation.z;\r\n                        item.measures.rotationX = transformation.rotationX;\r\n                        item.measures.rotationY = transformation.rotationY;\r\n                        item.measures.rotationZ = transformation.rotationZ;\r\n                        item.measures.scaleX = transformation.scaleX;\r\n                        item.measures.scaleY = transformation.scaleY;\r\n                        item.measures.scaleZ = transformation.scaleZ;\r\n                        item.config.opacity = transformation.opacity;\r\n                        item.config.filter = transformation.filter;\r\n                        item.config.blendColor = transformation.blendColor;\r\n                        item.config.zIndex = String(transformation.zIndex);\r\n                    }\r\n                }\r\n            }\r\n        }\r\n        return displayItems;\r\n    }\r\n\r\n    resetPositions() {\r\n        this._tracker.clearTrackMap();\r\n\r\n        this.track();\r\n    }\r\n\r\n    /**\r\n     * tracking by propName\r\n     */\r\n    track(): void {\r\n        if (!this._items || !this._displayComponents) {\r\n            return;\r\n        }\r\n\r\n        this._tracker.track(this._items, this._displayComponents, this._snappedDisplayComponents, this._scrollDirection, this._trackBy);\r\n    }\r\n\r\n    setDisplayObjectIndexMapById(v: { [id: number]: number }): void {\r\n        this._tracker.displayObjectIndexMapById = v;\r\n    }\r\n\r\n    untrackComponentByIdProperty(component?: C | undefined) {\r\n        this._tracker.untrackComponentByIdProperty(component);\r\n    }\r\n\r\n    getItemBounds(id: Id): ISize | null {\r\n        if (this.has(id)) {\r\n            return this.get(id) ?? null;\r\n        }\r\n        return null;\r\n    }\r\n\r\n    getComponentBoundsByIntersectionPosition(position: number, maxPosition: number | null = null): (IRect & { id: Id | null; isFirst: boolean; isLast: boolean; }) | null {\r\n        const components = this._displayComponents;\r\n        let first: (IRect & { id: Id | null; isFirst: boolean; isLast: boolean; }) | null = null,\r\n            last: (IRect & { id: Id | null; isFirst: boolean; isLast: boolean; }) | null = null;\r\n        if (!!components) {\r\n            for (const comp of components) {\r\n                const id = comp.instance.itemId ?? null, isVertical = comp.instance.item?.config?.isVertical,\r\n                    x = comp.instance.item?.measures?.x ?? 0,\r\n                    y = comp.instance.item?.measures?.y ?? 0,\r\n                    isFirst = comp.instance.item?.config?.isFirst ?? false,\r\n                    isLast = comp.instance.item?.config?.isLast ?? false,\r\n                    { width, height } = comp.instance.getBounds(),\r\n                    pos = position;\r\n                if (isVertical && (pos >= y && pos < y + height)) {\r\n                    return { id, x, y, width, height, isFirst, isLast };\r\n                } else if (!isVertical && (pos >= x && pos < x + width)) {\r\n                    return { id, x, y, width, height, isFirst, isLast };\r\n                }\r\n                if (isFirst) {\r\n                    first = { id, x, y, width, height, isFirst, isLast };\r\n                } else if (isLast) {\r\n                    last = { id, x, y, width, height, isFirst, isLast };\r\n                }\r\n            }\r\n        }\r\n        if (position < 0) {\r\n            return first;\r\n        }\r\n        if (maxPosition !== null && position > maxPosition) {\r\n            return last;\r\n        }\r\n        return null;\r\n    }\r\n    private _debouncedIsScrollStartOff = debounce(() => {\r\n        this._isScrollStart = false;\r\n    });\r\n\r\n    protected cacheElements(isVertical: boolean, itemSize: number): void {\r\n        if (!this._displayComponents) {\r\n            return;\r\n        }\r\n\r\n        for (let i = 0, l = this._displayComponents.length; i < l; i++) {\r\n            const component = this._displayComponents[i], itemId = component.instance.itemId;\r\n            if (itemId === undefined) {\r\n                continue;\r\n            }\r\n            const bounds = component.instance.getBounds();\r\n            this.set(itemId, {\r\n                ...this.get(itemId), ...bounds,\r\n                width: bounds.width || (isVertical ? 0 : itemSize),\r\n                height: bounds.height || (isVertical ? itemSize : 0),\r\n            });\r\n            if (this._isLazy && (this._isScrollStart)) {\r\n                this._debouncedIsScrollStartOff.execute();\r\n            }\r\n        }\r\n        const cache = this._prerenderedCache;\r\n        if (!!cache) {\r\n            for (const id in cache) {\r\n                const cacheItem = cache[id];\r\n                this.set(id, { ...(this.get(id) || {}), ...cacheItem });\r\n            }\r\n            this._prerenderedCache = null;\r\n        }\r\n    }\r\n\r\n    resetCacheChunkInfo(): void {\r\n        this._newItems = [];\r\n    }\r\n\r\n    cacheClean() {\r\n        this._map.clear();\r\n        this._snapshot.clear();\r\n    }\r\n\r\n    override dispose() {\r\n        super.dispose();\r\n\r\n        this.disposeClearBufferSizeTimer();\r\n\r\n        if (!!this._debouncedIsScrollStartOff) {\r\n            this._debouncedIsScrollStartOff.dispose();\r\n        }\r\n\r\n        if (!!this._tracker) {\r\n            this._tracker.dispose();\r\n        }\r\n    }\r\n}\r\n"]}