@ringcentral/juno 2.40.0 → 2.41.0

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 var tslib_1 = require("tslib");
-var u = tslib_1.__importStar(require("@virtuoso.dev/urx"));
+var u = tslib_1.__importStar(require("./urx"));
 var comparators_1 = require("./comparators");
 var domIOSystem_1 = require("./domIOSystem");
 var propsReadySystem_1 = require("./propsReadySystem");
@@ -9,7 +9,10 @@ var scrollSeekSystem_1 = require("./scrollSeekSystem");
 var scrollToIndexSystem_1 = require("./scrollToIndexSystem");
 var sizeRangeSystem_1 = require("./sizeRangeSystem");
 var stateFlagsSystem_1 = require("./stateFlagsSystem");
+var loggerSystem_1 = require("./loggerSystem");
 var windowScrollerSystem_1 = require("./windowScrollerSystem");
+var initialTopMostItemIndexSystem_1 = require("./initialTopMostItemIndexSystem");
+var skipFrames_1 = require("./utils/skipFrames");
 var INITIAL_GRID_STATE = {
     items: [],
     offsetBottom: 0,
@@ -29,86 +32,161 @@ var PROBE_GRID_STATE = {
     itemWidth: 0,
 };
 var round = Math.round, ceil = Math.ceil, floor = Math.floor, min = Math.min, max = Math.max;
-function buildItems(startIndex, endIndex) {
-    return Array.from({ length: endIndex - startIndex + 1 }).map(function (_, i) { return ({ index: i + startIndex }); });
+function buildProbeGridState(items) {
+    return tslib_1.__assign(tslib_1.__assign({}, PROBE_GRID_STATE), { items: items });
+}
+function buildItems(startIndex, endIndex, data) {
+    return Array.from({ length: endIndex - startIndex + 1 }).map(function (_, i) {
+        var dataItem = data === null ? null : data[i + startIndex];
+        return { index: i + startIndex, data: dataItem };
+    });
+}
+function gapComparator(prev, next) {
+    return prev && prev.column === next.column && prev.row === next.row;
+}
+function dimensionComparator(prev, next) {
+    return prev && prev.width === next.width && prev.height === next.height;
 }
 exports.gridSystem = u.system(function (_a) {
-    var _b = tslib_1.__read(_a, 6), _c = _b[0], overscan = _c.overscan, visibleRange = _c.visibleRange, listBoundary = _c.listBoundary, _d = _b[1], scrollTop = _d.scrollTop, viewportHeight = _d.viewportHeight, scrollBy = _d.scrollBy, scrollTo = _d.scrollTo, smoothScrollTargetReached = _d.smoothScrollTargetReached, scrollContainerState = _d.scrollContainerState, stateFlags = _b[2], scrollSeek = _b[3], _e = _b[4], propsReady = _e.propsReady, didMount = _e.didMount, _f = _b[5], windowViewportRect = _f.windowViewportRect, windowScrollTo = _f.windowScrollTo, useWindowScroll = _f.useWindowScroll, customScrollParent = _f.customScrollParent, windowScrollContainerState = _f.windowScrollContainerState;
+    var _b = tslib_1.__read(_a, 7), _c = _b[0], overscan = _c.overscan, visibleRange = _c.visibleRange, listBoundary = _c.listBoundary, _d = _b[1], scrollTop = _d.scrollTop, viewportHeight = _d.viewportHeight, scrollBy = _d.scrollBy, scrollTo = _d.scrollTo, smoothScrollTargetReached = _d.smoothScrollTargetReached, scrollContainerState = _d.scrollContainerState, footerHeight = _d.footerHeight, headerHeight = _d.headerHeight, stateFlags = _b[2], scrollSeek = _b[3], _e = _b[4], propsReady = _e.propsReady, didMount = _e.didMount, _f = _b[5], windowViewportRect = _f.windowViewportRect, useWindowScroll = _f.useWindowScroll, customScrollParent = _f.customScrollParent, windowScrollContainerState = _f.windowScrollContainerState, windowScrollTo = _f.windowScrollTo, log = _b[6];
     var totalCount = u.statefulStream(0);
     var initialItemCount = u.statefulStream(0);
     var gridState = u.statefulStream(INITIAL_GRID_STATE);
-    var viewportDimensions = u.statefulStream({
-        height: 0,
-        width: 0,
-    });
-    var itemDimensions = u.statefulStream({
-        height: 0,
-        width: 0,
-    });
+    var viewportDimensions = u.statefulStream({ height: 0, width: 0 });
+    var itemDimensions = u.statefulStream({ height: 0, width: 0 });
     var scrollToIndex = u.stream();
     var scrollHeight = u.stream();
     var deviation = u.statefulStream(0);
-    u.connect(u.pipe(didMount, u.withLatestFrom(initialItemCount), u.filter(function (_a) {
-        var _b = tslib_1.__read(_a, 2), count = _b[1];
-        return count !== 0;
+    var data = u.statefulStream(null);
+    var gap = u.statefulStream({ row: 0, column: 0 });
+    var stateChanged = u.stream();
+    var restoreStateFrom = u.stream();
+    var stateRestoreInProgress = u.statefulStream(false);
+    var initialTopMostItemIndex = u.statefulStream(0);
+    var scrolledToInitialItem = u.statefulStream(true);
+    var scrollScheduled = u.statefulStream(false);
+    u.subscribe(u.pipe(didMount, u.withLatestFrom(initialTopMostItemIndex), u.filter(function (_a) {
+        var _b = tslib_1.__read(_a, 2), _ = _b[0], location = _b[1];
+        return !!location;
+    })), function () {
+        // console.log('block rendering')
+        u.publish(scrolledToInitialItem, false);
+        // topmost item index takes precedence over initial item count
+        u.publish(initialItemCount, 0);
+    });
+    u.subscribe(u.pipe(u.combineLatest(didMount, scrolledToInitialItem, itemDimensions, viewportDimensions, initialTopMostItemIndex, scrollScheduled), u.filter(function (_a) {
+        var _b = tslib_1.__read(_a, 6), didMount = _b[0], scrolledToInitialItem = _b[1], itemDimensions = _b[2], viewportDimensions = _b[3], scrollScheduled = _b[5];
+        return didMount && !scrolledToInitialItem && itemDimensions.height !== 0 && viewportDimensions.height !== 0 && !scrollScheduled;
+    })), function (_a) {
+        var _b = tslib_1.__read(_a, 5), initialTopMostItemIndex = _b[4];
+        u.publish(scrollScheduled, true);
+        skipFrames_1.skipFrames(1, function () {
+            u.publish(scrollToIndex, initialTopMostItemIndex);
+        });
+        u.handleNext(u.pipe(scrollTop), function () {
+            // this refreshes the sizeRangeSystem start/endOffset
+            u.publish(listBoundary, [0, 0]);
+            // console.log('resume rendering')
+            u.publish(scrolledToInitialItem, true);
+        });
+    });
+    // state snapshot takes precedence over initial item count
+    u.connect(u.pipe(restoreStateFrom, u.filter(function (value) { return value !== undefined && value !== null && value.scrollTop > 0; }), u.mapTo(0)), initialItemCount);
+    u.subscribe(u.pipe(didMount, u.withLatestFrom(restoreStateFrom), u.filter(function (_a) {
+        var _b = tslib_1.__read(_a, 2), snapshot = _b[1];
+        return snapshot !== undefined && snapshot !== null;
+    })), function (_a) {
+        var _b = tslib_1.__read(_a, 2), snapshot = _b[1];
+        if (!snapshot) {
+            return;
+        }
+        u.publish(viewportDimensions, snapshot.viewport), u.publish(itemDimensions, snapshot === null || snapshot === void 0 ? void 0 : snapshot.item);
+        u.publish(gap, snapshot.gap);
+        if (snapshot.scrollTop > 0) {
+            u.publish(stateRestoreInProgress, true);
+            u.handleNext(u.pipe(scrollTop, u.skip(1)), function (_value) {
+                u.publish(stateRestoreInProgress, false);
+            });
+            u.publish(scrollTo, { top: snapshot.scrollTop });
+        }
+    });
+    u.connect(u.pipe(viewportDimensions, u.map(function (_a) {
+        var height = _a.height;
+        return height;
+    })), viewportHeight);
+    u.connect(u.pipe(u.combineLatest(u.duc(viewportDimensions, dimensionComparator), u.duc(itemDimensions, dimensionComparator), u.duc(gap, function (prev, next) { return prev && prev.column === next.column && prev.row === next.row; }), u.duc(scrollTop)), u.map(function (_a) {
+        var _b = tslib_1.__read(_a, 4), viewport = _b[0], item = _b[1], gap = _b[2], scrollTop = _b[3];
+        return ({
+            viewport: viewport,
+            item: item,
+            gap: gap,
+            scrollTop: scrollTop,
+        });
+    })), stateChanged);
+    u.connect(u.pipe(u.combineLatest(u.duc(totalCount), visibleRange, u.duc(gap, gapComparator), u.duc(itemDimensions, dimensionComparator), u.duc(viewportDimensions, dimensionComparator), u.duc(data), u.duc(initialItemCount), u.duc(stateRestoreInProgress), u.duc(scrolledToInitialItem), u.duc(initialTopMostItemIndex)), u.filter(function (_a) {
+        var _b = tslib_1.__read(_a, 8), stateRestoreInProgress = _b[7];
+        return !stateRestoreInProgress;
     }), u.map(function (_a) {
-        var _b = tslib_1.__read(_a, 2), count = _b[1];
-        return {
-            items: buildItems(0, count - 1),
-            top: 0,
-            bottom: 0,
-            offsetBottom: 0,
-            offsetTop: 0,
-            itemHeight: 0,
-            itemWidth: 0,
-        };
-    })), gridState);
-    u.connect(u.pipe(u.combineLatest(u.duc(totalCount), visibleRange, u.duc(itemDimensions, function (prev, next) {
-        return prev && prev.width === next.width && prev.height === next.height;
-    })), u.withLatestFrom(viewportDimensions), u.map(function (_a) {
-        var _b = tslib_1.__read(_a, 2), _c = tslib_1.__read(_b[0], 3), totalCount = _c[0], _d = tslib_1.__read(_c[1], 2), startOffset = _d[0], endOffset = _d[1], item = _c[2], viewport = _b[1];
+        var _b = tslib_1.__read(_a, 10), totalCount = _b[0], _c = tslib_1.__read(_b[1], 2), startOffset = _c[0], endOffset = _c[1], gap = _b[2], item = _b[3], viewport = _b[4], data = _b[5], initialItemCount = _b[6], scrolledToInitialItem = _b[8], initialTopMostItemIndex = _b[9];
+        var rowGap = gap.row, columnGap = gap.column;
         var itemHeight = item.height, itemWidth = item.width;
         var viewportWidth = viewport.width;
-        if (totalCount === 0 || viewportWidth === 0) {
+        // don't wipeout the already rendered state if there's an initial item count
+        if (initialItemCount === 0 && (totalCount === 0 || viewportWidth === 0)) {
             return INITIAL_GRID_STATE;
         }
         if (itemWidth === 0) {
-            return PROBE_GRID_STATE;
+            var startIndex_1 = initialTopMostItemIndexSystem_1.getInitialTopMostItemIndexNumber(initialTopMostItemIndex, totalCount);
+            // if the initial item count is set, we don't render the items from the initial item count.
+            var endIndex_1 = startIndex_1 === 0 ? Math.max(initialItemCount - 1, 0) : startIndex_1;
+            return buildProbeGridState(buildItems(startIndex_1, endIndex_1, data));
+        }
+        var perRow = itemsPerRow(viewportWidth, itemWidth, columnGap);
+        var startIndex;
+        var endIndex;
+        // render empty items until the scroller reaches the initial item
+        if (!scrolledToInitialItem) {
+            startIndex = 0;
+            endIndex = -1;
+        }
+        // we know the dimensions from a restored state, but the offsets are not calculated yet
+        else if (startOffset === 0 && endOffset === 0 && initialItemCount > 0) {
+            startIndex = 0;
+            endIndex = initialItemCount - 1;
         }
-        var perRow = itemsPerRow(viewportWidth, itemWidth);
-        var startIndex = perRow * floor(startOffset / itemHeight);
-        var endIndex = perRow * ceil(endOffset / itemHeight) - 1;
-        endIndex = min(totalCount - 1, endIndex);
-        startIndex = min(endIndex, max(0, startIndex));
-        var items = buildItems(startIndex, endIndex);
-        var _e = gridLayout(viewport, item, items), top = _e.top, bottom = _e.bottom;
-        var totalHeight = ceil(totalCount / perRow) * itemHeight;
+        else {
+            startIndex = perRow * floor((startOffset + rowGap) / (itemHeight + rowGap));
+            endIndex = perRow * ceil((endOffset + rowGap) / (itemHeight + rowGap)) - 1;
+            endIndex = min(totalCount - 1, max(endIndex, perRow - 1));
+            startIndex = min(endIndex, max(0, startIndex));
+        }
+        var items = buildItems(startIndex, endIndex, data);
+        var _d = gridLayout(viewport, gap, item, items), top = _d.top, bottom = _d.bottom;
+        var rowCount = ceil(totalCount / perRow);
+        var totalHeight = rowCount * itemHeight + (rowCount - 1) * rowGap;
         var offsetBottom = totalHeight - bottom;
-        return {
-            items: items,
-            offsetTop: top,
-            offsetBottom: offsetBottom,
-            top: top,
-            bottom: bottom,
-            itemHeight: itemHeight,
-            itemWidth: itemWidth,
-        };
+        return { items: items, offsetTop: top, offsetBottom: offsetBottom, top: top, bottom: bottom, itemHeight: itemHeight, itemWidth: itemWidth };
     })), gridState);
-    u.connect(u.pipe(viewportDimensions, u.map(function (_a) {
-        var height = _a.height;
-        return height;
-    })), viewportHeight);
-    u.connect(u.pipe(u.combineLatest(viewportDimensions, itemDimensions, gridState), u.map(function (_a) {
-        var _b = tslib_1.__read(_a, 3), viewportDimensions = _b[0], item = _b[1], items = _b[2].items;
-        var _c = gridLayout(viewportDimensions, item, items), top = _c.top, bottom = _c.bottom;
+    u.connect(u.pipe(data, u.filter(function (data) { return data !== null; }), u.map(function (data) { return data.length; })), totalCount);
+    u.connect(u.pipe(u.combineLatest(viewportDimensions, itemDimensions, gridState, gap), u.filter(function (_a) {
+        var _b = tslib_1.__read(_a, 3), viewportDimensions = _b[0], itemDimensions = _b[1], items = _b[2].items;
+        return items.length > 0 && itemDimensions.height !== 0 && viewportDimensions.height !== 0;
+    }), u.map(function (_a) {
+        var _b = tslib_1.__read(_a, 4), viewportDimensions = _b[0], itemDimensions = _b[1], items = _b[2].items, gap = _b[3];
+        var _c = gridLayout(viewportDimensions, gap, itemDimensions, items), top = _c.top, bottom = _c.bottom;
         return [top, bottom];
     }), u.distinctUntilChanged(comparators_1.tupleComparator)), listBoundary);
+    var hasScrolled = u.statefulStream(false);
+    u.connect(u.pipe(scrollTop, u.withLatestFrom(hasScrolled), u.map(function (_a) {
+        var _b = tslib_1.__read(_a, 2), scrollTop = _b[0], hasScrolled = _b[1];
+        return hasScrolled || scrollTop !== 0;
+    })), hasScrolled);
     var endReached = u.streamFromEmitter(u.pipe(u.duc(gridState), u.filter(function (_a) {
         var items = _a.items;
         return items.length > 0;
-    }), u.withLatestFrom(totalCount), u.filter(function (_a) {
-        var _b = tslib_1.__read(_a, 2), items = _b[0].items, totalCount = _b[1];
-        return items[items.length - 1].index === totalCount - 1;
+    }), u.withLatestFrom(totalCount, hasScrolled), u.filter(function (_a) {
+        var _b = tslib_1.__read(_a, 3), items = _b[0].items, totalCount = _b[1], hasScrolled = _b[2];
+        return hasScrolled && items[items.length - 1].index === totalCount - 1;
     }), u.map(function (_a) {
         var _b = tslib_1.__read(_a, 2), totalCount = _b[1];
         return totalCount - 1;
@@ -116,20 +194,22 @@ exports.gridSystem = u.system(function (_a) {
     var startReached = u.streamFromEmitter(u.pipe(u.duc(gridState), u.filter(function (_a) {
         var items = _a.items;
         return items.length > 0 && items[0].index === 0;
-    }), u.mapTo(0), u.distinctUntilChanged()));
-    var rangeChanged = u.streamFromEmitter(u.pipe(u.duc(gridState), u.filter(function (_a) {
-        var items = _a.items;
-        return items.length > 0;
+    }), 
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    u.mapTo(0), u.distinctUntilChanged()));
+    var rangeChanged = u.streamFromEmitter(u.pipe(u.duc(gridState), u.withLatestFrom(stateRestoreInProgress), u.filter(function (_a) {
+        var _b = tslib_1.__read(_a, 2), items = _b[0].items, stateRestoreInProgress = _b[1];
+        return items.length > 0 && !stateRestoreInProgress;
     }), u.map(function (_a) {
-        var items = _a.items;
+        var _b = tslib_1.__read(_a, 1), items = _b[0].items;
         return {
             startIndex: items[0].index,
             endIndex: items[items.length - 1].index,
         };
-    }), u.distinctUntilChanged(comparators_1.rangeComparator)));
+    }), u.distinctUntilChanged(comparators_1.rangeComparator), u.throttleTime(0)));
     u.connect(rangeChanged, scrollSeek.scrollSeekRangeChanged);
-    u.connect(u.pipe(scrollToIndex, u.withLatestFrom(viewportDimensions, itemDimensions, totalCount), u.map(function (_a) {
-        var _b = tslib_1.__read(_a, 4), location = _b[0], viewport = _b[1], item = _b[2], totalCount = _b[3];
+    u.connect(u.pipe(scrollToIndex, u.withLatestFrom(viewportDimensions, itemDimensions, totalCount, gap), u.map(function (_a) {
+        var _b = tslib_1.__read(_a, 5), location = _b[0], viewportDimensions = _b[1], itemDimensions = _b[2], totalCount = _b[3], gap = _b[4];
         var normalLocation = scrollToIndexSystem_1.normalizeIndexLocation(location);
         var align = normalLocation.align, behavior = normalLocation.behavior, offset = normalLocation.offset;
         var index = normalLocation.index;
@@ -137,12 +217,12 @@ exports.gridSystem = u.system(function (_a) {
             index = totalCount - 1;
         }
         index = max(0, index, min(totalCount - 1, index));
-        var top = itemTop(viewport, item, index);
+        var top = itemTop(viewportDimensions, gap, itemDimensions, index);
         if (align === 'end') {
-            top = round(top - viewport.height + item.height);
+            top = round(top - viewportDimensions.height + itemDimensions.height);
         }
         else if (align === 'center') {
-            top = round(top - viewport.height / 2 + item.height / 2);
+            top = round(top - viewportDimensions.height / 2 + itemDimensions.height / 2);
         }
         if (offset) {
             top += offset;
@@ -152,12 +232,10 @@ exports.gridSystem = u.system(function (_a) {
     var totalListHeight = u.statefulStreamFromEmitter(u.pipe(gridState, u.map(function (gridState) {
         return gridState.offsetBottom + gridState.bottom;
     })), 0);
-    u.connect(u.pipe(windowViewportRect, u.map(function (viewportInfo) { return ({
-        width: viewportInfo.visibleWidth,
-        height: viewportInfo.visibleHeight,
-    }); })), viewportDimensions);
-    return tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({ 
+    u.connect(u.pipe(windowViewportRect, u.map(function (viewportInfo) { return ({ width: viewportInfo.visibleWidth, height: viewportInfo.visibleHeight }); })), viewportDimensions);
+    return tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({ 
         // input
+        data: data,
         totalCount: totalCount,
         viewportDimensions: viewportDimensions,
         itemDimensions: itemDimensions,
@@ -175,27 +253,36 @@ exports.gridSystem = u.system(function (_a) {
         windowScrollContainerState: windowScrollContainerState,
         deviation: deviation,
         scrollContainerState: scrollContainerState,
-        initialItemCount: initialItemCount }, scrollSeek), { 
+        footerHeight: footerHeight,
+        headerHeight: headerHeight,
+        initialItemCount: initialItemCount,
+        gap: gap,
+        restoreStateFrom: restoreStateFrom }, scrollSeek), { initialTopMostItemIndex: initialTopMostItemIndex,
         // output
         gridState: gridState,
         totalListHeight: totalListHeight }), stateFlags), { startReached: startReached,
         endReached: endReached,
         rangeChanged: rangeChanged,
-        propsReady: propsReady });
-}, u.tup(sizeRangeSystem_1.sizeRangeSystem, domIOSystem_1.domIOSystem, stateFlagsSystem_1.stateFlagsSystem, scrollSeekSystem_1.scrollSeekSystem, propsReadySystem_1.propsReadySystem, windowScrollerSystem_1.windowScrollerSystem));
-function gridLayout(viewport, item, items) {
+        stateChanged: stateChanged,
+        propsReady: propsReady,
+        stateRestoreInProgress: stateRestoreInProgress }), log);
+}, u.tup(sizeRangeSystem_1.sizeRangeSystem, domIOSystem_1.domIOSystem, stateFlagsSystem_1.stateFlagsSystem, scrollSeekSystem_1.scrollSeekSystem, propsReadySystem_1.propsReadySystem, windowScrollerSystem_1.windowScrollerSystem, loggerSystem_1.loggerSystem));
+function gridLayout(viewport, gap, item, items) {
     var itemHeight = item.height;
     if (itemHeight === undefined || items.length === 0) {
         return { top: 0, bottom: 0 };
     }
-    var top = itemTop(viewport, item, items[0].index);
-    var bottom = itemTop(viewport, item, items[items.length - 1].index) + itemHeight;
+    var top = itemTop(viewport, gap, item, items[0].index);
+    var bottom = itemTop(viewport, gap, item, items[items.length - 1].index) + itemHeight;
     return { top: top, bottom: bottom };
 }
-function itemTop(viewport, item, index) {
-    var perRow = itemsPerRow(viewport.width, item.width);
-    return floor(index / perRow) * item.height;
+function itemTop(viewport, gap, item, index) {
+    var perRow = itemsPerRow(viewport.width, item.width, gap.column);
+    var rowCount = floor(index / perRow);
+    var top = rowCount * item.height + max(0, rowCount - 1) * gap.row;
+    return top > 0 ? top + gap.row : top;
 }
-function itemsPerRow(viewportWidth, itemWidth) {
-    return max(1, floor(viewportWidth / itemWidth));
+function itemsPerRow(viewportWidth, itemWidth, gap) {
+    return max(1, floor((viewportWidth + gap) / (floor(itemWidth) + gap)));
 }
+exports.itemsPerRow = itemsPerRow;

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

@@ -1,77 +1,86 @@
+import * as u from './urx';
 export interface GroupIndexesAndCount {
     totalCount: number;
     groupIndices: number[];
 }
 export declare function groupCountsToIndicesAndCount(counts: number[]): GroupIndexesAndCount;
-export declare const groupedListSystem: import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<[import("@virtuoso.dev/urx").SystemSpec<never[], () => {
-    log: import("@virtuoso.dev/urx").StatefulStream<import("./loggerSystem").Log>;
-    logLevel: import("@virtuoso.dev/urx").StatefulStream<import("./loggerSystem").LogLevel>;
-}>], ([{ log }]: [{
-    log: import("@virtuoso.dev/urx").StatefulStream<import("./loggerSystem").Log>;
-    logLevel: import("@virtuoso.dev/urx").StatefulStream<import("./loggerSystem").LogLevel>;
+export declare const groupedListSystem: u.SystemSpec<[u.SystemSpec<[u.SystemSpec<never[], () => {
+    log: u.StatefulStream<import("./loggerSystem").Log>;
+    logLevel: u.StatefulStream<import("./loggerSystem").LogLevel>;
+}>, u.SystemSpec<never[], () => {
+    recalcInProgress: u.StatefulStream<boolean>;
+}>], ([{ log }, { recalcInProgress }]: [{
+    log: u.StatefulStream<import("./loggerSystem").Log>;
+    logLevel: u.StatefulStream<import("./loggerSystem").LogLevel>;
+}, {
+    recalcInProgress: u.StatefulStream<boolean>;
 }]) => {
-    data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
-    totalCount: import("@virtuoso.dev/urx").Stream<number>;
-    sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
-    groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
-    defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
-    fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
-    unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
-    shiftWith: import("@virtuoso.dev/urx").Stream<number>;
-    shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
-    beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
-    firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
-    sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
-    listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
-    statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
-    trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
-    itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
-}>, import("@virtuoso.dev/urx").SystemSpec<never[], () => {
-    scrollContainerState: import("@virtuoso.dev/urx").Stream<import("./interfaces").ScrollContainerState>;
-    scrollTop: import("@virtuoso.dev/urx").Stream<number>;
-    viewportHeight: import("@virtuoso.dev/urx").Stream<number>;
-    headerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
-    footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
-    scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
-    smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
-    react18ConcurrentRendering: import("@virtuoso.dev/urx").StatefulStream<boolean>;
-    scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
-    scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
-    statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
-    deviation: import("@virtuoso.dev/urx").StatefulStream<number>;
-    scrollingInProgress: import("@virtuoso.dev/urx").StatefulStream<boolean>;
+    data: u.StatefulStream<import("./sizeSystem").Data>;
+    totalCount: u.Stream<number>;
+    sizeRanges: u.Stream<import("./interfaces").SizeRange[]>;
+    groupIndices: u.StatefulStream<number[]>;
+    defaultItemSize: u.StatefulStream<number | undefined>;
+    fixedItemSize: u.StatefulStream<number | undefined>;
+    unshiftWith: u.Stream<number>;
+    shiftWith: u.Stream<number>;
+    shiftWithOffset: u.Stream<number>;
+    beforeUnshiftWith: u.Stream<number>;
+    firstItemIndex: u.StatefulStream<number>;
+    gap: u.StatefulStream<number>;
+    sizes: u.StatefulStream<import("./sizeSystem").SizeState>;
+    listRefresh: u.Stream<boolean>;
+    statefulTotalCount: u.StatefulStream<number>;
+    trackItemSizes: u.StatefulStream<boolean>;
+    itemSize: u.StatefulStream<import("./interfaces").SizeFunction>;
+}>, u.SystemSpec<never[], () => {
+    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>;
+    scrollTo: u.Stream<ScrollToOptions>;
+    scrollBy: u.Stream<ScrollToOptions>;
+    statefulScrollTop: u.StatefulStream<number>;
+    deviation: u.StatefulStream<number>;
+    scrollingInProgress: u.StatefulStream<boolean>;
 }>], ([{ totalCount, groupIndices, sizes }, { scrollTop, headerHeight }]: [{
-    data: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").Data>;
-    totalCount: import("@virtuoso.dev/urx").Stream<number>;
-    sizeRanges: import("@virtuoso.dev/urx").Stream<import("./sizeSystem").SizeRange[]>;
-    groupIndices: import("@virtuoso.dev/urx").StatefulStream<number[]>;
-    defaultItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
-    fixedItemSize: import("@virtuoso.dev/urx").StatefulStream<number | undefined>;
-    unshiftWith: import("@virtuoso.dev/urx").Stream<number>;
-    shiftWith: import("@virtuoso.dev/urx").Stream<number>;
-    shiftWithOffset: import("@virtuoso.dev/urx").Stream<number>;
-    beforeUnshiftWith: import("@virtuoso.dev/urx").Stream<number>;
-    firstItemIndex: import("@virtuoso.dev/urx").StatefulStream<number>;
-    sizes: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeState>;
-    listRefresh: import("@virtuoso.dev/urx").Stream<boolean>;
-    statefulTotalCount: import("@virtuoso.dev/urx").StatefulStream<number>;
-    trackItemSizes: import("@virtuoso.dev/urx").StatefulStream<boolean>;
-    itemSize: import("@virtuoso.dev/urx").StatefulStream<import("./sizeSystem").SizeFunction>;
+    data: u.StatefulStream<import("./sizeSystem").Data>;
+    totalCount: u.Stream<number>;
+    sizeRanges: u.Stream<import("./interfaces").SizeRange[]>;
+    groupIndices: u.StatefulStream<number[]>;
+    defaultItemSize: u.StatefulStream<number | undefined>;
+    fixedItemSize: u.StatefulStream<number | undefined>;
+    unshiftWith: u.Stream<number>;
+    shiftWith: u.Stream<number>;
+    shiftWithOffset: u.Stream<number>;
+    beforeUnshiftWith: u.Stream<number>;
+    firstItemIndex: u.StatefulStream<number>;
+    gap: u.StatefulStream<number>;
+    sizes: u.StatefulStream<import("./sizeSystem").SizeState>;
+    listRefresh: u.Stream<boolean>;
+    statefulTotalCount: u.StatefulStream<number>;
+    trackItemSizes: u.StatefulStream<boolean>;
+    itemSize: u.StatefulStream<import("./interfaces").SizeFunction>;
 }, {
-    scrollContainerState: import("@virtuoso.dev/urx").Stream<import("./interfaces").ScrollContainerState>;
-    scrollTop: import("@virtuoso.dev/urx").Stream<number>;
-    viewportHeight: import("@virtuoso.dev/urx").Stream<number>;
-    headerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
-    footerHeight: import("@virtuoso.dev/urx").StatefulStream<number>;
-    scrollHeight: import("@virtuoso.dev/urx").Stream<number>;
-    smoothScrollTargetReached: import("@virtuoso.dev/urx").Stream<true>;
-    react18ConcurrentRendering: import("@virtuoso.dev/urx").StatefulStream<boolean>;
-    scrollTo: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
-    scrollBy: import("@virtuoso.dev/urx").Stream<ScrollToOptions>;
-    statefulScrollTop: import("@virtuoso.dev/urx").StatefulStream<number>;
-    deviation: import("@virtuoso.dev/urx").StatefulStream<number>;
-    scrollingInProgress: import("@virtuoso.dev/urx").StatefulStream<boolean>;
+    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>;
+    scrollTo: u.Stream<ScrollToOptions>;
+    scrollBy: u.Stream<ScrollToOptions>;
+    statefulScrollTop: u.StatefulStream<number>;
+    deviation: u.StatefulStream<number>;
+    scrollingInProgress: u.StatefulStream<boolean>;
 }]) => {
-    groupCounts: import("@virtuoso.dev/urx").Stream<number[]>;
-    topItemsIndexes: import("@virtuoso.dev/urx").Stream<[number]>;
+    groupCounts: u.Stream<number[]>;
+    topItemsIndexes: u.Stream<[number]>;
 }>;

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 var tslib_1 = require("tslib");
-var urx_1 = require("@virtuoso.dev/urx");
+var u = tslib_1.__importStar(require("./urx"));
 var AATree_1 = require("./AATree");
 var domIOSystem_1 = require("./domIOSystem");
 var sizeSystem_1 = require("./sizeSystem");
@@ -16,19 +16,19 @@ function groupCountsToIndicesAndCount(counts) {
     });
 }
 exports.groupCountsToIndicesAndCount = groupCountsToIndicesAndCount;
-exports.groupedListSystem = urx_1.system(function (_a) {
+exports.groupedListSystem = u.system(function (_a) {
     var _b = tslib_1.__read(_a, 2), _c = _b[0], totalCount = _c.totalCount, groupIndices = _c.groupIndices, sizes = _c.sizes, _d = _b[1], scrollTop = _d.scrollTop, headerHeight = _d.headerHeight;
-    var groupCounts = urx_1.stream();
-    var topItemsIndexes = urx_1.stream();
-    var groupIndicesAndCount = urx_1.streamFromEmitter(urx_1.pipe(groupCounts, urx_1.map(groupCountsToIndicesAndCount)));
-    urx_1.connect(urx_1.pipe(groupIndicesAndCount, urx_1.map(urx_1.prop('totalCount'))), totalCount);
-    urx_1.connect(urx_1.pipe(groupIndicesAndCount, urx_1.map(urx_1.prop('groupIndices'))), groupIndices);
-    urx_1.connect(urx_1.pipe(urx_1.combineLatest(scrollTop, sizes, headerHeight), urx_1.filter(function (_a) {
-        var _b = tslib_1.__read(_a, 2), sizes = _b[1];
+    var groupCounts = u.stream();
+    var topItemsIndexes = u.stream();
+    var groupIndicesAndCount = u.streamFromEmitter(u.pipe(groupCounts, u.map(groupCountsToIndicesAndCount)));
+    u.connect(u.pipe(groupIndicesAndCount, u.map(function (value) { return value.totalCount; })), totalCount);
+    u.connect(u.pipe(groupIndicesAndCount, u.map(function (value) { return value.groupIndices; })), groupIndices);
+    u.connect(u.pipe(u.combineLatest(scrollTop, sizes, headerHeight), u.filter(function (_a) {
+        var _b = tslib_1.__read(_a, 2), _ = _b[0], sizes = _b[1];
         return sizeSystem_1.hasGroups(sizes);
-    }), urx_1.map(function (_a) {
+    }), u.map(function (_a) {
         var _b = tslib_1.__read(_a, 3), scrollTop = _b[0], state = _b[1], headerHeight = _b[2];
         return AATree_1.findMaxKeyValue(state.groupOffsetTree, Math.max(scrollTop - headerHeight, 0), 'v')[0];
-    }), urx_1.distinctUntilChanged(), urx_1.map(function (index) { return [index]; })), topItemsIndexes);
+    }), u.distinctUntilChanged(), u.map(function (index) { return [index]; })), topItemsIndexes);
     return { groupCounts: groupCounts, topItemsIndexes: topItemsIndexes };
-}, urx_1.tup(sizeSystem_1.sizeSystem, domIOSystem_1.domIOSystem));
+}, u.tup(sizeSystem_1.sizeSystem, domIOSystem_1.domIOSystem));

package/components/Virtuoso/react-virtuoso/hooks/useChangedChildSizes.d.ts

@@ -1,4 +1,7 @@
-import { ScrollContainerState } from '../interfaces';
+import React from 'react';
 import { Log } from '../loggerSystem';
-import { SizeFunction, SizeRange } from '../sizeSystem';
-export default function useChangedListContentsSizes(callback: (ranges: SizeRange[]) => void, itemSize: SizeFunction, enabled: boolean, scrollContainerStateCallback: (state: ScrollContainerState) => void, log: Log, customScrollParent?: HTMLElement): (_el: HTMLElement | null) => void;
+import { SizeRange, SizeFunction, ScrollContainerState } from '../interfaces';
+export default function useChangedListContentsSizes(callback: (ranges: SizeRange[]) => void, itemSize: SizeFunction, enabled: boolean, scrollContainerStateCallback: (state: ScrollContainerState) => void, log: Log, gap?: (gap: number) => void, customScrollParent?: HTMLElement): {
+    ref: React.MutableRefObject<HTMLElement | null>;
+    callbackRef: (_el: HTMLElement | null) => void;
+};