@depup/react-virtualized 9.22.6-depup.0

package/dist/es/MultiGrid/index.js

@@ -0,0 +1,3 @@
+import MultiGrid from './MultiGrid';
+export default MultiGrid;
+export { MultiGrid };

package/dist/es/ScrollSync/ScrollSync.example.js

@@ -0,0 +1,248 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/inherits";
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+import * as React from 'react';
+import { ContentBox, ContentBoxHeader, ContentBoxParagraph } from '../demo/ContentBox';
+import AutoSizer from '../AutoSizer';
+import Grid from '../Grid';
+import ScrollSync from './ScrollSync';
+import clsx from 'clsx';
+import styles from './ScrollSync.example.css';
+import scrollbarSize from 'dom-helpers/scrollbarSize';
+var LEFT_COLOR_FROM = hexToRgb('#471061');
+var LEFT_COLOR_TO = hexToRgb('#BC3959');
+var TOP_COLOR_FROM = hexToRgb('#000000');
+var TOP_COLOR_TO = hexToRgb('#333333');
+var GridExample = /*#__PURE__*/function (_React$PureComponent) {
+  function GridExample(props, context) {
+    var _this;
+    _classCallCheck(this, GridExample);
+    _this = _callSuper(this, GridExample, [props, context]);
+    _this.state = {
+      columnWidth: 75,
+      columnCount: 50,
+      height: 300,
+      overscanColumnCount: 0,
+      overscanRowCount: 5,
+      rowHeight: 40,
+      rowCount: 100
+    };
+    _this._renderBodyCell = _this._renderBodyCell.bind(_this);
+    _this._renderHeaderCell = _this._renderHeaderCell.bind(_this);
+    _this._renderLeftSideCell = _this._renderLeftSideCell.bind(_this);
+    return _this;
+  }
+  _inherits(GridExample, _React$PureComponent);
+  return _createClass(GridExample, [{
+    key: "render",
+    value: function render() {
+      var _this2 = this;
+      var _this$state = this.state,
+        columnCount = _this$state.columnCount,
+        columnWidth = _this$state.columnWidth,
+        height = _this$state.height,
+        overscanColumnCount = _this$state.overscanColumnCount,
+        overscanRowCount = _this$state.overscanRowCount,
+        rowHeight = _this$state.rowHeight,
+        rowCount = _this$state.rowCount;
+      return /*#__PURE__*/React.createElement(ContentBox, null, /*#__PURE__*/React.createElement(ContentBoxHeader, {
+        text: "ScrollSync",
+        sourceLink: "https://github.com/bvaughn/react-virtualized/blob/master/source/ScrollSync/ScrollSync.example.js",
+        docsLink: "https://github.com/bvaughn/react-virtualized/blob/master/docs/ScrollSync.md"
+      }), /*#__PURE__*/React.createElement(ContentBoxParagraph, null, "High order component that simplifies the process of synchronizing scrolling between two or more virtualized components."), /*#__PURE__*/React.createElement(ContentBoxParagraph, null, "This example shows two ", /*#__PURE__*/React.createElement("code", null, "Grid"), "s and one ", /*#__PURE__*/React.createElement("code", null, "List"), ' ', "configured to mimic a spreadsheet with a fixed header and first column. It also shows how a scroll callback can be used to control UI properties such as background color."), /*#__PURE__*/React.createElement(ScrollSync, null, function (_ref) {
+        var clientHeight = _ref.clientHeight,
+          clientWidth = _ref.clientWidth,
+          onScroll = _ref.onScroll,
+          scrollHeight = _ref.scrollHeight,
+          scrollLeft = _ref.scrollLeft,
+          scrollTop = _ref.scrollTop,
+          scrollWidth = _ref.scrollWidth;
+        var x = scrollLeft / (scrollWidth - clientWidth);
+        var y = scrollTop / (scrollHeight - clientHeight);
+        var leftBackgroundColor = mixColors(LEFT_COLOR_FROM, LEFT_COLOR_TO, y);
+        var leftColor = '#ffffff';
+        var topBackgroundColor = mixColors(TOP_COLOR_FROM, TOP_COLOR_TO, x);
+        var topColor = '#ffffff';
+        var middleBackgroundColor = mixColors(leftBackgroundColor, topBackgroundColor, 0.5);
+        var middleColor = '#ffffff';
+        return /*#__PURE__*/React.createElement("div", {
+          className: styles.GridRow
+        }, /*#__PURE__*/React.createElement("div", {
+          className: styles.LeftSideGridContainer,
+          style: {
+            position: 'absolute',
+            left: 0,
+            top: 0,
+            color: leftColor,
+            backgroundColor: "rgb(".concat(topBackgroundColor.r, ",").concat(topBackgroundColor.g, ",").concat(topBackgroundColor.b, ")")
+          }
+        }, /*#__PURE__*/React.createElement(Grid, {
+          cellRenderer: _this2._renderLeftHeaderCell,
+          className: styles.HeaderGrid,
+          width: columnWidth,
+          height: rowHeight,
+          rowHeight: rowHeight,
+          columnWidth: columnWidth,
+          rowCount: 1,
+          columnCount: 1
+        })), /*#__PURE__*/React.createElement("div", {
+          className: styles.LeftSideGridContainer,
+          style: {
+            position: 'absolute',
+            left: 0,
+            top: rowHeight,
+            color: leftColor,
+            backgroundColor: "rgb(".concat(leftBackgroundColor.r, ",").concat(leftBackgroundColor.g, ",").concat(leftBackgroundColor.b, ")")
+          }
+        }, /*#__PURE__*/React.createElement(Grid, {
+          overscanColumnCount: overscanColumnCount,
+          overscanRowCount: overscanRowCount,
+          cellRenderer: _this2._renderLeftSideCell,
+          columnWidth: columnWidth,
+          columnCount: 1,
+          className: styles.LeftSideGrid,
+          height: height - scrollbarSize(),
+          rowHeight: rowHeight,
+          rowCount: rowCount,
+          scrollTop: scrollTop,
+          width: columnWidth
+        })), /*#__PURE__*/React.createElement("div", {
+          className: styles.GridColumn
+        }, /*#__PURE__*/React.createElement(AutoSizer, {
+          disableHeight: true
+        }, function (_ref2) {
+          var width = _ref2.width;
+          return /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement("div", {
+            style: {
+              backgroundColor: "rgb(".concat(topBackgroundColor.r, ",").concat(topBackgroundColor.g, ",").concat(topBackgroundColor.b, ")"),
+              color: topColor,
+              height: rowHeight,
+              width: width - scrollbarSize()
+            }
+          }, /*#__PURE__*/React.createElement(Grid, {
+            className: styles.HeaderGrid,
+            columnWidth: columnWidth,
+            columnCount: columnCount,
+            height: rowHeight,
+            overscanColumnCount: overscanColumnCount,
+            cellRenderer: _this2._renderHeaderCell,
+            rowHeight: rowHeight,
+            rowCount: 1,
+            scrollLeft: scrollLeft,
+            width: width - scrollbarSize()
+          })), /*#__PURE__*/React.createElement("div", {
+            style: {
+              backgroundColor: "rgb(".concat(middleBackgroundColor.r, ",").concat(middleBackgroundColor.g, ",").concat(middleBackgroundColor.b, ")"),
+              color: middleColor,
+              height: height,
+              width: width
+            }
+          }, /*#__PURE__*/React.createElement(Grid, {
+            className: styles.BodyGrid,
+            columnWidth: columnWidth,
+            columnCount: columnCount,
+            height: height,
+            onScroll: onScroll,
+            overscanColumnCount: overscanColumnCount,
+            overscanRowCount: overscanRowCount,
+            cellRenderer: _this2._renderBodyCell,
+            rowHeight: rowHeight,
+            rowCount: rowCount,
+            width: width
+          })));
+        })));
+      }));
+    }
+  }, {
+    key: "_renderBodyCell",
+    value: function _renderBodyCell(_ref3) {
+      var columnIndex = _ref3.columnIndex,
+        key = _ref3.key,
+        rowIndex = _ref3.rowIndex,
+        style = _ref3.style;
+      if (columnIndex < 1) {
+        return;
+      }
+      return this._renderLeftSideCell({
+        columnIndex: columnIndex,
+        key: key,
+        rowIndex: rowIndex,
+        style: style
+      });
+    }
+  }, {
+    key: "_renderHeaderCell",
+    value: function _renderHeaderCell(_ref4) {
+      var columnIndex = _ref4.columnIndex,
+        key = _ref4.key,
+        rowIndex = _ref4.rowIndex,
+        style = _ref4.style;
+      if (columnIndex < 1) {
+        return;
+      }
+      return this._renderLeftHeaderCell({
+        columnIndex: columnIndex,
+        key: key,
+        rowIndex: rowIndex,
+        style: style
+      });
+    }
+  }, {
+    key: "_renderLeftHeaderCell",
+    value: function _renderLeftHeaderCell(_ref5) {
+      var columnIndex = _ref5.columnIndex,
+        key = _ref5.key,
+        style = _ref5.style;
+      return /*#__PURE__*/React.createElement("div", {
+        className: styles.headerCell,
+        key: key,
+        style: style
+      }, "C".concat(columnIndex));
+    }
+  }, {
+    key: "_renderLeftSideCell",
+    value: function _renderLeftSideCell(_ref6) {
+      var columnIndex = _ref6.columnIndex,
+        key = _ref6.key,
+        rowIndex = _ref6.rowIndex,
+        style = _ref6.style;
+      var rowClass = rowIndex % 2 === 0 ? columnIndex % 2 === 0 ? styles.evenRow : styles.oddRow : columnIndex % 2 !== 0 ? styles.evenRow : styles.oddRow;
+      var classNames = clsx(rowClass, styles.cell);
+      return /*#__PURE__*/React.createElement("div", {
+        className: classNames,
+        key: key,
+        style: style
+      }, "R".concat(rowIndex, ", C").concat(columnIndex));
+    }
+  }]);
+}(React.PureComponent);
+export { GridExample as default };
+function hexToRgb(hex) {
+  var result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+  return result ? {
+    r: parseInt(result[1], 16),
+    g: parseInt(result[2], 16),
+    b: parseInt(result[3], 16)
+  } : null;
+}
+
+/**
+ * Ported from sass implementation in C
+ * https://github.com/sass/libsass/blob/0e6b4a2850092356aa3ece07c6b249f0221caced/functions.cpp#L209
+ */
+function mixColors(color1, color2, amount) {
+  var weight1 = amount;
+  var weight2 = 1 - amount;
+  var r = Math.round(weight1 * color1.r + weight2 * color2.r);
+  var g = Math.round(weight1 * color1.g + weight2 * color2.g);
+  var b = Math.round(weight1 * color1.b + weight2 * color2.b);
+  return {
+    r: r,
+    g: g,
+    b: b
+  };
+}

package/dist/es/ScrollSync/ScrollSync.jest.js

@@ -0,0 +1,60 @@
+import * as React from 'react';
+import { findDOMNode } from 'react-dom';
+import { render } from '../TestUtils';
+import ScrollSync from './ScrollSync';
+function ChildComponent(_ref) {
+  var clientHeight = _ref.clientHeight,
+    clientWidth = _ref.clientWidth,
+    scrollHeight = _ref.scrollHeight,
+    scrollLeft = _ref.scrollLeft,
+    scrollTop = _ref.scrollTop,
+    scrollWidth = _ref.scrollWidth;
+  return /*#__PURE__*/React.createElement("div", null, "clientHeight:".concat(clientHeight), "clientWidth:".concat(clientWidth), "scrollHeight:".concat(scrollHeight), "scrollLeft:".concat(scrollLeft), "scrollTop:".concat(scrollTop), "scrollWidth:".concat(scrollWidth));
+}
+describe('ScrollSync', function () {
+  it('should pass through an initial value of 0 for :scrollLeft and :scrollTop', function () {
+    var component = render(/*#__PURE__*/React.createElement(ScrollSync, null, function (_ref2) {
+      var clientHeight = _ref2.clientHeight,
+        clientWidth = _ref2.clientWidth,
+        scrollHeight = _ref2.scrollHeight,
+        scrollLeft = _ref2.scrollLeft,
+        scrollTop = _ref2.scrollTop,
+        scrollWidth = _ref2.scrollWidth;
+      return /*#__PURE__*/React.createElement(ChildComponent, {
+        clientHeight: clientHeight,
+        clientWidth: clientWidth,
+        scrollHeight: scrollHeight,
+        scrollLeft: scrollLeft,
+        scrollTop: scrollTop,
+        scrollWidth: scrollWidth
+      });
+    }));
+    expect(findDOMNode(component).textContent).toContain('clientHeight:0');
+    expect(findDOMNode(component).textContent).toContain('clientWidth:0');
+    expect(findDOMNode(component).textContent).toContain('scrollHeight:0');
+    expect(findDOMNode(component).textContent).toContain('scrollLeft:0');
+    expect(findDOMNode(component).textContent).toContain('scrollTop:0');
+    expect(findDOMNode(component).textContent).toContain('scrollWidth:0');
+  });
+  it('should update :scrollLeft and :scrollTop when :onScroll is called', function () {
+    var onScroll;
+    var component = render(/*#__PURE__*/React.createElement(ScrollSync, null, function (params) {
+      onScroll = params.onScroll;
+      return /*#__PURE__*/React.createElement(ChildComponent, params);
+    }));
+    onScroll({
+      clientHeight: 400,
+      clientWidth: 200,
+      scrollHeight: 1000,
+      scrollLeft: 50,
+      scrollTop: 100,
+      scrollWidth: 500
+    });
+    expect(findDOMNode(component).textContent).toContain('clientHeight:400');
+    expect(findDOMNode(component).textContent).toContain('clientWidth:200');
+    expect(findDOMNode(component).textContent).toContain('scrollHeight:1000');
+    expect(findDOMNode(component).textContent).toContain('scrollLeft:50');
+    expect(findDOMNode(component).textContent).toContain('scrollTop:100');
+    expect(findDOMNode(component).textContent).toContain('scrollWidth:500');
+  });
+});

package/dist/es/ScrollSync/ScrollSync.js

@@ -0,0 +1,80 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/inherits";
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+import PropTypes from 'prop-types';
+import * as React from 'react';
+
+/**
+ * HOC that simplifies the process of synchronizing scrolling between two or more virtualized components.
+ */
+var ScrollSync = /*#__PURE__*/function (_React$PureComponent) {
+  function ScrollSync(props, context) {
+    var _this;
+    _classCallCheck(this, ScrollSync);
+    _this = _callSuper(this, ScrollSync, [props, context]);
+    _this.state = {
+      clientHeight: 0,
+      clientWidth: 0,
+      scrollHeight: 0,
+      scrollLeft: 0,
+      scrollTop: 0,
+      scrollWidth: 0
+    };
+    _this._onScroll = _this._onScroll.bind(_this);
+    return _this;
+  }
+  _inherits(ScrollSync, _React$PureComponent);
+  return _createClass(ScrollSync, [{
+    key: "render",
+    value: function render() {
+      var children = this.props.children;
+      var _this$state = this.state,
+        clientHeight = _this$state.clientHeight,
+        clientWidth = _this$state.clientWidth,
+        scrollHeight = _this$state.scrollHeight,
+        scrollLeft = _this$state.scrollLeft,
+        scrollTop = _this$state.scrollTop,
+        scrollWidth = _this$state.scrollWidth;
+      return children({
+        clientHeight: clientHeight,
+        clientWidth: clientWidth,
+        onScroll: this._onScroll,
+        scrollHeight: scrollHeight,
+        scrollLeft: scrollLeft,
+        scrollTop: scrollTop,
+        scrollWidth: scrollWidth
+      });
+    }
+  }, {
+    key: "_onScroll",
+    value: function _onScroll(_ref) {
+      var clientHeight = _ref.clientHeight,
+        clientWidth = _ref.clientWidth,
+        scrollHeight = _ref.scrollHeight,
+        scrollLeft = _ref.scrollLeft,
+        scrollTop = _ref.scrollTop,
+        scrollWidth = _ref.scrollWidth;
+      this.setState({
+        clientHeight: clientHeight,
+        clientWidth: clientWidth,
+        scrollHeight: scrollHeight,
+        scrollLeft: scrollLeft,
+        scrollTop: scrollTop,
+        scrollWidth: scrollWidth
+      });
+    }
+  }]);
+}(React.PureComponent);
+export { ScrollSync as default };
+ScrollSync.propTypes = process.env.NODE_ENV !== "production" ? {
+  /**
+   * Function responsible for rendering 2 or more virtualized components.
+   * This function should implement the following signature:
+   * ({ onScroll, scrollLeft, scrollTop }) => PropTypes.element
+   */
+  children: PropTypes.func.isRequired
+} : {};

package/dist/es/ScrollSync/index.js

@@ -0,0 +1,3 @@
+import ScrollSync from './ScrollSync';
+export default ScrollSync;
+export { ScrollSync };

package/dist/es/Table/Column.jest.js

@@ -0,0 +1,84 @@
+import * as React from 'react';
+import Immutable from 'immutable';
+import defaultCellDataGetter from './defaultCellDataGetter';
+import defaultCellRenderer from './defaultCellRenderer';
+import defaultHeaderRenderer from './defaultHeaderRenderer';
+describe('Column', function () {
+  var rowData = Immutable.Map({
+    foo: 'Foo',
+    bar: 1
+  });
+  describe('defaultCellDataGetter', function () {
+    it('should return a value for specified attributes', function () {
+      expect(defaultCellDataGetter({
+        dataKey: 'foo',
+        rowData: rowData
+      })).toEqual('Foo');
+      expect(defaultCellDataGetter({
+        dataKey: 'bar',
+        rowData: rowData
+      })).toEqual(1);
+    });
+    it('should return undefined for missing attributes', function () {
+      expect(defaultCellDataGetter({
+        dataKey: 'baz',
+        rowData: rowData
+      })).toEqual(undefined);
+    });
+  });
+  describe('defaultCellRenderer', function () {
+    it('should render a value for specified attributes', function () {
+      expect(defaultCellRenderer({
+        cellData: 'Foo',
+        dataKey: 'foo',
+        rowData: rowData,
+        rowIndex: 0
+      })).toEqual('Foo');
+      expect(defaultCellRenderer({
+        cellData: 1,
+        dataKey: 'bar',
+        rowData: rowData,
+        rowIndex: 0
+      })).toEqual('1');
+    });
+    it('should render empty string for null or missing attributes', function () {
+      expect(defaultCellRenderer({
+        cellData: null,
+        dataKey: 'baz',
+        rowData: rowData,
+        rowIndex: 0
+      })).toEqual('');
+      expect(defaultCellRenderer({
+        cellData: undefined,
+        dataKey: 'baz',
+        rowData: rowData,
+        rowIndex: 0
+      })).toEqual('');
+    });
+  });
+  describe('defaultHeaderRenderer', function () {
+    it('should render a value for specified attributes', function () {
+      expect(defaultHeaderRenderer({
+        dataKey: 'foo',
+        label: 'squirrel'
+      })[0].props.children).toEqual('squirrel');
+      var label = /*#__PURE__*/React.createElement("div", {
+        className: "rabbit"
+      }, "Rabbit");
+      expect(defaultHeaderRenderer({
+        dataKey: 'bar',
+        label: label
+      })[0].props.children).toEqual(label);
+    });
+    it('should render empty string for null or missing attributes', function () {
+      expect(defaultHeaderRenderer({
+        dataKey: 'foo',
+        label: null
+      })[0].props.children).toBeNull();
+      expect(defaultHeaderRenderer({
+        dataKey: 'bar',
+        label: undefined
+      })[0].props.children).toBeUndefined();
+    });
+  });
+});

package/dist/es/Table/Column.js

@@ -0,0 +1,85 @@
+import _createClass from "@babel/runtime/helpers/createClass";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+import PropTypes from 'prop-types';
+import * as React from 'react';
+import defaultHeaderRenderer from './defaultHeaderRenderer';
+import defaultCellRenderer from './defaultCellRenderer';
+import defaultCellDataGetter from './defaultCellDataGetter';
+import SortDirection from './SortDirection';
+
+/**
+ * Describes the header and cell contents of a table column.
+ */
+var Column = /*#__PURE__*/function (_React$Component) {
+  function Column() {
+    _classCallCheck(this, Column);
+    return _callSuper(this, Column, arguments);
+  }
+  _inherits(Column, _React$Component);
+  return _createClass(Column);
+}(React.Component);
+_defineProperty(Column, "defaultProps", {
+  cellDataGetter: defaultCellDataGetter,
+  cellRenderer: defaultCellRenderer,
+  defaultSortDirection: SortDirection.ASC,
+  flexGrow: 0,
+  flexShrink: 1,
+  headerRenderer: defaultHeaderRenderer,
+  style: {}
+});
+export { Column as default };
+Column.propTypes = process.env.NODE_ENV !== "production" ? {
+  /** Optional aria-label value to set on the column header */
+  'aria-label': PropTypes.string,
+  /**
+   * Callback responsible for returning a cell's data, given its :dataKey
+   * ({ columnData: any, dataKey: string, rowData: any }): any
+   */
+  cellDataGetter: PropTypes.func,
+  /**
+   * Callback responsible for rendering a cell's contents.
+   * ({ cellData: any, columnData: any, dataKey: string, rowData: any, rowIndex: number }): node
+   */
+  cellRenderer: PropTypes.func,
+  /** Optional CSS class to apply to cell */
+  className: PropTypes.string,
+  /** Optional additional data passed to this column's :cellDataGetter */
+  columnData: PropTypes.object,
+  /** Uniquely identifies the row-data attribute corresponding to this cell */
+  dataKey: PropTypes.any.isRequired,
+  /** Optional direction to be used when clicked the first time */
+  defaultSortDirection: PropTypes.oneOf([SortDirection.ASC, SortDirection.DESC]),
+  /** If sort is enabled for the table at large, disable it for this column */
+  disableSort: PropTypes.bool,
+  /** Flex grow style; defaults to 0 */
+  flexGrow: PropTypes.number,
+  /** Flex shrink style; defaults to 1 */
+  flexShrink: PropTypes.number,
+  /** Optional CSS class to apply to this column's header */
+  headerClassName: PropTypes.string,
+  /**
+   * Optional callback responsible for rendering a column header contents.
+   * ({ columnData: object, dataKey: string, disableSort: boolean, label: node, sortBy: string, sortDirection: string }): PropTypes.node
+   */
+  headerRenderer: PropTypes.func.isRequired,
+  /** Optional inline style to apply to this column's header */
+  headerStyle: PropTypes.object,
+  /** Optional id to set on the column header */
+  id: PropTypes.string,
+  /** Header label for this column */
+  label: PropTypes.node,
+  /** Maximum width of column; this property will only be used if :flexGrow is > 0. */
+  maxWidth: PropTypes.number,
+  /** Minimum width of column. */
+  minWidth: PropTypes.number,
+  /** Optional inline style to apply to cell */
+  style: PropTypes.object,
+  /** Flex basis (width) for this column; This value can grow or shrink based on :flexGrow and :flexShrink properties. */
+  width: PropTypes.number.isRequired
+} : {};

package/dist/es/Table/SortDirection.js

@@ -0,0 +1,13 @@
+var SortDirection = {
+  /**
+   * Sort items in ascending order.
+   * This means arranging from the lowest value to the highest (e.g. a-z, 0-9).
+   */
+  ASC: 'ASC',
+  /**
+   * Sort items in descending order.
+   * This means arranging from the highest value to the lowest (e.g. z-a, 9-0).
+   */
+  DESC: 'DESC'
+};
+export default SortDirection;

package/dist/es/Table/SortIndicator.js

@@ -0,0 +1,31 @@
+import clsx from 'clsx';
+import PropTypes from 'prop-types';
+import * as React from 'react';
+import SortDirection from './SortDirection';
+
+/**
+ * Displayed beside a header to indicate that a Table is currently sorted by this column.
+ */
+export default function SortIndicator(_ref) {
+  var sortDirection = _ref.sortDirection;
+  var classNames = clsx('ReactVirtualized__Table__sortableHeaderIcon', {
+    'ReactVirtualized__Table__sortableHeaderIcon--ASC': sortDirection === SortDirection.ASC,
+    'ReactVirtualized__Table__sortableHeaderIcon--DESC': sortDirection === SortDirection.DESC
+  });
+  return /*#__PURE__*/React.createElement("svg", {
+    className: classNames,
+    width: 18,
+    height: 18,
+    viewBox: "0 0 24 24"
+  }, sortDirection === SortDirection.ASC ? /*#__PURE__*/React.createElement("path", {
+    d: "M7 14l5-5 5 5z"
+  }) : /*#__PURE__*/React.createElement("path", {
+    d: "M7 10l5 5 5-5z"
+  }), /*#__PURE__*/React.createElement("path", {
+    d: "M0 0h24v24H0z",
+    fill: "none"
+  }));
+}
+SortIndicator.propTypes = process.env.NODE_ENV !== "production" ? {
+  sortDirection: PropTypes.oneOf([SortDirection.ASC, SortDirection.DESC])
+} : {};