@depup/react-virtualized 9.22.6-depup.0

package/dist/commonjs/Table/createMultiSort.jest.js

@@ -0,0 +1,165 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _createMultiSort = _interopRequireDefault(require("./createMultiSort"));
+describe('createMultiSort', function () {
+  function simulate(sort, dataKey) {
+    var eventModifier = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+    var defaultSortDirection = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'ASC';
+    sort({
+      defaultSortDirection: defaultSortDirection,
+      event: {
+        ctrlKey: eventModifier === 'control',
+        metaKey: eventModifier === 'meta',
+        shiftKey: eventModifier === 'shift'
+      },
+      sortBy: dataKey
+    });
+  }
+  it('errors if the user did not specify a sort callback', function () {
+    expect(_createMultiSort["default"]).toThrow();
+  });
+  it('sets the correct default values', function () {
+    var multiSort = (0, _createMultiSort["default"])(jest.fn(), {
+      defaultSortBy: ['a', 'b'],
+      defaultSortDirection: {
+        a: 'ASC',
+        b: 'DESC'
+      }
+    });
+    expect(multiSort.sortBy).toEqual(['a', 'b']);
+    expect(multiSort.sortDirection.a).toBe('ASC');
+    expect(multiSort.sortDirection.b).toBe('DESC');
+  });
+  it('sets the correct default sparse values', function () {
+    var multiSort = (0, _createMultiSort["default"])(jest.fn(), {
+      defaultSortBy: ['a', 'b']
+    });
+    expect(multiSort.sortBy).toEqual(['a', 'b']);
+    expect(multiSort.sortDirection.a).toBe('ASC');
+    expect(multiSort.sortDirection.b).toBe('ASC');
+  });
+  describe('on click', function () {
+    it('sets the correct default value for a field', function () {
+      var multiSort = (0, _createMultiSort["default"])(jest.fn());
+      simulate(multiSort.sort, 'a');
+      expect(multiSort.sortBy).toEqual(['a']);
+      expect(multiSort.sortDirection.a).toBe('ASC');
+      simulate(multiSort.sort, 'b', '', 'DESC');
+      expect(multiSort.sortBy).toEqual(['b']);
+      expect(multiSort.sortDirection.b).toBe('DESC');
+    });
+    it('toggles a field value', function () {
+      var multiSort = (0, _createMultiSort["default"])(jest.fn());
+      simulate(multiSort.sort, 'a');
+      expect(multiSort.sortBy).toEqual(['a']);
+      expect(multiSort.sortDirection.a).toBe('ASC');
+      simulate(multiSort.sort, 'a');
+      expect(multiSort.sortBy).toEqual(['a']);
+      expect(multiSort.sortDirection.a).toBe('DESC');
+      simulate(multiSort.sort, 'b', '', 'DESC');
+      expect(multiSort.sortBy).toEqual(['b']);
+      expect(multiSort.sortDirection.b).toBe('DESC');
+      simulate(multiSort.sort, 'b', '', 'DESC');
+      expect(multiSort.sortBy).toEqual(['b']);
+      expect(multiSort.sortDirection.b).toBe('ASC');
+    });
+    it('resets sort-by fields', function () {
+      var multiSort = (0, _createMultiSort["default"])(jest.fn(), {
+        defaultSortBy: ['a', 'b']
+      });
+      expect(multiSort.sortBy).toEqual(['a', 'b']);
+      simulate(multiSort.sort, 'a');
+      expect(multiSort.sortBy).toEqual(['a']);
+    });
+    it('resets sort-direction fields', function () {
+      var multiSort = (0, _createMultiSort["default"])(jest.fn(), {
+        defaultSortBy: ['a', 'b'],
+        defaultSortDirection: {
+          a: 'DESC',
+          b: 'ASC'
+        }
+      });
+      expect(multiSort.sortBy).toEqual(['a', 'b']);
+      expect(multiSort.sortDirection.a).toEqual('DESC');
+      expect(multiSort.sortDirection.b).toEqual('ASC');
+      simulate(multiSort.sort, 'a');
+      expect(multiSort.sortBy).toEqual(['a']);
+      expect(multiSort.sortDirection.a).toEqual('ASC');
+      expect(multiSort.sortDirection.b).toEqual(undefined);
+      simulate(multiSort.sort, 'b');
+      expect(multiSort.sortBy).toEqual(['b']);
+      expect(multiSort.sortDirection.a).toEqual(undefined);
+      expect(multiSort.sortDirection.b).toEqual('ASC');
+    });
+  });
+  describe('on shift click', function () {
+    it('appends a field to the sort by list', function () {
+      var multiSort = (0, _createMultiSort["default"])(jest.fn());
+      simulate(multiSort.sort, 'a');
+      expect(multiSort.sortBy).toEqual(['a']);
+      expect(multiSort.sortDirection.a).toBe('ASC');
+      simulate(multiSort.sort, 'b', 'shift');
+      expect(multiSort.sortBy).toEqual(['a', 'b']);
+      expect(multiSort.sortDirection.a).toBe('ASC');
+      expect(multiSort.sortDirection.b).toBe('ASC');
+    });
+    it('toggles an appended field value', function () {
+      var multiSort = (0, _createMultiSort["default"])(jest.fn());
+      simulate(multiSort.sort, 'a');
+      expect(multiSort.sortBy).toEqual(['a']);
+      expect(multiSort.sortDirection.a).toBe('ASC');
+      simulate(multiSort.sort, 'b', 'shift');
+      expect(multiSort.sortBy).toEqual(['a', 'b']);
+      expect(multiSort.sortDirection.a).toBe('ASC');
+      expect(multiSort.sortDirection.b).toBe('ASC');
+      simulate(multiSort.sort, 'a', 'shift');
+      expect(multiSort.sortBy).toEqual(['a', 'b']);
+      expect(multiSort.sortDirection.a).toBe('DESC');
+      expect(multiSort.sortDirection.b).toBe('ASC');
+      simulate(multiSort.sort, 'a', 'shift');
+      expect(multiSort.sortBy).toEqual(['a', 'b']);
+      expect(multiSort.sortDirection.a).toBe('ASC');
+      expect(multiSort.sortDirection.b).toBe('ASC');
+    });
+    it('able to shift+click more than once', function () {
+      var multiSort = (0, _createMultiSort["default"])(jest.fn());
+      simulate(multiSort.sort, 'a');
+      expect(multiSort.sortBy).toEqual(['a']);
+      expect(multiSort.sortDirection.a).toBe('ASC');
+      simulate(multiSort.sort, 'b', 'shift');
+      expect(multiSort.sortBy).toEqual(['a', 'b']);
+      expect(multiSort.sortDirection.a).toBe('ASC');
+      expect(multiSort.sortDirection.b).toBe('ASC');
+      simulate(multiSort.sort, 'b');
+      expect(multiSort.sortBy).toEqual(['b']);
+      expect(multiSort.sortDirection.b).toBe('DESC');
+      simulate(multiSort.sort, 'a', 'shift');
+      expect(multiSort.sortBy).toEqual(['b', 'a']);
+      expect(multiSort.sortDirection.a).toBe('ASC');
+      expect(multiSort.sortDirection.b).toBe('DESC');
+    });
+  });
+  ['control', 'meta'].forEach(function (modifier) {
+    describe("".concat(modifier, " click"), function () {
+      it('removes a field from the sort by list', function () {
+        var multiSort = (0, _createMultiSort["default"])(jest.fn(), {
+          defaultSortBy: ['a', 'b']
+        });
+        expect(multiSort.sortBy).toEqual(['a', 'b']);
+        simulate(multiSort.sort, 'a', modifier);
+        expect(multiSort.sortBy).toEqual(['b']);
+        simulate(multiSort.sort, 'b', modifier);
+        expect(multiSort.sortBy).toEqual([]);
+      });
+      it('ignores fields not in the list on control click', function () {
+        var multiSort = (0, _createMultiSort["default"])(jest.fn(), {
+          defaultSortBy: ['a', 'b']
+        });
+        expect(multiSort.sortBy).toEqual(['a', 'b']);
+        simulate(multiSort.sort, 'c', modifier);
+        expect(multiSort.sortBy).toEqual(['a', 'b']);
+      });
+    });
+  });
+});

package/dist/commonjs/Table/createMultiSort.js

@@ -0,0 +1,99 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = createMultiSort;
+/*:: type SortDirection = 'ASC' | 'DESC';*/
+/*:: type SortParams = {
+  defaultSortDirection: SortDirection,
+  event: MouseEvent,
+  sortBy: string,
+};*/
+/*:: type SortDirectionMap = {[string]: SortDirection};*/
+/*:: type MultiSortOptions = {
+  defaultSortBy: ?Array<string>,
+  defaultSortDirection: ?SortDirectionMap,
+};*/
+/*:: type MultiSortReturn = {
+  /**
+   * Sort property to be passed to the `Table` component.
+   * This function updates `sortBy` and `sortDirection` values.
+   *-/
+  sort: (params: SortParams) => void,
+
+  /**
+   * Specifies the fields currently responsible for sorting data,
+   * In order of importance.
+   *-/
+  sortBy: Array<string>,
+
+  /**
+   * Specifies the direction a specific field is being sorted in.
+   *-/
+  sortDirection: SortDirectionMap,
+};*/
+function createMultiSort(sortCallback /*: Function*/) /*: MultiSortReturn*/{
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    defaultSortBy = _ref.defaultSortBy,
+    _ref$defaultSortDirec = _ref.defaultSortDirection,
+    defaultSortDirection = _ref$defaultSortDirec === void 0 ? {} : _ref$defaultSortDirec;
+  if (!sortCallback) {
+    throw Error("Required parameter \"sortCallback\" not specified");
+  }
+  var sortBy = defaultSortBy || [];
+  var sortDirection = {};
+  sortBy.forEach(function (dataKey) {
+    sortDirection[dataKey] = defaultSortDirection[dataKey] !== undefined ? defaultSortDirection[dataKey] : 'ASC';
+  });
+  function sort(_ref2 /*:: */) /*: void*/{
+    var defaultSortDirection = _ref2 /*:: */.defaultSortDirection,
+      event = _ref2 /*:: */.event,
+      dataKey = _ref2 /*:: */.sortBy;
+    if (event.shiftKey) {
+      // Shift + click appends a column to existing criteria
+      if (sortDirection[dataKey] !== undefined) {
+        sortDirection[dataKey] = sortDirection[dataKey] === 'ASC' ? 'DESC' : 'ASC';
+      } else {
+        sortDirection[dataKey] = defaultSortDirection;
+        sortBy.push(dataKey);
+      }
+    } else if (event.ctrlKey || event.metaKey) {
+      // Control + click removes column from sort (if pressent)
+      var index = sortBy.indexOf(dataKey);
+      if (index >= 0) {
+        sortBy.splice(index, 1);
+        delete sortDirection[dataKey];
+      }
+    } else {
+      // Clear sortBy array of all non-selected keys
+      sortBy.length = 0;
+      sortBy.push(dataKey);
+
+      // Clear sortDirection object of all non-selected keys
+      var sortDirectionKeys = Object.keys(sortDirection);
+      sortDirectionKeys.forEach(function (key) {
+        if (key !== dataKey) delete sortDirection[key];
+      });
+
+      // If key is already selected, reverse sort direction.
+      // Else, set sort direction to default direction.
+      if (sortDirection[dataKey] !== undefined) {
+        sortDirection[dataKey] = sortDirection[dataKey] === 'ASC' ? 'DESC' : 'ASC';
+      } else {
+        sortDirection[dataKey] = defaultSortDirection;
+      }
+    }
+
+    // Notify application code
+    sortCallback({
+      sortBy: sortBy,
+      sortDirection: sortDirection
+    });
+  }
+  return {
+    sort: sort,
+    sortBy: sortBy,
+    sortDirection: sortDirection
+  };
+}

package/dist/commonjs/Table/defaultCellDataGetter.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = defaultCellDataGetter;
+/*:: import type {CellDataGetterParams} from './types';*/
+/**
+ * Default accessor for returning a cell value for a given attribute.
+ * This function expects to operate on either a vanilla Object or an Immutable Map.
+ * You should override the column's cellDataGetter if your data is some other type of object.
+ */
+function defaultCellDataGetter(_ref /*:: */) {
+  var dataKey = _ref /*:: */.dataKey,
+    rowData = _ref /*:: */.rowData;
+  if (typeof rowData.get === 'function') {
+    return rowData.get(dataKey);
+  } else {
+    return rowData[dataKey];
+  }
+}

package/dist/commonjs/Table/defaultCellRenderer.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = defaultCellRenderer;
+/*:: import type {CellRendererParams} from './types';*/
+/**
+ * Default cell renderer that displays an attribute as a simple string
+ * You should override the column's cellRenderer if your data is some other type of object.
+ */
+function defaultCellRenderer(_ref /*:: */) /*: string*/{
+  var cellData = _ref /*:: */.cellData;
+  if (cellData == null) {
+    return '';
+  } else {
+    return String(cellData);
+  }
+}

package/dist/commonjs/Table/defaultHeaderRenderer.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = defaultHeaderRenderer;
+var React = _interopRequireWildcard(require("react"));
+var _SortIndicator = _interopRequireDefault(require("./SortIndicator"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+/*:: import type {HeaderRendererParams} from './types';*/
+/**
+ * Default table header renderer.
+ */
+function defaultHeaderRenderer(_ref /*:: */) {
+  var dataKey = _ref /*:: */.dataKey,
+    label = _ref /*:: */.label,
+    sortBy = _ref /*:: */.sortBy,
+    sortDirection = _ref /*:: */.sortDirection;
+  var showSortIndicator = sortBy === dataKey;
+  var children = [/*#__PURE__*/React.createElement("span", {
+    className: "ReactVirtualized__Table__headerTruncatedText",
+    key: "label",
+    title: typeof label === 'string' ? label : null
+  }, label)];
+  if (showSortIndicator) {
+    children.push(/*#__PURE__*/React.createElement(_SortIndicator["default"], {
+      key: "SortIndicator",
+      sortDirection: sortDirection
+    }));
+  }
+  return children;
+}

package/dist/commonjs/Table/defaultHeaderRowRenderer.js

@@ -0,0 +1,21 @@
+"use strict";
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = defaultHeaderRowRenderer;
+var React = _interopRequireWildcard(require("react"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+/*:: import type {HeaderRowRendererParams} from './types';*/
+function defaultHeaderRowRenderer(_ref /*:: */) {
+  var className = _ref /*:: */.className,
+    columns = _ref /*:: */.columns,
+    style = _ref /*:: */.style;
+  return /*#__PURE__*/React.createElement("div", {
+    className: className,
+    role: "row",
+    style: style
+  }, columns);
+}

package/dist/commonjs/Table/defaultRowRenderer.js

@@ -0,0 +1,87 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = defaultRowRenderer;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var React = _interopRequireWildcard(require("react"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+/*:: import type {RowRendererParams} from './types';*/
+/**
+ * Default row renderer for Table.
+ */
+function defaultRowRenderer(_ref /*:: */) {
+  var className = _ref /*:: */.className,
+    columns = _ref /*:: */.columns,
+    index = _ref /*:: */.index,
+    key = _ref /*:: */.key,
+    onRowClick = _ref /*:: */.onRowClick,
+    onRowDoubleClick = _ref /*:: */.onRowDoubleClick,
+    onRowMouseOut = _ref /*:: */.onRowMouseOut,
+    onRowMouseOver = _ref /*:: */.onRowMouseOver,
+    onRowRightClick = _ref /*:: */.onRowRightClick,
+    rowData = _ref /*:: */.rowData,
+    style = _ref /*:: */.style;
+  var a11yProps = {
+    'aria-rowindex': index + 1
+  };
+  if (onRowClick || onRowDoubleClick || onRowMouseOut || onRowMouseOver || onRowRightClick) {
+    a11yProps['aria-label'] = 'row';
+    a11yProps.tabIndex = 0;
+    if (onRowClick) {
+      a11yProps.onClick = function (event) {
+        return onRowClick({
+          event: event,
+          index: index,
+          rowData: rowData
+        });
+      };
+    }
+    if (onRowDoubleClick) {
+      a11yProps.onDoubleClick = function (event) {
+        return onRowDoubleClick({
+          event: event,
+          index: index,
+          rowData: rowData
+        });
+      };
+    }
+    if (onRowMouseOut) {
+      a11yProps.onMouseOut = function (event) {
+        return onRowMouseOut({
+          event: event,
+          index: index,
+          rowData: rowData
+        });
+      };
+    }
+    if (onRowMouseOver) {
+      a11yProps.onMouseOver = function (event) {
+        return onRowMouseOver({
+          event: event,
+          index: index,
+          rowData: rowData
+        });
+      };
+    }
+    if (onRowRightClick) {
+      a11yProps.onContextMenu = function (event) {
+        return onRowRightClick({
+          event: event,
+          index: index,
+          rowData: rowData
+        });
+      };
+    }
+  }
+  return /*#__PURE__*/React.createElement("div", (0, _extends2["default"])({}, a11yProps, {
+    className: className,
+    key: key,
+    role: "row",
+    style: style
+  }), columns);
+}

package/dist/commonjs/Table/index.js

@@ -0,0 +1,78 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Column", {
+  enumerable: true,
+  get: function get() {
+    return _Column["default"];
+  }
+});
+Object.defineProperty(exports, "SortDirection", {
+  enumerable: true,
+  get: function get() {
+    return _SortDirection["default"];
+  }
+});
+Object.defineProperty(exports, "SortIndicator", {
+  enumerable: true,
+  get: function get() {
+    return _SortIndicator["default"];
+  }
+});
+Object.defineProperty(exports, "Table", {
+  enumerable: true,
+  get: function get() {
+    return _Table["default"];
+  }
+});
+Object.defineProperty(exports, "createMultiSort", {
+  enumerable: true,
+  get: function get() {
+    return _createMultiSort["default"];
+  }
+});
+exports["default"] = void 0;
+Object.defineProperty(exports, "defaultCellDataGetter", {
+  enumerable: true,
+  get: function get() {
+    return _defaultCellDataGetter["default"];
+  }
+});
+Object.defineProperty(exports, "defaultCellRenderer", {
+  enumerable: true,
+  get: function get() {
+    return _defaultCellRenderer["default"];
+  }
+});
+Object.defineProperty(exports, "defaultHeaderRenderer", {
+  enumerable: true,
+  get: function get() {
+    return _defaultHeaderRenderer["default"];
+  }
+});
+Object.defineProperty(exports, "defaultHeaderRowRenderer", {
+  enumerable: true,
+  get: function get() {
+    return _defaultHeaderRowRenderer["default"];
+  }
+});
+Object.defineProperty(exports, "defaultRowRenderer", {
+  enumerable: true,
+  get: function get() {
+    return _defaultRowRenderer["default"];
+  }
+});
+var _createMultiSort = _interopRequireDefault(require("./createMultiSort"));
+var _defaultCellDataGetter = _interopRequireDefault(require("./defaultCellDataGetter"));
+var _defaultCellRenderer = _interopRequireDefault(require("./defaultCellRenderer"));
+var _defaultHeaderRowRenderer = _interopRequireDefault(require("./defaultHeaderRowRenderer.js"));
+var _defaultHeaderRenderer = _interopRequireDefault(require("./defaultHeaderRenderer"));
+var _defaultRowRenderer = _interopRequireDefault(require("./defaultRowRenderer"));
+var _Column = _interopRequireDefault(require("./Column"));
+var _SortDirection = _interopRequireDefault(require("./SortDirection"));
+var _SortIndicator = _interopRequireDefault(require("./SortIndicator"));
+var _Table = _interopRequireDefault(require("./Table"));
+var _default = exports["default"] = _Table["default"];

package/dist/commonjs/Table/types.js

@@ -0,0 +1,39 @@
+/*:: export type CellDataGetterParams = {
+  columnData: ?any,
+  dataKey: string,
+  rowData: any,
+};*/
+/*:: export type CellRendererParams = {
+  cellData: ?any,
+  columnData: ?any,
+  dataKey: string,
+  rowData: any,
+  rowIndex: number,
+};*/
+/*:: export type HeaderRowRendererParams = {
+  className: string,
+  columns: Array<any>,
+  style: any,
+};*/
+/*:: export type HeaderRendererParams = {
+  columnData: ?any,
+  dataKey: string,
+  disableSort: ?boolean,
+  label: ?any,
+  sortBy: ?string,
+  sortDirection: ?string,
+};*/
+/*:: export type RowRendererParams = {
+  className: string,
+  columns: Array<any>,
+  index: number,
+  isScrolling: boolean,
+  onRowClick: ?Function,
+  onRowDoubleClick: ?Function,
+  onRowMouseOver: ?Function,
+  onRowMouseOut: ?Function,
+  rowData: any,
+  style: any,
+  key: string,
+};*/
+"use strict";