@depup/react-virtualized 9.22.6-depup.0

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

@@ -0,0 +1,162 @@
+import createMultiSort from './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).toThrow();
+  });
+  it('sets the correct default values', function () {
+    var multiSort = createMultiSort(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 = createMultiSort(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 = createMultiSort(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 = createMultiSort(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 = createMultiSort(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 = createMultiSort(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 = createMultiSort(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 = createMultiSort(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 = createMultiSort(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 = createMultiSort(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 = createMultiSort(jest.fn(), {
+          defaultSortBy: ['a', 'b']
+        });
+        expect(multiSort.sortBy).toEqual(['a', 'b']);
+        simulate(multiSort.sort, 'c', modifier);
+        expect(multiSort.sortBy).toEqual(['a', 'b']);
+      });
+    });
+  });
+});

package/dist/es/Table/createMultiSort.js

@@ -0,0 +1,93 @@
+/*:: 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,
+};*/
+export default 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/es/Table/defaultCellDataGetter.js

@@ -0,0 +1,15 @@
+/*:: 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.
+ */
+export default 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/es/Table/defaultCellRenderer.js

@@ -0,0 +1,13 @@
+/*:: 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.
+ */
+export default function defaultCellRenderer(_ref /*:: */) /*: string*/{
+  var cellData = _ref /*:: */.cellData;
+  if (cellData == null) {
+    return '';
+  } else {
+    return String(cellData);
+  }
+}

package/dist/es/Table/defaultHeaderRenderer.js

@@ -0,0 +1,25 @@
+import * as React from 'react';
+import SortIndicator from './SortIndicator';
+/*:: import type {HeaderRendererParams} from './types';*/
+/**
+ * Default table header renderer.
+ */
+export default 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, {
+      key: "SortIndicator",
+      sortDirection: sortDirection
+    }));
+  }
+  return children;
+}

package/dist/es/Table/defaultHeaderRowRenderer.js

@@ -0,0 +1,12 @@
+import * as React from 'react';
+/*:: import type {HeaderRowRendererParams} from './types';*/
+export default 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/es/Table/defaultRowRenderer.js

@@ -0,0 +1,77 @@
+import _extends from "@babel/runtime/helpers/extends";
+import * as React from 'react';
+/*:: import type {RowRendererParams} from './types';*/
+/**
+ * Default row renderer for Table.
+ */
+export default 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", _extends({}, a11yProps, {
+    className: className,
+    key: key,
+    role: "row",
+    style: style
+  }), columns);
+}

package/dist/es/Table/index.js

@@ -0,0 +1,12 @@
+import createMultiSort from './createMultiSort';
+import defaultCellDataGetter from './defaultCellDataGetter';
+import defaultCellRenderer from './defaultCellRenderer';
+import defaultHeaderRowRenderer from './defaultHeaderRowRenderer.js';
+import defaultHeaderRenderer from './defaultHeaderRenderer';
+import defaultRowRenderer from './defaultRowRenderer';
+import Column from './Column';
+import SortDirection from './SortDirection';
+import SortIndicator from './SortIndicator';
+import Table from './Table';
+export default Table;
+export { createMultiSort, defaultCellDataGetter, defaultCellRenderer, defaultHeaderRowRenderer, defaultHeaderRenderer, defaultRowRenderer, Column, SortDirection, SortIndicator, Table };

package/dist/es/Table/types.js

@@ -0,0 +1,38 @@
+/*:: 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,
+};*/