@ringcentral/juno 2.46.0 → 3.0.0-alpha.0

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

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.scrollIntoViewSystem = void 0;
 var tslib_1 = require("tslib");
 var u = tslib_1.__importStar(require("./urx"));
 var AATree_1 = require("./AATree");
@@ -24,9 +25,9 @@ exports.scrollIntoViewSystem = u.system(function (_a) {
     u.connect(u.pipe(scrollIntoView, u.withLatestFrom(sizes, viewportHeight, totalCount, headerHeight, fixedHeaderHeight, fixedFooterHeight, scrollTop), u.withLatestFrom(gap), u.map(function (_a) {
         var _b = tslib_1.__read(_a, 2), _c = tslib_1.__read(_b[0], 8), viewLocation = _c[0], sizes = _c[1], viewportHeight = _c[2], totalCount = _c[3], headerHeight = _c[4], fixedHeaderHeight = _c[5], fixedFooterHeight = _c[6], scrollTop = _c[7], gap = _b[1];
         var done = viewLocation.done, behavior = viewLocation.behavior, align = viewLocation.align, _d = viewLocation.calculateViewLocation, calculateViewLocation = _d === void 0 ? defaultCalculateViewLocation : _d, rest = tslib_1.__rest(viewLocation, ["done", "behavior", "align", "calculateViewLocation"]);
-        var actualIndex = sizeSystem_1.originalIndexFromLocation(viewLocation, sizes, totalCount - 1);
-        var itemTop = sizeSystem_1.offsetOf(actualIndex, sizes.offsetTree, gap) + headerHeight + fixedHeaderHeight;
-        var itemBottom = itemTop + AATree_1.findMaxKeyValue(sizes.sizeTree, actualIndex)[1];
+        var actualIndex = (0, sizeSystem_1.originalIndexFromLocation)(viewLocation, sizes, totalCount - 1);
+        var itemTop = (0, sizeSystem_1.offsetOf)(actualIndex, sizes.offsetTree, gap) + headerHeight + fixedHeaderHeight;
+        var itemBottom = itemTop + (0, AATree_1.findMaxKeyValue)(sizes.sizeTree, actualIndex)[1];
         var viewportTop = scrollTop + fixedHeaderHeight;
         var viewportBottom = scrollTop + viewportHeight - fixedFooterHeight;
         var location = calculateViewLocation({

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

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.scrollSeekSystem = void 0;
 var tslib_1 = require("tslib");
 var u = tslib_1.__importStar(require("./urx"));
 var stateFlagsSystem_1 = require("./stateFlagsSystem");

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

@@ -1,7 +1,7 @@
 import * as u from './urx';
 import { IndexLocationWithAlign } from './interfaces';
 import { LogLevel } from './loggerSystem';
-export declare type IndexLocation = number | IndexLocationWithAlign;
+export type IndexLocation = number | IndexLocationWithAlign;
 export declare function normalizeIndexLocation(location: IndexLocation): IndexLocationWithAlign;
 export declare const scrollToIndexSystem: u.SystemSpec<[u.SystemSpec<[u.SystemSpec<never[], () => {
     log: u.StatefulStream<import("./loggerSystem").Log>;
@@ -86,6 +86,6 @@ export declare const scrollToIndexSystem: u.SystemSpec<[u.SystemSpec<[u.SystemSp
     log: u.StatefulStream<import("./loggerSystem").Log>;
     logLevel: u.StatefulStream<LogLevel>;
 }]) => {
-    scrollToIndex: u.Stream<number | import("./interfaces").FlatIndexLocationWithAlign | import("./interfaces").GroupIndexLocationWithAlign>;
+    scrollToIndex: u.Stream<IndexLocation>;
     topListHeight: u.StatefulStream<number>;
 }>;

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

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.scrollToIndexSystem = exports.normalizeIndexLocation = void 0;
 var tslib_1 = require("tslib");
 /* eslint-disable @typescript-eslint/no-unsafe-call */
 var u = tslib_1.__importStar(require("./urx"));
@@ -49,16 +50,16 @@ exports.scrollToIndexSystem = u.system(function (_a) {
         var normalLocation = normalizeIndexLocation(location);
         var align = normalLocation.align, behavior = normalLocation.behavior, offset = normalLocation.offset;
         var lastIndex = totalCount - 1;
-        var index = sizeSystem_1.originalIndexFromLocation(normalLocation, sizes, lastIndex);
-        var top = sizeSystem_1.offsetOf(index, sizes.offsetTree, gap) + headerHeight;
+        var index = (0, sizeSystem_1.originalIndexFromLocation)(normalLocation, sizes, lastIndex);
+        var top = (0, sizeSystem_1.offsetOf)(index, sizes.offsetTree, gap) + headerHeight;
         if (align === 'end') {
-            top += fixedHeaderHeight + AATree_1.findMaxKeyValue(sizes.sizeTree, index)[1] - viewportHeight + fixedFooterHeight;
+            top += fixedHeaderHeight + (0, AATree_1.findMaxKeyValue)(sizes.sizeTree, index)[1] - viewportHeight + fixedFooterHeight;
             if (index === lastIndex) {
                 top += footerHeight;
             }
         }
         else if (align === 'center') {
-            top += (fixedHeaderHeight + AATree_1.findMaxKeyValue(sizes.sizeTree, index)[1] - viewportHeight + fixedFooterHeight) / 2;
+            top += (fixedHeaderHeight + (0, AATree_1.findMaxKeyValue)(sizes.sizeTree, index)[1] - viewportHeight + fixedFooterHeight) / 2;
         }
         else {
             top -= topListHeight;

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

@@ -1,18 +1,18 @@
 import * as u from './urx';
 import { UP, DOWN, ScrollDirection } from './stateFlagsSystem';
-export declare type NumberTuple = [number, number];
-export declare type Overscan = number | {
+export type NumberTuple = [number, number];
+export type Overscan = number | {
     main: number;
     reverse: number;
 };
 export declare const TOP: "top";
 export declare const BOTTOM: "bottom";
 export declare const NONE: "none";
-export declare type ListEnd = typeof TOP | typeof BOTTOM;
-export declare type ViewportIncrease = number | {
+export type ListEnd = typeof TOP | typeof BOTTOM;
+export type ViewportIncrease = number | {
     [k in ListEnd]?: number;
 };
-export declare type ChangeDirection = typeof UP | typeof DOWN | typeof NONE;
+export type ChangeDirection = typeof UP | typeof DOWN | typeof NONE;
 export declare function getOverscan(overscan: Overscan, end: ListEnd, direction: ScrollDirection): number;
 export declare const sizeRangeSystem: u.SystemSpec<[u.SystemSpec<never[], () => {
     scrollContainerState: u.Stream<import("./interfaces").ScrollContainerState>;

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

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.sizeRangeSystem = exports.getOverscan = exports.NONE = exports.BOTTOM = exports.TOP = void 0;
 var tslib_1 = require("tslib");
 var u = tslib_1.__importStar(require("./urx"));
 var domIOSystem_1 = require("./domIOSystem");

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

@@ -2,7 +2,7 @@ import * as u from './urx';
 import { AANode } from './AATree';
 import { Log, LogLevel } from './loggerSystem';
 import { SizeFunction, SizeRange } from './interfaces';
-export declare type Data = readonly unknown[] | undefined;
+export type Data = readonly unknown[] | undefined;
 export declare function insertRanges(sizeTree: AANode<number>, ranges: SizeRange[]): readonly [AANode<number>, number];
 export interface OffsetPoint {
     offset: number;
@@ -32,7 +32,7 @@ export declare function rangesWithinOffsets(tree: Array<OffsetPoint>, startOffse
 }>;
 export declare function sizeStateReducer(state: SizeState, [ranges, groupIndices, log, gap]: [SizeRange[], number[], Log, number]): SizeState;
 export declare function offsetOf(index: number, tree: Array<OffsetPoint>, gap: number): number;
-export declare type FlatOrGroupedLocation = {
+export type FlatOrGroupedLocation = {
     index: number | 'LAST';
 } | {
     groupIndex: number;
@@ -44,6 +44,7 @@ export declare function originalIndexFromLocation(location: FlatOrGroupedLocatio
 export declare function originalIndexFromItemIndex(itemIndex: number, sizes: SizeState): number;
 export declare function hasGroups(sizes: SizeState): boolean;
 export declare function sizeTreeToRanges(sizeTree: AANode<number>): SizeRange[];
+type OptionalNumber = number | undefined;
 export declare const sizeSystem: u.SystemSpec<[u.SystemSpec<never[], () => {
     log: u.StatefulStream<Log>;
     logLevel: u.StatefulStream<LogLevel>;
@@ -59,8 +60,8 @@ export declare const sizeSystem: u.SystemSpec<[u.SystemSpec<never[], () => {
     totalCount: u.Stream<number>;
     sizeRanges: u.Stream<SizeRange[]>;
     groupIndices: u.StatefulStream<number[]>;
-    defaultItemSize: u.StatefulStream<number | undefined>;
-    fixedItemSize: u.StatefulStream<number | undefined>;
+    defaultItemSize: u.StatefulStream<OptionalNumber>;
+    fixedItemSize: u.StatefulStream<OptionalNumber>;
     unshiftWith: u.Stream<number>;
     shiftWith: u.Stream<number>;
     shiftWithOffset: u.Stream<number>;
@@ -73,3 +74,4 @@ export declare const sizeSystem: u.SystemSpec<[u.SystemSpec<never[], () => {
     trackItemSizes: u.StatefulStream<boolean>;
     itemSize: u.StatefulStream<SizeFunction>;
 }>;
+export {};

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

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.sizeSystem = exports.sizeTreeToRanges = exports.hasGroups = exports.originalIndexFromItemIndex = exports.originalIndexFromLocation = exports.isGroupLocation = exports.offsetOf = exports.sizeStateReducer = exports.rangesWithinOffsets = exports.offsetComparator = exports.indexComparator = exports.initialSizeState = exports.insertRanges = void 0;
 var tslib_1 = require("tslib");
 var u = tslib_1.__importStar(require("./urx"));
 var AATree_1 = require("./AATree");
@@ -25,20 +26,20 @@ function affectedGroupCount(offset, groupIndices) {
 }
 function insertRanges(sizeTree, ranges) {
     var e_1, _a, e_2, _b;
-    var syncStart = AATree_1.empty(sizeTree) ? 0 : Infinity;
+    var syncStart = (0, AATree_1.empty)(sizeTree) ? 0 : Infinity;
     try {
         for (var ranges_1 = tslib_1.__values(ranges), ranges_1_1 = ranges_1.next(); !ranges_1_1.done; ranges_1_1 = ranges_1.next()) {
             var range = ranges_1_1.value;
             var size = range.size, startIndex = range.startIndex, endIndex = range.endIndex;
             syncStart = Math.min(syncStart, startIndex);
-            if (AATree_1.empty(sizeTree)) {
-                sizeTree = AATree_1.insert(sizeTree, 0, size);
+            if ((0, AATree_1.empty)(sizeTree)) {
+                sizeTree = (0, AATree_1.insert)(sizeTree, 0, size);
                 continue;
             }
             // extend the range in both directions, so that we can get adjacent neighbours.
             // if the previous / next ones have the same value as the one we are about to insert,
             // we 'merge' them.
-            var overlappingRanges = AATree_1.rangesWithin(sizeTree, startIndex - 1, endIndex + 1);
+            var overlappingRanges = (0, AATree_1.rangesWithin)(sizeTree, startIndex - 1, endIndex + 1);
             if (overlappingRanges.some(rangeIncludes(range))) {
                 continue;
             }
@@ -56,13 +57,13 @@ function insertRanges(sizeTree, ranges) {
                         // 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);
+                            sizeTree = (0, AATree_1.remove)(sizeTree, rangeStart);
                         }
                     }
                     // next range
                     if (rangeEnd > endIndex && endIndex >= rangeStart) {
                         if (rangeValue !== size) {
-                            sizeTree = AATree_1.insert(sizeTree, endIndex + 1, rangeValue);
+                            sizeTree = (0, AATree_1.insert)(sizeTree, endIndex + 1, rangeValue);
                         }
                     }
                 }
@@ -75,7 +76,7 @@ function insertRanges(sizeTree, ranges) {
                 finally { if (e_2) throw e_2.error; }
             }
             if (shouldInsert) {
-                sizeTree = AATree_1.insert(sizeTree, startIndex, size);
+                sizeTree = (0, AATree_1.insert)(sizeTree, startIndex, size);
             }
         }
     }
@@ -92,8 +93,8 @@ exports.insertRanges = insertRanges;
 function initialSizeState() {
     return {
         offsetTree: [],
-        sizeTree: AATree_1.newTree(),
-        groupOffsetTree: AATree_1.newTree(),
+        sizeTree: (0, AATree_1.newTree)(),
+        groupOffsetTree: (0, AATree_1.newTree)(),
         lastIndex: 0,
         lastOffset: 0,
         lastSize: 0,
@@ -119,7 +120,7 @@ function rangesWithinOffsets(tree, startOffset, endOffset, minStartIndex) {
     if (minStartIndex > 0) {
         startOffset = Math.max(startOffset, arrayBinarySearch.findClosestSmallerOrEqual(tree, minStartIndex, indexComparator).offset);
     }
-    return AATree_1.arrayToRanges(arrayBinarySearch.findRange(tree, startOffset, endOffset, offsetComparator), offsetPointParser);
+    return (0, AATree_1.arrayToRanges)(arrayBinarySearch.findRange(tree, startOffset, endOffset, offsetComparator), offsetPointParser);
 }
 exports.rangesWithinOffsets = rangesWithinOffsets;
 function createOffsetTree(prevOffsetTree, syncStart, sizeTree, gap) {
@@ -133,10 +134,10 @@ function createOffsetTree(prevOffsetTree, syncStart, sizeTree, gap) {
         startIndex = arrayBinarySearch.findIndexOfClosestSmallerOrEqual(offsetTree, syncStart - 1, indexComparator);
         var offsetInfo = offsetTree[startIndex];
         prevOffset = offsetInfo.offset;
-        var kv = AATree_1.findMaxKeyValue(sizeTree, syncStart - 1);
+        var kv = (0, 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 === (0, AATree_1.findMaxKeyValue)(sizeTree, syncStart)[1]) {
             startIndex -= 1;
         }
         offsetTree = offsetTree.slice(0, startIndex + 1);
@@ -145,7 +146,7 @@ function createOffsetTree(prevOffsetTree, syncStart, sizeTree, gap) {
         offsetTree = [];
     }
     try {
-        for (var _b = tslib_1.__values(AATree_1.rangesWithin(sizeTree, syncStart, Infinity)), _c = _b.next(); !_c.done; _c = _b.next()) {
+        for (var _b = tslib_1.__values((0, 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 indexOffset = startIndex_1 - prevIndex;
             var aOffset = indexOffset * prevSize + prevOffset + indexOffset * gap;
@@ -185,11 +186,11 @@ function sizeStateReducer(state, _a) {
     // We receive probe item results from a group probe,
     // which should always pass an item and a group
     // the results contain two ranges, which we consider to mean that groups and items have different size
-    if (groupIndices.length > 0 && AATree_1.empty(sizeTree) && ranges.length === 2) {
+    if (groupIndices.length > 0 && (0, AATree_1.empty)(sizeTree) && ranges.length === 2) {
         var groupSize_1 = ranges[0].size;
         var itemSize_1 = ranges[1].size;
         newSizeTree = groupIndices.reduce(function (tree, groupIndex) {
-            return AATree_1.insert(AATree_1.insert(tree, groupIndex, groupSize_1), groupIndex + 1, itemSize_1);
+            return (0, AATree_1.insert)((0, AATree_1.insert)(tree, groupIndex, groupSize_1), groupIndex + 1, itemSize_1);
         }, newSizeTree);
     }
     else {
@@ -207,8 +208,8 @@ function sizeStateReducer(state, _a) {
         lastOffset: lastOffset,
         lastSize: lastSize,
         groupOffsetTree: groupIndices.reduce(function (tree, index) {
-            return AATree_1.insert(tree, index, offsetOf(index, newOffsetTree, gap));
-        }, AATree_1.newTree()),
+            return (0, AATree_1.insert)(tree, index, offsetOf(index, newOffsetTree, gap));
+        }, (0, AATree_1.newTree)()),
         groupIndices: groupIndices,
     };
 }
@@ -255,11 +256,11 @@ function originalIndexFromItemIndex(itemIndex, sizes) {
 }
 exports.originalIndexFromItemIndex = originalIndexFromItemIndex;
 function hasGroups(sizes) {
-    return !AATree_1.empty(sizes.groupOffsetTree);
+    return !(0, AATree_1.empty)(sizes.groupOffsetTree);
 }
 exports.hasGroups = hasGroups;
 function sizeTreeToRanges(sizeTree) {
-    return AATree_1.walk(sizeTree).map(function (_a, index, sizeArray) {
+    return (0, 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;
@@ -282,7 +283,7 @@ 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 (0, correctItemSize_1.correctItemSize)(el, SIZE_MAP[field]); });
     var data = u.statefulStream(undefined);
     var gap = u.statefulStream(0);
     var initial = initialSizeState();
@@ -297,10 +298,9 @@ exports.sizeSystem = u.system(function (_a) {
     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, gap) || idx);
-        }, AATree_1.newTree());
-        return tslib_1.__assign(tslib_1.__assign({}, sizes), { groupIndices: groupIndices,
-            groupOffsetTree: groupOffsetTree });
+            return (0, AATree_1.insert)(tree, index, offsetOf(index, sizes.offsetTree, gap) || idx);
+        }, (0, 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.
@@ -322,7 +322,7 @@ exports.sizeSystem = u.system(function (_a) {
     u.connect(fixedItemSize, defaultItemSize);
     var trackItemSizes = u.statefulStreamFromEmitter(u.pipe(fixedItemSize, u.map(function (size) { return size === undefined; })), true);
     u.connect(u.pipe(defaultItemSize, u.filter(function (value) {
-        return value !== undefined && AATree_1.empty(u.getValue(sizes).sizeTree);
+        return value !== undefined && (0, AATree_1.empty)(u.getValue(sizes).sizeTree);
     }), 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;
@@ -362,7 +362,7 @@ exports.sizeSystem = u.system(function (_a) {
         var initialRanges = [];
         var defaultSize = sizes.lastSize;
         if (groupedMode) {
-            var firstGroupSize = AATree_1.find(sizes.sizeTree, 0);
+            var firstGroupSize = (0, AATree_1.find)(sizes.sizeTree, 0);
             var prependedGroupItemsCount = 0;
             var groupIndex = 0;
             while (prependedGroupItemsCount < unshiftWith) {
@@ -381,7 +381,7 @@ exports.sizeSystem = u.system(function (_a) {
                 groupIndex++;
                 prependedGroupItemsCount += groupItemCount + 1;
             }
-            var sizeTreeKV = AATree_1.walk(sizes.sizeTree);
+            var sizeTreeKV = (0, 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) {
@@ -392,13 +392,13 @@ exports.sizeSystem = u.system(function (_a) {
                 var index = _a.k, size = _a.v;
                 var ranges = acc.ranges;
                 if (acc.prevSize !== 0) {
-                    ranges = tslib_1.__spread(acc.ranges, [
+                    ranges = tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(acc.ranges), false), [
                         {
                             startIndex: acc.prevIndex,
                             endIndex: index + unshiftWith - 1,
                             size: acc.prevSize,
                         },
-                    ]);
+                    ], false);
                 }
                 return {
                     ranges: ranges,
@@ -411,10 +411,10 @@ exports.sizeSystem = u.system(function (_a) {
                 prevSize: 0,
             }).ranges;
         }
-        return AATree_1.walk(sizes.sizeTree).reduce(function (acc, _a) {
+        return (0, 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.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(acc.ranges), false), [{ startIndex: acc.prevIndex, endIndex: index + unshiftWith - 1, size: acc.prevSize }], false),
                 prevIndex: index + unshiftWith,
                 prevSize: size,
             };
@@ -434,10 +434,10 @@ exports.sizeSystem = u.system(function (_a) {
         var groupedMode = sizes.groupIndices.length > 0;
         if (groupedMode) {
             // we can't shift an empty tree
-            if (AATree_1.empty(sizes.sizeTree)) {
+            if ((0, AATree_1.empty)(sizes.sizeTree)) {
                 return sizes;
             }
-            var newSizeTree = AATree_1.newTree();
+            var newSizeTree = (0, AATree_1.newTree)();
             var prevGroupIndicesValue = u.getValue(prevGroupIndices);
             var removedItemsCount = 0;
             var groupIndex = 0;
@@ -448,25 +448,25 @@ exports.sizeSystem = u.system(function (_a) {
                 groupIndex++;
                 removedItemsCount += groupItemCount + 1;
             }
-            newSizeTree = AATree_1.walk(sizes.sizeTree).reduce(function (acc, _a) {
+            newSizeTree = (0, 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);
+                return (0, 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);
+                var firstGroupSize = (0, AATree_1.find)(sizes.sizeTree, groupOffset);
+                newSizeTree = (0, AATree_1.insert)(newSizeTree, 0, firstGroupSize);
+                var nextItemSize = (0, AATree_1.findMaxKeyValue)(sizes.sizeTree, -shiftWith + 1)[1];
+                newSizeTree = (0, 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 newSizeTree = (0, 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 (0, AATree_1.insert)(acc, Math.max(0, k + shiftWith), v);
+            }, (0, AATree_1.newTree)());
             return tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({}, sizes), { sizeTree: newSizeTree }), createOffsetTree(sizes.offsetTree, 0, newSizeTree, gap));
         }
     })), sizes);

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

@@ -2,7 +2,7 @@ import * as u from './urx';
 export declare const UP: "up";
 export declare const DOWN: "down";
 export declare const NONE: "none";
-export declare type ScrollDirection = typeof UP | typeof DOWN | typeof NONE;
+export type ScrollDirection = typeof UP | typeof DOWN | typeof NONE;
 export interface ListBottomInfo {
     bottom: number;
     offsetBottom: number;
@@ -13,9 +13,9 @@ export interface AtBottomParams {
     viewportHeight: number;
     scrollHeight: number;
 }
-export declare type NotAtBottomReason = 'SIZE_INCREASED' | 'NOT_SHOWING_LAST_ITEM' | 'VIEWPORT_HEIGHT_DECREASING' | 'SCROLLING_UPWARDS' | 'NOT_FULLY_SCROLLED_TO_LAST_ITEM_BOTTOM';
-export declare type AtBottomReason = 'SIZE_DECREASED' | 'SCROLLED_DOWN';
-export declare type AtBottomState = {
+export type NotAtBottomReason = 'SIZE_INCREASED' | 'NOT_SHOWING_LAST_ITEM' | 'VIEWPORT_HEIGHT_DECREASING' | 'SCROLLING_UPWARDS' | 'NOT_FULLY_SCROLLED_TO_LAST_ITEM_BOTTOM';
+export type AtBottomReason = 'SIZE_DECREASED' | 'SCROLLED_DOWN';
+export type AtBottomState = {
     atBottom: false;
     notAtBottomBecause: NotAtBottomReason;
     state: AtBottomParams;

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

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.stateFlagsSystem = exports.NONE = exports.DOWN = exports.UP = void 0;
 var tslib_1 = require("tslib");
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
 var u = tslib_1.__importStar(require("./urx"));
@@ -85,7 +86,7 @@ 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 (!approximatelyEqual_1.approximatelyEqual(current.scrollHeight, scrollHeight)) {
+        if (!(0, approximatelyEqual_1.approximatelyEqual)(current.scrollHeight, scrollHeight)) {
             var atBottom = scrollHeight - (scrollTop + viewportHeight) < 1;
             if (current.scrollTop !== scrollTop && atBottom) {
                 return {

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

@@ -169,7 +169,7 @@ export declare const stateLoadSystem: u.SystemSpec<[u.SystemSpec<[u.SystemSpec<n
     log: u.StatefulStream<import("./loggerSystem").Log>;
     logLevel: u.StatefulStream<import("./loggerSystem").LogLevel>;
 }]) => {
-    scrollToIndex: u.Stream<number | import("./interfaces").FlatIndexLocationWithAlign | import("./interfaces").GroupIndexLocationWithAlign>;
+    scrollToIndex: u.Stream<import("./scrollToIndexSystem").IndexLocation>;
     topListHeight: u.StatefulStream<number>;
 }>, u.SystemSpec<[u.SystemSpec<never[], () => {
     log: u.StatefulStream<import("./loggerSystem").Log>;
@@ -214,7 +214,7 @@ export declare const stateLoadSystem: u.SystemSpec<[u.SystemSpec<[u.SystemSpec<n
     deviation: u.StatefulStream<number>;
     scrollingInProgress: u.StatefulStream<boolean>;
 }, {
-    scrollToIndex: u.Stream<number | import("./interfaces").FlatIndexLocationWithAlign | import("./interfaces").GroupIndexLocationWithAlign>;
+    scrollToIndex: u.Stream<import("./scrollToIndexSystem").IndexLocation>;
     topListHeight: u.StatefulStream<number>;
 }, {
     propsReady: u.StatefulStream<boolean>;

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

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.stateLoadSystem = void 0;
 var tslib_1 = require("tslib");
 var domIOSystem_1 = require("./domIOSystem");
 var initialTopMostItemIndexSystem_1 = require("./initialTopMostItemIndexSystem");
@@ -17,7 +18,7 @@ exports.stateLoadSystem = u.system(function (_a) {
     u.connect(windowViewportRect, statefulWindowViewportRect);
     u.subscribe(u.pipe(getState, u.withLatestFrom(sizes, scrollTop, useWindowScroll, statefulWindowScrollContainerState, statefulWindowViewportRect)), function (_a) {
         var _b = tslib_1.__read(_a, 6), callback = _b[0], sizes = _b[1], scrollTop = _b[2], useWindowScroll = _b[3], windowScrollContainerState = _b[4], windowViewportRect = _b[5];
-        var ranges = sizeSystem_1.sizeTreeToRanges(sizes.sizeTree);
+        var ranges = (0, sizeSystem_1.sizeTreeToRanges)(sizes.sizeTree);
         if (useWindowScroll && windowScrollContainerState !== null && windowViewportRect !== null) {
             scrollTop = windowScrollContainerState.scrollTop - windowViewportRect.offsetTop;
         }

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

@@ -268,7 +268,7 @@ export declare const topItemCountSystem: u.SystemSpec<[u.SystemSpec<[u.SystemSpe
     log: u.StatefulStream<import("./loggerSystem").Log>;
     logLevel: u.StatefulStream<import("./loggerSystem").LogLevel>;
 }]) => {
-    scrollToIndex: u.Stream<number | import("./interfaces").FlatIndexLocationWithAlign | import("./interfaces").GroupIndexLocationWithAlign>;
+    scrollToIndex: u.Stream<import("./scrollToIndexSystem").IndexLocation>;
     topListHeight: u.StatefulStream<number>;
 }>, u.SystemSpec<[u.SystemSpec<never[], () => {
     log: u.StatefulStream<import("./loggerSystem").Log>;
@@ -313,7 +313,7 @@ export declare const topItemCountSystem: u.SystemSpec<[u.SystemSpec<[u.SystemSpe
     deviation: u.StatefulStream<number>;
     scrollingInProgress: u.StatefulStream<boolean>;
 }, {
-    scrollToIndex: u.Stream<number | import("./interfaces").FlatIndexLocationWithAlign | import("./interfaces").GroupIndexLocationWithAlign>;
+    scrollToIndex: u.Stream<import("./scrollToIndexSystem").IndexLocation>;
     topListHeight: u.StatefulStream<number>;
 }, {
     propsReady: u.StatefulStream<boolean>;
@@ -404,7 +404,7 @@ export declare const topItemCountSystem: u.SystemSpec<[u.SystemSpec<[u.SystemSpe
     log: u.StatefulStream<import("./loggerSystem").Log>;
     logLevel: u.StatefulStream<import("./loggerSystem").LogLevel>;
 }]) => {
-    scrollToIndex: u.Stream<number | import("./interfaces").FlatIndexLocationWithAlign | import("./interfaces").GroupIndexLocationWithAlign>;
+    scrollToIndex: u.Stream<import("./scrollToIndexSystem").IndexLocation>;
     topListHeight: u.StatefulStream<number>;
 }>, u.SystemSpec<[u.SystemSpec<never[], () => {
     scrollContainerState: u.Stream<import("./interfaces").ScrollContainerState>;
@@ -490,7 +490,7 @@ export declare const topItemCountSystem: u.SystemSpec<[u.SystemSpec<[u.SystemSpe
     scrolledToInitialItem: u.StatefulStream<boolean>;
     initialTopMostItemIndex: u.StatefulStream<number | import("./interfaces").FlatIndexLocationWithAlign>;
 }, {
-    scrollToIndex: u.Stream<number | import("./interfaces").FlatIndexLocationWithAlign | import("./interfaces").GroupIndexLocationWithAlign>;
+    scrollToIndex: u.Stream<import("./scrollToIndexSystem").IndexLocation>;
     topListHeight: u.StatefulStream<number>;
 }, {
     isScrolling: u.StatefulStream<boolean>;

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

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.topItemCountSystem = void 0;
 var tslib_1 = require("tslib");
 var u = tslib_1.__importStar(require("./urx"));
 var listStateSystem_1 = require("./listStateSystem");

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

@@ -283,7 +283,7 @@ export declare const totalListHeightSystem: u.SystemSpec<[u.SystemSpec<never[],
     log: u.StatefulStream<import("./loggerSystem").Log>;
     logLevel: u.StatefulStream<import("./loggerSystem").LogLevel>;
 }]) => {
-    scrollToIndex: u.Stream<number | import("./interfaces").FlatIndexLocationWithAlign | import("./interfaces").GroupIndexLocationWithAlign>;
+    scrollToIndex: u.Stream<import("./scrollToIndexSystem").IndexLocation>;
     topListHeight: u.StatefulStream<number>;
 }>, u.SystemSpec<[u.SystemSpec<never[], () => {
     log: u.StatefulStream<import("./loggerSystem").Log>;
@@ -328,7 +328,7 @@ export declare const totalListHeightSystem: u.SystemSpec<[u.SystemSpec<never[],
     deviation: u.StatefulStream<number>;
     scrollingInProgress: u.StatefulStream<boolean>;
 }, {
-    scrollToIndex: u.Stream<number | import("./interfaces").FlatIndexLocationWithAlign | import("./interfaces").GroupIndexLocationWithAlign>;
+    scrollToIndex: u.Stream<import("./scrollToIndexSystem").IndexLocation>;
     topListHeight: u.StatefulStream<number>;
 }, {
     propsReady: u.StatefulStream<boolean>;
@@ -419,7 +419,7 @@ export declare const totalListHeightSystem: u.SystemSpec<[u.SystemSpec<never[],
     log: u.StatefulStream<import("./loggerSystem").Log>;
     logLevel: u.StatefulStream<import("./loggerSystem").LogLevel>;
 }]) => {
-    scrollToIndex: u.Stream<number | import("./interfaces").FlatIndexLocationWithAlign | import("./interfaces").GroupIndexLocationWithAlign>;
+    scrollToIndex: u.Stream<import("./scrollToIndexSystem").IndexLocation>;
     topListHeight: u.StatefulStream<number>;
 }>, u.SystemSpec<[u.SystemSpec<never[], () => {
     scrollContainerState: u.Stream<import("./interfaces").ScrollContainerState>;
@@ -505,7 +505,7 @@ export declare const totalListHeightSystem: u.SystemSpec<[u.SystemSpec<never[],
     scrolledToInitialItem: u.StatefulStream<boolean>;
     initialTopMostItemIndex: u.StatefulStream<number | import("./interfaces").FlatIndexLocationWithAlign>;
 }, {
-    scrollToIndex: u.Stream<number | import("./interfaces").FlatIndexLocationWithAlign | import("./interfaces").GroupIndexLocationWithAlign>;
+    scrollToIndex: u.Stream<import("./scrollToIndexSystem").IndexLocation>;
     topListHeight: u.StatefulStream<number>;
 }, {
     isScrolling: u.StatefulStream<boolean>;

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

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.totalListHeightSystem = void 0;
 var tslib_1 = require("tslib");
 var u = tslib_1.__importStar(require("./urx"));
 var listStateSystem_1 = require("./listStateSystem");

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

@@ -329,7 +329,7 @@ export declare const upwardScrollFixSystem: u.SystemSpec<[u.SystemSpec<never[],
     log: u.StatefulStream<import("./loggerSystem").Log>;
     logLevel: u.StatefulStream<LogLevel>;
 }]) => {
-    scrollToIndex: u.Stream<number | import("./interfaces").FlatIndexLocationWithAlign | import("./interfaces").GroupIndexLocationWithAlign>;
+    scrollToIndex: u.Stream<import("./scrollToIndexSystem").IndexLocation>;
     topListHeight: u.StatefulStream<number>;
 }>, u.SystemSpec<[u.SystemSpec<never[], () => {
     log: u.StatefulStream<import("./loggerSystem").Log>;
@@ -374,7 +374,7 @@ export declare const upwardScrollFixSystem: u.SystemSpec<[u.SystemSpec<never[],
     deviation: u.StatefulStream<number>;
     scrollingInProgress: u.StatefulStream<boolean>;
 }, {
-    scrollToIndex: u.Stream<number | import("./interfaces").FlatIndexLocationWithAlign | import("./interfaces").GroupIndexLocationWithAlign>;
+    scrollToIndex: u.Stream<import("./scrollToIndexSystem").IndexLocation>;
     topListHeight: u.StatefulStream<number>;
 }, {
     propsReady: u.StatefulStream<boolean>;
@@ -465,7 +465,7 @@ export declare const upwardScrollFixSystem: u.SystemSpec<[u.SystemSpec<never[],
     log: u.StatefulStream<import("./loggerSystem").Log>;
     logLevel: u.StatefulStream<LogLevel>;
 }]) => {
-    scrollToIndex: u.Stream<number | import("./interfaces").FlatIndexLocationWithAlign | import("./interfaces").GroupIndexLocationWithAlign>;
+    scrollToIndex: u.Stream<import("./scrollToIndexSystem").IndexLocation>;
     topListHeight: u.StatefulStream<number>;
 }>, u.SystemSpec<[u.SystemSpec<never[], () => {
     scrollContainerState: u.Stream<import("./interfaces").ScrollContainerState>;
@@ -551,7 +551,7 @@ export declare const upwardScrollFixSystem: u.SystemSpec<[u.SystemSpec<never[],
     scrolledToInitialItem: u.StatefulStream<boolean>;
     initialTopMostItemIndex: u.StatefulStream<number | import("./interfaces").FlatIndexLocationWithAlign>;
 }, {
-    scrollToIndex: u.Stream<number | import("./interfaces").FlatIndexLocationWithAlign | import("./interfaces").GroupIndexLocationWithAlign>;
+    scrollToIndex: u.Stream<import("./scrollToIndexSystem").IndexLocation>;
     topListHeight: u.StatefulStream<number>;
 }, {
     isScrolling: u.StatefulStream<boolean>;