ng-virtual-list 14.4.2 → 14.4.4

package/esm2022/lib/utils/trackBox.mjs

@@ -0,0 +1,762 @@
+import { CacheMap } from "./cacheMap";
+import { Tracker } from "./tracker";
+import { HEIGHT_PROP_NAME, TRACK_BY_PROPERTY_NAME, WIDTH_PROP_NAME, X_PROP_NAME, Y_PROP_NAME } from "../const";
+import { bufferInterpolation } from "./buffer-interpolation";
+export const TRACK_BOX_CHANGE_EVENT_NAME = 'change';
+export var ItemDisplayMethods;
+(function (ItemDisplayMethods) {
+    ItemDisplayMethods[ItemDisplayMethods["CREATE"] = 0] = "CREATE";
+    ItemDisplayMethods[ItemDisplayMethods["UPDATE"] = 1] = "UPDATE";
+    ItemDisplayMethods[ItemDisplayMethods["DELETE"] = 2] = "DELETE";
+    ItemDisplayMethods[ItemDisplayMethods["NOT_CHANGED"] = 3] = "NOT_CHANGED";
+})(ItemDisplayMethods || (ItemDisplayMethods = {}));
+const DEFAULT_BUFFER_EXTREMUM_THRESHOLD = 15, DEFAULT_MAX_BUFFER_SEQUENCE_LENGTH = 30, DEFAULT_RESET_BUFFER_SIZE_TIMEOUT = 10000;
+/**
+ * An object that performs tracking, calculations and caching.
+ * @link https://github.com/DjonnyX/ng-virtual-list/blob/18.x/projects/ng-virtual-list/src/lib/utils/trackBox.ts
+ * @author Evgenii Grebennikov
+ * @email djonnyx@gmail.com
+ */
+export class TrackBox extends CacheMap {
+    _tracker;
+    _items;
+    set items(v) {
+        if (this._items === v) {
+            return;
+        }
+        this._items = v;
+    }
+    _displayComponents;
+    set displayComponents(v) {
+        if (this._displayComponents === v) {
+            return;
+        }
+        this._displayComponents = v;
+    }
+    _snapedDisplayComponent;
+    set snapedDisplayComponent(v) {
+        if (this._snapedDisplayComponent === v) {
+            return;
+        }
+        this._snapedDisplayComponent = v;
+    }
+    _isSnappingMethodAdvanced = false;
+    set isSnappingMethodAdvanced(v) {
+        if (this._isSnappingMethodAdvanced === v) {
+            return;
+        }
+        this._isSnappingMethodAdvanced = v;
+    }
+    /**
+     * Set the trackBy property
+     */
+    set trackingPropertyName(v) {
+        this._trackingPropertyName = this._tracker.trackingPropertyName = v;
+    }
+    _trackingPropertyName = TRACK_BY_PROPERTY_NAME;
+    constructor(trackingPropertyName) {
+        super();
+        this._trackingPropertyName = trackingPropertyName;
+        this.initialize();
+    }
+    initialize() {
+        this._tracker = new Tracker(this._trackingPropertyName);
+    }
+    set(id, bounds) {
+        if (this._map.has(id)) {
+            const b = this._map.get(id);
+            if (b?.width === bounds.width && b.height === bounds.height) {
+                return this._map;
+            }
+        }
+        const v = this._map.set(id, bounds);
+        this.bumpVersion();
+        return v;
+    }
+    _previousCollection;
+    _deletedItemsMap = {};
+    _crudDetected = false;
+    get crudDetected() { return this._crudDetected; }
+    fireChangeIfNeed() {
+        if (this.changesDetected()) {
+            this.dispatch(TRACK_BOX_CHANGE_EVENT_NAME, this._version);
+        }
+    }
+    _previousTotalSize = 0;
+    _scrollDelta = 0;
+    get scrollDelta() { return this._scrollDelta; }
+    isAdaptiveBuffer = true;
+    _bufferSequenceExtraThreshold = DEFAULT_BUFFER_EXTREMUM_THRESHOLD;
+    _maxBufferSequenceLength = DEFAULT_MAX_BUFFER_SEQUENCE_LENGTH;
+    _bufferSizeSequence = [];
+    _bufferSize = 0;
+    get bufferSize() { return this._bufferSize; }
+    _defaultBufferSize = 0;
+    _maxBufferSize = this._defaultBufferSize;
+    _resetBufferSizeTimeout = DEFAULT_RESET_BUFFER_SIZE_TIMEOUT;
+    _resetBufferSizeTimer;
+    lifeCircle() {
+        this.fireChangeIfNeed();
+        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;
+        }
+        this.updateCache(this._previousCollection, currentCollection, itemSize);
+        this._previousCollection = currentCollection;
+    }
+    /**
+     * Update the cache of items from the list
+     */
+    updateCache(previousCollection, currentCollection, itemSize) {
+        let crudDetected = false;
+        if (!currentCollection || currentCollection.length === 0) {
+            if (previousCollection) {
+                // deleted
+                for (let i = 0, l = previousCollection.length; i < l; i++) {
+                    const item = previousCollection[i], id = item.id;
+                    crudDetected = true;
+                    if (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.id;
+                    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.id] = item;
+            }
+        }
+        const notChangedMap = {}, deletedMap = {}, deletedItemsMap = {}, updatedMap = {};
+        for (let i = 0, l = previousCollection.length; i < l; i++) {
+            const item = previousCollection[i], id = item.id;
+            if (item) {
+                if (collectionDict.hasOwnProperty(id)) {
+                    if (item === collectionDict[id]) {
+                        // not changed
+                        notChangedMap[item.id] = item;
+                        this._map.set(id, { ...(this._map.get(id) || { width: itemSize, height: itemSize }), method: ItemDisplayMethods.NOT_CHANGED });
+                        continue;
+                    }
+                    else {
+                        // updated
+                        crudDetected = true;
+                        updatedMap[item.id] = item;
+                        this._map.set(id, { ...(this._map.get(id) || { width: itemSize, height: itemSize }), method: ItemDisplayMethods.UPDATE });
+                        continue;
+                    }
+                }
+                // deleted
+                crudDetected = true;
+                deletedMap[item.id] = item;
+                deletedItemsMap[i] = this._map.get(item.id);
+                this._map.delete(id);
+            }
+        }
+        for (let i = 0, l = currentCollection.length; i < l; i++) {
+            const item = currentCollection[i], id = item.id;
+            if (item && !deletedMap.hasOwnProperty(id) && !updatedMap.hasOwnProperty(id) && !notChangedMap.hasOwnProperty(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, stickyMap, options) {
+        const opt = { fromItemId: id, stickyMap, ...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;
+    }
+    /**
+     * Updates the collection of display objects
+     */
+    updateCollection(items, stickyMap, options) {
+        const opt = { stickyMap, ...options }, crudDetected = this._crudDetected, deletedItemsMap = this._deletedItemsMap;
+        if (opt.dynamicSize) {
+            this.cacheElements();
+        }
+        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(items, stickyMap, { ...metrics, });
+        return { displayItems, totalSize: metrics.totalSize, delta: metrics.delta, crudDetected };
+    }
+    /**
+     * Finds the closest element in the collection by scrollSize
+     */
+    getNearestItem(scrollSize, items, itemSize, isVertical) {
+        return this.getElementFromStart(scrollSize, items, this._map, itemSize, isVertical);
+    }
+    _previousScrollSize = 0;
+    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(delta / metrics.typicalItemSize) * 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 position of an element based on the given scrollSize
+     */
+    getElementFromStart(scrollSize, collection, map, typicalItemSize, isVertical) {
+        const sizeProperty = isVertical ? HEIGHT_PROP_NAME : WIDTH_PROP_NAME;
+        let offset = 0;
+        for (let i = 0, l = collection.length; i < l; i++) {
+            const item = collection[i];
+            let itemSize = 0;
+            if (map.has(item.id)) {
+                const bounds = map.get(item.id);
+                itemSize = bounds ? bounds[sizeProperty] : typicalItemSize;
+            }
+            else {
+                itemSize = typicalItemSize;
+            }
+            if (offset > scrollSize) {
+                return item;
+            }
+            offset += itemSize;
+        }
+        return undefined;
+    }
+    /**
+     * Calculates the entry into the overscroll area and returns the number of overscroll elements
+     */
+    getElementNumToEnd(i, collection, map, typicalItemSize, size, isVertical, indexOffset = 0) {
+        const sizeProperty = isVertical ? HEIGHT_PROP_NAME : WIDTH_PROP_NAME;
+        let offset = 0, num = 0;
+        for (let j = collection.length - indexOffset - 1; j >= i; j--) {
+            const item = collection[j];
+            let itemSize = 0;
+            if (map.has(item.id)) {
+                const bounds = map.get(item.id);
+                itemSize = bounds ? bounds[sizeProperty] : typicalItemSize;
+            }
+            else {
+                itemSize = typicalItemSize;
+            }
+            offset += itemSize;
+            num++;
+            if (offset > size) {
+                return { num: 0, offset };
+            }
+        }
+        return { num, offset };
+    }
+    /**
+     * Calculates list metrics
+     */
+    recalculateMetrics(options) {
+        const { fromItemId, bounds, collection, dynamicSize, isVertical, itemSize, bufferSize: minBufferSize, scrollSize, snap, stickyMap, enabledBufferOptimization, previousTotalSize, crudDetected, deletedItemsMap } = options;
+        const 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, checkOverscrollItemsLimit = Math.ceil(size / typicalItemSize), snippedPos = Math.floor(scrollSize), leftItemsWeights = [], 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;
+                    break;
+                }
+                case -1: {
+                    leftItemsOffset = bufferSize;
+                    rightItemsOffset = 0;
+                    break;
+                }
+                case 0:
+                default: {
+                    leftItemsOffset = rightItemsOffset = bufferSize;
+                }
+            }
+        }
+        else {
+            leftItemsOffset = rightItemsOffset = bufferSize;
+        }
+        let itemsFromStartToScrollEnd = -1, itemsFromDisplayEndToOffsetEnd = 0, itemsFromStartToDisplayEnd = -1, leftItemLength = 0, rightItemLength = 0, leftItemsWeight = 0, rightItemsWeight = 0, leftHiddenItemsWeight = 0, totalItemsToDisplayEndWeight = 0, leftSizeOfAddedItems = 0, leftSizeOfUpdatedItems = 0, leftSizeOfDeletedItems = 0, itemById = undefined, itemByIdPos = 0, targetDisplayItemIndex = -1, isTargetInOverscroll = false, actualScrollSize = itemByIdPos, totalSize = 0, startIndex, isFromItemIdFound = false;
+        // If the list is dynamic or there are new elements in the collection, then it switches to the long algorithm.
+        if (dynamicSize) {
+            let y = 0, stickyCollectionItem = undefined, stickyComponentSize = 0;
+            for (let i = 0, l = collection.length; i < l; i++) {
+                const ii = i + 1, collectionItem = collection[i], id = collectionItem.id;
+                let componentSize = 0, componentSizeDelta = 0, itemDisplayMethod = ItemDisplayMethods.NOT_CHANGED;
+                if (map.has(id)) {
+                    const bounds = map.get(id) || { width: typicalItemSize, height: typicalItemSize };
+                    componentSize = bounds[sizeProperty];
+                    itemDisplayMethod = bounds?.method ?? ItemDisplayMethods.UPDATE;
+                    switch (itemDisplayMethod) {
+                        case ItemDisplayMethods.UPDATE: {
+                            const snapshotBounds = snapshot.get(id);
+                            const componentSnapshotSize = componentSize - (snapshotBounds ? snapshotBounds[sizeProperty] : typicalItemSize);
+                            componentSizeDelta = componentSnapshotSize;
+                            map.set(id, { ...bounds, method: ItemDisplayMethods.NOT_CHANGED });
+                            break;
+                        }
+                        case ItemDisplayMethods.CREATE: {
+                            componentSizeDelta = typicalItemSize;
+                            map.set(id, { ...bounds, method: ItemDisplayMethods.NOT_CHANGED });
+                            break;
+                        }
+                    }
+                }
+                if (deletedItemsMap.hasOwnProperty(i)) {
+                    const bounds = deletedItemsMap[i], size = bounds?.[sizeProperty] ?? typicalItemSize;
+                    if (y < scrollSize - size) {
+                        leftSizeOfDeletedItems += size;
+                    }
+                }
+                totalSize += componentSize;
+                if (isFromId) {
+                    if (itemById === undefined) {
+                        if (id !== fromItemId && stickyMap && stickyMap[id] === 1) {
+                            stickyComponentSize = componentSize;
+                            stickyCollectionItem = collectionItem;
+                        }
+                        if (id === fromItemId) {
+                            isFromItemIdFound = true;
+                            targetDisplayItemIndex = i;
+                            if (stickyCollectionItem && stickyMap) {
+                                const { num } = this.getElementNumToEnd(i, collection, map, typicalItemSize, size, isVertical);
+                                if (num > 0) {
+                                    isTargetInOverscroll = true;
+                                    y -= size - componentSize;
+                                }
+                                else {
+                                    if (stickyMap && !stickyMap[collectionItem.id] && y >= scrollSize && y < scrollSize + stickyComponentSize) {
+                                        const snappedY = scrollSize - stickyComponentSize;
+                                        leftHiddenItemsWeight -= (snappedY - y);
+                                        y = snappedY;
+                                    }
+                                    else {
+                                        y -= stickyComponentSize;
+                                        leftHiddenItemsWeight -= stickyComponentSize;
+                                    }
+                                }
+                            }
+                            itemById = collectionItem;
+                            itemByIdPos = y;
+                        }
+                        else {
+                            leftItemsWeights.push(componentSize);
+                            leftHiddenItemsWeight += componentSize;
+                            itemsFromStartToScrollEnd = ii;
+                        }
+                    }
+                }
+                else if (y <= scrollSize - componentSize) {
+                    leftItemsWeights.push(componentSize);
+                    leftHiddenItemsWeight += componentSize;
+                    itemsFromStartToScrollEnd = ii;
+                }
+                if (isFromId) {
+                    if (itemById === undefined || y < itemByIdPos + size + componentSize) {
+                        itemsFromStartToDisplayEnd = ii;
+                        totalItemsToDisplayEndWeight += componentSize;
+                        itemsFromDisplayEndToOffsetEnd = itemsFromStartToDisplayEnd + rightItemsOffset;
+                    }
+                }
+                else if (y <= scrollSize + size + componentSize) {
+                    itemsFromStartToDisplayEnd = ii;
+                    totalItemsToDisplayEndWeight += componentSize;
+                    itemsFromDisplayEndToOffsetEnd = itemsFromStartToDisplayEnd + rightItemsOffset;
+                    if (y <= scrollSize - componentSize) {
+                        switch (itemDisplayMethod) {
+                            case ItemDisplayMethods.CREATE: {
+                                leftSizeOfAddedItems += componentSizeDelta;
+                                break;
+                            }
+                            case ItemDisplayMethods.UPDATE: {
+                                leftSizeOfUpdatedItems += componentSizeDelta;
+                                break;
+                            }
+                            case ItemDisplayMethods.DELETE: {
+                                leftSizeOfDeletedItems += componentSizeDelta;
+                                break;
+                            }
+                        }
+                    }
+                }
+                else {
+                    if (i < itemsFromDisplayEndToOffsetEnd) {
+                        rightItemsWeight += componentSize;
+                    }
+                }
+                y += componentSize;
+            }
+            if (isTargetInOverscroll) {
+                const { num } = this.getElementNumToEnd(collection.length - (checkOverscrollItemsLimit < 0 ? 0 : collection.length - checkOverscrollItemsLimit), collection, map, typicalItemSize, size, isVertical, collection.length - (collection.length - (targetDisplayItemIndex + 1)));
+                if (num > 0) {
+                    itemsFromStartToScrollEnd -= num;
+                }
+            }
+            if (itemsFromStartToScrollEnd <= -1) {
+                itemsFromStartToScrollEnd = 0;
+            }
+            if (itemsFromStartToDisplayEnd <= -1) {
+                itemsFromStartToDisplayEnd = 0;
+            }
+            actualScrollSize = isFromId ? itemByIdPos : scrollSize;
+            leftItemsWeights.splice(0, leftItemsWeights.length - leftItemsOffset);
+            leftItemsWeights.forEach(v => {
+                leftItemsWeight += v;
+            });
+            leftItemLength = Math.min(itemsFromStartToScrollEnd, leftItemsOffset);
+            rightItemLength = itemsFromStartToDisplayEnd + rightItemsOffset > totalLength
+                ? totalLength - itemsFromStartToDisplayEnd : rightItemsOffset;
+        }
+        else 
+        // Buffer optimization does not work on fast linear algorithm
+        {
+            if (crudDetected) {
+                let y = 0;
+                for (let i = 0, l = collection.length; i < l; i++) {
+                    const collectionItem = collection[i], id = collectionItem.id;
+                    let componentSize = typicalItemSize, itemDisplayMethod = ItemDisplayMethods.NOT_CHANGED;
+                    if (map.has(id)) {
+                        const bounds = map.get(id);
+                        itemDisplayMethod = bounds?.method ?? ItemDisplayMethods.UPDATE;
+                        if (itemDisplayMethod === ItemDisplayMethods.CREATE) {
+                            map.set(id, { ...bounds, method: ItemDisplayMethods.NOT_CHANGED });
+                        }
+                    }
+                    if (deletedItemsMap.hasOwnProperty(i)) {
+                        const bounds = deletedItemsMap[i], size = bounds?.[sizeProperty] ?? typicalItemSize;
+                        if (y < scrollSize - size) {
+                            leftSizeOfDeletedItems += size;
+                        }
+                    }
+                    if (y < scrollSize - componentSize) {
+                        switch (itemDisplayMethod) {
+                            case ItemDisplayMethods.CREATE: {
+                                leftSizeOfUpdatedItems += componentSize;
+                                break;
+                            }
+                            case ItemDisplayMethods.UPDATE: {
+                                leftSizeOfUpdatedItems += componentSize;
+                                break;
+                            }
+                            case ItemDisplayMethods.DELETE: {
+                                leftSizeOfDeletedItems += componentSize;
+                                break;
+                            }
+                        }
+                    }
+                    y += componentSize;
+                }
+            }
+            itemsFromStartToScrollEnd = Math.floor(scrollSize / typicalItemSize);
+            itemsFromStartToDisplayEnd = Math.ceil((scrollSize + size) / typicalItemSize);
+            leftItemLength = Math.min(itemsFromStartToScrollEnd, bufferSize);
+            rightItemLength = itemsFromStartToDisplayEnd + bufferSize > totalLength
+                ? totalLength - itemsFromStartToDisplayEnd : bufferSize;
+            leftItemsWeight = leftItemLength * typicalItemSize;
+            rightItemsWeight = rightItemLength * typicalItemSize;
+            leftHiddenItemsWeight = itemsFromStartToScrollEnd * typicalItemSize;
+            totalItemsToDisplayEndWeight = itemsFromStartToDisplayEnd * typicalItemSize;
+            totalSize = totalLength * typicalItemSize;
+            const k = totalSize !== 0 ? previousTotalSize / totalSize : 0;
+            actualScrollSize = scrollSize * k;
+        }
+        startIndex = Math.min(itemsFromStartToScrollEnd - leftItemLength, totalLength > 0 ? totalLength - 1 : 0);
+        const itemsOnDisplayWeight = totalItemsToDisplayEndWeight - leftItemsWeight, itemsOnDisplayLength = itemsFromStartToDisplayEnd - itemsFromStartToScrollEnd, startPosition = leftHiddenItemsWeight - leftItemsWeight, renderItems = itemsOnDisplayLength + leftItemLength + rightItemLength, delta = leftSizeOfUpdatedItems + leftSizeOfAddedItems - leftSizeOfDeletedItems;
+        const metrics = {
+            delta,
+            normalizedItemWidth: w,
+            normalizedItemHeight: h,
+            width,
+            height,
+            dynamicSize,
+            itemSize,
+            itemsFromStartToScrollEnd,
+            itemsFromStartToDisplayEnd,
+            itemsOnDisplayWeight,
+            itemsOnDisplayLength,
+            isVertical,
+            leftHiddenItemsWeight,
+            leftItemLength,
+            leftItemsWeight,
+            renderItems,
+            rightItemLength,
+            rightItemsWeight,
+            scrollSize: actualScrollSize,
+            leftSizeOfAddedItems,
+            sizeProperty,
+            snap,
+            snippedPos,
+            startIndex,
+            startPosition,
+            totalItemsToDisplayEndWeight,
+            totalLength,
+            totalSize,
+            typicalItemSize,
+            isFromItemIdFound,
+        };
+        return metrics;
+    }
+    clearDeltaDirection() {
+        this.clearScrollDirectionCache();
+    }
+    clearDelta(clearDirectionDetector = false) {
+        this._delta = 0;
+        if (clearDirectionDetector) {
+            this.clearScrollDirectionCache();
+        }
+    }
+    changes() {
+        this.bumpVersion();
+    }
+    generateDisplayCollection(items, stickyMap, metrics) {
+        const { width, height, normalizedItemWidth, normalizedItemHeight, dynamicSize, itemsOnDisplayLength, itemsFromStartToScrollEnd, isVertical, renderItems: renderItemsLength, scrollSize, sizeProperty, snap, snippedPos, startPosition, totalLength, startIndex, typicalItemSize, } = metrics, displayItems = [];
+        if (items.length) {
+            const actualSnippedPosition = snippedPos, isSnappingMethodAdvanced = this.isSnappingMethodAdvanced, boundsSize = isVertical ? height : width, actualEndSnippedPosition = boundsSize;
+            let pos = startPosition, renderItems = renderItemsLength, stickyItem, nextSticky, stickyItemIndex = -1, stickyItemSize = 0, endStickyItem, nextEndSticky, endStickyItemIndex = -1, endStickyItemSize = 0;
+            if (snap) {
+                for (let i = Math.min(itemsFromStartToScrollEnd > 0 ? itemsFromStartToScrollEnd : 0, totalLength - 1); i >= 0; i--) {
+                    if (!items[i]) {
+                        continue;
+                    }
+                    const id = items[i].id, sticky = stickyMap[id], size = dynamicSize ? this.get(id)?.[sizeProperty] || typicalItemSize : typicalItemSize;
+                    if (sticky === 1) {
+                        const measures = {
+                            x: isVertical ? 0 : actualSnippedPosition,
+                            y: isVertical ? actualSnippedPosition : 0,
+                            width: isVertical ? normalizedItemWidth : size,
+                            height: isVertical ? size : normalizedItemHeight,
+                            delta: 0,
+                        }, config = {
+                            isVertical,
+                            sticky,
+                            snap,
+                            snapped: true,
+                            snappedOut: false,
+                            dynamic: dynamicSize,
+                            isSnappingMethodAdvanced,
+                            zIndex: '1',
+                        };
+                        const itemData = items[i];
+                        stickyItem = { id, measures, data: itemData, config };
+                        stickyItemIndex = i;
+                        stickyItemSize = size;
+                        displayItems.push(stickyItem);
+                        break;
+                    }
+                }
+            }
+            if (snap) {
+                const startIndex = itemsFromStartToScrollEnd + itemsOnDisplayLength - 1;
+                for (let i = Math.min(startIndex, totalLength > 0 ? totalLength - 1 : 0), l = totalLength; i < l; i++) {
+                    if (!items[i]) {
+                        continue;
+                    }
+                    const id = items[i].id, sticky = stickyMap[id], size = dynamicSize
+                        ? this.get(id)?.[sizeProperty] || typicalItemSize
+                        : typicalItemSize;
+                    if (sticky === 2) {
+                        const w = isVertical ? normalizedItemWidth : size, h = isVertical ? size : normalizedItemHeight, measures = {
+                            x: isVertical ? 0 : actualEndSnippedPosition - w,
+                            y: isVertical ? actualEndSnippedPosition - h : 0,
+                            width: w,
+                            height: h,
+                            delta: 0,
+                        }, config = {
+                            isVertical,
+                            sticky,
+                            snap,
+                            snapped: true,
+                            snappedOut: false,
+                            dynamic: dynamicSize,
+                            isSnappingMethodAdvanced,
+                            zIndex: '1',
+                        };
+                        const itemData = items[i];
+                        endStickyItem = { id, measures, data: itemData, config };
+                        endStickyItemIndex = i;
+                        endStickyItemSize = size;
+                        displayItems.push(endStickyItem);
+                        break;
+                    }
+                }
+            }
+            let i = startIndex;
+            while (renderItems > 0) {
+                if (i >= totalLength) {
+                    break;
+                }
+                if (!items[i]) {
+                    continue;
+                }
+                const id = items[i].id, size = dynamicSize ? this.get(id)?.[sizeProperty] || typicalItemSize : typicalItemSize;
+                if (id !== stickyItem?.id && id !== endStickyItem?.id) {
+                    const snapped = snap && (stickyMap[id] === 1 && pos <= scrollSize || stickyMap[id] === 2 && pos >= scrollSize + boundsSize - size), measures = {
+                        x: isVertical ? stickyMap[id] === 1 ? 0 : boundsSize - size : pos,
+                        y: isVertical ? pos : stickyMap[id] === 2 ? boundsSize - size : 0,
+                        width: isVertical ? normalizedItemWidth : size,
+                        height: isVertical ? size : normalizedItemHeight,
+                        delta: 0,
+                    }, config = {
+                        isVertical,
+                        sticky: stickyMap[id],
+                        snap,
+                        snapped: false,
+                        snappedOut: false,
+                        dynamic: dynamicSize,
+                        isSnappingMethodAdvanced,
+                        zIndex: '0',
+                    };
+                    if (snapped) {
+                        config.zIndex = '2';
+                    }
+                    const itemData = items[i];
+                    const item = { id, measures, data: itemData, config };
+                    if (!nextSticky && stickyItemIndex < i && stickyMap[id] === 1 && (pos <= scrollSize + 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 - scrollSize) : (item.measures.x - scrollSize);
+                        nextSticky.config.zIndex = '3';
+                    }
+                    else if (!nextEndSticky && endStickyItemIndex > i && stickyMap[id] === 2 && (pos >= scrollSize + boundsSize - 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 = '3';
+                        nextEndSticky.config.snapped = snapped;
+                        nextEndSticky.measures.delta = isVertical ? (item.measures.y - scrollSize) : (item.measures.x - scrollSize);
+                    }
+                    displayItems.push(item);
+                }
+                renderItems -= 1;
+                pos += size;
+                i++;
+            }
+            const axis = isVertical ? Y_PROP_NAME : X_PROP_NAME;
+            if (nextSticky && stickyItem && nextSticky.measures[axis] <= scrollSize + stickyItemSize) {
+                if (nextSticky.measures[axis] > scrollSize) {
+                    stickyItem.measures[axis] = nextSticky.measures[axis] - stickyItemSize;
+                    stickyItem.config.snapped = nextSticky.config.snapped = false;
+                    stickyItem.config.snappedOut = true;
+                    stickyItem.config.sticky = 1;
+                    stickyItem.measures.delta = isVertical ? stickyItem.measures.y - scrollSize : stickyItem.measures.x - scrollSize;
+                }
+                else {
+                    nextSticky.config.snapped = true;
+                    nextSticky.measures.delta = isVertical ? nextSticky.measures.y - scrollSize : nextSticky.measures.x - scrollSize;
+                }
+            }
+            if (nextEndSticky && endStickyItem && nextEndSticky.measures[axis] >= scrollSize + boundsSize - endStickyItemSize - nextEndSticky.measures[sizeProperty]) {
+                if (nextEndSticky.measures[axis] < scrollSize + boundsSize - endStickyItemSize) {
+                    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 - scrollSize : endStickyItem.measures.x - scrollSize;
+                }
+                else {
+                    nextEndSticky.config.snapped = true;
+                    nextEndSticky.measures.delta = isVertical ? nextEndSticky.measures.y - scrollSize : nextEndSticky.measures.x - scrollSize;
+                }
+            }
+        }
+        return displayItems;
+    }
+    /**
+     * tracking by propName
+     */
+    track() {
+        if (!this._items || !this._displayComponents) {
+            return;
+        }
+        this._tracker.track(this._items, this._displayComponents, this._snapedDisplayComponent, this.scrollDirection);
+    }
+    setDisplayObjectIndexMapById(v) {
+        this._tracker.displayObjectIndexMapById = v;
+    }
+    untrackComponentByIdProperty(component) {
+        this._tracker.untrackComponentByIdProperty(component);
+    }
+    getItemBounds(id) {
+        if (this.has(id)) {
+            return this.get(id);
+        }
+        return undefined;
+    }
+    cacheElements() {
+        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, bounds);
+        }
+    }
+    dispose() {
+        super.dispose();
+        this.disposeClearBufferSizeTimer();
+        if (this._tracker) {
+            this._tracker.dispose();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"trackBox.js","sourceRoot":"","sources":["../../../../../projects/ng-virtual-list/src/lib/utils/trackBox.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 { CacheMap, CMap } from \"./cacheMap\";\r\nimport { Tracker } from \"./tracker\";\r\nimport { ISize } from \"../types\";\r\nimport { HEIGHT_PROP_NAME, TRACK_BY_PROPERTY_NAME, WIDTH_PROP_NAME, X_PROP_NAME, Y_PROP_NAME } from \"../const\";\r\nimport { IVirtualListStickyMap } from \"../models\";\r\nimport { bufferInterpolation } from \"./buffer-interpolation\";\r\nimport { BaseVirtualListItemComponent } from \"../models/base-virtual-list-item-component\";\r\n\r\nexport const TRACK_BOX_CHANGE_EVENT_NAME = 'change';\r\n\r\nexport interface IMetrics {\r\n    delta: number;\r\n    normalizedItemWidth: number;\r\n    normalizedItemHeight: number;\r\n    width: number;\r\n    height: number;\r\n    dynamicSize: boolean;\r\n    itemSize: number;\r\n    itemsFromStartToScrollEnd: number;\r\n    itemsFromStartToDisplayEnd: number;\r\n    itemsOnDisplayWeight: number;\r\n    itemsOnDisplayLength: number;\r\n    isVertical: boolean;\r\n    leftHiddenItemsWeight: number;\r\n    leftItemLength: number;\r\n    leftItemsWeight: number;\r\n    renderItems: number;\r\n    rightItemLength: number;\r\n    rightItemsWeight: number;\r\n    scrollSize: number;\r\n    leftSizeOfAddedItems: number;\r\n    sizeProperty: typeof HEIGHT_PROP_NAME | typeof WIDTH_PROP_NAME;\r\n    snap: boolean;\r\n    snippedPos: number;\r\n    startIndex: number;\r\n    startPosition: number;\r\n    totalItemsToDisplayEndWeight: number;\r\n    totalLength: number;\r\n    totalSize: number;\r\n    typicalItemSize: number;\r\n    isFromItemIdFound: boolean;\r\n}\r\n\r\nexport interface IRecalculateMetricsOptions<I extends { id: Id }, C extends Array<I>> {\r\n    bounds: ISize;\r\n    collection: C;\r\n    isVertical: boolean;\r\n    itemSize: number;\r\n    bufferSize: number;\r\n    maxBufferSize: number;\r\n    dynamicSize: boolean;\r\n    scrollSize: number;\r\n    snap: boolean;\r\n    enabledBufferOptimization: boolean;\r\n    fromItemId?: Id;\r\n    previousTotalSize: number;\r\n    crudDetected: boolean;\r\n    deletedItemsMap: { [index: number]: ISize; };\r\n}\r\n\r\nexport interface IGetItemPositionOptions<I extends { id: Id }, C extends Array<I>>\r\n    extends Omit<IRecalculateMetricsOptions<I, C>, 'previousTotalSize' | 'crudDetected' | 'deletedItemsMap'> { }\r\n\r\nexport interface IUpdateCollectionOptions<I extends { id: Id }, C extends Array<I>>\r\n    extends Omit<IRecalculateMetricsOptions<I, C>, 'collection' | 'previousTotalSize' | 'crudDetected' | 'deletedItemsMap'> { }\r\n\r\nexport type CacheMapEvents = typeof TRACK_BOX_CHANGE_EVENT_NAME;\r\n\r\nexport type OnChangeEventListener = (version: number) => void;\r\n\r\nexport type CacheMapListeners = OnChangeEventListener;\r\n\r\nexport enum ItemDisplayMethods {\r\n    CREATE,\r\n    UPDATE,\r\n    DELETE,\r\n    NOT_CHANGED,\r\n}\r\n\r\nexport interface IUpdateCollectionReturns {\r\n    displayItems: IRenderVirtualListCollection;\r\n    totalSize: number;\r\n    delta: number;\r\n    crudDetected: boolean;\r\n}\r\n\r\nconst DEFAULT_BUFFER_EXTREMUM_THRESHOLD = 15,\r\n    DEFAULT_MAX_BUFFER_SEQUENCE_LENGTH = 30,\r\n    DEFAULT_RESET_BUFFER_SIZE_TIMEOUT = 10000;\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/18.x/projects/ng-virtual-list/src/lib/utils/trackBox.ts\r\n * @author Evgenii Grebennikov\r\n * @email djonnyx@gmail.com\r\n */\r\nexport class TrackBox<C extends BaseVirtualListItemComponent = any>\r\n    extends CacheMap<Id, ISize & { method?: ItemDisplayMethods }, 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 _snapedDisplayComponent: ComponentRef<C> | null | undefined;\r\n\r\n    set snapedDisplayComponent(v: ComponentRef<C> | null | undefined) {\r\n        if (this._snapedDisplayComponent === v) {\r\n            return;\r\n        }\r\n\r\n        this._snapedDisplayComponent = 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    /**\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    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, bounds: ISize): CMap<Id, ISize> {\r\n        if (this._map.has(id)) {\r\n            const b = this._map.get(id);\r\n            if (b?.width === bounds.width && b.height === bounds.height) {\r\n                return this._map;\r\n            }\r\n        }\r\n\r\n        const v = this._map.set(id, bounds);\r\n\r\n        this.bumpVersion();\r\n        return v;\r\n    }\r\n\r\n    protected _previousCollection: Array<{ id: Id; }> | 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(TRACK_BOX_CHANGE_EVENT_NAME, this._version);\r\n        }\r\n    }\r\n\r\n    protected _previousTotalSize = 0;\r\n\r\n    protected _scrollDelta: number = 0;\r\n    get scrollDelta() { return this._scrollDelta; }\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 override lifeCircle() {\r\n        this.fireChangeIfNeed();\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 { id: Id; }, C extends Array<I>>(currentCollection: C | null | undefined, itemSize: number): void {\r\n        if (currentCollection !== undefined && currentCollection !== null && currentCollection === this._previousCollection) {\r\n            console.warn('Attention! The collection must be immutable.');\r\n            return;\r\n        }\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 { id: Id; }, C extends Array<I>>(previousCollection: C | null | undefined, currentCollection: C | null | undefined,\r\n        itemSize: number): void {\r\n        let crudDetected = false;\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.id;\r\n                    crudDetected = true;\r\n                    if (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.id;\r\n                    this._map.set(id, { width: itemSize, height: itemSize, method: ItemDisplayMethods.CREATE });\r\n                }\r\n            }\r\n            return;\r\n        }\r\n        const collectionDict: { [id: Id]: 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.id] = item;\r\n            }\r\n        }\r\n        const notChangedMap: { [id: Id]: I } = {}, deletedMap: { [id: Id]: I } = {}, deletedItemsMap: { [index: number]: ISize } = {}, updatedMap: { [id: Id]: I } = {};\r\n        for (let i = 0, l = previousCollection.length; i < l; i++) {\r\n            const item = previousCollection[i], id = item.id;\r\n            if (item) {\r\n                if (collectionDict.hasOwnProperty(id)) {\r\n                    if (item === collectionDict[id]) {\r\n                        // not changed\r\n                        notChangedMap[item.id] = item;\r\n                        this._map.set(id, { ...(this._map.get(id) || { width: itemSize, height: itemSize }), method: ItemDisplayMethods.NOT_CHANGED });\r\n                        continue;\r\n                    } else {\r\n                        // updated\r\n                        crudDetected = true;\r\n                        updatedMap[item.id] = item;\r\n                        this._map.set(id, { ...(this._map.get(id) || { width: itemSize, height: itemSize }), method: ItemDisplayMethods.UPDATE });\r\n                        continue;\r\n                    }\r\n                }\r\n\r\n                // deleted\r\n                crudDetected = true;\r\n                deletedMap[item.id] = item;\r\n                deletedItemsMap[i] = this._map.get(item.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.id;\r\n            if (item && !deletedMap.hasOwnProperty(id) && !updatedMap.hasOwnProperty(id) && !notChangedMap.hasOwnProperty(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 { id: Id }, C extends Array<I>>(id: Id, stickyMap: IVirtualListStickyMap,\r\n        options: IGetItemPositionOptions<I, C>): number {\r\n        const opt = { fromItemId: id, stickyMap, ...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    /**\r\n     * Updates the collection of display objects\r\n     */\r\n    updateCollection<I extends { id: Id }, C extends Array<I>>(items: C, stickyMap: IVirtualListStickyMap,\r\n        options: IUpdateCollectionOptions<I, C>): IUpdateCollectionReturns {\r\n        const opt = { stickyMap, ...options }, crudDetected = this._crudDetected, deletedItemsMap = this._deletedItemsMap;\r\n        if (opt.dynamicSize) {\r\n            this.cacheElements();\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(items, stickyMap, { ...metrics, });\r\n        return { displayItems, totalSize: metrics.totalSize, delta: metrics.delta, crudDetected };\r\n    }\r\n\r\n    /**\r\n     * Finds the closest element in the collection by scrollSize\r\n     */\r\n    getNearestItem<I extends { id: Id }, C extends Array<I>>(scrollSize: number, items: C, itemSize: number, isVertical: boolean): I | undefined {\r\n        return this.getElementFromStart(scrollSize, items, this._map, itemSize, isVertical);\r\n    }\r\n\r\n    protected _previousScrollSize = 0;\r\n\r\n    protected updateAdaptiveBufferParams(metrics: IMetrics, 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(delta / metrics.typicalItemSize) * 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 position of an element based on the given scrollSize\r\n     */\r\n    protected getElementFromStart<I extends { id: Id }, C extends Array<I>>(scrollSize: number, collection: C, map: CMap<Id, ISize>, typicalItemSize: number,\r\n        isVertical: boolean): I | undefined {\r\n        const sizeProperty = isVertical ? HEIGHT_PROP_NAME : WIDTH_PROP_NAME;\r\n        let offset = 0;\r\n        for (let i = 0, l = collection.length; i < l; i++) {\r\n            const item = collection[i];\r\n            let itemSize = 0;\r\n            if (map.has(item.id)) {\r\n                const bounds = map.get(item.id);\r\n                itemSize = bounds ? bounds[sizeProperty] : typicalItemSize;\r\n            } else {\r\n                itemSize = typicalItemSize;\r\n            }\r\n            if (offset > scrollSize) {\r\n                return item;\r\n            }\r\n            offset += itemSize;\r\n        }\r\n        return undefined;\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 { id: Id }, C extends Array<I>>(i: number, collection: C, map: CMap<Id, ISize>, typicalItemSize: number,\r\n        size: number, isVertical: boolean, indexOffset: number = 0): { num: number, offset: number } {\r\n        const sizeProperty = isVertical ? HEIGHT_PROP_NAME : WIDTH_PROP_NAME;\r\n        let offset = 0, num = 0;\r\n        for (let j = collection.length - indexOffset - 1; j >= i; j--) {\r\n            const item = collection[j];\r\n            let itemSize = 0;\r\n            if (map.has(item.id)) {\r\n                const bounds = map.get(item.id);\r\n                itemSize = bounds ? bounds[sizeProperty] : typicalItemSize;\r\n            } else {\r\n                itemSize = typicalItemSize;\r\n            }\r\n            offset += itemSize;\r\n            num++;\r\n            if (offset > size) {\r\n                return { num: 0, offset };\r\n            }\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 { id: Id }, C extends Array<I>>(options: IRecalculateMetricsOptions<I, C>): IMetrics {\r\n        const { fromItemId, bounds, collection, dynamicSize, isVertical, itemSize,\r\n            bufferSize: minBufferSize, scrollSize, snap, stickyMap, enabledBufferOptimization,\r\n            previousTotalSize, crudDetected, deletedItemsMap } = options as IRecalculateMetricsOptions<I, C> & {\r\n                stickyMap: IVirtualListStickyMap,\r\n            };\r\n\r\n        const 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, checkOverscrollItemsLimit = Math.ceil(size / typicalItemSize),\r\n            snippedPos = Math.floor(scrollSize), leftItemsWeights: 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;\r\n                    break;\r\n                }\r\n                case -1: {\r\n                    leftItemsOffset = bufferSize;\r\n                    rightItemsOffset = 0;\r\n                    break;\r\n                }\r\n                case 0:\r\n                default: {\r\n                    leftItemsOffset = rightItemsOffset = bufferSize;\r\n                }\r\n            }\r\n        } else {\r\n            leftItemsOffset = rightItemsOffset = bufferSize;\r\n        }\r\n\r\n        let itemsFromStartToScrollEnd: number = -1, itemsFromDisplayEndToOffsetEnd = 0, itemsFromStartToDisplayEnd = -1,\r\n            leftItemLength = 0, rightItemLength = 0,\r\n            leftItemsWeight = 0, rightItemsWeight = 0,\r\n            leftHiddenItemsWeight = 0,\r\n            totalItemsToDisplayEndWeight = 0,\r\n            leftSizeOfAddedItems = 0,\r\n            leftSizeOfUpdatedItems = 0,\r\n            leftSizeOfDeletedItems = 0,\r\n            itemById: I | undefined = undefined,\r\n            itemByIdPos: number = 0,\r\n            targetDisplayItemIndex: number = -1,\r\n            isTargetInOverscroll: boolean = false,\r\n            actualScrollSize = itemByIdPos,\r\n            totalSize = 0,\r\n            startIndex: number,\r\n            isFromItemIdFound = false;\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            let y = 0, stickyCollectionItem: I | undefined = undefined, stickyComponentSize = 0;\r\n            for (let i = 0, l = collection.length; i < l; i++) {\r\n                const ii = i + 1, collectionItem = collection[i], id = collectionItem.id;\r\n\r\n                let componentSize = 0, componentSizeDelta = 0, itemDisplayMethod: ItemDisplayMethods = ItemDisplayMethods.NOT_CHANGED;\r\n                if (map.has(id)) {\r\n                    const bounds = map.get(id) || { width: typicalItemSize, height: typicalItemSize };\r\n                    componentSize = bounds[sizeProperty];\r\n                    itemDisplayMethod = bounds?.method ?? ItemDisplayMethods.UPDATE;\r\n                    switch (itemDisplayMethod) {\r\n                        case ItemDisplayMethods.UPDATE: {\r\n                            const snapshotBounds = snapshot.get(id);\r\n                            const componentSnapshotSize = componentSize - (snapshotBounds ? snapshotBounds[sizeProperty] : typicalItemSize);\r\n                            componentSizeDelta = componentSnapshotSize;\r\n                            map.set(id, { ...bounds, method: ItemDisplayMethods.NOT_CHANGED });\r\n                            break;\r\n                        }\r\n                        case ItemDisplayMethods.CREATE: {\r\n                            componentSizeDelta = typicalItemSize;\r\n                            map.set(id, { ...bounds, method: ItemDisplayMethods.NOT_CHANGED });\r\n                            break;\r\n                        }\r\n                    }\r\n                }\r\n\r\n                if (deletedItemsMap.hasOwnProperty(i)) {\r\n                    const bounds = deletedItemsMap[i], size = bounds?.[sizeProperty] ?? typicalItemSize;\r\n                    if (y < scrollSize - size) {\r\n                        leftSizeOfDeletedItems += size;\r\n                    }\r\n                }\r\n\r\n                totalSize += componentSize;\r\n\r\n                if (isFromId) {\r\n                    if (itemById === undefined) {\r\n                        if (id !== fromItemId && stickyMap && stickyMap[id] === 1) {\r\n                            stickyComponentSize = componentSize;\r\n                            stickyCollectionItem = collectionItem;\r\n                        }\r\n\r\n                        if (id === fromItemId) {\r\n                            isFromItemIdFound = true;\r\n                            targetDisplayItemIndex = i;\r\n                            if (stickyCollectionItem && stickyMap) {\r\n                                const { num } = this.getElementNumToEnd(i, collection, map, typicalItemSize, size, isVertical);\r\n                                if (num > 0) {\r\n                                    isTargetInOverscroll = true;\r\n                                    y -= size - componentSize;\r\n                                } else {\r\n                                    if (stickyMap && !stickyMap[collectionItem.id] && y >= scrollSize && y < scrollSize + stickyComponentSize) {\r\n                                        const snappedY = scrollSize - stickyComponentSize;\r\n                                        leftHiddenItemsWeight -= (snappedY - y);\r\n                                        y = snappedY;\r\n                                    } else {\r\n                                        y -= stickyComponentSize;\r\n                                        leftHiddenItemsWeight -= stickyComponentSize;\r\n                                    }\r\n                                }\r\n                            }\r\n                            itemById = collectionItem;\r\n                            itemByIdPos = y;\r\n                        } else {\r\n                            leftItemsWeights.push(componentSize);\r\n                            leftHiddenItemsWeight += componentSize;\r\n                            itemsFromStartToScrollEnd = ii;\r\n                        }\r\n                    }\r\n                } else if (y <= scrollSize - componentSize) {\r\n                    leftItemsWeights.push(componentSize);\r\n                    leftHiddenItemsWeight += componentSize;\r\n                    itemsFromStartToScrollEnd = ii;\r\n                }\r\n\r\n                if (isFromId) {\r\n                    if (itemById === undefined || y < itemByIdPos + size + componentSize) {\r\n                        itemsFromStartToDisplayEnd = ii;\r\n                        totalItemsToDisplayEndWeight += componentSize;\r\n                        itemsFromDisplayEndToOffsetEnd = itemsFromStartToDisplayEnd + rightItemsOffset;\r\n                    }\r\n                } else if (y <= scrollSize + size + componentSize) {\r\n                    itemsFromStartToDisplayEnd = ii;\r\n                    totalItemsToDisplayEndWeight += componentSize;\r\n                    itemsFromDisplayEndToOffsetEnd = itemsFromStartToDisplayEnd + rightItemsOffset;\r\n\r\n                    if (y <= scrollSize - componentSize) {\r\n                        switch (itemDisplayMethod) {\r\n                            case ItemDisplayMethods.CREATE: {\r\n                                leftSizeOfAddedItems += componentSizeDelta;\r\n                                break;\r\n                            }\r\n                            case ItemDisplayMethods.UPDATE: {\r\n                                leftSizeOfUpdatedItems += componentSizeDelta;\r\n                                break;\r\n                            }\r\n                            case ItemDisplayMethods.DELETE: {\r\n                                leftSizeOfDeletedItems += componentSizeDelta;\r\n                                break;\r\n                            }\r\n                        }\r\n                    }\r\n                } else {\r\n                    if (i < itemsFromDisplayEndToOffsetEnd) {\r\n                        rightItemsWeight += componentSize;\r\n                    }\r\n                }\r\n\r\n                y += componentSize;\r\n            }\r\n\r\n            if (isTargetInOverscroll) {\r\n                const { num } = this.getElementNumToEnd(\r\n                    collection.length - (checkOverscrollItemsLimit < 0 ? 0 : collection.length - checkOverscrollItemsLimit),\r\n                    collection, map, typicalItemSize, size, isVertical, collection.length - (collection.length - (targetDisplayItemIndex + 1)),\r\n                );\r\n                if (num > 0) {\r\n                    itemsFromStartToScrollEnd -= num;\r\n                }\r\n            }\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            actualScrollSize = isFromId ? itemByIdPos : scrollSize;\r\n\r\n            leftItemsWeights.splice(0, leftItemsWeights.length - leftItemsOffset);\r\n            leftItemsWeights.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        } else\r\n        // Buffer optimization does not work on fast linear algorithm\r\n        {\r\n            if (crudDetected) {\r\n                let y = 0;\r\n                for (let i = 0, l = collection.length; i < l; i++) {\r\n                    const collectionItem = collection[i], id = collectionItem.id;\r\n                    let componentSize = typicalItemSize, itemDisplayMethod: ItemDisplayMethods = ItemDisplayMethods.NOT_CHANGED;\r\n                    if (map.has(id)) {\r\n                        const bounds = map.get(id)!;\r\n                        itemDisplayMethod = bounds?.method ?? ItemDisplayMethods.UPDATE;\r\n                        if (itemDisplayMethod === ItemDisplayMethods.CREATE) {\r\n                            map.set(id, { ...bounds, method: ItemDisplayMethods.NOT_CHANGED });\r\n                        }\r\n                    }\r\n\r\n                    if (deletedItemsMap.hasOwnProperty(i)) {\r\n                        const bounds = deletedItemsMap[i], size = bounds?.[sizeProperty] ?? typicalItemSize;\r\n                        if (y < scrollSize - size) {\r\n                            leftSizeOfDeletedItems += size;\r\n                        }\r\n                    }\r\n\r\n                    if (y < scrollSize - componentSize) {\r\n                        switch (itemDisplayMethod) {\r\n                            case ItemDisplayMethods.CREATE: {\r\n                                leftSizeOfUpdatedItems += componentSize;\r\n                                break;\r\n                            }\r\n                            case ItemDisplayMethods.UPDATE: {\r\n                                leftSizeOfUpdatedItems += componentSize;\r\n                                break;\r\n                            }\r\n                            case ItemDisplayMethods.DELETE: {\r\n                                leftSizeOfDeletedItems += componentSize;\r\n                                break;\r\n                            }\r\n                        }\r\n                    }\r\n                    y += componentSize;\r\n                }\r\n            }\r\n            itemsFromStartToScrollEnd = Math.floor(scrollSize / typicalItemSize);\r\n            itemsFromStartToDisplayEnd = Math.ceil((scrollSize + size) / typicalItemSize);\r\n            leftItemLength = Math.min(itemsFromStartToScrollEnd, bufferSize);\r\n            rightItemLength = itemsFromStartToDisplayEnd + bufferSize > totalLength\r\n                ? totalLength - itemsFromStartToDisplayEnd : bufferSize;\r\n            leftItemsWeight = leftItemLength * typicalItemSize;\r\n            rightItemsWeight = rightItemLength * typicalItemSize;\r\n            leftHiddenItemsWeight = itemsFromStartToScrollEnd * typicalItemSize;\r\n            totalItemsToDisplayEndWeight = itemsFromStartToDisplayEnd * typicalItemSize;\r\n            totalSize = totalLength * typicalItemSize;\r\n\r\n            const k = totalSize !== 0 ? previousTotalSize / totalSize : 0;\r\n            actualScrollSize = scrollSize * k;\r\n        }\r\n        startIndex = Math.min(itemsFromStartToScrollEnd - leftItemLength, totalLength > 0 ? totalLength - 1 : 0);\r\n\r\n        const itemsOnDisplayWeight = totalItemsToDisplayEndWeight - leftItemsWeight,\r\n            itemsOnDisplayLength = itemsFromStartToDisplayEnd - itemsFromStartToScrollEnd,\r\n            startPosition = leftHiddenItemsWeight - leftItemsWeight,\r\n            renderItems = itemsOnDisplayLength + leftItemLength + rightItemLength,\r\n            delta = leftSizeOfUpdatedItems + leftSizeOfAddedItems - leftSizeOfDeletedItems;\r\n\r\n        const metrics: IMetrics = {\r\n            delta,\r\n            normalizedItemWidth: w,\r\n            normalizedItemHeight: h,\r\n            width,\r\n            height,\r\n            dynamicSize,\r\n            itemSize,\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            renderItems,\r\n            rightItemLength,\r\n            rightItemsWeight,\r\n            scrollSize: actualScrollSize,\r\n            leftSizeOfAddedItems,\r\n            sizeProperty,\r\n            snap,\r\n            snippedPos,\r\n            startIndex,\r\n            startPosition,\r\n            totalItemsToDisplayEndWeight,\r\n            totalLength,\r\n            totalSize,\r\n            typicalItemSize,\r\n            isFromItemIdFound,\r\n        };\r\n\r\n        return metrics;\r\n    }\r\n\r\n    clearDeltaDirection() {\r\n        this.clearScrollDirectionCache();\r\n    }\r\n\r\n    clearDelta(clearDirectionDetector = false): void {\r\n        this._delta = 0;\r\n\r\n        if (clearDirectionDetector) {\r\n            this.clearScrollDirectionCache();\r\n        }\r\n    }\r\n\r\n    changes(): void {\r\n        this.bumpVersion();\r\n    }\r\n\r\n    protected generateDisplayCollection<I extends { id: Id }, C extends Array<I>>(items: C, stickyMap: IVirtualListStickyMap,\r\n        metrics: IMetrics): IRenderVirtualListCollection {\r\n        const {\r\n            width,\r\n            height,\r\n            normalizedItemWidth,\r\n            normalizedItemHeight,\r\n            dynamicSize,\r\n            itemsOnDisplayLength,\r\n            itemsFromStartToScrollEnd,\r\n            isVertical,\r\n            renderItems: renderItemsLength,\r\n            scrollSize,\r\n            sizeProperty,\r\n            snap,\r\n            snippedPos,\r\n            startPosition,\r\n            totalLength,\r\n            startIndex,\r\n            typicalItemSize,\r\n        } = metrics,\r\n            displayItems: IRenderVirtualListCollection = [];\r\n        if (items.length) {\r\n            const actualSnippedPosition = snippedPos, isSnappingMethodAdvanced = this.isSnappingMethodAdvanced,\r\n                boundsSize = isVertical ? height : width, actualEndSnippedPosition = boundsSize;\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            if (snap) {\r\n                for (let i = Math.min(itemsFromStartToScrollEnd > 0 ? itemsFromStartToScrollEnd : 0, totalLength - 1); i >= 0; i--) {\r\n                    if (!items[i]) {\r\n                        continue;\r\n                    }\r\n                    const id = items[i].id, sticky = stickyMap[id], size = dynamicSize ? this.get(id)?.[sizeProperty] || typicalItemSize : typicalItemSize;\r\n                    if (sticky === 1) {\r\n                        const measures = {\r\n                            x: isVertical ? 0 : actualSnippedPosition,\r\n                            y: isVertical ? actualSnippedPosition : 0,\r\n                            width: isVertical ? normalizedItemWidth : size,\r\n                            height: isVertical ? size : normalizedItemHeight,\r\n                            delta: 0,\r\n                        }, config = {\r\n                            isVertical,\r\n                            sticky,\r\n                            snap,\r\n                            snapped: true,\r\n                            snappedOut: false,\r\n                            dynamic: dynamicSize,\r\n                            isSnappingMethodAdvanced,\r\n                            zIndex: '1',\r\n                        };\r\n\r\n                        const itemData: I = items[i];\r\n\r\n                        stickyItem = { id, measures, data: itemData, config };\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 (snap) {\r\n                const startIndex = itemsFromStartToScrollEnd + itemsOnDisplayLength - 1;\r\n                for (let i = Math.min(startIndex, totalLength > 0 ? totalLength - 1 : 0), l = totalLength; i < l; i++) {\r\n                    if (!items[i]) {\r\n                        continue;\r\n                    }\r\n                    const id = items[i].id, sticky = stickyMap[id], size = dynamicSize\r\n                        ? this.get(id)?.[sizeProperty] || typicalItemSize\r\n                        : typicalItemSize;\r\n                    if (sticky === 2) {\r\n                        const w = isVertical ? normalizedItemWidth : size, h = isVertical ? size : normalizedItemHeight, measures = {\r\n                            x: isVertical ? 0 : actualEndSnippedPosition - w,\r\n                            y: isVertical ? actualEndSnippedPosition - h : 0,\r\n                            width: w,\r\n                            height: h,\r\n                            delta: 0,\r\n                        }, config = {\r\n                            isVertical,\r\n                            sticky,\r\n                            snap,\r\n                            snapped: true,\r\n                            snappedOut: false,\r\n                            dynamic: dynamicSize,\r\n                            isSnappingMethodAdvanced,\r\n                            zIndex: '1',\r\n                        };\r\n\r\n                        const itemData: I = items[i];\r\n\r\n                        endStickyItem = { id, measures, data: itemData, config };\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            let i = startIndex;\r\n\r\n            while (renderItems > 0) {\r\n                if (i >= totalLength) {\r\n                    break;\r\n                }\r\n                if (!items[i]) {\r\n                    continue;\r\n                }\r\n\r\n                const id = items[i].id, size = dynamicSize ? this.get(id)?.[sizeProperty] || typicalItemSize : typicalItemSize;\r\n\r\n                if (id !== stickyItem?.id && id !== endStickyItem?.id) {\r\n                    const snapped = snap && (stickyMap[id] === 1 && pos <= scrollSize || stickyMap[id] === 2 && pos >= scrollSize + boundsSize - size),\r\n                        measures = {\r\n                            x: isVertical ? stickyMap[id] === 1 ? 0 : boundsSize - size : pos,\r\n                            y: isVertical ? pos : stickyMap[id] === 2 ? boundsSize - size : 0,\r\n                            width: isVertical ? normalizedItemWidth : size,\r\n                            height: isVertical ? size : normalizedItemHeight,\r\n                            delta: 0,\r\n                        }, config = {\r\n                            isVertical,\r\n                            sticky: stickyMap[id],\r\n                            snap,\r\n                            snapped: false,\r\n                            snappedOut: false,\r\n                            dynamic: dynamicSize,\r\n                            isSnappingMethodAdvanced,\r\n                            zIndex: '0',\r\n                        };\r\n\r\n                    if (snapped) {\r\n                        config.zIndex = '2';\r\n                    }\r\n\r\n                    const itemData: I = items[i];\r\n\r\n                    const item: IRenderVirtualListItem = { id, measures, data: itemData, config };\r\n                    if (!nextSticky && stickyItemIndex < i && stickyMap[id] === 1 && (pos <= scrollSize + 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 - scrollSize) : (item.measures.x - scrollSize);\r\n                        nextSticky.config.zIndex = '3';\r\n                    } else if (!nextEndSticky && endStickyItemIndex > i && stickyMap[id] === 2 && (pos >= scrollSize + boundsSize - 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 = '3';\r\n                        nextEndSticky.config.snapped = snapped;\r\n                        nextEndSticky.measures.delta = isVertical ? (item.measures.y - scrollSize) : (item.measures.x - scrollSize);\r\n                    }\r\n\r\n                    displayItems.push(item);\r\n                }\r\n\r\n                renderItems -= 1;\r\n                pos += size;\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] <= scrollSize + stickyItemSize) {\r\n                if (nextSticky.measures[axis] > scrollSize) {\r\n                    stickyItem.measures[axis] = nextSticky.measures[axis] - stickyItemSize;\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 - scrollSize : stickyItem.measures.x - scrollSize;\r\n                } else {\r\n                    nextSticky.config.snapped = true;\r\n                    nextSticky.measures.delta = isVertical ? nextSticky.measures.y - scrollSize : nextSticky.measures.x - scrollSize;\r\n                }\r\n            }\r\n\r\n            if (nextEndSticky && endStickyItem && nextEndSticky.measures[axis] >= scrollSize + boundsSize - endStickyItemSize - nextEndSticky.measures[sizeProperty]) {\r\n                if (nextEndSticky.measures[axis] < scrollSize + boundsSize - endStickyItemSize) {\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 - scrollSize : endStickyItem.measures.x - scrollSize;\r\n                } else {\r\n                    nextEndSticky.config.snapped = true;\r\n                    nextEndSticky.measures.delta = isVertical ? nextEndSticky.measures.y - scrollSize : nextEndSticky.measures.x - scrollSize;\r\n                }\r\n            }\r\n        }\r\n        return displayItems;\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._snapedDisplayComponent, this.scrollDirection);\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 | undefined {\r\n        if (this.has(id)) {\r\n            return this.get(id);\r\n        }\r\n        return undefined;\r\n    }\r\n\r\n    protected cacheElements(): 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, bounds);\r\n        }\r\n    }\r\n\r\n    override dispose() {\r\n        super.dispose();\r\n\r\n        this.disposeClearBufferSizeTimer();\r\n\r\n        if (this._tracker) {\r\n            this._tracker.dispose();\r\n        }\r\n    }\r\n}\r\n"]}