@ringcentral/juno 2.40.1 → 2.41.1

package/components/Virtuoso/react-virtuoso/sizeSystem.js

@@ -1,20 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 var tslib_1 = require("tslib");
-/* eslint-disable no-continue */
-var u = tslib_1.__importStar(require("@virtuoso.dev/urx"));
+var u = tslib_1.__importStar(require("./urx"));
 var AATree_1 = require("./AATree");
-var loggerSystem_1 = require("./loggerSystem");
 var arrayBinarySearch = tslib_1.__importStar(require("./utils/binaryArraySearch"));
 var correctItemSize_1 = require("./utils/correctItemSize");
+var loggerSystem_1 = require("./loggerSystem");
+var recalcSystem_1 = require("./recalcSystem");
 function rangeIncludes(refRange) {
     var size = refRange.size, startIndex = refRange.startIndex, endIndex = refRange.endIndex;
     return function (range) {
-        return (range.start === startIndex &&
-            (range.end === endIndex || range.end === Infinity) &&
-            range.value === size);
+        return range.start === startIndex && (range.end === endIndex || range.end === Infinity) && range.value === size;
     };
 }
+function affectedGroupCount(offset, groupIndices) {
+    var recognizedOffsetItems = 0;
+    var groupIndex = 0;
+    while (recognizedOffsetItems < offset) {
+        recognizedOffsetItems += groupIndices[groupIndex + 1] - groupIndices[groupIndex] - 1;
+        groupIndex++;
+    }
+    var offsetIsExact = recognizedOffsetItems === offset;
+    return groupIndex - (offsetIsExact ? 0 : 1);
+}
 function insertRanges(sizeTree, ranges) {
     var e_1, _a, e_2, _b;
     var syncStart = AATree_1.empty(sizeTree) ? 0 : Infinity;
@@ -44,10 +52,12 @@ function insertRanges(sizeTree, ranges) {
                         shouldInsert = rangeValue !== size;
                         firstPassDone = true;
                     }
-                    // remove the range if it starts within the new range OR if
-                    // it has the same value as it, in order to perform a merge
-                    else if (endIndex >= rangeStart || size === rangeValue) {
-                        sizeTree = AATree_1.remove(sizeTree, rangeStart);
+                    else {
+                        // remove the range if it starts within the new range OR if
+                        // it has the same value as it, in order to perform a merge
+                        if (endIndex >= rangeStart || size === rangeValue) {
+                            sizeTree = AATree_1.remove(sizeTree, rangeStart);
+                        }
                     }
                     // next range
                     if (rangeEnd > endIndex && endIndex >= rangeStart) {
@@ -112,7 +122,7 @@ function rangesWithinOffsets(tree, startOffset, endOffset, minStartIndex) {
     return AATree_1.arrayToRanges(arrayBinarySearch.findRange(tree, startOffset, endOffset, offsetComparator), offsetPointParser);
 }
 exports.rangesWithinOffsets = rangesWithinOffsets;
-function createOffsetTree(prevOffsetTree, syncStart, sizeTree) {
+function createOffsetTree(prevOffsetTree, syncStart, sizeTree, gap) {
     var e_3, _a;
     var offsetTree = prevOffsetTree;
     var prevIndex = 0;
@@ -126,8 +136,7 @@ function createOffsetTree(prevOffsetTree, syncStart, sizeTree) {
         var kv = AATree_1.findMaxKeyValue(sizeTree, syncStart - 1);
         prevIndex = kv[0];
         prevSize = kv[1];
-        if (offsetTree.length &&
-            offsetTree[startIndex].size === AATree_1.findMaxKeyValue(sizeTree, syncStart)[1]) {
+        if (offsetTree.length && offsetTree[startIndex].size === AATree_1.findMaxKeyValue(sizeTree, syncStart)[1]) {
             startIndex -= 1;
         }
         offsetTree = offsetTree.slice(0, startIndex + 1);
@@ -138,7 +147,8 @@ function createOffsetTree(prevOffsetTree, syncStart, sizeTree) {
     try {
         for (var _b = tslib_1.__values(AATree_1.rangesWithin(sizeTree, syncStart, Infinity)), _c = _b.next(); !_c.done; _c = _b.next()) {
             var _d = _c.value, startIndex_1 = _d.start, value = _d.value;
-            var aOffset = (startIndex_1 - prevIndex) * prevSize + prevOffset;
+            var indexOffset = startIndex_1 - prevIndex;
+            var aOffset = indexOffset * prevSize + prevOffset + indexOffset * gap;
             offsetTree.push({
                 offset: aOffset,
                 size: value,
@@ -165,7 +175,7 @@ function createOffsetTree(prevOffsetTree, syncStart, sizeTree) {
 }
 function sizeStateReducer(state, _a) {
     var _b;
-    var _c = tslib_1.__read(_a, 3), ranges = _c[0], groupIndices = _c[1], log = _c[2];
+    var _c = tslib_1.__read(_a, 4), ranges = _c[0], groupIndices = _c[1], log = _c[2], gap = _c[3];
     if (ranges.length > 0) {
         log('received item sizes', ranges, loggerSystem_1.LogLevel.DEBUG);
     }
@@ -183,12 +193,13 @@ function sizeStateReducer(state, _a) {
         }, newSizeTree);
     }
     else {
+        ;
         _b = tslib_1.__read(insertRanges(newSizeTree, ranges), 2), newSizeTree = _b[0], syncStart = _b[1];
     }
     if (newSizeTree === sizeTree) {
         return state;
     }
-    var _d = createOffsetTree(state.offsetTree, syncStart, newSizeTree), newOffsetTree = _d.offsetTree, lastIndex = _d.lastIndex, lastSize = _d.lastSize, lastOffset = _d.lastOffset;
+    var _d = createOffsetTree(state.offsetTree, syncStart, newSizeTree, gap), newOffsetTree = _d.offsetTree, lastIndex = _d.lastIndex, lastSize = _d.lastSize, lastOffset = _d.lastOffset;
     return {
         sizeTree: newSizeTree,
         offsetTree: newOffsetTree,
@@ -196,20 +207,41 @@ function sizeStateReducer(state, _a) {
         lastOffset: lastOffset,
         lastSize: lastSize,
         groupOffsetTree: groupIndices.reduce(function (tree, index) {
-            return AATree_1.insert(tree, index, offsetOf(index, newOffsetTree));
+            return AATree_1.insert(tree, index, offsetOf(index, newOffsetTree, gap));
         }, AATree_1.newTree()),
         groupIndices: groupIndices,
     };
 }
 exports.sizeStateReducer = sizeStateReducer;
-function offsetOf(index, tree) {
+function offsetOf(index, tree, gap) {
     if (tree.length === 0) {
         return 0;
     }
     var _a = arrayBinarySearch.findClosestSmallerOrEqual(tree, index, indexComparator), offset = _a.offset, startIndex = _a.index, size = _a.size;
-    return size * (index - startIndex) + offset;
+    var itemCount = index - startIndex;
+    var top = size * itemCount + (itemCount - 1) * gap + offset;
+    return top > 0 ? top + gap : top;
 }
 exports.offsetOf = offsetOf;
+function isGroupLocation(location) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    return typeof location.groupIndex !== 'undefined';
+}
+exports.isGroupLocation = isGroupLocation;
+function originalIndexFromLocation(location, sizes, lastIndex) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    if (isGroupLocation(location)) {
+        // return the index of the first item below the index
+        return sizes.groupIndices[location.groupIndex] + 1;
+    }
+    else {
+        var numericIndex = location.index === 'LAST' ? lastIndex : location.index;
+        var result = originalIndexFromItemIndex(numericIndex, sizes);
+        result = Math.max(0, result, Math.min(lastIndex, result));
+        return result;
+    }
+}
+exports.originalIndexFromLocation = originalIndexFromLocation;
 function originalIndexFromItemIndex(itemIndex, sizes) {
     if (!hasGroups(sizes)) {
         return itemIndex;
@@ -226,12 +258,21 @@ function hasGroups(sizes) {
     return !AATree_1.empty(sizes.groupOffsetTree);
 }
 exports.hasGroups = hasGroups;
+function sizeTreeToRanges(sizeTree) {
+    return AATree_1.walk(sizeTree).map(function (_a, index, sizeArray) {
+        var startIndex = _a.k, size = _a.v;
+        var nextSize = sizeArray[index + 1];
+        var endIndex = nextSize ? nextSize.k - 1 : Infinity;
+        return { startIndex: startIndex, endIndex: endIndex, size: size };
+    });
+}
+exports.sizeTreeToRanges = sizeTreeToRanges;
 var SIZE_MAP = {
     offsetHeight: 'height',
     offsetWidth: 'width',
 };
 exports.sizeSystem = u.system(function (_a) {
-    var _b = tslib_1.__read(_a, 1), log = _b[0].log;
+    var _b = tslib_1.__read(_a, 2), log = _b[0].log, recalcInProgress = _b[1].recalcInProgress;
     var sizeRanges = u.stream();
     var totalCount = u.stream();
     var statefulTotalCount = u.statefulStreamFromEmitter(totalCount, 0);
@@ -241,22 +282,30 @@ exports.sizeSystem = u.system(function (_a) {
     var groupIndices = u.statefulStream([]);
     var fixedItemSize = u.statefulStream(undefined);
     var defaultItemSize = u.statefulStream(undefined);
-    var itemSize = u.statefulStream(function (el, field) {
-        return correctItemSize_1.correctItemSize(el, SIZE_MAP[field]);
-    });
+    var itemSize = u.statefulStream(function (el, field) { return correctItemSize_1.correctItemSize(el, SIZE_MAP[field]); });
     var data = u.statefulStream(undefined);
+    var gap = u.statefulStream(0);
     var initial = initialSizeState();
-    var sizes = u.statefulStreamFromEmitter(u.pipe(sizeRanges, u.withLatestFrom(groupIndices, log), u.scan(sizeStateReducer, initial), u.distinctUntilChanged()), initial);
-    u.connect(u.pipe(groupIndices, u.filter(function (indexes) { return indexes.length > 0; }), u.withLatestFrom(sizes), u.map(function (_a) {
-        var _b = tslib_1.__read(_a, 2), groupIndices = _b[0], sizes = _b[1];
+    var sizes = u.statefulStreamFromEmitter(u.pipe(sizeRanges, u.withLatestFrom(groupIndices, log, gap), u.scan(sizeStateReducer, initial), u.distinctUntilChanged()), initial);
+    var prevGroupIndices = u.statefulStreamFromEmitter(u.pipe(groupIndices, u.distinctUntilChanged(), u.scan(function (prev, curr) { return ({ prev: prev.current, current: curr }); }, {
+        prev: [],
+        current: [],
+    }), u.map(function (_a) {
+        var prev = _a.prev;
+        return prev;
+    })), []);
+    u.connect(u.pipe(groupIndices, u.filter(function (indexes) { return indexes.length > 0; }), u.withLatestFrom(sizes, gap), u.map(function (_a) {
+        var _b = tslib_1.__read(_a, 3), groupIndices = _b[0], sizes = _b[1], gap = _b[2];
         var groupOffsetTree = groupIndices.reduce(function (tree, index, idx) {
-            return AATree_1.insert(tree, index, offsetOf(index, sizes.offsetTree) || idx);
+            return AATree_1.insert(tree, index, offsetOf(index, sizes.offsetTree, gap) || idx);
         }, AATree_1.newTree());
         return tslib_1.__assign(tslib_1.__assign({}, sizes), { groupIndices: groupIndices,
             groupOffsetTree: groupOffsetTree });
     })), sizes);
     // decreasing the total count should remove any existing entries
     // beyond the last index - do this by publishing the default size as a range over them.
+    // This causes some size loss in for the last items, but it's better than having the wrong measurements
+    // see #896
     u.connect(u.pipe(totalCount, u.withLatestFrom(sizes), u.filter(function (_a) {
         var _b = tslib_1.__read(_a, 2), totalCount = _b[0], lastIndex = _b[1].lastIndex;
         return totalCount < lastIndex;
@@ -277,7 +326,7 @@ exports.sizeSystem = u.system(function (_a) {
     }), u.map(function (size) { return [{ startIndex: 0, endIndex: 0, size: size }]; })), sizeRanges);
     var listRefresh = u.streamFromEmitter(u.pipe(sizeRanges, u.withLatestFrom(sizes), u.scan(function (_a, _b) {
         var oldSizes = _a.sizes;
-        var _c = tslib_1.__read(_b, 2), newSizes = _c[1];
+        var _c = tslib_1.__read(_b, 2), _ = _c[0], newSizes = _c[1];
         return {
             changed: newSizes !== oldSizes,
             sizes: newSizes,
@@ -286,10 +335,16 @@ exports.sizeSystem = u.system(function (_a) {
     u.subscribe(u.pipe(firstItemIndex, u.scan(function (prev, next) {
         return { diff: prev.prev - next, prev: next };
     }, { diff: 0, prev: 0 }), u.map(function (val) { return val.diff; })), function (offset) {
+        var groupIndices = u.getValue(sizes).groupIndices;
         if (offset > 0) {
-            u.publish(unshiftWith, offset);
+            u.publish(recalcInProgress, true);
+            u.publish(unshiftWith, offset + affectedGroupCount(offset, groupIndices));
         }
         else if (offset < 0) {
+            var prevGroupIndicesValue = u.getValue(prevGroupIndices);
+            if (prevGroupIndicesValue.length > 0) {
+                offset -= affectedGroupCount(-offset, prevGroupIndicesValue);
+            }
             u.publish(shiftWith, offset);
         }
     });
@@ -303,43 +358,117 @@ exports.sizeSystem = u.system(function (_a) {
     var beforeUnshiftWith = u.streamFromEmitter(unshiftWith);
     u.connect(u.pipe(unshiftWith, u.withLatestFrom(sizes), u.map(function (_a) {
         var _b = tslib_1.__read(_a, 2), unshiftWith = _b[0], sizes = _b[1];
-        if (sizes.groupIndices.length > 0) {
-            throw new Error('Virtuoso: prepending items does not work with groups');
+        var groupedMode = sizes.groupIndices.length > 0;
+        var initialRanges = [];
+        var defaultSize = sizes.lastSize;
+        if (groupedMode) {
+            var firstGroupSize = AATree_1.find(sizes.sizeTree, 0);
+            var prependedGroupItemsCount = 0;
+            var groupIndex = 0;
+            while (prependedGroupItemsCount < unshiftWith) {
+                var theGroupIndex = sizes.groupIndices[groupIndex];
+                var groupItemCount = sizes.groupIndices.length === groupIndex + 1 ? Infinity : sizes.groupIndices[groupIndex + 1] - theGroupIndex - 1;
+                initialRanges.push({
+                    startIndex: theGroupIndex,
+                    endIndex: theGroupIndex,
+                    size: firstGroupSize,
+                });
+                initialRanges.push({
+                    startIndex: theGroupIndex + 1,
+                    endIndex: theGroupIndex + 1 + groupItemCount - 1,
+                    size: defaultSize,
+                });
+                groupIndex++;
+                prependedGroupItemsCount += groupItemCount + 1;
+            }
+            var sizeTreeKV = AATree_1.walk(sizes.sizeTree);
+            // here, we detect if the first group item size has increased, so that we can delete its value.
+            var firstGroupIsExpanded = prependedGroupItemsCount !== unshiftWith;
+            if (firstGroupIsExpanded) {
+                // remove the first group item size, already incorporated
+                sizeTreeKV.shift();
+            }
+            return sizeTreeKV.reduce(function (acc, _a) {
+                var index = _a.k, size = _a.v;
+                var ranges = acc.ranges;
+                if (acc.prevSize !== 0) {
+                    ranges = tslib_1.__spread(acc.ranges, [
+                        {
+                            startIndex: acc.prevIndex,
+                            endIndex: index + unshiftWith - 1,
+                            size: acc.prevSize,
+                        },
+                    ]);
+                }
+                return {
+                    ranges: ranges,
+                    prevIndex: index + unshiftWith,
+                    prevSize: size,
+                };
+            }, {
+                ranges: initialRanges,
+                prevIndex: unshiftWith,
+                prevSize: 0,
+            }).ranges;
         }
         return AATree_1.walk(sizes.sizeTree).reduce(function (acc, _a) {
             var index = _a.k, size = _a.v;
             return {
-                ranges: tslib_1.__spread(acc.ranges, [
-                    {
-                        startIndex: acc.prevIndex,
-                        endIndex: index + unshiftWith - 1,
-                        size: acc.prevSize,
-                    },
-                ]),
+                ranges: tslib_1.__spread(acc.ranges, [{ startIndex: acc.prevIndex, endIndex: index + unshiftWith - 1, size: acc.prevSize }]),
                 prevIndex: index + unshiftWith,
                 prevSize: size,
             };
         }, {
             ranges: [],
             prevIndex: 0,
-            prevSize: sizes.lastSize,
+            prevSize: defaultSize,
         }).ranges;
     })), sizeRanges);
-    var shiftWithOffset = u.streamFromEmitter(u.pipe(shiftWith, u.withLatestFrom(sizes), u.map(function (_a) {
-        var _b = tslib_1.__read(_a, 2), shiftWith = _b[0], offsetTree = _b[1].offsetTree;
+    var shiftWithOffset = u.streamFromEmitter(u.pipe(shiftWith, u.withLatestFrom(sizes, gap), u.map(function (_a) {
+        var _b = tslib_1.__read(_a, 3), shiftWith = _b[0], offsetTree = _b[1].offsetTree, gap = _b[2];
         var newFirstItemIndex = -shiftWith;
-        return offsetOf(newFirstItemIndex, offsetTree);
+        return offsetOf(newFirstItemIndex, offsetTree, gap);
     })));
-    u.connect(u.pipe(shiftWith, u.withLatestFrom(sizes), u.map(function (_a) {
-        var _b = tslib_1.__read(_a, 2), shiftWith = _b[0], sizes = _b[1];
-        if (sizes.groupIndices.length > 0) {
-            throw new Error('Virtuoso: shifting items does not work with groups');
+    u.connect(u.pipe(shiftWith, u.withLatestFrom(sizes, gap), u.map(function (_a) {
+        var _b = tslib_1.__read(_a, 3), shiftWith = _b[0], sizes = _b[1], gap = _b[2];
+        var groupedMode = sizes.groupIndices.length > 0;
+        if (groupedMode) {
+            // we can't shift an empty tree
+            if (AATree_1.empty(sizes.sizeTree)) {
+                return sizes;
+            }
+            var newSizeTree = AATree_1.newTree();
+            var prevGroupIndicesValue = u.getValue(prevGroupIndices);
+            var removedItemsCount = 0;
+            var groupIndex = 0;
+            var groupOffset = 0;
+            while (removedItemsCount < -shiftWith) {
+                groupOffset = prevGroupIndicesValue[groupIndex];
+                var groupItemCount = prevGroupIndicesValue[groupIndex + 1] - groupOffset - 1;
+                groupIndex++;
+                removedItemsCount += groupItemCount + 1;
+            }
+            newSizeTree = AATree_1.walk(sizes.sizeTree).reduce(function (acc, _a) {
+                var k = _a.k, v = _a.v;
+                return AATree_1.insert(acc, Math.max(0, k + shiftWith), v);
+            }, newSizeTree);
+            // here, we detect if the first group item size has increased, so that we can delete its value.
+            var aGroupIsShrunk = removedItemsCount !== -shiftWith;
+            if (aGroupIsShrunk) {
+                var firstGroupSize = AATree_1.find(sizes.sizeTree, groupOffset);
+                newSizeTree = AATree_1.insert(newSizeTree, 0, firstGroupSize);
+                var nextItemSize = AATree_1.findMaxKeyValue(sizes.sizeTree, -shiftWith + 1)[1];
+                newSizeTree = AATree_1.insert(newSizeTree, 1, nextItemSize);
+            }
+            return tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({}, sizes), { sizeTree: newSizeTree }), createOffsetTree(sizes.offsetTree, 0, newSizeTree, gap));
+        }
+        else {
+            var newSizeTree = AATree_1.walk(sizes.sizeTree).reduce(function (acc, _a) {
+                var k = _a.k, v = _a.v;
+                return AATree_1.insert(acc, Math.max(0, k + shiftWith), v);
+            }, AATree_1.newTree());
+            return tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({}, sizes), { sizeTree: newSizeTree }), createOffsetTree(sizes.offsetTree, 0, newSizeTree, gap));
         }
-        var newSizeTree = AATree_1.walk(sizes.sizeTree).reduce(function (acc, _a) {
-            var k = _a.k, v = _a.v;
-            return AATree_1.insert(acc, Math.max(0, k + shiftWith), v);
-        }, AATree_1.newTree());
-        return tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({}, sizes), { sizeTree: newSizeTree }), createOffsetTree(sizes.offsetTree, 0, newSizeTree));
     })), sizes);
     return {
         // input
@@ -354,6 +483,7 @@ exports.sizeSystem = u.system(function (_a) {
         shiftWithOffset: shiftWithOffset,
         beforeUnshiftWith: beforeUnshiftWith,
         firstItemIndex: firstItemIndex,
+        gap: gap,
         // output
         sizes: sizes,
         listRefresh: listRefresh,
@@ -361,4 +491,4 @@ exports.sizeSystem = u.system(function (_a) {
         trackItemSizes: trackItemSizes,
         itemSize: itemSize,
     };
-}, u.tup(loggerSystem_1.loggerSystem), { singleton: true });
+}, u.tup(loggerSystem_1.loggerSystem, recalcSystem_1.recalcSystem), { singleton: true });

package/components/Virtuoso/react-virtuoso/stateFlagsSystem.d.ts

@@ -1,4 +1,4 @@
-import * as u from '@virtuoso.dev/urx';
+import * as u from './urx';
 export declare const UP: "up";
 export declare const DOWN: "down";
 export declare const NONE: "none";
@@ -30,31 +30,33 @@ export declare const stateFlagsSystem: u.SystemSpec<[u.SystemSpec<never[], () =>
     scrollTop: u.Stream<number>;
     viewportHeight: u.Stream<number>;
     headerHeight: u.StatefulStream<number>;
+    fixedHeaderHeight: u.StatefulStream<number>;
+    fixedFooterHeight: u.StatefulStream<number>;
     footerHeight: u.StatefulStream<number>;
     scrollHeight: u.Stream<number>;
     smoothScrollTargetReached: u.Stream<true>;
-    react18ConcurrentRendering: u.StatefulStream<boolean>;
     scrollTo: u.Stream<ScrollToOptions>;
     scrollBy: u.Stream<ScrollToOptions>;
     statefulScrollTop: u.StatefulStream<number>;
     deviation: u.StatefulStream<number>;
     scrollingInProgress: u.StatefulStream<boolean>;
-}>], ([{ scrollContainerState, scrollTop, viewportHeight, headerHeight, footerHeight, scrollBy, },]: [{
+}>], ([{ scrollContainerState, scrollTop, viewportHeight, headerHeight, footerHeight, scrollBy }]: [{
     scrollContainerState: u.Stream<import("./interfaces").ScrollContainerState>;
     scrollTop: u.Stream<number>;
     viewportHeight: u.Stream<number>;
     headerHeight: u.StatefulStream<number>;
+    fixedHeaderHeight: u.StatefulStream<number>;
+    fixedFooterHeight: u.StatefulStream<number>;
     footerHeight: u.StatefulStream<number>;
     scrollHeight: u.Stream<number>;
     smoothScrollTargetReached: u.Stream<true>;
-    react18ConcurrentRendering: u.StatefulStream<boolean>;
     scrollTo: u.Stream<ScrollToOptions>;
     scrollBy: u.Stream<ScrollToOptions>;
     statefulScrollTop: u.StatefulStream<number>;
     deviation: u.StatefulStream<number>;
     scrollingInProgress: u.StatefulStream<boolean>;
 }]) => {
-    isScrolling: u.Stream<boolean>;
+    isScrolling: u.StatefulStream<boolean>;
     isAtTop: u.StatefulStream<boolean>;
     isAtBottom: u.StatefulStream<boolean>;
     atBottomState: u.Stream<AtBottomState>;
@@ -62,6 +64,7 @@ export declare const stateFlagsSystem: u.SystemSpec<[u.SystemSpec<never[], () =>
     atBottomStateChange: u.Stream<boolean>;
     scrollDirection: u.StatefulStream<ScrollDirection>;
     atBottomThreshold: u.StatefulStream<number>;
+    atTopThreshold: u.StatefulStream<number>;
     scrollVelocity: u.StatefulStream<number>;
     lastJumpDueToItemResize: u.StatefulStream<number>;
 }>;

package/components/Virtuoso/react-virtuoso/stateFlagsSystem.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 var tslib_1 = require("tslib");
-/* eslint-disable @typescript-eslint/no-unused-vars */
-var u = tslib_1.__importStar(require("@virtuoso.dev/urx"));
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+var u = tslib_1.__importStar(require("./urx"));
 var domIOSystem_1 = require("./domIOSystem");
+var approximatelyEqual_1 = require("./utils/approximatelyEqual");
 exports.UP = 'up';
 exports.DOWN = 'down';
 exports.NONE = 'none';
@@ -17,6 +18,7 @@ var INITIAL_BOTTOM_STATE = {
         scrollHeight: 0,
     },
 };
+var DEFAULT_AT_TOP_THRESHOLD = 0;
 exports.stateFlagsSystem = u.system(function (_a) {
     var _b = tslib_1.__read(_a, 1), _c = _b[0], scrollContainerState = _c.scrollContainerState, scrollTop = _c.scrollTop, viewportHeight = _c.viewportHeight, headerHeight = _c.headerHeight, footerHeight = _c.footerHeight, scrollBy = _c.scrollBy;
     var isAtBottom = u.statefulStream(false);
@@ -24,12 +26,16 @@ exports.stateFlagsSystem = u.system(function (_a) {
     var atBottomStateChange = u.stream();
     var atTopStateChange = u.stream();
     var atBottomThreshold = u.statefulStream(4);
+    var atTopThreshold = u.statefulStream(DEFAULT_AT_TOP_THRESHOLD);
     // skip 1 to avoid an initial on/off flick
-    var isScrolling = u.streamFromEmitter(u.pipe(u.merge(u.pipe(u.duc(scrollTop), u.skip(1), u.mapTo(true)), u.pipe(u.duc(scrollTop), u.skip(1), u.mapTo(false), u.debounceTime(100))), u.distinctUntilChanged()));
+    var isScrolling = u.statefulStreamFromEmitter(u.pipe(u.merge(u.pipe(u.duc(scrollTop), u.skip(1), u.mapTo(true)), u.pipe(u.duc(scrollTop), u.skip(1), u.mapTo(false), u.debounceTime(100))), u.distinctUntilChanged()), false);
     var isScrollingBy = u.statefulStreamFromEmitter(u.pipe(u.merge(u.pipe(scrollBy, u.mapTo(true)), u.pipe(scrollBy, u.mapTo(false), u.debounceTime(200))), u.distinctUntilChanged()), false);
     // u.subscribe(isScrollingBy, (isScrollingBy) => console.log({ isScrollingBy }))
-    u.connect(u.pipe(u.duc(scrollTop), u.map(function (top) { return top === 0; }), u.distinctUntilChanged()), isAtTop);
-    u.connect(isAtTop, atTopStateChange);
+    u.connect(u.pipe(u.combineLatest(u.duc(scrollTop), u.duc(atTopThreshold)), u.map(function (_a) {
+        var _b = tslib_1.__read(_a, 2), top = _b[0], atTopThreshold = _b[1];
+        return top <= atTopThreshold;
+    }), u.distinctUntilChanged()), isAtTop);
+    u.connect(u.pipe(isAtTop, u.throttleTime(50)), atTopStateChange);
     var atBottomState = u.streamFromEmitter(u.pipe(u.combineLatest(scrollContainerState, u.duc(viewportHeight), u.duc(headerHeight), u.duc(footerHeight), u.duc(atBottomThreshold)), u.scan(function (current, _a) {
         var _b = tslib_1.__read(_a, 5), _c = _b[0], scrollTop = _c.scrollTop, scrollHeight = _c.scrollHeight, viewportHeight = _b[1], _headerHeight = _b[2], _footerHeight = _b[3], atBottomThreshold = _b[4];
         var isAtBottom = scrollTop + viewportHeight - scrollHeight > -atBottomThreshold;
@@ -47,9 +53,7 @@ exports.stateFlagsSystem = u.system(function (_a) {
             }
             else {
                 atBottomBecause = 'SIZE_DECREASED';
-                scrollTopDelta =
-                    current.state.scrollTop - scrollTop ||
-                        current.scrollTopDelta;
+                scrollTopDelta = current.state.scrollTop - scrollTop || current.scrollTopDelta;
             }
             return {
                 atBottom: true,
@@ -81,8 +85,8 @@ exports.stateFlagsSystem = u.system(function (_a) {
     })));
     var lastJumpDueToItemResize = u.statefulStreamFromEmitter(u.pipe(scrollContainerState, u.scan(function (current, _a) {
         var scrollTop = _a.scrollTop, scrollHeight = _a.scrollHeight, viewportHeight = _a.viewportHeight;
-        if (current.scrollHeight !== scrollHeight) {
-            var atBottom = scrollTop === scrollHeight - viewportHeight;
+        if (!approximatelyEqual_1.approximatelyEqual(current.scrollHeight, scrollHeight)) {
+            var atBottom = scrollHeight - (scrollTop + viewportHeight) < 1;
             if (current.scrollTop !== scrollTop && atBottom) {
                 return {
                     scrollHeight: scrollHeight,
@@ -91,19 +95,23 @@ exports.stateFlagsSystem = u.system(function (_a) {
                     changed: true,
                 };
             }
+            else {
+                return {
+                    scrollHeight: scrollHeight,
+                    scrollTop: scrollTop,
+                    jump: 0,
+                    changed: true,
+                };
+            }
+        }
+        else {
             return {
-                scrollHeight: scrollHeight,
                 scrollTop: scrollTop,
+                scrollHeight: scrollHeight,
                 jump: 0,
-                changed: true,
+                changed: false,
             };
         }
-        return {
-            scrollTop: scrollTop,
-            scrollHeight: scrollHeight,
-            jump: 0,
-            changed: false,
-        };
     }, { scrollHeight: 0, jump: 0, scrollTop: 0, changed: false }), u.filter(function (value) { return value.changed; }), u.map(function (value) { return value.jump; })), 0);
     u.connect(u.pipe(atBottomState, u.map(function (state) { return state.atBottom; })), isAtBottom);
     u.connect(u.pipe(isAtBottom, u.throttleTime(50)), atBottomStateChange);
@@ -117,14 +125,14 @@ exports.stateFlagsSystem = u.system(function (_a) {
         if (u.getValue(isScrollingBy)) {
             return { direction: acc.direction, prevScrollTop: scrollTop };
         }
-        return {
-            direction: scrollTop < acc.prevScrollTop ? exports.UP : exports.DOWN,
-            prevScrollTop: scrollTop,
-        };
+        return { direction: scrollTop < acc.prevScrollTop ? exports.UP : exports.DOWN, prevScrollTop: scrollTop };
     }, { direction: exports.DOWN, prevScrollTop: 0 }), u.map(function (value) { return value.direction; })), scrollDirection);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
     u.connect(u.pipe(scrollContainerState, u.throttleTime(50), u.mapTo(exports.NONE)), scrollDirection);
     var scrollVelocity = u.statefulStream(0);
-    u.connect(u.pipe(isScrolling, u.filter(function (value) { return !value; }), u.mapTo(0)), scrollVelocity);
+    u.connect(u.pipe(isScrolling, u.filter(function (value) { return !value; }), 
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    u.mapTo(0)), scrollVelocity);
     u.connect(u.pipe(scrollTop, u.throttleTime(100), u.withLatestFrom(isScrolling), u.filter(function (_a) {
         var _b = tslib_1.__read(_a, 2), _ = _b[0], isScrolling = _b[1];
         return !!isScrolling;
@@ -145,6 +153,7 @@ exports.stateFlagsSystem = u.system(function (_a) {
         atBottomStateChange: atBottomStateChange,
         scrollDirection: scrollDirection,
         atBottomThreshold: atBottomThreshold,
+        atTopThreshold: atTopThreshold,
         scrollVelocity: scrollVelocity,
         lastJumpDueToItemResize: lastJumpDueToItemResize,
     };