@ringcentral/juno 2.40.1 → 2.41.0

package/components/Virtuoso/react-virtuoso/windowScrollerSystem.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 domIOSystem_1 = require("./domIOSystem");
 exports.windowScrollerSystem = u.system(function (_a) {
     var _b = tslib_1.__read(_a, 1), _c = _b[0], scrollTo = _c.scrollTo, scrollContainerState = _c.scrollContainerState;

package/components/Virtuoso/utils/isOutOfRange.d.ts

@@ -1,2 +1,2 @@
-import { ListRange } from '../Virtuoso';
+import { ListRange } from '../react-virtuoso';
 export declare function isOutOfRange(focusedIndex: number, range: ListRange): boolean;

package/components/Virtuoso/utils/useHighlightScroll.d.ts

@@ -1,8 +1,8 @@
 import React from 'react';
-import { IndexLocationWithAlign, ListItem } from 'react-virtuoso';
+import { FlatIndexLocationWithAlign, ListItem } from '../react-virtuoso';
 declare type UseHighlightScrollParams = {
     /** function to call to scroll to target index */
-    scrollToIndex: (location: IndexLocationWithAlign) => void;
+    scrollToIndex: (location: FlatIndexLocationWithAlign) => void;
     /** that scroll container height ref */
     containerHeighRef: React.MutableRefObject<number>;
 };

package/es6/components/Virtuoso/index.js

@@ -1,2 +1,2 @@
-export * from './Virtuoso';
+export * from './react-virtuoso';
 export * from './utils';

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

@@ -19,16 +19,20 @@ export function remove(node, key) {
         if (empty(l)) {
             return r;
         }
-        if (empty(r)) {
+        else if (empty(r)) {
             return l;
         }
-        var _a = __read(last(l), 2), lastKey = _a[0], lastValue = _a[1];
-        return adjust(clone(node, { k: lastKey, v: lastValue, l: deleteLast(l) }));
+        else {
+            var _a = __read(last(l), 2), lastKey = _a[0], lastValue = _a[1];
+            return adjust(clone(node, { k: lastKey, v: lastValue, l: deleteLast(l) }));
+        }
     }
-    if (key < k) {
+    else if (key < k) {
         return adjust(clone(node, { l: remove(l, key) }));
     }
-    return adjust(clone(node, { r: remove(r, key) }));
+    else {
+        return adjust(clone(node, { r: remove(r, key) }));
+    }
 }
 export function find(node, key) {
     if (empty(node)) {
@@ -37,25 +41,29 @@ export function find(node, key) {
     if (key === node.k) {
         return node.v;
     }
-    if (key < node.k) {
+    else if (key < node.k) {
         return find(node.l, key);
     }
-    return find(node.r, key);
+    else {
+        return find(node.r, key);
+    }
 }
 export function findMaxKeyValue(node, value, field) {
     if (field === void 0) { field = 'k'; }
     if (empty(node)) {
         return [-Infinity, undefined];
     }
-    if (node[field] === value) {
+    if (Number(node[field]) === value) {
         return [node.k, node.v];
     }
-    if (node[field] < value) {
+    if (Number(node[field]) < value) {
         var r = findMaxKeyValue(node.r, value, field);
         if (r[0] === -Infinity) {
             return [node.k, node.v];
         }
-        return r;
+        else {
+            return r;
+        }
     }
     return findMaxKeyValue(node.l, value, field);
 }
@@ -66,10 +74,12 @@ export function insert(node, k, v) {
     if (k === node.k) {
         return clone(node, { k: k, v: v });
     }
-    if (k < node.k) {
+    else if (k < node.k) {
         return rebalance(clone(node, { l: insert(node.l, k, v) }));
     }
-    return rebalance(clone(node, { r: insert(node.r, k, v) }));
+    else {
+        return rebalance(clone(node, { r: insert(node.r, k, v) }));
+    }
 }
 export function walkWithin(node, start, end) {
     if (empty(node)) {
@@ -98,9 +108,7 @@ function last(node) {
     return empty(node.r) ? [node.k, node.v] : last(node.r);
 }
 function deleteLast(node) {
-    return empty(node.r)
-        ? node.l
-        : adjust(clone(node, { r: deleteLast(node.r) }));
+    return empty(node.r) ? node.l : adjust(clone(node, { r: deleteLast(node.r) }));
 }
 function clone(node, args) {
     return newAANode(args.k !== undefined ? args.k : node.k, args.v !== undefined ? args.v : node.v, args.lvl !== undefined ? args.lvl : node.lvl, args.l !== undefined ? args.l : node.l, args.r !== undefined ? args.r : node.r);
@@ -116,39 +124,47 @@ function adjust(node) {
     if (r.lvl >= lvl - 1 && l.lvl >= lvl - 1) {
         return node;
     }
-    if (lvl > r.lvl + 1) {
+    else if (lvl > r.lvl + 1) {
         if (isSingle(l)) {
             return skew(clone(node, { lvl: lvl - 1 }));
         }
-        if (!empty(l) && !empty(l.r)) {
-            return clone(l.r, {
-                l: clone(l, { r: l.r.l }),
-                r: clone(node, {
-                    l: l.r.r,
-                    lvl: lvl - 1,
-                }),
-                lvl: lvl,
-            });
+        else {
+            if (!empty(l) && !empty(l.r)) {
+                return clone(l.r, {
+                    l: clone(l, { r: l.r.l }),
+                    r: clone(node, {
+                        l: l.r.r,
+                        lvl: lvl - 1,
+                    }),
+                    lvl: lvl,
+                });
+            }
+            else {
+                throw new Error('Unexpected empty nodes');
+            }
         }
-        throw new Error('Unexpected empty nodes');
-    }
-    else if (isSingle(node)) {
-        return split(clone(node, { lvl: lvl - 1 }));
-    }
-    else if (!empty(r) && !empty(r.l)) {
-        var rl = r.l;
-        var rlvl = isSingle(rl) ? r.lvl - 1 : r.lvl;
-        return clone(rl, {
-            l: clone(node, {
-                r: rl.l,
-                lvl: lvl - 1,
-            }),
-            r: split(clone(r, { l: rl.r, lvl: rlvl })),
-            lvl: rl.lvl + 1,
-        });
     }
     else {
-        throw new Error('Unexpected empty nodes');
+        if (isSingle(node)) {
+            return split(clone(node, { lvl: lvl - 1 }));
+        }
+        else {
+            if (!empty(r) && !empty(r.l)) {
+                var rl = r.l;
+                var rlvl = isSingle(rl) ? r.lvl - 1 : r.lvl;
+                return clone(rl, {
+                    l: clone(node, {
+                        r: rl.l,
+                        lvl: lvl - 1,
+                    }),
+                    r: split(clone(r, { l: rl.r, lvl: rlvl })),
+                    lvl: rl.lvl + 1,
+                });
+            }
+            else {
+                throw new Error('Unexpected empty nodes');
+            }
+        }
     }
 }
 export function keys(node) {
@@ -191,13 +207,9 @@ function toRanges(nodes) {
 }
 function split(node) {
     var r = node.r, lvl = node.lvl;
-    return !empty(r) && !empty(r.r) && r.lvl === lvl && r.r.lvl === lvl
-        ? clone(r, { l: clone(node, { r: r.l }), lvl: lvl + 1 })
-        : node;
+    return !empty(r) && !empty(r.r) && r.lvl === lvl && r.r.lvl === lvl ? clone(r, { l: clone(node, { r: r.l }), lvl: lvl + 1 }) : node;
 }
 function skew(node) {
     var l = node.l;
-    return !empty(l) && l.lvl === node.lvl
-        ? clone(l, { r: clone(node, { l: l.r }) })
-        : node;
+    return !empty(l) && l.lvl === node.lvl ? clone(l, { r: clone(node, { l: l.r }) }) : node;
 }

package/es6/components/Virtuoso/react-virtuoso/{Table.js → TableVirtuoso.js}

@@ -1,38 +1,39 @@
-var _a;
 import { __assign, __read, __spread } from "tslib";
-import * as React from 'react';
-import { createElement } from 'react';
-import { systemToComponent } from '@virtuoso.dev/react-urx';
-import { compose, distinctUntilChanged, map, noop, pipe, statefulStream, statefulStreamFromEmitter, system, tup, } from '@virtuoso.dev/urx';
+import { systemToComponent } from './react-urx';
+import * as u from './urx';
+import React from 'react';
 import useChangedListContentsSizes from './hooks/useChangedChildSizes';
-import useSize from './hooks/useSize';
-import useWindowViewportRectRef from './hooks/useWindowViewportRect';
-import { buildScroller, buildWindowScroller, contextPropIfNotDomElement, identity, viewportStyle, } from './List';
 import { listSystem } from './listSystem';
-import conditionalFlushSync from './utils/conditionalFlushSync';
+import { identity, buildScroller, buildWindowScroller, viewportStyle, contextPropIfNotDomElement, itemPropIfNotDomElement, } from './Virtuoso';
+import useSize from './hooks/useSize';
 import { correctItemSize } from './utils/correctItemSize';
-var tableComponentPropsSystem = system(function () {
-    var itemContent = statefulStream(function (index) { return React.createElement("td", null,
+import useWindowViewportRectRef from './hooks/useWindowViewportRect';
+import { VirtuosoMockContext } from './utils/context';
+var tableComponentPropsSystem = /*#__PURE__*/ u.system(function () {
+    var itemContent = u.statefulStream(function (index) { return React.createElement("td", null,
         "Item $",
         index); });
-    var context = statefulStream(null);
-    var fixedHeaderContent = statefulStream(null);
-    var components = statefulStream({});
-    var computeItemKey = statefulStream(identity);
-    var scrollerRef = statefulStream(noop);
+    var context = u.statefulStream(null);
+    var fixedHeaderContent = u.statefulStream(null);
+    var fixedFooterContent = u.statefulStream(null);
+    var components = u.statefulStream({});
+    var computeItemKey = u.statefulStream(identity);
+    var scrollerRef = u.statefulStream(u.noop);
     var distinctProp = function (propName, defaultValue) {
         if (defaultValue === void 0) { defaultValue = null; }
-        return statefulStreamFromEmitter(pipe(components, map(function (components) { return components[propName]; }), distinctUntilChanged()), defaultValue);
+        return u.statefulStreamFromEmitter(u.pipe(components, u.map(function (components) { return components[propName]; }), u.distinctUntilChanged()), defaultValue);
     };
     return {
         context: context,
         itemContent: itemContent,
         fixedHeaderContent: fixedHeaderContent,
+        fixedFooterContent: fixedFooterContent,
         components: components,
         computeItemKey: computeItemKey,
         scrollerRef: scrollerRef,
         TableComponent: distinctProp('Table', 'table'),
         TableHeadComponent: distinctProp('TableHead', 'thead'),
+        TableFooterComponent: distinctProp('TableFoot', 'tfoot'),
         TableBodyComponent: distinctProp('TableBody', 'tbody'),
         TableRowComponent: distinctProp('TableRow', 'tr'),
         ScrollerComponent: distinctProp('Scroller', 'div'),
@@ -41,10 +42,10 @@ var tableComponentPropsSystem = system(function () {
         FillerRow: distinctProp('FillerRow'),
     };
 });
-var combinedSystem = system(function (_a) {
+var combinedSystem = /*#__PURE__*/ u.system(function (_a) {
     var _b = __read(_a, 2), listSystem = _b[0], propsSystem = _b[1];
     return __assign(__assign({}, listSystem), propsSystem);
-}, tup(listSystem, tableComponentPropsSystem));
+}, u.tup(listSystem, tableComponentPropsSystem));
 var DefaultScrollSeekPlaceholder = function (_a) {
     var height = _a.height;
     return (React.createElement("tr", null,
@@ -55,30 +56,27 @@ var DefaultFillerRow = function (_a) {
     return (React.createElement("tr", null,
         React.createElement("td", { style: { height: height, padding: 0, border: 0 } })));
 };
-export var Items = React.memo(function VirtuosoItems() {
+var ITEM_STYLE = { overflowAnchor: 'none' };
+var Items = /*#__PURE__*/ React.memo(function VirtuosoItems() {
     var listState = useEmitterValue('listState');
-    var _a = __read(React.useState(0), 2), deviation = _a[0], setDeviation = _a[1];
-    var react18ConcurrentRendering = useEmitterValue('react18ConcurrentRendering');
-    useEmitter('deviation', function (value) {
-        if (deviation !== value) {
-            conditionalFlushSync(react18ConcurrentRendering)(function () {
-                return setDeviation(value);
-            });
-        }
-    });
     var sizeRanges = usePublisher('sizeRanges');
     var useWindowScroll = useEmitterValue('useWindowScroll');
     var customScrollParent = useEmitterValue('customScrollParent');
     var windowScrollContainerStateCallback = usePublisher('windowScrollContainerState');
     var _scrollContainerStateCallback = usePublisher('scrollContainerState');
-    var scrollContainerStateCallback = customScrollParent || useWindowScroll
-        ? windowScrollContainerStateCallback
-        : _scrollContainerStateCallback;
+    var scrollContainerStateCallback = customScrollParent || useWindowScroll ? windowScrollContainerStateCallback : _scrollContainerStateCallback;
     var itemContent = useEmitterValue('itemContent');
     var trackItemSizes = useEmitterValue('trackItemSizes');
     var itemSize = useEmitterValue('itemSize');
     var log = useEmitterValue('log');
-    var ref = useChangedListContentsSizes(sizeRanges, itemSize, trackItemSizes, scrollContainerStateCallback, log, customScrollParent);
+    var _a = useChangedListContentsSizes(sizeRanges, itemSize, trackItemSizes, scrollContainerStateCallback, log, undefined, customScrollParent), callbackRef = _a.callbackRef, ref = _a.ref;
+    var _b = __read(React.useState(0), 2), deviation = _b[0], setDeviation = _b[1];
+    useEmitter('deviation', function (value) {
+        if (deviation !== value) {
+            ref.current.style.marginTop = value + "px";
+            setDeviation(value);
+        }
+    });
     var EmptyPlaceholder = useEmitterValue('EmptyPlaceholder');
     var ScrollSeekPlaceholder = useEmitterValue('ScrollSeekPlaceholder') || DefaultScrollSeekPlaceholder;
     var FillerRow = useEmitterValue('FillerRow') || DefaultFillerRow;
@@ -91,60 +89,85 @@ export var Items = React.memo(function VirtuosoItems() {
     var statefulTotalCount = useEmitterValue('statefulTotalCount');
     var context = useEmitterValue('context');
     if (statefulTotalCount === 0 && EmptyPlaceholder) {
-        return createElement(EmptyPlaceholder, contextPropIfNotDomElement(EmptyPlaceholder, context));
+        return React.createElement(EmptyPlaceholder, contextPropIfNotDomElement(EmptyPlaceholder, context));
     }
     var paddingTop = listState.offsetTop + paddingTopAddition + deviation;
     var paddingBottom = listState.offsetBottom;
-    var paddingTopEl = paddingTop > 0 ? React.createElement(FillerRow, { height: paddingTop, key: "padding-top" }) : null;
-    var paddingBottomEl = paddingBottom > 0 ? (React.createElement(FillerRow, { height: paddingBottom, key: "padding-bottom" })) : null;
+    var paddingTopEl = paddingTop > 0 ? React.createElement(FillerRow, { height: paddingTop, key: "padding-top", context: context }) : null;
+    var paddingBottomEl = paddingBottom > 0 ? React.createElement(FillerRow, { height: paddingBottom, key: "padding-bottom", context: context }) : null;
     var items = listState.items.map(function (item) {
         var index = item.originalIndex;
         var key = computeItemKey(index + firstItemIndex, item.data, context);
         if (isSeeking) {
-            return createElement(ScrollSeekPlaceholder, __assign(__assign({}, contextPropIfNotDomElement(ScrollSeekPlaceholder, context)), { key: key, index: item.index, height: item.size, type: item.type || 'item' }));
+            return React.createElement(ScrollSeekPlaceholder, __assign(__assign({}, contextPropIfNotDomElement(ScrollSeekPlaceholder, context)), { key: key, index: item.index, height: item.size, type: item.type || 'item' }));
         }
-        return createElement(TableRowComponent, __assign(__assign({}, contextPropIfNotDomElement(TableRowComponent, context)), { key: key, 'data-index': index, 'data-known-size': item.size, 'data-item-index': item.index, style: { overflowAnchor: 'none' } }), itemContent(item.index, item.data, context));
+        return React.createElement(TableRowComponent, __assign(__assign(__assign({}, contextPropIfNotDomElement(TableRowComponent, context)), itemPropIfNotDomElement(TableRowComponent, item.data)), { key: key, 'data-index': index, 'data-known-size': item.size, 'data-item-index': item.index, style: ITEM_STYLE }), itemContent(item.index, item.data, context));
     });
-    return createElement(TableBodyComponent, __assign({ ref: ref, 'data-test-id': 'virtuoso-item-list' }, contextPropIfNotDomElement(TableBodyComponent, context)), __spread([paddingTopEl], items, [paddingBottomEl]));
+    return React.createElement(TableBodyComponent, __assign({ ref: callbackRef, 'data-test-id': 'virtuoso-item-list' }, contextPropIfNotDomElement(TableBodyComponent, context)), __spread([paddingTopEl], items, [paddingBottomEl]));
 });
 var Viewport = function (_a) {
     var children = _a.children;
+    var ctx = React.useContext(VirtuosoMockContext);
     var viewportHeight = usePublisher('viewportHeight');
-    var viewportRef = useSize(compose(viewportHeight, function (el) { return correctItemSize(el, 'height'); }));
+    var fixedItemHeight = usePublisher('fixedItemHeight');
+    var viewportRef = useSize(u.compose(viewportHeight, function (el) { return correctItemSize(el, 'height'); }));
+    React.useEffect(function () {
+        if (ctx) {
+            viewportHeight(ctx.viewportHeight);
+            fixedItemHeight(ctx.itemHeight);
+        }
+    }, [ctx, viewportHeight, fixedItemHeight]);
     return (React.createElement("div", { style: viewportStyle, ref: viewportRef, "data-viewport-type": "element" }, children));
 };
 var WindowViewport = function (_a) {
     var children = _a.children;
+    var ctx = React.useContext(VirtuosoMockContext);
     var windowViewportRect = usePublisher('windowViewportRect');
+    var fixedItemHeight = usePublisher('fixedItemHeight');
     var customScrollParent = useEmitterValue('customScrollParent');
     var viewportRef = useWindowViewportRectRef(windowViewportRect, customScrollParent);
+    React.useEffect(function () {
+        if (ctx) {
+            fixedItemHeight(ctx.itemHeight);
+            windowViewportRect({ offsetTop: 0, visibleHeight: ctx.viewportHeight, visibleWidth: 100 });
+        }
+    }, [ctx, windowViewportRect, fixedItemHeight]);
     return (React.createElement("div", { ref: viewportRef, style: viewportStyle, "data-viewport-type": "window" }, children));
 };
 var TableRoot = React.memo(function TableVirtuosoRoot(props) {
     var useWindowScroll = useEmitterValue('useWindowScroll');
     var customScrollParent = useEmitterValue('customScrollParent');
     var fixedHeaderHeight = usePublisher('fixedHeaderHeight');
+    var fixedFooterHeight = usePublisher('fixedFooterHeight');
     var fixedHeaderContent = useEmitterValue('fixedHeaderContent');
+    var fixedFooterContent = useEmitterValue('fixedFooterContent');
     var context = useEmitterValue('context');
-    var theadRef = useSize(compose(fixedHeaderHeight, function (el) { return correctItemSize(el, 'height'); }));
+    var theadRef = useSize(u.compose(fixedHeaderHeight, function (el) { return correctItemSize(el, 'height'); }));
+    var tfootRef = useSize(u.compose(fixedFooterHeight, function (el) { return correctItemSize(el, 'height'); }));
     var TheScroller = customScrollParent || useWindowScroll ? WindowScroller : Scroller;
     var TheViewport = customScrollParent || useWindowScroll ? WindowViewport : Viewport;
     var TheTable = useEmitterValue('TableComponent');
     var TheTHead = useEmitterValue('TableHeadComponent');
+    var TheTFoot = useEmitterValue('TableFooterComponent');
     var theHead = fixedHeaderContent
-        ? React.createElement(TheTHead, __assign({ key: 'TableHead', style: { zIndex: 1, position: 'sticky', top: 0 }, ref: theadRef }, contextPropIfNotDomElement(TheTHead, context)), fixedHeaderContent())
+        ? React.createElement(TheTHead, __assign({ key: 'TableHead', style: { zIndex: 2, position: 'sticky', top: 0 }, ref: theadRef }, contextPropIfNotDomElement(TheTHead, context)), fixedHeaderContent())
+        : null;
+    var theFoot = fixedFooterContent
+        ? React.createElement(TheTFoot, __assign({ key: 'TableFoot', style: { zIndex: 1, position: 'sticky', bottom: 0 }, ref: tfootRef }, contextPropIfNotDomElement(TheTFoot, context)), fixedFooterContent())
         : null;
     return (React.createElement(TheScroller, __assign({}, props),
-        React.createElement(TheViewport, null, React.createElement(TheTable, __assign({ style: { borderSpacing: 0 } }, contextPropIfNotDomElement(TheTable, context)), [theHead, React.createElement(Items, { key: "TableBody" })]))));
+        React.createElement(TheViewport, null, React.createElement(TheTable, __assign({ style: { borderSpacing: 0, overflowAnchor: 'none' } }, contextPropIfNotDomElement(TheTable, context)), [theHead, React.createElement(Items, { key: "TableBody" }), theFoot]))));
 });
-export var Table = (_a = systemToComponent(combinedSystem, {
+var _a = systemToComponent(combinedSystem, {
     required: {},
     optional: {
+        restoreStateFrom: 'restoreStateFrom',
         context: 'context',
         followOutput: 'followOutput',
         firstItemIndex: 'firstItemIndex',
         itemContent: 'itemContent',
         fixedHeaderContent: 'fixedHeaderContent',
+        fixedFooterContent: 'fixedFooterContent',
         overscan: 'overscan',
         increaseViewportBy: 'increaseViewportBy',
         totalCount: 'totalCount',
@@ -153,6 +176,7 @@ export var Table = (_a = systemToComponent(combinedSystem, {
         components: 'components',
         groupCounts: 'groupCounts',
         atBottomThreshold: 'atBottomThreshold',
+        atTopThreshold: 'atTopThreshold',
         computeItemKey: 'computeItemKey',
         defaultItemHeight: 'defaultItemHeight',
         fixedItemHeight: 'fixedItemHeight',
@@ -166,13 +190,13 @@ export var Table = (_a = systemToComponent(combinedSystem, {
         customScrollParent: 'customScrollParent',
         scrollerRef: 'scrollerRef',
         logLevel: 'logLevel',
-        react18ConcurrentRendering: 'react18ConcurrentRendering',
     },
     methods: {
         scrollToIndex: 'scrollToIndex',
         scrollIntoView: 'scrollIntoView',
         scrollTo: 'scrollTo',
         scrollBy: 'scrollBy',
+        getState: 'getState',
     },
     events: {
         isScrolling: 'isScrolling',
@@ -185,10 +209,7 @@ export var Table = (_a = systemToComponent(combinedSystem, {
         itemsRendered: 'itemsRendered',
         groupIndices: 'groupIndices',
     },
-}, TableRoot), _a.Component), usePublisher = _a.usePublisher, useEmitterValue = _a.useEmitterValue, useEmitter = _a.useEmitter;
-var Scroller = buildScroller({ usePublisher: usePublisher, useEmitterValue: useEmitterValue, useEmitter: useEmitter });
-var WindowScroller = buildWindowScroller({
-    usePublisher: usePublisher,
-    useEmitterValue: useEmitterValue,
-    useEmitter: useEmitter,
-});
+}, TableRoot), Table = _a.Component, usePublisher = _a.usePublisher, useEmitterValue = _a.useEmitterValue, useEmitter = _a.useEmitter;
+var Scroller = /*#__PURE__*/ buildScroller({ usePublisher: usePublisher, useEmitterValue: useEmitterValue, useEmitter: useEmitter });
+var WindowScroller = /*#__PURE__*/ buildWindowScroller({ usePublisher: usePublisher, useEmitterValue: useEmitterValue, useEmitter: useEmitter });
+export var TableVirtuoso = Table;