@synerise/ds-table 0.47.16 → 0.48.0

package/dist/VirtualTable/VirtualTable.js

@@ -10,62 +10,28 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
-import * as React from 'react';
+import React, { useCallback, useState, useRef, forwardRef, useEffect, useMemo, useImperativeHandle } from 'react';
 import { FixedSizeList as List } from 'react-window';
 import ResizeObserver from 'rc-resize-observer';
 import classNames from 'classnames';
 import { compact } from 'lodash';
 import { useIntl } from 'react-intl';
-import Scrollbar from '@synerise/ds-scrollbar';
 import { infiniteLoaderItemHeight } from '../InfiniteScroll/constants';
 import BackToTopButton from '../InfiniteScroll/BackToTopButton';
+import OuterListElement from '../InfiniteScroll/OuterListElement';
 import DSTable from '../Table';
 import VirtualTableRow from './VirtualTableRow';
-import { RelativeContainer } from './VirtualTable.styles';
+import * as S from './VirtualTable.styles';
 import { useTableLocale, calculatePixels } from '../utils';
 import { useRowKey } from '../hooks/useRowKey';
 import { useRowStar } from '../hooks/useRowStar';
 import { RowSelectionColumn } from '../RowSelection';
-export var EXPANDED_ROW_PROPERTY = 'expandedChild';
+import { EXPANDED_ROW_PROPERTY, HEADER_ROW_HEIGHT } from './constants';
 var relativeInlineStyle = {
   position: 'relative'
 };
 
-var CustomScrollbar = function CustomScrollbar(containerRef) {
-  return React.forwardRef(function (_ref, ref) {
-    var onScroll = _ref.onScroll,
-        children = _ref.children,
-        style = _ref.style;
-
-    var _React$useState = React.useState(null),
-        header = _React$useState[0],
-        setHeader = _React$useState[1];
-
-    React.useEffect(function () {
-      if (containerRef != null && containerRef.current) {
-        var headerElement = containerRef.current.querySelector('.ant-table-header');
-        headerElement && setHeader(headerElement);
-      }
-    }, []);
-    var onScrollHandler = React.useCallback(function (e) {
-      if (header) {
-        header.scrollTo({
-          left: e.currentTarget.scrollLeft
-        });
-      }
-
-      onScroll && onScroll(e);
-    }, [onScroll, header]);
-    return /*#__PURE__*/React.createElement(Scrollbar, {
-      ref: ref,
-      onScroll: onScrollHandler,
-      absolute: true,
-      maxHeight: style == null ? void 0 : style.height
-    }, children);
-  });
-};
-
-function VirtualTable(props) {
+var VirtualTable = function VirtualTable(props, ref) {
   var _props$columns = props.columns,
       columns = _props$columns === void 0 ? [] : _props$columns,
       scroll = props.scroll,
@@ -84,22 +50,41 @@ function VirtualTable(props) {
       dataSourceFull = props.dataSourceFull,
       expandable = props.expandable,
       locale = props.locale,
+      loading = props.loading,
+      sticky = props.sticky,
       onListRefChange = props.onListRefChange;
   var intl = useIntl();
   var tableLocale = useTableLocale(intl, locale);
-  var listRef = React.useRef(null);
-  var containerRef = React.useRef(null);
+  var listRef = useRef(null);
+  var outerListRef = useRef(null);
+  var containerRef = useRef(null);
+  var horizontalScrollRef = useRef(null);
+  var customBodyOnScrollRef = useRef();
+  useImperativeHandle(ref, function () {
+    return {
+      virtualListRef: listRef,
+      outerListRef: outerListRef,
+      horizontalScrollRef: horizontalScrollRef,
+      scrollTo: scrollTo,
+      scrollToTop: scrollToTop
+    };
+  });
 
-  var _React$useState2 = React.useState(initialWidth),
-      tableWidth = _React$useState2[0],
-      setTableWidth = _React$useState2[1];
+  var _useState = useState(initialWidth),
+      tableWidth = _useState[0],
+      setTableWidth = _useState[1];
+
+  var _useState2 = useState(initialWidth),
+      scrollWidth = _useState2[0],
+      setScrollWidth = _useState2[1];
 
   var _useRowStar = useRowStar((rowStar == null ? void 0 : rowStar.starredRowKeys) || []),
-      getRowStarColumn = _useRowStar.getRowStarColumn;
+      getRowStarColumn = _useRowStar.getRowStarColumn; // deprecated, verify if not used and remove
+
 
-  React.useEffect(function () {
-    onListRefChange && onListRefChange(listRef);
-  }, [listRef, onListRefChange]);
+  useEffect(function () {
+    listRef.current && onListRefChange && onListRefChange(listRef);
+  });
 
   var _useRowKey = useRowKey(rowKey),
       getRowKey = _useRowKey.getRowKey;
@@ -125,8 +110,8 @@ function VirtualTable(props) {
 
   function getSelectedRecords() {
     if (selection) {
-      var _ref2 = selection,
-          selectedRowKeys = _ref2.selectedRowKeys;
+      var _ref = selection,
+          selectedRowKeys = _ref.selectedRowKeys;
       var selectedRows = [];
       allData.forEach(function (row) {
         var key = getRowKey(row);
@@ -151,12 +136,12 @@ function VirtualTable(props) {
     return [];
   }
 
-  var renderRowSelection = React.useCallback(function (key, record) {
-    var _ref3 = selection,
-        selectedRowKeys = _ref3.selectedRowKeys,
-        limit = _ref3.limit,
-        independentSelectionExpandedRows = _ref3.independentSelectionExpandedRows,
-        onChange = _ref3.onChange;
+  var renderRowSelection = useCallback(function (key, record) {
+    var _ref2 = selection,
+        selectedRowKeys = _ref2.selectedRowKeys,
+        limit = _ref2.limit,
+        independentSelectionExpandedRows = _ref2.independentSelectionExpandedRows,
+        onChange = _ref2.onChange;
     return /*#__PURE__*/React.createElement(RowSelectionColumn, {
       rowKey: rowKey,
       record: record,
@@ -169,7 +154,7 @@ function VirtualTable(props) {
     });
   }, [locale, rowKey, selectedRecords, selection]); // eslint-disable-next-line @typescript-eslint/no-explicit-any
 
-  var virtualColumns = React.useMemo(function () {
+  var virtualColumns = useMemo(function () {
     return compact([!!selection && {
       width: 64,
       key: 'key',
@@ -177,14 +162,14 @@ function VirtualTable(props) {
       render: renderRowSelection
     }, !!rowStar && rowStarColumn].concat(columns));
   }, [selection, renderRowSelection, rowStar, rowStarColumn, columns]);
-  var mergedColumns = React.useMemo(function () {
-    var widthColumnCount = virtualColumns.filter(function (_ref4) {
-      var width = _ref4.width;
+  var mergedColumns = useMemo(function () {
+    var widthColumnCount = virtualColumns.filter(function (_ref3) {
+      var width = _ref3.width;
       return !width;
     }).length;
     var rowWidth = tableWidth || initialWidth;
-    var definedWidth = virtualColumns.reduce(function (total, _ref5) {
-      var width = _ref5.width;
+    var definedWidth = virtualColumns.reduce(function (total, _ref4) {
+      var width = _ref4.width;
       var widthInPx = calculatePixels(width) || 0;
       return total + widthInPx;
     }, 0);
@@ -195,35 +180,37 @@ function VirtualTable(props) {
         });
       }
 
+      var calculatedWidth = Math.floor((rowWidth - definedWidth) / widthColumnCount);
       return _objectSpread({}, column, {
-        width: Math.floor((rowWidth - definedWidth) / widthColumnCount)
+        width: calculatedWidth > 0 ? calculatedWidth : 1
       });
     });
   }, [virtualColumns, tableWidth, initialWidth]);
-  var listInnerElementType = React.forwardRef(function (_ref6, ref) {
-    var style = _ref6.style,
-        rest = _objectWithoutPropertiesLoose(_ref6, _excluded);
+  var listInnerElementType = forwardRef(function (_ref5, innerElementRef) {
+    var style = _ref5.style,
+        rest = _objectWithoutPropertiesLoose(_ref5, _excluded);
 
-    return /*#__PURE__*/React.createElement("div", _extends({
-      ref: ref,
+    return /*#__PURE__*/React.createElement(S.InnerListElement, _extends({
+      ref: innerElementRef,
       style: _objectSpread({}, style, {
         height: Number(style == null ? void 0 : style.height) + infiniteLoaderItemHeight + "px"
       })
     }, rest));
   });
-
-  var handleBackToTopClick = function handleBackToTopClick() {
+  var scrollTo = useCallback(function (top) {
     if (!listRef.current) {
       return;
     }
 
-    listRef.current.scrollTo(0);
-  };
-
-  var outerElement = React.useMemo(function () {
-    return CustomScrollbar(containerRef);
-  }, [containerRef]);
-  var createItemData = React.useCallback(function (data, defaultTableProps) {
+    listRef.current.scrollTo(top);
+  }, []);
+  var scrollToTop = useCallback(function () {
+    scrollTo(0);
+  }, [scrollTo]);
+  var outerElement = useMemo(function () {
+    return OuterListElement(containerRef, Boolean(sticky));
+  }, [sticky]);
+  var createItemData = useCallback(function (data, defaultTableProps) {
     return {
       mergedColumns: mergedColumns,
       selection: selection,
@@ -235,18 +222,33 @@ function VirtualTable(props) {
       defaultTableProps: defaultTableProps
     };
   }, [cellHeight, infiniteScroll, mergedColumns, onRowClick, rowStar, selection]);
-  var renderBody = React.useCallback(function (rawData, meta, defaultTableProps) {
+  var handleStickyScrollbarScroll = useCallback(function (event) {
+    if (customBodyOnScrollRef.current) {
+      customBodyOnScrollRef.current({
+        scrollLeft: event.currentTarget.scrollLeft
+      });
+    }
+  }, []);
+  var renderBody = useCallback(function (rawData, meta, defaultTableProps) {
     var _expandable$expandedR;
 
+    customBodyOnScrollRef.current = meta.onScroll;
+
     var renderVirtualList = function renderVirtualList(data) {
       var listHeight = data.length * cellHeight - scroll.y + infiniteLoaderItemHeight;
+      var listMaxScroll = sticky && sticky.scrollThreshold && infiniteScroll != null && infiniteScroll.maxScroll ? (infiniteScroll == null ? void 0 : infiniteScroll.maxScroll) - sticky.scrollThreshold : listHeight;
+
+      var handleListScroll = function handleListScroll(_ref6) {
+        var scrollOffset = _ref6.scrollOffset,
+            scrollDirection = _ref6.scrollDirection;
+
+        if (loading || listMaxScroll <= 0) {
+          return;
+        }
 
-      var handleListScroll = function handleListScroll(_ref7) {
-        var scrollOffset = _ref7.scrollOffset,
-            scrollDirection = _ref7.scrollDirection;
         var roundedOffset = Math.ceil(scrollOffset);
 
-        if (scrollDirection === 'forward' && roundedOffset >= listHeight && typeof (infiniteScroll == null ? void 0 : infiniteScroll.onScrollEndReach) === 'function') {
+        if (scrollDirection === 'forward' && roundedOffset >= listMaxScroll && typeof (infiniteScroll == null ? void 0 : infiniteScroll.onScrollEndReach) === 'function') {
           infiniteScroll.onScrollEndReach();
         }
 
@@ -256,12 +258,38 @@ function VirtualTable(props) {
       };
 
       var itemData = createItemData(data, defaultTableProps);
-      return /*#__PURE__*/React.createElement(List, {
+      var scrollableHeight = sticky ? scroll.y - HEADER_ROW_HEIGHT : scroll.y;
+
+      var handleBodyScroll = function handleBodyScroll(event) {
+        var scrollLeft = event.currentTarget.scrollLeft;
+        var info = {
+          scrollLeft: scrollLeft,
+          currentTarget: event.currentTarget
+        };
+        meta.onScroll(info);
+
+        if (horizontalScrollRef.current && horizontalScrollRef.current.scrollLeft !== scrollLeft) {
+          horizontalScrollRef.current.scrollTo({
+            left: scrollLeft
+          });
+        }
+      };
+
+      return /*#__PURE__*/React.createElement(S.VirtualListWrapper, {
+        listWidth: tableWidth,
+        "data-testid": "virtual-list-wrapper",
+        isSticky: Boolean(sticky),
+        listHeight: listHeight + HEADER_ROW_HEIGHT,
+        onScroll: handleBodyScroll // @ts-ignore
+        ,
+        ref: meta.ref
+      }, /*#__PURE__*/React.createElement(List, {
         ref: listRef,
         key: "virtual-list",
         onScroll: handleListScroll,
         className: "virtual-grid",
-        height: scroll.y,
+        height: scrollableHeight,
+        layout: "vertical",
         itemCount: data.length,
         itemSize: cellHeight,
         width: "100%",
@@ -272,9 +300,10 @@ function VirtualTable(props) {
           return String(key instanceof String ? key.toLowerCase() : key);
         },
         outerElementType: outerElement,
-        overscanCount: 1,
+        overscanCount: 5,
+        outerRef: outerListRef,
         innerElementType: infiniteScroll && listInnerElementType
-      }, VirtualTableRow);
+      }, VirtualTableRow));
     };
 
     if (expandable != null && (_expandable$expandedR = expandable.expandedRowKeys) != null && _expandable$expandedR.length) {
@@ -297,33 +326,51 @@ function VirtualTable(props) {
     }
 
     return renderVirtualList(rawData);
-  }, [cellHeight, createItemData, expandable, getRowKey, infiniteScroll, listInnerElementType, outerElement, scroll.y]);
+  }, [cellHeight, createItemData, expandable == null ? void 0 : expandable.expandedRowKeys, getRowKey, infiniteScroll, listInnerElementType, loading, outerElement, scroll.y, sticky, tableWidth]);
   var columnsSliceStartIndex = Number(!!selection) + Number(!!rowStar); // eslint-disable-next-line
 
   var scrollValue = !dataSource || (dataSource == null ? void 0 : dataSource.length) === 0 ? undefined : props == null ? void 0 : props.scroll;
-  return /*#__PURE__*/React.createElement(RelativeContainer, {
+  var finalColumns = mergedColumns.slice(columnsSliceStartIndex);
+  useEffect(function () {
+    if (containerRef != null && containerRef.current) {
+      var headerElement = containerRef.current.querySelector('.ant-table-header');
+      headerElement && setScrollWidth(headerElement.scrollWidth);
+    }
+  }, [finalColumns]);
+  var offsetScroll = sticky && sticky !== true ? sticky.offsetScroll : 0;
+  return /*#__PURE__*/React.createElement(S.VirtualTableWrapper, {
+    isSticky: Boolean(sticky),
+    style: sticky ? {} : relativeInlineStyle,
     key: "relative-container",
-    ref: containerRef,
-    style: relativeInlineStyle
+    ref: containerRef
   }, /*#__PURE__*/React.createElement(ResizeObserver, {
-    onResize: function onResize(_ref8) {
-      var offsetWidth = _ref8.offsetWidth;
+    onResize: function onResize(_ref7) {
+      var offsetWidth = _ref7.offsetWidth;
       setTableWidth(offsetWidth);
     }
   }, /*#__PURE__*/React.createElement(DSTable, _extends({}, props, {
+    sticky: dataSource.length ? sticky : undefined,
+    loading: loading,
     scroll: scrollValue,
-    className: classNames(className, 'virtual-table', !!infiniteScroll && 'virtual-table-infinite-scroll') // Remove columns which cause header columns indent
+    className: classNames(className, 'virtual-table', !!infiniteScroll && 'virtual-table-infinite-scroll', Boolean(sticky) && 'with-sticky-header') // Remove columns which cause header columns indent
     // @ts-ignore
     ,
-    columns: mergedColumns.slice(columnsSliceStartIndex),
+    columns: finalColumns,
     pagination: false,
     components: {
       body: renderBody
     },
     locale: tableLocale
   }))), !!(infiniteScroll != null && infiniteScroll.showBackToTopButton) && /*#__PURE__*/React.createElement(BackToTopButton, {
-    onClick: handleBackToTopClick
-  }, tableLocale.infiniteScrollBackToTop));
-}
+    onClick: scrollToTop
+  }, tableLocale.infiniteScrollBackToTop), sticky && dataSource.length ? /*#__PURE__*/React.createElement(S.StickyScrollbar, {
+    offset: offsetScroll || 0,
+    ref: horizontalScrollRef,
+    onScroll: handleStickyScrollbarScroll,
+    absolute: true
+  }, /*#__PURE__*/React.createElement(S.StickyScrollbarContent, {
+    scrollWidth: scrollWidth
+  })) : null);
+};
 
-export default VirtualTable;
+export default forwardRef(VirtualTable);

package/dist/VirtualTable/VirtualTable.styles.d.ts

@@ -1,9 +1,25 @@
+/// <reference types="react" />
 type ColWrapperProps = {
     width?: number | null;
     minWidth?: number | null;
     maxWidth?: number | null;
 };
 export declare const RowWrapper: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const InnerListElement: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const VirtualListSpace: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const VirtualListWrapper: import("styled-components").StyledComponent<"div", any, {
+    isSticky: boolean;
+    listHeight: number;
+    listWidth: number;
+}, never>;
+export declare const StickyScrollbar: import("styled-components").StyledComponent<import("react").ForwardRefExoticComponent<(import("@synerise/ds-scrollbar").ScrollbarProps | import("@synerise/ds-scrollbar").VirtualScrollbarProps) & import("react").RefAttributes<HTMLElement>>, any, {
+    offset: number;
+}, never>;
+export declare const StickyScrollbarContent: import("styled-components").StyledComponent<"div", any, {
+    scrollWidth: number;
+}, never>;
 export declare const ColWrapper: import("styled-components").StyledComponent<"div", any, ColWrapperProps, never>;
-export declare const RelativeContainer: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const VirtualTableWrapper: import("styled-components").StyledComponent<"div", any, {
+    isSticky: boolean;
+}, never>;
 export {};

package/dist/VirtualTable/VirtualTable.styles.js

@@ -1,4 +1,5 @@
-import styled from 'styled-components';
+import styled, { css } from 'styled-components';
+import Scrollbar from '@synerise/ds-scrollbar';
 
 var numberToPixels = function numberToPixels(num) {
   return num + "px";
@@ -24,15 +25,45 @@ export var RowWrapper = styled.div.withConfig({
   displayName: "VirtualTablestyles__RowWrapper",
   componentId: "aehkhc-0"
 })(["display:inline-table;"]);
+export var InnerListElement = styled.div.withConfig({
+  displayName: "VirtualTablestyles__InnerListElement",
+  componentId: "aehkhc-1"
+})(["background:", ";"], function (props) {
+  return props.theme.palette.white;
+});
+export var VirtualListSpace = styled.div.withConfig({
+  displayName: "VirtualTablestyles__VirtualListSpace",
+  componentId: "aehkhc-2"
+})([""]);
+export var VirtualListWrapper = styled.div.withConfig({
+  displayName: "VirtualTablestyles__VirtualListWrapper",
+  componentId: "aehkhc-3"
+})(["", " overscroll-behavior-x:contain;"], function (props) {
+  return props.isSticky && css(["width:", "px;overflow:overlay hidden;scrollbar-color:transparent;scrollbar-width:none;::-webkit-scrollbar-thumb{background-color:transparent;}::-webkit-scrollbar{display:none;}:after{content:'';width:10px;height:", "px;display:block;}"], props.listWidth, props.listHeight);
+});
+export var StickyScrollbar = styled(Scrollbar).withConfig({
+  displayName: "VirtualTablestyles__StickyScrollbar",
+  componentId: "aehkhc-4"
+})(["position:sticky;bottom:0;z-index:2;transform:translate(5px,", "px);"], function (props) {
+  return props.offset;
+});
+export var StickyScrollbarContent = styled.div.withConfig({
+  displayName: "VirtualTablestyles__StickyScrollbarContent",
+  componentId: "aehkhc-5"
+})(["width:", "px;height:10px;"], function (props) {
+  return props.scrollWidth;
+});
 export var ColWrapper = styled.div.withConfig({
   displayName: "VirtualTablestyles__ColWrapper",
-  componentId: "aehkhc-1"
+  componentId: "aehkhc-6"
 })(["display:table-cell;vertical-align:middle;width:inherit;min-width:", ";max-width:", ";padding:0 24px;&.virtual-table-cell.ant-table-selection-column{padding:0 8px 0 24px;width:auto;}&.virtual-table-cell.ds-table-star-column{padding:0 8px 0 24px;width:auto;& > button{display:flex;}}&.virtual-table-cell.ant-table-selection-column + .virtual-table-cell.ds-table-star-column{padding-left:0;}"], function (props) {
   return getColumnMinWidth(props);
 }, function (props) {
   return getColumnMaxWidth(props);
 });
-export var RelativeContainer = styled.div.withConfig({
-  displayName: "VirtualTablestyles__RelativeContainer",
-  componentId: "aehkhc-2"
-})(["position:relative;"]);
+export var VirtualTableWrapper = styled.div.withConfig({
+  displayName: "VirtualTablestyles__VirtualTableWrapper",
+  componentId: "aehkhc-7"
+})(["", ""], function (props) {
+  return props.isSticky ? '' : 'position: relative;';
+});

package/dist/VirtualTable/VirtualTable.types.d.ts

@@ -1,8 +1,8 @@
 import { RefObject } from 'react';
 import { FixedSizeList as List } from 'react-window';
-import { InfiniteScrollProps } from '../InfiniteScroll/constants';
+import { InfiniteScrollProps } from '../InfiniteScroll/InfiniteLoaderItem.types';
 import { DSTableProps } from '../Table.types';
-export interface Props<T> extends DSTableProps<T> {
+export type Props<T> = DSTableProps<T> & {
     cellHeight: number;
     infiniteScroll?: InfiniteScrollProps;
     initialWidth: number;
@@ -10,6 +10,16 @@ export interface Props<T> extends DSTableProps<T> {
         x?: number;
         y: number;
     };
+    sticky?: DSTableProps<T>['sticky'] & {
+        scrollThreshold?: number;
+    };
     onListRefChange?: (ref: RefObject<List>) => void;
     onRowClick?: (row: T) => void;
-}
+};
+export type VirtualTableRef = {
+    virtualListRef: RefObject<List>;
+    outerListRef: RefObject<HTMLDivElement>;
+    horizontalScrollRef: RefObject<HTMLDivElement>;
+    scrollToTop: () => void;
+    scrollTo: (top: number) => void;
+};

package/dist/VirtualTable/VirtualTableRow.d.ts

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import { InfiniteScrollProps } from '../InfiniteScroll/constants';
+import { InfiniteScrollProps } from '../InfiniteScroll/InfiniteLoaderItem.types';
 import { RowSelection, DSTableProps } from '../Table.types';
 import { RowStar } from '../hooks/useRowStar';
 export interface VirtualTableRowProps<T> {

package/dist/VirtualTable/VirtualTableRow.js

@@ -8,7 +8,7 @@ import * as React from 'react';
 import classNames from 'classnames';
 import { areEqual } from 'react-window';
 import InfiniteLoaderItem from '../InfiniteScroll/InfiniteLoaderItem';
-import { EXPANDED_ROW_PROPERTY } from './VirtualTable';
+import { EXPANDED_ROW_PROPERTY } from './constants';
 import * as S from './VirtualTable.styles';
 import { getValueFromPath, calculatePixels } from '../utils';
 

package/dist/VirtualTable/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const HEADER_ROW_HEIGHT = 64;
+export declare const EXPANDED_ROW_PROPERTY = "expandedChild";

package/dist/VirtualTable/constants.js

@@ -0,0 +1,2 @@
+export var HEADER_ROW_HEIGHT = 64;
+export var EXPANDED_ROW_PROPERTY = 'expandedChild';

package/dist/index.d.ts

@@ -5,3 +5,5 @@ import ItemsMenu from './ItemsMenu/ItemsMenu';
 import TreeTable from './TreeTable/TreeTable';
 export { default } from './Table';
 export { GroupedTable, VirtualTable, TableCell, ItemsMenu, TreeTable };
+export type { Props as VirtualTableProps, VirtualTableRef } from './VirtualTable/VirtualTable.types';
+export { default as BackToTopButton } from './InfiniteScroll/BackToTopButton';

package/dist/index.js

@@ -4,4 +4,5 @@ import * as TableCell from './Cell';
 import ItemsMenu from './ItemsMenu/ItemsMenu';
 import TreeTable from './TreeTable/TreeTable';
 export { default } from './Table';
-export { GroupedTable, VirtualTable, TableCell, ItemsMenu, TreeTable };
+export { GroupedTable, VirtualTable, TableCell, ItemsMenu, TreeTable };
+export { default as BackToTopButton } from './InfiniteScroll/BackToTopButton';