ng-virtual-list 22.12.0 → 22.12.2

package/README.md

@@ -612,11 +612,7 @@ Inputs
 | itemSize | number \| 'viewport' = 24 | If direction = 'vertical', then the height of a typical element. If direction = 'horizontal', then the width of a typical element. If the dynamicSize property is true, the items in the list can have different sizes, and you must specify the itemSize property to adjust the sizes of the items in the unallocated area. If the value is 'viewport', the sizes of elements are automatically resized to fit the viewport size. |
 | itemTransform | [ItemTransform](https://github.com/DjonnyX/ng-virtual-list/blob/22.x/projects/ng-virtual-list/src/lib/types/item-transform.ts) \| null = null | Custom transformation of element's position, rotation, scale, opacity and zIndex. The default value is `null`. |
 | itemRenderer | TemplateRef | Rendering element template. |
-| itemConfigMap | [IVirtualListItemConfigMap?](https://github.com/DjonnyX/ng-virtual-list/blob/22.x/projects/ng-virtual-list/src/lib/models/item-config-map.model.ts) | Sets `sticky` position, `fullSize`, `collapsable` and `selectable` for the list item element. If `sticky` position is greater than `0`, then `sticky` position is applied. 
-   If the `sticky` value is greater than `0`, then the `sticky` position mode is enabled for the element. `1` - position start, `2` - position end. Default value is `0`.
-   `selectable` determines whether an element can be selected or not. Default value is `true`.
-   `collapsable` determines whether an element with a `sticky` property greater than zero can collapse and collapse elements in front that do not have a `sticky` property.
-   `fullSize` determines the size of an element when rendering lists with cell divisions. If sticky is 1 or 2, fullSize automatically becomes true. The default value is false. |
+| itemConfigMap | [IVirtualListItemConfigMap?](https://github.com/DjonnyX/ng-virtual-list/blob/22.x/projects/ng-virtual-list/src/lib/models/item-config-map.model.ts) | Sets `sticky` position, `fullSize`, `collapsable` and `selectable` for the list item element. If `sticky` position is greater than `0`, then `sticky` position is applied. If the `sticky` value is greater than `0`, then the `sticky` position mode is enabled for the element. `1` - position start, `2` - position end. Default value is `0`. `selectable` determines whether an element can be selected or not. Default value is `true`. `collapsable` determines whether an element with a `sticky` property greater than zero can collapse and collapse elements in front that do not have a `sticky` property. `fullSize` determines the size of an element when rendering lists with cell divisions. If sticky is 1 or 2, fullSize automatically becomes true. The default value is false. |
 | langTextDir | [TextDirection? = 'ltr'](https://github.com/DjonnyX/ng-virtual-list/blob/22.x/projects/ng-virtual-list/src/lib/enums/text-direction.ts) | A string indicating the direction of text for the locale. Can be either "ltr" (left-to-right) or "rtl" (right-to-left). |
 | loading | boolean? = false | If `true`, the scrollBar goes into loading state. The default value is `false`. |
 | maxBufferSize | number? = 10 | Maximum number of elements outside the scope of visibility. Default value is 10. If maxBufferSize is set to be greater than bufferSize, then adaptive buffer mode is enabled. The greater the scroll size, the more elements are allocated for rendering. |
@@ -730,25 +726,20 @@ import { NgVirtualListModule, VirtualClickModule } from 'ng-virtual-list';
 </ng-template>
 ```
 
+<br/>
+
 ## 📦 Previous versions
 
 | Angular version | ng-virtual-list version | git | npm |
 |--|--|--|--|
-| 21.x | 21.12.0 | [20.x](https://github.com/DjonnyX/ng-virtual-list/tree/21.x) | [21.12.0](https://www.npmjs.com/package/ng-virtual-list/v/21.12.0) |
-| 20.x | 20.12.0 | [20.x](https://github.com/DjonnyX/ng-virtual-list/tree/20.x) | [20.12.0](https://www.npmjs.com/package/ng-virtual-list/v/20.12.0) |
-| 19.x | 19.12.0 | [19.x](https://github.com/DjonnyX/ng-virtual-list/tree/19.x) | [19.12.0](https://www.npmjs.com/package/ng-virtual-list/v/19.12.0) |
-| 18.x | 18.12.0 | [18.x](https://github.com/DjonnyX/ng-virtual-list/tree/18.x) | [18.12.0](https://www.npmjs.com/package/ng-virtual-list/v/18.12.0) |
-| 17.x | 17.12.0 | [17.x](https://github.com/DjonnyX/ng-virtual-list/tree/17.x) | [17.12.0](https://www.npmjs.com/package/ng-virtual-list/v/17.12.0) |
-| 16.x | 16.12.0 | [16.x](https://github.com/DjonnyX/ng-virtual-list/tree/16.x) | [16.12.0](https://www.npmjs.com/package/ng-virtual-list/v/16.12.0) |
-| 15.x | 15.12.0 | [15.x](https://github.com/DjonnyX/ng-virtual-list/tree/15.x) | [15.12.0](https://www.npmjs.com/package/ng-virtual-list/v/15.12.0) |
-| 14.x | 14.12.0 | [14.x](https://github.com/DjonnyX/ng-virtual-list/tree/14.x) | [14.12.0](https://www.npmjs.com/package/ng-virtual-list/v/14.12.0) |
-<br/>
-
-## 🤝 Contributing
-
-PRs and feature requests are welcome!
-Open an issue or start a discussion to shape the future of [ng-virtual-list](https://github.com/DjonnyX/ng-virtual-list/).
-Try it out, star ⭐ the repo, and let us know what you’re building.
+| 21.x | 21.12.2 | [20.x](https://github.com/DjonnyX/ng-virtual-list/tree/21.x) | [21.12.2](https://www.npmjs.com/package/ng-virtual-list/v/21.12.2) |
+| 20.x | 20.12.2 | [20.x](https://github.com/DjonnyX/ng-virtual-list/tree/20.x) | [20.12.2](https://www.npmjs.com/package/ng-virtual-list/v/20.12.2) |
+| 19.x | 19.12.2 | [19.x](https://github.com/DjonnyX/ng-virtual-list/tree/19.x) | [19.12.2](https://www.npmjs.com/package/ng-virtual-list/v/19.12.2) |
+| 18.x | 18.12.2 | [18.x](https://github.com/DjonnyX/ng-virtual-list/tree/18.x) | [18.12.2](https://www.npmjs.com/package/ng-virtual-list/v/18.12.2) |
+| 17.x | 17.12.2 | [17.x](https://github.com/DjonnyX/ng-virtual-list/tree/17.x) | [17.12.2](https://www.npmjs.com/package/ng-virtual-list/v/17.12.2) |
+| 16.x | 16.12.2 | [16.x](https://github.com/DjonnyX/ng-virtual-list/tree/16.x) | [16.12.2](https://www.npmjs.com/package/ng-virtual-list/v/16.12.2) |
+| 15.x | 15.12.2 | [15.x](https://github.com/DjonnyX/ng-virtual-list/tree/15.x) | [15.12.2](https://www.npmjs.com/package/ng-virtual-list/v/15.12.2) |
+| 14.x | 14.12.2 | [14.x](https://github.com/DjonnyX/ng-virtual-list/tree/14.x) | [14.12.2](https://www.npmjs.com/package/ng-virtual-list/v/14.12.2) |
 
 <br/>
 

package/fesm2022/ng-virtual-list.mjs

@@ -1775,7 +1775,7 @@ class ScrollEvent {
 
 /**
  * Event emitter
- * @link https://github.com/DjonnyX/data-channel-router/blob/main/library/src/utils/event-emitter/event-emitter.ts
+ * @link https://github.com/DjonnyX/ng-virtual-list/blob/main/library/src/utils/event-emitter/event-emitter.ts
  * @author Evgenii Alexandrovich Grebennikov
  * @email djonnyx@gmail.com
  */
@@ -2078,7 +2078,7 @@ class Tracker {
         }
         const untrackedItems = [...components], newTrackItems = [], untrackedComponentsByTypeMap = {}, isDown = direction === 0 || direction === 1, snapped = !!snappedComponents ? [...snappedComponents] : [];
         let isRegularSnapped = false;
-        const serviceIdProp = getServiceIdProp(trackBy);
+        const serviceIdProp = getServiceIdProp(trackBy), snappedItems = new Array();
         for (let i = isDown ? 0 : items.length - 1, l = isDown ? items.length : 0; isDown ? i < l : i >= l; isDown ? i++ : i--) {
             const item = items[i], isDummy = item?.data?.[SERVICE_PROP_DUMMY] && (item?.data?.[SERVICE_PROP_DUMMY] === SERVICE_PROP_DUMMY_ENABLED);
             if (isDummy) {
@@ -2101,6 +2101,7 @@ class Tracker {
                                         isRegularSnapped = true;
                                         snappedComponent.instance.item = item;
                                         snappedComponent.instance.show();
+                                        snappedItems.push(snappedComponent);
                                     }
                                 }
                             }
@@ -2166,6 +2167,7 @@ class Tracker {
                             if (!!snappedComponent) {
                                 snappedComponent.instance.item = item;
                                 snappedComponent.instance.show();
+                                snappedItems.push(snappedComponent);
                             }
                         }
                     }
@@ -2196,13 +2198,14 @@ class Tracker {
                 comp.instance.hide();
             }
         }
-        if (!isRegularSnapped) {
-            for (let i = 0, l = snapped.length; i < l; i++) {
-                const snappedComponent = snapped[i];
-                if (!!snappedComponent) {
-                    snappedComponent.instance.item = null;
-                    snappedComponent.instance.hide();
-                }
+        for (let i = 0, l = snapped.length; i < l; i++) {
+            const snappedComponent = snapped[i];
+            if (snappedItems.indexOf(snappedComponent) > -1) {
+                continue;
+            }
+            if (!!snappedComponent) {
+                snappedComponent.instance.item = null;
+                snappedComponent.instance.hide();
             }
         }
     }
@@ -2682,7 +2685,7 @@ class TrackBox extends CacheMap {
      * Calculates list metrics
      */
     recalculateMetrics(options) {
-        const { 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 { 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;
@@ -2822,15 +2825,17 @@ class TrackBox extends CacheMap {
                         }
                         if (id == fromItemId) {
                             isFromItemIdFound = true;
-                            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;
+                            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;
@@ -3017,7 +3022,7 @@ class TrackBox extends CacheMap {
             rightItemsWeight = Math.floor(rightItemLength * dividedTypicalItemSize / typicalItemSize) * typicalItemSize;
             leftHiddenItemsWeight = Math.floor(itemsFromStartToScrollEnd * dividedTypicalItemSize / typicalItemSize) * typicalItemSize;
             totalItemsToDisplayEndWeight = Math.floor(itemsFromStartToDisplayEnd * dividedTypicalItemSize / typicalItemSize) * typicalItemSize;
-            totalSize = (totalLength * dividedTypicalItemSize) + this._scrollStartOffset + this._scrollEndOffset;
+            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);
@@ -3393,7 +3398,7 @@ class TrackBox extends CacheMap {
                 }
                 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 = {
+                        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,
@@ -3421,7 +3426,7 @@ class TrackBox extends CacheMap {
                             maxWidth: maxItemSize,
                             maxHeight: maxItemSize,
                             scrollDirection,
-                            delta: sticky === 1 ? actualSnippedPosition : sticky === 2 ? actualEndSnippedPosition - deltaOffet - size : 0,
+                            delta: sticky === 1 ? actualSnippedPosition : (sticky === 2 ? (actualEndSnippedPosition - deltaOffet - size) : 0),
                         }, config = {
                             isFirst: i === layoutIndexOffset,
                             isLast: i === li,
@@ -3431,7 +3436,7 @@ class TrackBox extends CacheMap {
                             isVertical,
                             collapsable,
                             selectable,
-                            sticky: sticky,
+                            sticky,
                             snap: stickyEnabled,
                             snapped: false,
                             snappedOut: false,
@@ -3484,9 +3489,9 @@ class TrackBox extends CacheMap {
                 i++;
             }
             const axis = isVertical ? Y_PROP_NAME : X_PROP_NAME;
-            if (!!nextSticky && !!stickyItem && nextSticky.measures[axis] <= actualSnippedPosition + stickyItemSize) {
-                if (nextSticky.measures[axis] > scrollSize - stickyItemSize) {
-                    stickyItem.measures[axis] = nextSticky.measures[axis] - stickyItemSize;
+            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;
@@ -3495,7 +3500,8 @@ class TrackBox extends CacheMap {
                 else {
                     nextSticky.config.snapped = true;
                     nextSticky.measures.delta = (isVertical ? nextSticky.measures.y : nextSticky.measures.x) - scrollSize;
-                    stickyItem.measures[axis] = stickyItem.measures[axis] + stickyItem.measures[sizeProperty];
+                    stickyItem.measures[axis] = nextSticky.measures[axis] - stickyItem.measures[sizeProperty];
+                    stickyItem.measures.delta = (isVertical ? stickyItem.measures.y : stickyItem.measures.x) - scrollSize;
                 }
             }
             if (!!nextEndSticky && !!endStickyItem &&
@@ -3512,6 +3518,7 @@ class TrackBox extends CacheMap {
                     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) {
@@ -3967,7 +3974,7 @@ const easeLinear = (t) => {
 
 /**
  * Animator
- * @link https://github.com/DjonnyX/data-channel-router/blob/main/library/src/utils/animator/animator.ts
+ * @link https://github.com/DjonnyX/ng-virtual-list/blob/main/library/src/utils/animator/animator.ts
  * @author Evgenii Alexandrovich Grebennikov
  * @email djonnyx@gmail.com
  */
@@ -4044,7 +4051,7 @@ class Animator {
 const SCROLL_VIEW_INVERSION = new InjectionToken('ScrollViewInversion');
 const SCROLL_VIEW_OVERSCROLL_ENABLED = new InjectionToken('ScrollViewOverscrollEnabled');
 const SCROLL_VIEW_NORMALIZE_VALUE_FROM_ZERO = new InjectionToken('ScrollViewNormalizeValueFromZero');
-const TOP$1 = 'top', LEFT$1 = 'left', INSTANT$1 = 'instant', AUTO = 'auto', SMOOTH = 'smooth', DURATION = 2000, FRICTION_FORCE = .035, MAX_DURATION = 4000, ANIMATION_DURATION = 50, MASS = .005, MAX_DIST = 12500, MAX_VELOCITY_TIMESTAMP = 100, SPEED_SCALE = 15, OVERSCROLL_START_ITERATION = 2, INTERSECTION_DISTANCE = 1;
+const TOP$1 = 'top', LEFT$1 = 'left', INSTANT$1 = 'instant', AUTO = 'auto', SMOOTH = 'smooth', DURATION = 2000, FRICTION_FORCE = .035, MAX_DURATION = 4000, ANIMATION_DURATION = 50, MASS = .005, ACCELERATION_SCALE = 40, MAX_DIST = 12500, MAX_VELOCITY_TIMESTAMP = 100, SPEED_SCALE = 15, OVERSCROLL_START_ITERATION = 2;
 const MAX_ITERATIONS_FOR_AVERAGE_CALCULATIONS = 5, INSTANT_VELOCITY_SCALE = 1000;
 const SCROLL_EVENT$1 = new Event(SCROLLER_SCROLL);
 
@@ -4821,8 +4828,8 @@ class NgScrollView extends BaseScrollView {
                 continue;
             }
             if (v00) {
-                const a0 = timestamp < MAX_VELOCITY_TIMESTAMP ? (v00[1] !== 0 ? (lastVSign * Math.abs(Math.abs(v01[0]) - Math.abs(v00[0]))) / Math.abs(v00[1]) : 0) : 0.1;
-                aSum = (aSum * mass) + a0;
+                const a0 = timestamp < MAX_VELOCITY_TIMESTAMP ? (v00[1] !== 0 ? (lastVSign * Math.abs(Math.abs(v01[0]) - Math.abs(v00[0]))) / Math.abs(v00[1]) : 0) : .1;
+                aSum = Math.abs((aSum * mass)) + Math.abs(a0);
                 prevV0 = v01;
             }
             prevV0 = v01;
@@ -4843,7 +4850,7 @@ class NgScrollView extends BaseScrollView {
     }
     moveWithAcceleration(isVertical, position, v0, v, a0, timestamp) {
         if (a0 !== 0 && timestamp < MAX_VELOCITY_TIMESTAMP) {
-            const dvSign = Math.sign(v), mass = this.scrollingSettings()?.mass ?? MASS, duration = DURATION, maxDuration = this.scrollingSettings()?.maxDuration ?? MAX_DURATION, maxDist = this.scrollingSettings()?.maxDistance ?? MAX_DIST, maxDistance = dvSign * maxDist, s = (dvSign * Math.abs((a0 * Math.pow(duration, 2)) * .5) / 1000) / mass, distance = Math.abs(s) < maxDist ? s : maxDistance, positionWithVelocity = position + (this._inversion ? -1 : 1) * distance, vmax = Math.max(Math.abs(v0), Math.abs(v)), ad = Math.abs(vmax !== 0 ? Math.sqrt(vmax) : 0) * 10 / mass, aDuration = ad < maxDuration ? ad : maxDuration, startPosition = isVertical ? this.y : this.x;
+            const dvSign = Math.sign(v), mass = this.scrollingSettings()?.mass ?? MASS, duration = DURATION, maxDuration = this.scrollingSettings()?.maxDuration ?? MAX_DURATION, maxDist = this.scrollingSettings()?.maxDistance ?? MAX_DIST, maxDistance = dvSign * maxDist, s = (dvSign * Math.abs((a0 * Math.pow(duration, 2)) * .5) / 10000) / mass, distance = Math.abs(s) < maxDist ? s : maxDistance, positionWithVelocity = position + (this._inversion ? -1 : 1) * distance, ad = Math.abs(a0 !== 0 ? Math.sqrt(a0) : 0) * ACCELERATION_SCALE / mass, aDuration = ad < maxDuration ? ad : maxDuration, startPosition = isVertical ? this.y : this.x;
             this.animate(startPosition, Math.round(positionWithVelocity), aDuration, easeOutQuad, true);
         }
         else {
@@ -4859,7 +4866,7 @@ class NgScrollView extends BaseScrollView {
     }
     animate(startValue, endValue, duration = ANIMATION_DURATION, easingFunction = easeOutQuad, userAction = false, alignmentAtComplete = true, skipOverridedCoordinates = false) {
         const isVertical = this.isVertical();
-        let iteration = 0, position = startValue;
+        let position = startValue;
         this._isAlignmentAnimation = !alignmentAtComplete;
         this._animator.animate({
             withDelta: this._service.dynamic && !this.isInfinity(),
@@ -4876,17 +4883,16 @@ class NgScrollView extends BaseScrollView {
                     this.animate(currentCoordinate, currentCoordinate + delta, duration - elapsed, easingFunction, userAction, alignmentAtComplete);
                     return;
                 }
-                const v0 = calculateVelocity(position, value, timestamp) ?? this.averageVelocity;
+                const v0 = calculateVelocity(position, value - this._delta, timestamp) ?? this.averageVelocity;
                 position = value;
                 if (alignmentAtComplete && !this._isAlignmentAnimation && !skipOverridedCoordinates) {
-                    if (iteration < MAX_ITERATIONS_FOR_AVERAGE_CALCULATIONS || !this.snapIfNecessary(v0)) {
+                    if (!this.snapIfNecessary(v0)) {
                         this.move(isVertical, value, false, userAction);
                     }
                 }
                 else {
                     this.move(isVertical, value, false, userAction);
                 }
-                iteration++;
                 this._service.update(true);
             }, onComplete: ({ value, timestamp }) => {
                 this._isAlignmentAnimation = false;
@@ -4938,10 +4944,9 @@ class NgScrollView extends BaseScrollView {
         return size;
     }
     alignPosition(animated = true, force = false) {
-        if (!this.snapToItem() || this._isAlignmentAnimation) {
+        if (!this.snapToItem() || (this._isAlignmentAnimation && !force)) {
             return false;
         }
-        this.stopScrolling(true);
         const scrollDirection = this._scrollDirection.get() || (force ? 1 : 0);
         if (scrollDirection === 0) {
             return false;
@@ -5324,13 +5329,13 @@ class NgScrollBarComponent extends NgScrollView {
         })).subscribe();
     }
     createDragEvent(userAction) {
-        const isVertical = this.isVertical(), scrollSize = isVertical ? this.scrollHeight : this.scrollWidth, scrollContent = this.scrollContent()?.nativeElement, scrollViewport = this.scrollViewport()?.nativeElement;
+        const isVertical = this.isVertical(), scrollSize = isVertical ? this.scrollHeight : this.scrollWidth, scrollPosition = isVertical ? this.scrollTop : this.scrollLeft, startOffset = this.startOffset(), endOffset = this.endOffset(), scrollContent = this.scrollContent()?.nativeElement, scrollViewport = this.scrollViewport()?.nativeElement;
         if (!!scrollViewport && !!scrollContent) {
-            const contentSize = isVertical ? scrollContent.offsetHeight : scrollContent.offsetWidth, viewportSize = isVertical ? scrollViewport.offsetHeight : scrollViewport.offsetWidth;
+            const contentSize = isVertical ? scrollContent.offsetHeight : scrollContent.offsetWidth, viewportSize = isVertical ? scrollViewport.offsetHeight : scrollViewport.offsetWidth, offsetSize = (scrollSize !== 0 ? (startOffset / scrollSize) : 0), positionSize = (scrollSize !== 0 ? (scrollPosition / scrollSize) : 0), maxSize = 1 - offsetSize, pos = (positionSize - offsetSize);
             const event = {
-                position: scrollSize !== 0 ? ((isVertical ? this._y : this._x) / scrollSize) : 0,
-                min: scrollSize !== 0 ? (this.startOffset() / scrollSize) : 0,
-                max: scrollSize !== 0 ? ((viewportSize - this.endOffset() - contentSize) / scrollSize) : 0,
+                position: pos / maxSize,
+                min: scrollSize !== 0 ? (startOffset / scrollSize) : 0,
+                max: scrollSize !== 0 ? ((viewportSize - endOffset - contentSize) / scrollSize) : 0,
                 animation: !this._isMoving,
                 userAction,
             };
@@ -8234,7 +8239,7 @@ class NgVirtualListComponent {
             this._isLoading = false;
         })).subscribe();
         const update = (params) => {
-            const { alignment, precalculatedScrollStartOffset, precalculatedScrollEndOffset, trackBy, isInfinity, snapScrollToStart, snapScrollToEnd, bounds, listBounds, scrollEndOffset, items, itemConfigMap, scrollSize, itemSize, minItemSize, maxItemSize, divides, bufferSize, maxBufferSize, stickyEnabled, isVertical, dynamicSize, enabledBufferOptimization, snapToItem, snapToItemAlign, cacheVersion, userAction, collapsedIds, itemTransform, } = params;
+            const { alignment, snapScrollToStart, snapScrollToEnd, bounds, items, itemConfigMap, scrollSize, itemSize, minItemSize, maxItemSize, bufferSize, maxBufferSize, stickyEnabled, isVertical, dynamicSize, enabledBufferOptimization, snapToItem, snapToItemAlign, userAction, collapsedIds, itemTransform, } = params;
             const scroller = this._scrollerComponent();
             let totalSize = 0;
             if (!!scroller) {
@@ -8244,7 +8249,7 @@ class NgVirtualListComponent {
                     let actualScrollSize = !this._readyForShow && snapScrollToEnd ? (isVertical ? scroller.scrollHeight : scroller.scrollWidth) :
                         (isVertical ? scroller.scrollTop : scroller.scrollLeft), leftLayoutOffset = 0, displayItems;
                     const { width, height } = bounds, viewportSize = (isVertical ? height : width), opts = {
-                        bounds: { width, height }, dynamicSize, isVertical, itemSize, minItemSize, maxItemSize, bufferSize, maxBufferSize,
+                        alignment, bounds: { width, height }, dynamicSize, isVertical, itemSize, minItemSize, maxItemSize, bufferSize, maxBufferSize,
                         scrollSize: actualScrollSize, stickyEnabled, enabledBufferOptimization, snapToItem, snapToItemAlign, itemTransform,
                     };
                     if (snapScrollToEnd && !this._readyForShow) {
@@ -8252,12 +8257,24 @@ class NgVirtualListComponent {
                         displayItems = calculatedDisplayItems;
                         totalSize = calculatedTotalSize1;
                         leftLayoutOffset = leftLayoutOffset1;
+                        if (!!itemTransform && dynamicSize && this._trackBox.delta !== 0) {
+                            const { displayItems: calculatedDisplayItems, totalSize: calculatedTotalSize1, leftLayoutOffset: leftLayoutOffset1 } = this._trackBox.updateCollection(items, itemConfigMap, { ...opts, scrollSize: actualScrollSize + this._trackBox.delta });
+                            displayItems = calculatedDisplayItems;
+                            totalSize = calculatedTotalSize1;
+                            leftLayoutOffset = leftLayoutOffset1;
+                        }
                     }
                     else {
                         const { displayItems: calculatedDisplayItems, totalSize: calculatedTotalSize, leftLayoutOffset: leftLayoutOffset1 } = this._trackBox.updateCollection(items, itemConfigMap, opts);
                         displayItems = calculatedDisplayItems;
                         totalSize = calculatedTotalSize;
                         leftLayoutOffset = leftLayoutOffset1;
+                        if (!!itemTransform && dynamicSize && this._trackBox.delta !== 0) {
+                            const { displayItems: calculatedDisplayItems, totalSize: calculatedTotalSize, leftLayoutOffset: leftLayoutOffset1 } = this._trackBox.updateCollection(items, itemConfigMap, { ...opts, scrollSize: actualScrollSize + this._trackBox.delta });
+                            displayItems = calculatedDisplayItems;
+                            totalSize = calculatedTotalSize;
+                            leftLayoutOffset = leftLayoutOffset1;
+                        }
                     }
                     scroller.totalSize = totalSize;
                     scroller.startLayoutOffset = leftLayoutOffset;
@@ -8274,23 +8291,7 @@ class NgVirtualListComponent {
                     if (this._isSnappingMethodAdvanced) {
                         this.updateRegularRenderer();
                     }
-                    switch (alignment) {
-                        case Alignments.NONE: {
-                            this._actualScrollStartOffset.set(precalculatedScrollStartOffset);
-                            this._actualScrollEndOffset.set(precalculatedScrollEndOffset);
-                            break;
-                        }
-                        case Alignments.CENTER: {
-                            const firstItemId = items.length > 0 ? (items[0]?.[trackBy] ?? null) : null, endItemId = items.length > 0 ? (items?.[items.length - 1]?.[trackBy] ?? null) : null, alignmentStartOffset = viewportSize * .5 - (firstItemId !== null ? (isVertical ? (this._service.getItemBounds(firstItemId)?.height ?? 0) :
-                                (this._service.getItemBounds(firstItemId)?.width ?? 0)) : 0) * (isInfinity ? 0 : .5), alignmentEndOffset = viewportSize * .5 - (endItemId !== null ? (isVertical ? (this._service.getItemBounds(endItemId)?.height ?? 0) :
-                                (this._service.getItemBounds(endItemId)?.width ?? 0)) : 0) * (isInfinity ? 0 : .5);
-                            this._alignmentScrollStartOffset.set(alignmentStartOffset);
-                            this._alignmentScrollEndOffset.set(alignmentEndOffset);
-                            this._actualScrollStartOffset.set(precalculatedScrollStartOffset + alignmentStartOffset);
-                            this._actualScrollEndOffset.set(precalculatedScrollEndOffset + alignmentEndOffset);
-                            break;
-                        }
-                    }
+                    this.updateOffsetsByAllignment();
                     scroller.delta = delta;
                     if ((snapScrollToStart && this._trackBox.isSnappedToStart && scroller.scrollable) ||
                         (snapScrollToStart && currentScrollSize <= MIN_PIXELS_FOR_PREVENT_SNAPPING)) {
@@ -8469,6 +8470,7 @@ class NgVirtualListComponent {
                     const dynamicSize = this.dynamicSize(), itemSize = this._actualItemSize(), minItemSize = this._actualMinItemSize(), maxItemSize = this._actualMaxItemSize(), snapScrollToEnd = this.snapScrollToEnd();
                     if (dynamicSize) {
                         const { width, height } = this._bounds() || { width: DEFAULT_LIST_SIZE, height: DEFAULT_LIST_SIZE }, itemConfigMap = this.itemConfigMap(), isVertical = this._isVertical, currentScrollSize = isVertical ? scrollerComponent.scrollTop : scrollerComponent.scrollLeft, opts = {
+                            alignment: this.actualAlignment(),
                             bounds: { width, height }, collection: items, dynamicSize, isVertical: this._isVertical, itemSize, minItemSize, maxItemSize,
                             bufferSize: this.bufferSize(), maxBufferSize: this.maxBufferSize(), itemTransform: this.itemTransform(),
                             scrollSize: (isVertical ? scrollerComponent.scrollTop : scrollerComponent.scrollLeft),
@@ -8494,21 +8496,8 @@ class NgVirtualListComponent {
                         this.createDisplayComponentsIfNeed(displayItems);
                         this.tracking();
                         this.snappingHandler();
+                        this.updateOffsetsByAllignment();
                         scrollSize = this._trackBox.getItemPosition(id, itemConfigMap, { ...opts, scrollSize: actualScrollSize, fromItemId: id });
-                        if (this._isInfinity()) {
-                            if (this.snapToItem()) {
-                                const itemBounds = this._trackBox.getItemBounds(id);
-                                if (!!itemBounds) {
-                                    const itemSize = isVertical ? itemBounds.height : itemBounds.width;
-                                    switch (this.snapToItemAlign()) {
-                                        case SnapToItemAligns.CENTER: {
-                                            scrollSize += itemSize * .5;
-                                            break;
-                                        }
-                                    }
-                                }
-                            }
-                        }
                         if (scrollSize === -1) {
                             return of([finished, { id, blending, iteration: nextIteration, cb }]).pipe(delay(0));
                         }
@@ -8533,11 +8522,11 @@ class NgVirtualListComponent {
                     else {
                         const index = items.findIndex(item => item[trackBy] === id);
                         if (index > -1) {
-                            const isVertical = this._isVertical, itemSize = this._actualItemSize();
+                            const isVertical = this._isVertical, itemSize = this._actualItemSize(), isInfinity = this._isInfinity(), snapToItem = this.snapToItem(), snapToItemAlign = this.snapToItemAlign();
                             let scrollSize = index * itemSize;
-                            if (this._isInfinity()) {
-                                if (this.snapToItem()) {
-                                    switch (this.snapToItemAlign()) {
+                            if (isInfinity) {
+                                if (snapToItem) {
+                                    switch (snapToItemAlign) {
                                         case SnapToItemAligns.CENTER: {
                                             scrollSize += itemSize * .5;
                                             break;
@@ -8546,11 +8535,12 @@ class NgVirtualListComponent {
                                 }
                             }
                             const { width, height } = this._bounds() || { width: DEFAULT_LIST_SIZE, height: DEFAULT_LIST_SIZE }, itemConfigMap = this.itemConfigMap(), items = this._actualItems(), opts = {
+                                alignment: this._actualAlignment(),
                                 bounds: { width, height }, collection: items, dynamicSize, isVertical: this._isVertical, itemSize, minItemSize, maxItemSize,
                                 bufferSize: this.bufferSize(), maxBufferSize: this.maxBufferSize(), itemTransform: this.itemTransform(),
                                 scrollSize: (isVertical ? scrollerComponent.scrollTop : scrollerComponent.scrollLeft),
-                                snapToItem: this.snapToItem(), snapToItemAlign: this.snapToItemAlign(),
-                                stickyEnabled: this.stickyEnabled(), fromItemId: id, enabledBufferOptimization: this.enabledBufferOptimization(),
+                                snapToItem, snapToItemAlign, stickyEnabled: this.stickyEnabled(), fromItemId: id,
+                                enabledBufferOptimization: this.enabledBufferOptimization(),
                             };
                             this._trackBox.clearDelta();
                             const viewportSize = (isVertical ? height : width), { displayItems, totalSize, leftLayoutOffset } = this._trackBox.updateCollection(items, itemConfigMap, {
@@ -8565,6 +8555,7 @@ class NgVirtualListComponent {
                             this.createDisplayComponentsIfNeed(displayItems);
                             this.tracking();
                             this.snappingHandler();
+                            this.updateOffsetsByAllignment();
                             this._$preventScrollSnapping.next(true);
                             const params = {
                                 [this._isVertical ? TOP_PROP_NAME : LEFT_PROP_NAME]: scrollSize, fireUpdate: false,
@@ -8591,7 +8582,7 @@ class NgVirtualListComponent {
             this.emitScrollEvent(true, false, true);
             const scrollParams = params;
             scrollParams?.cb?.();
-        }), delay(100), tap(([finished]) => {
+        }), delay(0), tap(([finished]) => {
             if (finished) {
                 this._scrollerComponent()?.snapIfNeed();
             }
@@ -8632,6 +8623,14 @@ class NgVirtualListComponent {
                 }
             }));
         })).subscribe();
+        combineLatest([$itemConfigMap, $dynamicSize, $divides]).pipe(takeUntilDestroyed(), filter$1(([itemConfigMap, dynamicSize, divides]) => !!itemConfigMap && !dynamicSize && divides > 1), tap(([itemConfigMap]) => {
+            for (const id in itemConfigMap) {
+                const metaData = itemConfigMap[id];
+                if (metaData?.fullSize || metaData?.sticky === 1 || metaData?.sticky === 2) {
+                    throw Error('The accelerated rendering algorithm `[dynamicSize]="false"` cannot correctly handle non-uniform lists (the itemConfigMap specifies full-size elements). For correct rendering, specify `[dynamicSize]="true"`.');
+                }
+            }
+        })).subscribe();
         combineLatest([$collapsingMode, $items, $itemConfigMap, $trackBy]).pipe(takeUntilDestroyed(), tap(([collapsingMode, items, itemConfigMap, trackBy]) => {
             const isAccordion = isCollapseMode(collapsingMode, CollapsingModes.ACCORDION);
             if (isAccordion) {
@@ -8835,6 +8834,26 @@ class NgVirtualListComponent {
             this._trackBox.setDisplayObjectIndexMapById(doMap);
         }
     }
+    updateOffsetsByAllignment() {
+        const alignment = this._actualAlignment(), items = this._actualItems(), trackBy = this.trackBy(), isInfinity = this._isInfinity(), isVertical = this._isVertical, { width, height } = this._bounds() || { width: DEFAULT_LIST_SIZE, height: DEFAULT_LIST_SIZE }, viewportSize = isVertical ? height : width, precalculatedScrollStartOffset = this._precalculatedScrollStartOffset(), precalculatedScrollEndOffset = this._precalculatedScrollEndOffset();
+        switch (alignment) {
+            case Alignments.NONE: {
+                this._actualScrollStartOffset.set(precalculatedScrollStartOffset);
+                this._actualScrollEndOffset.set(precalculatedScrollEndOffset);
+                break;
+            }
+            case Alignments.CENTER: {
+                const firstItemId = items.length > 0 ? (items[0]?.[trackBy] ?? null) : null, endItemId = items.length > 0 ? (items?.[items.length - 1]?.[trackBy] ?? null) : null, alignmentStartOffset = viewportSize * .5 - (firstItemId !== null ? (isVertical ? (this._service.getItemBounds(firstItemId)?.height ?? 0) :
+                    (this._service.getItemBounds(firstItemId)?.width ?? 0)) : 0) * (isInfinity ? 0 : .5), alignmentEndOffset = viewportSize * .5 - (endItemId !== null ? (isVertical ? (this._service.getItemBounds(endItemId)?.height ?? 0) :
+                    (this._service.getItemBounds(endItemId)?.width ?? 0)) : 0) * (isInfinity ? 0 : .5);
+                this._alignmentScrollStartOffset.set(alignmentStartOffset);
+                this._alignmentScrollEndOffset.set(alignmentEndOffset);
+                this._actualScrollStartOffset.set(precalculatedScrollStartOffset + alignmentStartOffset);
+                this._actualScrollEndOffset.set(precalculatedScrollEndOffset + alignmentEndOffset);
+                break;
+            }
+        }
+    }
     updateRegularRenderer() {
         this._resizeSnappedComponentHandler();
     }