@ringcentral/juno 2.40.1 → 2.41.1

package/es6/components/Virtuoso/react-virtuoso/listSystem.js

@@ -1,16 +1,12 @@
 import { __assign, __read, __rest } from "tslib";
-import * as u from '@virtuoso.dev/urx';
-import { alignToBottomSystem } from './alignToBottomSystem';
+import * as u from './urx';
 import { domIOSystem } from './domIOSystem';
 import { followOutputSystem } from './followOutputSystem';
 import { groupedListSystem } from './groupedListSystem';
 import { initialItemCountSystem } from './initialItemCountSystem';
-import { initialScrollTopSystem } from './initialScrollTopSystem';
 import { initialTopMostItemIndexSystem } from './initialTopMostItemIndexSystem';
 import { listStateSystem } from './listStateSystem';
-import { loggerSystem } from './loggerSystem';
 import { propsReadySystem } from './propsReadySystem';
-import { scrollIntoViewSystem } from './scrollIntoViewSystem';
 import { scrollSeekSystem } from './scrollSeekSystem';
 import { scrollToIndexSystem } from './scrollToIndexSystem';
 import { sizeRangeSystem } from './sizeRangeSystem';
@@ -18,18 +14,21 @@ import { sizeSystem } from './sizeSystem';
 import { topItemCountSystem } from './topItemCountSystem';
 import { totalListHeightSystem } from './totalListHeightSystem';
 import { upwardScrollFixSystem } from './upwardScrollFixSystem';
+import { initialScrollTopSystem } from './initialScrollTopSystem';
+import { alignToBottomSystem } from './alignToBottomSystem';
 import { windowScrollerSystem } from './windowScrollerSystem';
-// workaround the growing list of systems below
-// fix this with 4.1 recursive conditional types
+import { loggerSystem } from './loggerSystem';
+import { scrollIntoViewSystem } from './scrollIntoViewSystem';
+import { stateLoadSystem } from './stateLoadSystem';
 var featureGroup1System = u.system(function (_a) {
-    var _b = __read(_a, 9), sizeRange = _b[0], initialItemCount = _b[1], propsReady = _b[2], scrollSeek = _b[3], totalListHeight = _b[4], initialScrollTopSystem = _b[5], alignToBottom = _b[6], windowScroller = _b[7], scrollIntoView = _b[8];
-    return __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({}, sizeRange), initialItemCount), propsReady), scrollSeek), totalListHeight), initialScrollTopSystem), alignToBottom), windowScroller), scrollIntoView);
-}, u.tup(sizeRangeSystem, initialItemCountSystem, propsReadySystem, scrollSeekSystem, totalListHeightSystem, initialScrollTopSystem, alignToBottomSystem, windowScrollerSystem, scrollIntoViewSystem));
+    var _b = __read(_a, 10), sizeRange = _b[0], initialItemCount = _b[1], propsReady = _b[2], scrollSeek = _b[3], totalListHeight = _b[4], initialScrollTopSystem = _b[5], alignToBottom = _b[6], windowScroller = _b[7], scrollIntoView = _b[8], logger = _b[9];
+    return __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({}, sizeRange), initialItemCount), propsReady), scrollSeek), totalListHeight), initialScrollTopSystem), alignToBottom), windowScroller), scrollIntoView), logger);
+}, u.tup(sizeRangeSystem, initialItemCountSystem, propsReadySystem, scrollSeekSystem, totalListHeightSystem, initialScrollTopSystem, alignToBottomSystem, windowScrollerSystem, scrollIntoViewSystem, loggerSystem));
 export var listSystem = u.system(function (_a) {
-    var _b = _a, _c = __read(_b, 11), _d = _c[0], totalCount = _d.totalCount, sizeRanges = _d.sizeRanges, fixedItemSize = _d.fixedItemSize, defaultItemSize = _d.defaultItemSize, trackItemSizes = _d.trackItemSizes, itemSize = _d.itemSize, data = _d.data, firstItemIndex = _d.firstItemIndex, groupIndices = _d.groupIndices, statefulTotalCount = _d.statefulTotalCount, _e = _c[1], initialTopMostItemIndex = _e.initialTopMostItemIndex, scrolledToInitialItem = _e.scrolledToInitialItem, domIO = _c[2], followOutput = _c[3], _f = _c[4], scrollToIndex = _c[5].scrollToIndex, topItemCount = _c[7].topItemCount, groupCounts = _c[8].groupCounts, featureGroup1 = _c[9], log = _c[10], listState = _f.listState, topItemsIndexes = _f.topItemsIndexes, flags = __rest(_f, ["listState", "topItemsIndexes"]);
+    var _b = _a, _c = __read(_b, 11), _d = _c[0], totalCount = _d.totalCount, sizeRanges = _d.sizeRanges, fixedItemSize = _d.fixedItemSize, defaultItemSize = _d.defaultItemSize, trackItemSizes = _d.trackItemSizes, itemSize = _d.itemSize, data = _d.data, firstItemIndex = _d.firstItemIndex, groupIndices = _d.groupIndices, statefulTotalCount = _d.statefulTotalCount, gap = _d.gap, sizes = _d.sizes, _e = _c[1], initialTopMostItemIndex = _e.initialTopMostItemIndex, scrolledToInitialItem = _e.scrolledToInitialItem, domIO = _c[2], stateLoad = _c[3], followOutput = _c[4], _f = _c[5], scrollToIndex = _c[6].scrollToIndex, _ = _c[7], topItemCount = _c[8].topItemCount, groupCounts = _c[9].groupCounts, featureGroup1 = _c[10], listState = _f.listState, topItemsIndexes = _f.topItemsIndexes, flags = __rest(_f, ["listState", "topItemsIndexes"]);
     u.connect(flags.rangeChanged, featureGroup1.scrollSeekRangeChanged);
-    u.connect(u.pipe(featureGroup1.windowViewportRect, u.map(u.prop('visibleHeight'))), domIO.viewportHeight);
-    return __assign(__assign(__assign(__assign(__assign(__assign({ 
+    u.connect(u.pipe(featureGroup1.windowViewportRect, u.map(function (value) { return value.visibleHeight; })), domIO.viewportHeight);
+    return __assign(__assign(__assign(__assign(__assign(__assign(__assign({ 
         // input
         totalCount: totalCount,
         data: data,
@@ -39,12 +38,12 @@ export var listSystem = u.system(function (_a) {
         scrolledToInitialItem: scrolledToInitialItem,
         topItemsIndexes: topItemsIndexes,
         topItemCount: topItemCount,
-        groupCounts: groupCounts, fixedItemHeight: fixedItemSize, defaultItemHeight: defaultItemSize }, followOutput), { 
+        groupCounts: groupCounts, fixedItemHeight: fixedItemSize, defaultItemHeight: defaultItemSize, gap: gap }, followOutput), { 
         // output
         statefulTotalCount: statefulTotalCount,
         listState: listState,
         scrollToIndex: scrollToIndex,
         trackItemSizes: trackItemSizes,
         itemSize: itemSize,
-        groupIndices: groupIndices }), flags), featureGroup1), domIO), log);
-}, u.tup(sizeSystem, initialTopMostItemIndexSystem, domIOSystem, followOutputSystem, listStateSystem, scrollToIndexSystem, upwardScrollFixSystem, topItemCountSystem, groupedListSystem, featureGroup1System, loggerSystem));
+        groupIndices: groupIndices }), flags), featureGroup1), domIO), { sizes: sizes }), stateLoad);
+}, u.tup(sizeSystem, initialTopMostItemIndexSystem, domIOSystem, stateLoadSystem, followOutputSystem, listStateSystem, scrollToIndexSystem, upwardScrollFixSystem, topItemCountSystem, groupedListSystem, featureGroup1System));

package/es6/components/Virtuoso/react-virtuoso/loggerSystem.js

@@ -1,5 +1,5 @@
 var _a;
-import * as u from '@virtuoso.dev/urx';
+import * as u from './urx';
 export var LogLevel;
 (function (LogLevel) {
     LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
@@ -13,9 +13,7 @@ var CONSOLE_METHOD_MAP = (_a = {},
     _a[LogLevel.WARN] = 'warn',
     _a[LogLevel.ERROR] = 'error',
     _a);
-var getGlobalThis = function () {
-    return typeof globalThis === 'undefined' ? window : globalThis;
-};
+var getGlobalThis = function () { return (typeof globalThis === 'undefined' ? window : globalThis); };
 export var loggerSystem = u.system(function () {
     var logLevel = u.statefulStream(LogLevel.ERROR);
     var log = u.statefulStream(function (label, message, level) {

package/es6/components/Virtuoso/react-virtuoso/propsReadySystem.js

@@ -1,13 +1,12 @@
 import { __read } from "tslib";
-import * as u from '@virtuoso.dev/urx';
-import { getValue, tup } from '@virtuoso.dev/urx';
+import * as u from './urx';
 import { loggerSystem, LogLevel } from './loggerSystem';
 export var propsReadySystem = u.system(function (_a) {
     var _b = __read(_a, 1), log = _b[0].log;
     var propsReady = u.statefulStream(false);
     var didMount = u.streamFromEmitter(u.pipe(propsReady, u.filter(function (ready) { return ready; }), u.distinctUntilChanged()));
     u.subscribe(propsReady, function (value) {
-        value && getValue(log)('props updated', {}, LogLevel.DEBUG);
+        value && u.getValue(log)('props updated', {}, LogLevel.DEBUG);
     });
     return { propsReady: propsReady, didMount: didMount };
-}, tup(loggerSystem), { singleton: true });
+}, u.tup(loggerSystem), { singleton: true });

package/es6/components/Virtuoso/react-virtuoso/react-urx/index.js

@@ -0,0 +1,197 @@
+import { __read, __rest, __spread, __values } from "tslib";
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/**
+ * `@virtuoso.dev/react-urx` exports the [[systemToComponent]] function.
+ * It wraps urx systems in to UI **logic provider components**,
+ * mapping the system input and output streams to the component input / output points.
+ *
+ * ### Simple System wrapped as React Component
+ *
+ * ```tsx
+ * const sys = system(() => {
+ *   const foo = statefulStream(42)
+ *   return { foo }
+ * })
+ *
+ * const { Component: MyComponent, useEmitterValue } = systemToComponent(sys, {
+ *   required: { fooProp: 'foo' },
+ * })
+ *
+ * const Child = () => {
+ *   const foo = useEmitterValue('foo')
+ *   return <div>{foo}</div>
+ * }
+ *
+ * const App = () => {
+ *   return <Comp fooProp={42}><Child /><Comp>
+ * }
+ * ```
+ *
+ * @packageDocumentation
+ */
+import React from 'react';
+import * as u from '../urx';
+/** @internal */
+function omit(keys, obj) {
+    var result = {};
+    var index = {};
+    var idx = 0;
+    var len = keys.length;
+    while (idx < len) {
+        index[keys[idx]] = 1;
+        idx += 1;
+    }
+    for (var prop in obj) {
+        if (!index.hasOwnProperty(prop)) {
+            result[prop] = obj[prop];
+        }
+    }
+    return result;
+}
+var useIsomorphicLayoutEffect = typeof document !== 'undefined' ? React.useLayoutEffect : React.useEffect;
+/**
+ * Converts a system spec to React component by mapping the system streams to component properties, events and methods. Returns hooks for querying and modifying
+ * the system streams from the component's child components.
+ * @param systemSpec The return value from a [[system]] call.
+ * @param map The streams to props / events / methods mapping Check [[SystemPropsMap]] for more details.
+ * @param Root The optional React component to render. By default, the resulting component renders nothing, acting as a logical wrapper for its children.
+ * @returns an object containing the following:
+ *  - `Component`: the React component.
+ *  - `useEmitterValue`: a hook that lets child components use values emitted from the specified output stream.
+ *  - `useEmitter`: a hook that calls the provided callback whenever the specified stream emits a value.
+ *  - `usePublisher`: a hook which lets child components publish values to the specified stream.
+ *  <hr />
+ */
+export function systemToComponent(systemSpec, map, Root) {
+    var requiredPropNames = Object.keys(map.required || {});
+    var optionalPropNames = Object.keys(map.optional || {});
+    var methodNames = Object.keys(map.methods || {});
+    var eventNames = Object.keys(map.events || {});
+    var Context = React.createContext({});
+    function applyPropsToSystem(system, props) {
+        var e_1, _a, e_2, _b;
+        if (system['propsReady']) {
+            u.publish(system['propsReady'], false);
+        }
+        try {
+            for (var requiredPropNames_1 = __values(requiredPropNames), requiredPropNames_1_1 = requiredPropNames_1.next(); !requiredPropNames_1_1.done; requiredPropNames_1_1 = requiredPropNames_1.next()) {
+                var requiredPropName = requiredPropNames_1_1.value;
+                var stream = system[map.required[requiredPropName]];
+                u.publish(stream, props[requiredPropName]);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (requiredPropNames_1_1 && !requiredPropNames_1_1.done && (_a = requiredPropNames_1.return)) _a.call(requiredPropNames_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        try {
+            for (var optionalPropNames_1 = __values(optionalPropNames), optionalPropNames_1_1 = optionalPropNames_1.next(); !optionalPropNames_1_1.done; optionalPropNames_1_1 = optionalPropNames_1.next()) {
+                var optionalPropName = optionalPropNames_1_1.value;
+                if (optionalPropName in props) {
+                    var stream = system[map.optional[optionalPropName]];
+                    u.publish(stream, props[optionalPropName]);
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (optionalPropNames_1_1 && !optionalPropNames_1_1.done && (_b = optionalPropNames_1.return)) _b.call(optionalPropNames_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        if (system['propsReady']) {
+            u.publish(system['propsReady'], true);
+        }
+    }
+    function buildMethods(system) {
+        return methodNames.reduce(function (acc, methodName) {
+            ;
+            acc[methodName] = function (value) {
+                var stream = system[map.methods[methodName]];
+                u.publish(stream, value);
+            };
+            return acc;
+        }, {});
+    }
+    function buildEventHandlers(system) {
+        return eventNames.reduce(function (handlers, eventName) {
+            handlers[eventName] = u.eventHandler(system[map.events[eventName]]);
+            return handlers;
+        }, {});
+    }
+    /**
+     * A React component generated from an urx system
+     */
+    // eslint-disable-next-line react/display-name
+    var Component = React.forwardRef(function (propsWithChildren, ref) {
+        var _a = propsWithChildren, children = _a.children, props = __rest(_a, ["children"]);
+        var _b = __read(React.useState(function () {
+            return u.tap(u.init(systemSpec), function (system) { return applyPropsToSystem(system, props); });
+        }), 1), system = _b[0];
+        var _c = __read(React.useState(u.curry1to0(buildEventHandlers, system)), 1), handlers = _c[0];
+        useIsomorphicLayoutEffect(function () {
+            var e_3, _a;
+            try {
+                for (var eventNames_1 = __values(eventNames), eventNames_1_1 = eventNames_1.next(); !eventNames_1_1.done; eventNames_1_1 = eventNames_1.next()) {
+                    var eventName = eventNames_1_1.value;
+                    if (eventName in props) {
+                        u.subscribe(handlers[eventName], props[eventName]);
+                    }
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (eventNames_1_1 && !eventNames_1_1.done && (_a = eventNames_1.return)) _a.call(eventNames_1);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            return function () {
+                Object.values(handlers).map(u.reset);
+            };
+        }, [props, handlers, system]);
+        useIsomorphicLayoutEffect(function () {
+            applyPropsToSystem(system, props);
+        });
+        React.useImperativeHandle(ref, u.always(buildMethods(system)));
+        return React.createElement(Context.Provider, { value: system }, Root
+            ? React.createElement(Root, omit(__spread(requiredPropNames, optionalPropNames, eventNames), props), children)
+            : children);
+    });
+    var usePublisher = function (key) {
+        return React.useCallback(u.curry2to1(u.publish, React.useContext(Context)[key]), [key]);
+    };
+    /**
+     * Returns the value emitted from the stream.
+     */
+    var useEmitterValue = function (key) {
+        var system = React.useContext(Context);
+        var source = system[key];
+        var _a = __read(React.useState(u.curry1to0(u.getValue, source)), 2), value = _a[0], setValue = _a[1];
+        useIsomorphicLayoutEffect(function () {
+            return u.subscribe(source, function (next) {
+                if (next !== value) {
+                    setValue(u.always(next));
+                }
+            });
+        }, [source, value]);
+        return value;
+    };
+    var useEmitter = function (key, callback) {
+        var context = React.useContext(Context);
+        var source = context[key];
+        useIsomorphicLayoutEffect(function () { return u.subscribe(source, callback); }, [callback, source]);
+    };
+    return {
+        Component: Component,
+        usePublisher: usePublisher,
+        useEmitterValue: useEmitterValue,
+        useEmitter: useEmitter,
+    };
+}

package/es6/components/Virtuoso/react-virtuoso/recalcSystem.js

@@ -0,0 +1,5 @@
+import * as u from './urx';
+export var recalcSystem = u.system(function () {
+    var recalcInProgress = u.statefulStream(false);
+    return { recalcInProgress: recalcInProgress };
+}, [], { singleton: true });

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

@@ -1,33 +1,45 @@
-import { __read } from "tslib";
-import * as u from '@virtuoso.dev/urx';
+import { __assign, __read, __rest } from "tslib";
+import * as u from './urx';
 import { findMaxKeyValue } from './AATree';
 import { domIOSystem } from './domIOSystem';
-import { listStateSystem } from './listStateSystem';
+import { offsetOf, originalIndexFromLocation, sizeSystem } from './sizeSystem';
 import { loggerSystem } from './loggerSystem';
 import { scrollToIndexSystem } from './scrollToIndexSystem';
-import { offsetOf, originalIndexFromItemIndex, sizeSystem } from './sizeSystem';
+import { listStateSystem } from './listStateSystem';
+var defaultCalculateViewLocation = function (_a) {
+    var itemTop = _a.itemTop, itemBottom = _a.itemBottom, viewportTop = _a.viewportTop, viewportBottom = _a.viewportBottom, _b = _a.locationParams, behavior = _b.behavior, align = _b.align, rest = __rest(_b, ["behavior", "align"]);
+    if (itemTop < viewportTop) {
+        return __assign(__assign({}, rest), { behavior: behavior, align: align !== null && align !== void 0 ? align : 'start' });
+    }
+    if (itemBottom > viewportBottom) {
+        return __assign(__assign({}, rest), { behavior: behavior, align: align !== null && align !== void 0 ? align : 'end' });
+    }
+    return null;
+};
 export var scrollIntoViewSystem = u.system(function (_a) {
-    var _b = __read(_a, 3), _c = _b[0], sizes = _c.sizes, totalCount = _c.totalCount, _d = _b[1], scrollTop = _d.scrollTop, viewportHeight = _d.viewportHeight, headerHeight = _d.headerHeight, scrollingInProgress = _d.scrollingInProgress, scrollToIndex = _b[2].scrollToIndex;
+    var _b = __read(_a, 3), _c = _b[0], sizes = _c.sizes, totalCount = _c.totalCount, gap = _c.gap, _d = _b[1], scrollTop = _d.scrollTop, viewportHeight = _d.viewportHeight, headerHeight = _d.headerHeight, fixedHeaderHeight = _d.fixedHeaderHeight, fixedFooterHeight = _d.fixedFooterHeight, scrollingInProgress = _d.scrollingInProgress, scrollToIndex = _b[2].scrollToIndex;
     var scrollIntoView = u.stream();
-    u.connect(u.pipe(scrollIntoView, u.withLatestFrom(sizes, viewportHeight, totalCount, headerHeight, scrollTop), u.map(function (_a) {
-        var _b = __read(_a, 6), _c = _b[0], index = _c.index, _d = _c.behavior, behavior = _d === void 0 ? 'auto' : _d, done = _c.done, sizes = _b[1], viewportHeight = _b[2], totalCount = _b[3], headerHeight = _b[4], scrollTop = _b[5];
-        var lastIndex = totalCount - 1;
-        var location = null;
-        index = originalIndexFromItemIndex(index, sizes);
-        index = Math.max(0, index, Math.min(lastIndex, index));
-        var itemTop = offsetOf(index, sizes.offsetTree) + headerHeight;
-        if (itemTop < scrollTop) {
-            location = { index: index, behavior: behavior, align: 'start' };
-        }
-        else {
-            var itemBottom = itemTop + findMaxKeyValue(sizes.sizeTree, index)[1];
-            if (itemBottom > scrollTop + viewportHeight) {
-                location = { index: index, behavior: behavior, align: 'end' };
-            }
-        }
+    u.connect(u.pipe(scrollIntoView, u.withLatestFrom(sizes, viewportHeight, totalCount, headerHeight, fixedHeaderHeight, fixedFooterHeight, scrollTop), u.withLatestFrom(gap), u.map(function (_a) {
+        var _b = __read(_a, 2), _c = __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 = __rest(viewLocation, ["done", "behavior", "align", "calculateViewLocation"]);
+        var actualIndex = originalIndexFromLocation(viewLocation, sizes, totalCount - 1);
+        var itemTop = offsetOf(actualIndex, sizes.offsetTree, gap) + headerHeight + fixedHeaderHeight;
+        var itemBottom = itemTop + findMaxKeyValue(sizes.sizeTree, actualIndex)[1];
+        var viewportTop = scrollTop + fixedHeaderHeight;
+        var viewportBottom = scrollTop + viewportHeight - fixedFooterHeight;
+        var location = calculateViewLocation({
+            itemTop: itemTop,
+            itemBottom: itemBottom,
+            viewportTop: viewportTop,
+            viewportBottom: viewportBottom,
+            locationParams: __assign({ behavior: behavior, align: align }, rest),
+        });
         if (location) {
             done &&
-                u.handleNext(u.pipe(scrollingInProgress, u.skip(1), u.filter(function (value) { return value === false; })), done);
+                u.handleNext(u.pipe(scrollingInProgress, u.filter(function (value) { return value === false; }), 
+                // skips the initial publish of false, and the cleanup call.
+                // but if scrollingInProgress is true, we skip the initial publish.
+                u.skip(u.getValue(scrollingInProgress) ? 1 : 2)), done);
         }
         else {
             done && done();

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

@@ -1,5 +1,5 @@
 import { __read } from "tslib";
-import * as u from '@virtuoso.dev/urx';
+import * as u from './urx';
 import { stateFlagsSystem } from './stateFlagsSystem';
 export var scrollSeekSystem = u.system(function (_a) {
     var _b = __read(_a, 1), scrollVelocity = _b[0].scrollVelocity;
@@ -7,7 +7,7 @@ export var scrollSeekSystem = u.system(function (_a) {
     var rangeChanged = u.stream();
     var scrollSeekConfiguration = u.statefulStream(false);
     u.connect(u.pipe(scrollVelocity, u.withLatestFrom(scrollSeekConfiguration, isSeeking, rangeChanged), u.filter(function (_a) {
-        var _b = __read(_a, 2), config = _b[1];
+        var _b = __read(_a, 2), _ = _b[0], config = _b[1];
         return !!config;
     }), u.map(function (_a) {
         var _b = __read(_a, 4), speed = _b[0], config = _b[1], isSeeking = _b[2], range = _b[3];
@@ -17,8 +17,10 @@ export var scrollSeekSystem = u.system(function (_a) {
                 return false;
             }
         }
-        else if (enter(speed, range)) {
-            return true;
+        else {
+            if (enter(speed, range)) {
+                return true;
+            }
         }
         return isSeeking;
     }), u.distinctUntilChanged()), isSeeking);
@@ -26,10 +28,5 @@ export var scrollSeekSystem = u.system(function (_a) {
         var _b = __read(_a, 2), _c = __read(_b[0], 3), isSeeking = _c[0], velocity = _c[1], range = _c[2], config = _b[1];
         return isSeeking && config && config.change && config.change(velocity, range);
     });
-    return {
-        isSeeking: isSeeking,
-        scrollSeekConfiguration: scrollSeekConfiguration,
-        scrollVelocity: scrollVelocity,
-        scrollSeekRangeChanged: rangeChanged,
-    };
+    return { isSeeking: isSeeking, scrollSeekConfiguration: scrollSeekConfiguration, scrollVelocity: scrollVelocity, scrollSeekRangeChanged: rangeChanged };
 }, u.tup(stateFlagsSystem), { singleton: true });

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

@@ -1,12 +1,11 @@
 import { __read } from "tslib";
 /* eslint-disable @typescript-eslint/no-unsafe-call */
-import * as u from '@virtuoso.dev/urx';
+import * as u from './urx';
 import { findMaxKeyValue } from './AATree';
 import { domIOSystem } from './domIOSystem';
+import { offsetOf, originalIndexFromLocation, sizeSystem } from './sizeSystem';
 import { loggerSystem, LogLevel } from './loggerSystem';
-import { offsetOf, originalIndexFromItemIndex, sizeSystem } from './sizeSystem';
-var SUPPORTS_SCROLL_TO_OPTIONS = typeof document !== 'undefined' &&
-    'scrollBehavior' in document.documentElement.style;
+var SUPPORTS_SCROLL_TO_OPTIONS = typeof document !== 'undefined' && 'scrollBehavior' in document.documentElement.style;
 export function normalizeIndexLocation(location) {
     var result = typeof location === 'number' ? { index: location } : location;
     if (!result.align) {
@@ -21,7 +20,7 @@ export function normalizeIndexLocation(location) {
     return result;
 }
 export var scrollToIndexSystem = u.system(function (_a) {
-    var _b = __read(_a, 3), _c = _b[0], sizes = _c.sizes, totalCount = _c.totalCount, listRefresh = _c.listRefresh, _d = _b[1], scrollingInProgress = _d.scrollingInProgress, viewportHeight = _d.viewportHeight, scrollTo = _d.scrollTo, smoothScrollTargetReached = _d.smoothScrollTargetReached, headerHeight = _d.headerHeight, footerHeight = _d.footerHeight, log = _b[2].log;
+    var _b = __read(_a, 3), _c = _b[0], sizes = _c.sizes, totalCount = _c.totalCount, listRefresh = _c.listRefresh, gap = _c.gap, _d = _b[1], scrollingInProgress = _d.scrollingInProgress, viewportHeight = _d.viewportHeight, scrollTo = _d.scrollTo, smoothScrollTargetReached = _d.smoothScrollTargetReached, headerHeight = _d.headerHeight, footerHeight = _d.footerHeight, fixedHeaderHeight = _d.fixedHeaderHeight, fixedFooterHeight = _d.fixedFooterHeight, log = _b[2].log;
     var scrollToIndex = u.stream();
     var topListHeight = u.statefulStream(0);
     var unsubscribeNextListRefresh = null;
@@ -42,32 +41,21 @@ export var scrollToIndexSystem = u.system(function (_a) {
         }
         u.publish(scrollingInProgress, false);
     }
-    u.connect(u.pipe(scrollToIndex, u.withLatestFrom(sizes, viewportHeight, totalCount, topListHeight, headerHeight, footerHeight, log), u.map(function (_a) {
-        var _b = __read(_a, 8), location = _b[0], sizes = _b[1], viewportHeight = _b[2], totalCount = _b[3], topListHeight = _b[4], headerHeight = _b[5], footerHeight = _b[6], log = _b[7];
+    u.connect(u.pipe(scrollToIndex, u.withLatestFrom(sizes, viewportHeight, totalCount, topListHeight, headerHeight, footerHeight, log), u.withLatestFrom(gap, fixedHeaderHeight, fixedFooterHeight), u.map(function (_a) {
+        var _b = __read(_a, 4), _c = __read(_b[0], 8), location = _c[0], sizes = _c[1], viewportHeight = _c[2], totalCount = _c[3], topListHeight = _c[4], headerHeight = _c[5], footerHeight = _c[6], log = _c[7], gap = _b[1], fixedHeaderHeight = _b[2], fixedFooterHeight = _b[3];
         var normalLocation = normalizeIndexLocation(location);
         var align = normalLocation.align, behavior = normalLocation.behavior, offset = normalLocation.offset;
         var lastIndex = totalCount - 1;
-        var index = normalLocation.index;
-        if (index === 'LAST') {
-            index = lastIndex;
-        }
-        index = originalIndexFromItemIndex(index, sizes);
-        index = Math.max(0, index, Math.min(lastIndex, index));
-        var top = offsetOf(index, sizes.offsetTree) + headerHeight;
+        var index = originalIndexFromLocation(normalLocation, sizes, lastIndex);
+        var top = offsetOf(index, sizes.offsetTree, gap) + headerHeight;
         if (align === 'end') {
-            top =
-                top -
-                    viewportHeight +
-                    findMaxKeyValue(sizes.sizeTree, index)[1];
+            top += fixedHeaderHeight + findMaxKeyValue(sizes.sizeTree, index)[1] - viewportHeight + fixedFooterHeight;
             if (index === lastIndex) {
                 top += footerHeight;
             }
         }
         else if (align === 'center') {
-            top =
-                top -
-                    viewportHeight / 2 +
-                    findMaxKeyValue(sizes.sizeTree, index)[1] / 2;
+            top += (fixedHeaderHeight + findMaxKeyValue(sizes.sizeTree, index)[1] - viewportHeight + fixedFooterHeight) / 2;
         }
         else {
             top -= topListHeight;
@@ -96,7 +84,7 @@ export var scrollToIndexSystem = u.system(function (_a) {
             });
         }
         else {
-            unsubscribeNextListRefresh = u.handleNext(u.pipe(listRefresh, watchChangesFor(50)), retry);
+            unsubscribeNextListRefresh = u.handleNext(u.pipe(listRefresh, watchChangesFor(150)), retry);
         }
         // if the scroll jump is too small, the list won't get rerendered.
         // clean this listener

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

@@ -1,37 +1,35 @@
 import { __read } from "tslib";
-import * as u from '@virtuoso.dev/urx';
-import { tupleComparator } from './comparators';
+import * as u from './urx';
 import { domIOSystem } from './domIOSystem';
-import { DOWN, UP } from './stateFlagsSystem';
+import { UP, DOWN } from './stateFlagsSystem';
+import { tupleComparator } from './comparators';
 export var TOP = 'top';
 export var BOTTOM = 'bottom';
 export var NONE = 'none';
 export function getOverscan(overscan, end, direction) {
     if (typeof overscan === 'number') {
-        return (direction === UP && end === TOP) ||
-            (direction === DOWN && end === BOTTOM)
-            ? overscan
-            : 0;
+        return (direction === UP && end === TOP) || (direction === DOWN && end === BOTTOM) ? overscan : 0;
     }
-    if (direction === UP) {
-        return end === TOP ? overscan.main : overscan.reverse;
+    else {
+        if (direction === UP) {
+            return end === TOP ? overscan.main : overscan.reverse;
+        }
+        else {
+            return end === BOTTOM ? overscan.main : overscan.reverse;
+        }
     }
-    return end === BOTTOM ? overscan.main : overscan.reverse;
 }
 function getViewportIncrease(value, end) {
     return typeof value === 'number' ? value : value[end] || 0;
 }
 export var sizeRangeSystem = u.system(function (_a) {
-    var _b = __read(_a, 1), _c = _b[0], scrollTop = _c.scrollTop, viewportHeight = _c.viewportHeight, deviation = _c.deviation, headerHeight = _c.headerHeight;
+    var _b = __read(_a, 1), _c = _b[0], scrollTop = _c.scrollTop, viewportHeight = _c.viewportHeight, deviation = _c.deviation, headerHeight = _c.headerHeight, fixedHeaderHeight = _c.fixedHeaderHeight;
     var listBoundary = u.stream();
     var topListHeight = u.statefulStream(0);
-    var fixedHeaderHeight = u.statefulStream(0);
     var increaseViewportBy = u.statefulStream(0);
     var overscan = u.statefulStream(0);
     var visibleRange = u.statefulStreamFromEmitter(u.pipe(u.combineLatest(u.duc(scrollTop), u.duc(viewportHeight), u.duc(headerHeight), u.duc(listBoundary, tupleComparator), u.duc(overscan), u.duc(topListHeight), u.duc(fixedHeaderHeight), u.duc(deviation), u.duc(increaseViewportBy)), u.map(function (_a) {
-        var _b = __read(_a, 9), scrollTop = _b[0], viewportHeight = _b[1], headerHeight = _b[2], 
-        // @ts-ignore
-        _c = __read(_b[3], 2), listTop = _c[0], listBottom = _c[1], overscan = _b[4], topListHeight = _b[5], fixedHeaderHeight = _b[6], deviation = _b[7], increaseViewportBy = _b[8];
+        var _b = __read(_a, 9), scrollTop = _b[0], viewportHeight = _b[1], headerHeight = _b[2], _c = __read(_b[3], 2), listTop = _c[0], listBottom = _c[1], overscan = _b[4], topListHeight = _b[5], fixedHeaderHeight = _b[6], deviation = _b[7], increaseViewportBy = _b[8];
         var top = scrollTop - deviation;
         var stickyHeaderHeight = topListHeight + fixedHeaderHeight;
         var headerVisible = Math.max(headerHeight - top, 0);
@@ -42,24 +40,15 @@ export var sizeRangeSystem = u.system(function (_a) {
         listTop += headerHeight + fixedHeaderHeight;
         listBottom += headerHeight + fixedHeaderHeight;
         listBottom -= deviation;
-        // console.log({ listTop, scrollTop, stickyHeaderHeight, topViewportAddition })
-        if (listTop >
-            scrollTop + stickyHeaderHeight - topViewportAddition) {
+        if (listTop > scrollTop + stickyHeaderHeight - topViewportAddition) {
             direction = UP;
         }
-        if (listBottom <
-            scrollTop -
-                headerVisible +
-                viewportHeight +
-                bottomViewportAddition) {
+        if (listBottom < scrollTop - headerVisible + viewportHeight + bottomViewportAddition) {
             direction = DOWN;
         }
         if (direction !== NONE) {
             return [
-                Math.max(top -
-                    headerHeight -
-                    getOverscan(overscan, TOP, direction) -
-                    topViewportAddition, 0),
+                Math.max(top - headerHeight - getOverscan(overscan, TOP, direction) - topViewportAddition, 0),
                 top -
                     headerVisible -
                     fixedHeaderHeight +
@@ -75,7 +64,6 @@ export var sizeRangeSystem = u.system(function (_a) {
         listBoundary: listBoundary,
         overscan: overscan,
         topListHeight: topListHeight,
-        fixedHeaderHeight: fixedHeaderHeight,
         increaseViewportBy: increaseViewportBy,
         // output
         visibleRange: visibleRange,