@integec/grid-tools/lib/Grid.js

Integ Grid Tools

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _range2 = _interopRequireDefault(require("ramda/src/range"));

var _drop2 = _interopRequireDefault(require("ramda/src/drop"));

var _take2 = _interopRequireDefault(require("ramda/src/take"));

var _compose2 = _interopRequireDefault(require("ramda/src/compose"));

var _sort2 = _interopRequireDefault(require("ramda/src/sort"));

var _isEmpty2 = _interopRequireDefault(require("ramda/src/isEmpty"));

var _any2 = _interopRequireDefault(require("ramda/src/any"));

var _filter2 = _interopRequireDefault(require("ramda/src/filter"));

var _find2 = _interopRequireDefault(require("ramda/src/find"));

var _isNil2 = _interopRequireDefault(require("ramda/src/isNil"));

var _react = _interopRequireDefault(require("react"));

var _utils = require("./utils");

var _clipboardUtils = require("./clipboard-utils");

var _data = require("data.maybe");

var _propTypes = _interopRequireDefault(require("prop-types"));

var _ScrollSyncHelper = _interopRequireDefault(require("./ScrollSyncHelper"));

var _ScrollPane = _interopRequireDefault(require("./ScrollPane"));

var _moment = _interopRequireDefault(require("moment"));

var _RowEditor = _interopRequireDefault(require("./RowEditor"));

var _editEngine = require("./editEngine");

var _newSelectionUtils = require("./new-selection-utils");

var _constants = require("./constants.js");

var _context = _interopRequireDefault(require("./context"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }

function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { if (i % 2) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } else { Object.defineProperties(target, Object.getOwnPropertyDescriptors(arguments[i])); } } return target; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }

function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }

function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }

function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }

function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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; }

function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }

function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }

function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }

function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

var noopEditRowProcess = function noopEditRowProcess(_ref) {
  var editedRow = _ref.editedRow;
  return editedRow;
};

var rowHeightOf = function rowHeightOf(index, rowHeight) {
  return typeof rowHeight === 'function' ? rowHeight(index) : rowHeight;
};

var toggleSortOrder = function toggleSortOrder(order) {
  return order === 'asc' ? 'desc' : order === 'desc' ? undefined : 'asc';
};

var normalizeValue = function normalizeValue(val, type) {
  return type === 'num' && typeof val === 'string' ? parseFloat(val) : type === 'date' && (_moment["default"].isDate(val) || _moment["default"].isMoment(val)) ? val.valueOf() : type === 'date' && typeof val === 'string' ? (0, _moment["default"])(val).valueOf() : val;
};

var compare = function compare(_ref2) {
  var aVal = _ref2.aVal,
      bVal = _ref2.bVal,
      sortOrder = _ref2.sortOrder;
  var greaterThanResult = sortOrder === 'asc' ? 1 : -1;
  var lessThanResult = sortOrder === 'asc' ? -1 : 1;

  if (!(0, _isNil2["default"])(aVal) || !(0, _isNil2["default"])(bVal)) {
    if ((0, _isNil2["default"])(aVal)) return greaterThanResult;
    if ((0, _isNil2["default"])(bVal)) return lessThanResult;
    if (typeof aVal === 'string' && typeof bVal === 'string' && aVal.toLowerCase().localeCompare(bVal.toLowerCase()) === 1) return greaterThanResult;
    if (typeof aVal === 'string' && typeof bVal === 'string' && bVal.toLowerCase().localeCompare(aVal.toLowerCase()) === 1) return lessThanResult;
    if (typeof aVal === 'number' && typeof bVal === 'number' && aVal > bVal) return greaterThanResult;
    if (typeof aVal === 'number' && typeof bVal === 'number' && bVal > aVal) return lessThanResult;
  }

  return 0;
};

var defaultDataComparator = function defaultDataComparator(_ref3) {
  var sortOptions = _ref3.sortOptions,
      headers = _ref3.headers;
  return function (a, b) {
    var _loop = function _loop(i) {
      var _sortOptions$i = sortOptions[i],
          ident = _sortOptions$i.ident,
          display = _sortOptions$i.display,
          sortOrder = _sortOptions$i.sortOrder;
      var header = headers.find(function (a) {
        return a.ident === ident && (!display || display === a.display);
      });
      var type = header.type,
          sortIndexGetter = header.sortIndexGetter; // TODO may need to look into getting custom data for example date

      var aVal = normalizeValue(sortIndexGetter ? sortIndexGetter({
        rowData: a,
        header: header
      }) : (0, _utils.extractData)({
        rowData: a,
        header: header
      }), type);
      var bVal = normalizeValue(sortIndexGetter ? sortIndexGetter({
        rowData: b,
        header: header
      }) : (0, _utils.extractData)({
        rowData: b,
        header: header
      }), type);
      var res = compare({
        aVal: aVal,
        bVal: bVal,
        sortOrder: sortOrder
      });
      if (res !== 0) return {
        v: res
      };
    };

    // const headerMap = R.compose(R.fromPairs, R.map(header => [header.ident, header]))(headers)
    // console.log('**$$**$$sorting**$$**$$')
    for (var i = 0; i < sortOptions.length; i++) {
      var _ret = _loop(i);

      if (_typeof(_ret) === "object") return _ret.v;
    }

    return 0;
  };
};

var computeSortOptions = function computeSortOptions(sortOptions, _ref4) {
  var ident = _ref4.ident,
      display = _ref4.display;

  if ((0, _find2["default"])(function (opt) {
    return opt.ident === ident;
  }, sortOptions) !== undefined) {
    return sortOptions.map(function (opt) {
      return opt.ident === ident && (opt.display == null || opt.display === display) ? {
        ident: ident,
        sortOrder: toggleSortOrder(opt.sortOrder)
      } : opt;
    }).filter(function (opt) {
      return opt.sortOrder !== undefined;
    });
  } else {
    return [].concat(_toConsumableArray(sortOptions), [{
      ident: ident,
      display: display,
      sortOrder: 'asc'
    }]);
  }
};

var matchData = function matchData(rowData, fuzzyFilter) {
  return function (header) {
    return (0, _data.fromNullable)((0, _utils.extractAndFormatData)({
      rowData: rowData,
      header: header
    })).map(function (txt) {
      return txt.toLowerCase().includes(fuzzyFilter.toLowerCase());
    }).getOrElse(false);
  };
};

var filterData = function filterData(data, headers, fuzzyFilter) {
  var filteredHeaders = (0, _filter2["default"])(function (_ref5) {
    var isKey = _ref5.isKey,
        isFiltered = _ref5.isFiltered;
    return isKey || isFiltered;
  }, headers);
  return (0, _filter2["default"])(function (rowData) {
    return (0, _any2["default"])(matchData(rowData, fuzzyFilter), filteredHeaders);
  }, data);
};

var computeView = function computeView(_ref6) {
  var _ref6$data = _ref6.data,
      data = _ref6$data === void 0 ? [] : _ref6$data,
      sortOptions = _ref6.sortOptions,
      _ref6$comparator = _ref6.comparator,
      comparator = _ref6$comparator === void 0 ? defaultDataComparator : _ref6$comparator,
      fuzzyFilter = _ref6.fuzzyFilter,
      headers = _ref6.headers,
      rowsPerPage = _ref6.rowsPerPage,
      currentPage = _ref6.currentPage,
      editInfo = _ref6.editInfo,
      altBy = _ref6.altBy;
  // TODO have to add edited value
  //
  var editedData = (0, _editEngine.applyEdits)({
    data: data,
    editInfo: editInfo
  }); // console.log('*****calling compute view******')

  var filteredData = !(0, _isNil2["default"])(fuzzyFilter) && !(0, _isEmpty2["default"])(fuzzyFilter) ? filterData(editedData, headers, fuzzyFilter) : editedData;
  var sortredData = (0, _isNil2["default"])(sortOptions) || (0, _isEmpty2["default"])(sortOptions) ? filteredData : (0, _sort2["default"])(comparator({
    sortOptions: sortOptions,
    headers: headers
  }), filteredData);
  var normalizedCurrentPage = Math.min(Math.ceil(filteredData.length / rowsPerPage), currentPage);
  var pagedData = (0, _isNil2["default"])(rowsPerPage) ? sortredData : (0, _compose2["default"])((0, _take2["default"])(rowsPerPage), (0, _drop2["default"])((normalizedCurrentPage - 1) * rowsPerPage))(sortredData);
  return {
    view: pagedData,
    filteredDataLength: filteredData.length,
    currentPage: normalizedCurrentPage,
    altIndexes: (0, _utils.computeAltIndexes)({
      data: pagedData,
      altBy: altBy
    })
  };
};

var sortOrderOf = function sortOrderOf(header) {
  return function (options) {
    if ((0, _isNil2["default"])(options)) return undefined;
    return (0, _compose2["default"])(function (opt) {
      return opt ? opt.sortOrder : undefined;
    }, (0, _find2["default"])(function (opt) {
      return opt.ident === header.ident && (opt.display == null || opt.display === header.display);
    }))(options);
  };
};

var Grid =
/*#__PURE__*/
function (_React$PureComponent) {
  _inherits(Grid, _React$PureComponent);

  function Grid() {
    var _getPrototypeOf2;

    var _this;

    _classCallCheck(this, Grid);

    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(Grid)).call.apply(_getPrototypeOf2, [this].concat(args)));

    _defineProperty(_assertThisInitialized(_this), "scrollSync", new _ScrollSyncHelper["default"]());

    _defineProperty(_assertThisInitialized(_this), "localEditInfo", (0, _editEngine.generateInitialEditInfo)());

    _defineProperty(_assertThisInitialized(_this), "isEditInfoControlled", function () {
      return !(0, _isNil2["default"])(_this.props.editInfo) && !(0, _isNil2["default"])(_this.props.onEditInfoChange);
    });

    _defineProperty(_assertThisInitialized(_this), "editInfo", function () {
      return _this.isEditInfoControlled() ? _this.props.editInfo : _this.localEditInfo;
    });

    _defineProperty(_assertThisInitialized(_this), "setEditInfo", function (editInfo) {
      if (_this.isEditInfoControlled()) {
        _this.props.onEditInfoChange(editInfo);

        return false;
      }

      _this.localEditInfo = editInfo;
      return true;
    });

    _defineProperty(_assertThisInitialized(_this), "state", _objectSpread({
      hoveredRow: undefined,
      hoveredColumn: undefined,
      bitMaskMap: {},
      previousRectangleSelection: {
        x1: undefined,
        y1: undefined,
        x2: undefined,
        y2: undefined
      }
    }, computeView({
      data: _this.props.data,
      sortOptions: _this.props.initialSortOptions || _this.props.sortOptions,
      fuzzyFilter: _this.props.fuzzyFilter,
      headers: _this.props.headers,
      rowsPerPage: _this.props.rowsPerPage,
      currentPage: _this.props.currentPage || 1,
      editInfo: _this.editInfo(),
      altBy: _this.props.altBy
    }), {
      sortOptions: _this.props.initialSortOptions,
      currentPage: _this.props.currentPage || 1,
      editingRow: undefined,
      editingColumn: undefined
    }));

    _defineProperty(_assertThisInitialized(_this), "bodyMouseRelease", function (e) {
      /*
       * this will only work with one grid on screen
       * may need to figureout another solution
       * isPositionValid only cares if data-row-index data-column-index is there
       * */
      if (_this.selecting && !(0, _utils.isPositionValid)((0, _utils.extractPosition)(e))) {
        _this.selecting = false;
      }
    });

    _defineProperty(_assertThisInitialized(_this), "setSelectedRect", function (rect) {
      var newSelection = _objectSpread({}, rect);

      var x1 = newSelection.x1,
          y1 = newSelection.y1,
          x2 = newSelection.x2,
          y2 = newSelection.y2,
          isCtrl = newSelection.isCtrl;
      var newBitMaskMap = (0, _newSelectionUtils.selectRange)(_this.props.selectionMode === 'multi' && !!isCtrl ? _objectSpread({}, _this.state.bitMaskMap) : {}, x1, y1, _this.props.selectionMode === 'multi' ? x2 : x1, _this.props.selectionMode === 'multi' ? y2 : y1);

      _this.setState({
        bitMaskMap: newBitMaskMap,
        previousRectangleSelection: newSelection
      }, _this.selectionChanged);
    });

    _defineProperty(_assertThisInitialized(_this), "hasPaging", function () {
      var _ref7 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
          _ref7$data = _ref7.data,
          data = _ref7$data === void 0 ? _this.props.data : _ref7$data;

      return _this.props.rowsPerPage !== undefined && data.length > _this.props.rowsPerPage;
    });

    _defineProperty(_assertThisInitialized(_this), "isPagingControlled", function () {
      return _this.props.totalPages !== undefined && _this.props.currentPage !== undefined && _this.props.onPageChange !== undefined;
    });

    _defineProperty(_assertThisInitialized(_this), "currentPage", function () {
      return _this.hasPaging() ? _this.props.currentPage || _this.state.currentPage : undefined;
    });

    _defineProperty(_assertThisInitialized(_this), "totalPages", function () {
      return !_this.hasPaging() ? undefined : (0, _isNil2["default"])(_this.props.totalPages) ? Math.ceil(_this.state.filteredDataLength / _this.props.rowsPerPage) : _this.props.totalPages;
    });

    _defineProperty(_assertThisInitialized(_this), "setCurrentPage", function (page) {
      if (isNaN(parseInt(page))) return;

      if (_this.hasPaging()) {
        var guardedPage = Math.max(Math.min(_this.totalPages(), parseInt(page)), 1);

        if (guardedPage !== _this.currentPage()) {
          if (_this.isPagingControlled()) {
            _this.props.onPageChange(guardedPage);
          } else {
            _this.setState(function (_) {
              return _objectSpread({
                currentPage: guardedPage
              }, _this.generateViewProps({
                currentPage: guardedPage
              }));
            });
          }
        }
      }
    });

    _defineProperty(_assertThisInitialized(_this), "incrementPage", function () {
      if (_this.hasPaging()) {
        if (_this.isPagingControlled()) {
          _this.props.onPageChange(Math.max(Math.min(_this.totalPages(), _this.currentPage() + 1), 1));
        } else {
          // eslint-disable-next-line standard/object-curly-even-spacing
          _this.setState(function (_ref8) {
            var currentPage = _ref8.currentPage;
            var totalPages = Math.ceil(_this.props.data.length / _this.props.rowsPerPage);
            var newPage = Math.max(Math.min(totalPages, currentPage + 1), 1);

            if (newPage !== currentPage) {
              return _objectSpread({
                currentPage: newPage
              }, _this.generateViewProps({
                currentPage: newPage
              }));
            } else {
              return null;
            }
          });
        }
      }
    });

    _defineProperty(_assertThisInitialized(_this), "decrementPage", function () {
      if (_this.hasPaging()) {
        if (_this.isPagingControlled()) {
          _this.props.onPageChange(Math.max(Math.min(_this.totalPages(), _this.currentPage() - 1), 1));
        } else {
          // eslint-disable-next-line standard/object-curly-even-spacing
          _this.setState(function (_ref9) {
            var currentPage = _ref9.currentPage;
            var totalPages = Math.ceil(_this.props.data.length / _this.props.rowsPerPage);
            var newPage = Math.max(Math.min(totalPages, currentPage - 1), 1);

            if (newPage !== currentPage) {
              return _objectSpread({
                currentPage: newPage
              }, _this.generateViewProps({
                currentPage: newPage
              }));
            } else {
              return null;
            }
          });
        }
      }
    });

    _defineProperty(_assertThisInitialized(_this), "isSortControlled", function () {
      return _this.props.sortOptions !== undefined && _this.props.onSortOptionsChange !== undefined;
    });

    _defineProperty(_assertThisInitialized(_this), "toggleSort", function (header) {
      if (_this.isSortControlled()) {
        _this.props.onSortOptionsChange(computeSortOptions(_this.sortOptions(), header));
      } else {
        _this.setState(function (_ref10) {
          var _ref10$sortOptions = _ref10.sortOptions,
              sortOptions = _ref10$sortOptions === void 0 ? [] : _ref10$sortOptions;
          var newOptions = computeSortOptions(sortOptions, header);
          return _objectSpread({
            sortOptions: newOptions
          }, _this.generateViewProps({
            sortOptions: newOptions
          }));
        });
      }
    });

    _defineProperty(_assertThisInitialized(_this), "generateViewProps", function () {
      var _ref11 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
          _ref11$data = _ref11.data,
          data = _ref11$data === void 0 ? _this.props.data : _ref11$data,
          _ref11$sortOptions = _ref11.sortOptions,
          sortOptions = _ref11$sortOptions === void 0 ? _this.sortOptions() : _ref11$sortOptions,
          _ref11$fuzzyFilter = _ref11.fuzzyFilter,
          fuzzyFilter = _ref11$fuzzyFilter === void 0 ? _this.props.fuzzyFilter : _ref11$fuzzyFilter,
          _ref11$currentPage = _ref11.currentPage,
          currentPage = _ref11$currentPage === void 0 ? _this.currentPage() : _ref11$currentPage,
          _ref11$editInfo = _ref11.editInfo,
          editInfo = _ref11$editInfo === void 0 ? _this.editInfo() : _ref11$editInfo;

      return computeView({
        data: data,
        sortOptions: sortOptions,
        fuzzyFilter: fuzzyFilter,
        headers: _this.props.headers,
        rowsPerPage: _this.props.rowsPerPage,
        currentPage: currentPage,
        editInfo: editInfo,
        altBy: _this.props.altBy
      });
    });

    _defineProperty(_assertThisInitialized(_this), "selectRight", function (expand, isCtrl) {
      _this.setState(_newSelectionUtils.selector.right(_this.state, expand, isCtrl, _this.props.headers.length), _this.selectionChanged);
    });

    _defineProperty(_assertThisInitialized(_this), "selectLeft", function (expand, isCtrl) {
      _this.setState(_newSelectionUtils.selector.left(_this.state, _this.props.selectionMode === 'multi' && expand, _this.props.selectionMode === 'multi' && isCtrl), _this.selectionChanged);
    });

    _defineProperty(_assertThisInitialized(_this), "selectTop", function (expand, isCtrl) {
      _this.setState(_newSelectionUtils.selector.up(_this.state, _this.props.selectionMode === 'multi' && expand, _this.props.selectionMode === 'multi' && isCtrl), _this.selectionChanged);
    });

    _defineProperty(_assertThisInitialized(_this), "selectBottom", function (expand, isCtrl) {
      _this.setState(_newSelectionUtils.selector.down(_this.state, _this.props.selectionMode === 'multi' && expand, _this.props.selectionMode === 'multi' && isCtrl, _this.state.view.length), _this.selectionChanged);
    });

    _defineProperty(_assertThisInitialized(_this), "selectAll", function () {
      _this.setState(_newSelectionUtils.selector.selectAll(_this.props.headers.length, _this.state.view.length), _this.selectionChanged);
    });

    _defineProperty(_assertThisInitialized(_this), "selectionChanged", function (_) {
      var _this$props = _this.props,
          headers = _this$props.headers,
          onSelectionChange = _this$props.onSelectionChange; // console.log(this.state.x1, this.state.y1, this.state.x2, this.state.y2)

      if (onSelectionChange) {
        var _this$state = _objectSpread({}, _this.state),
            bitMaskMap = _this$state.bitMaskMap,
            view = _this$state.view;

        var _getGlobalColumnRange = (0, _newSelectionUtils.getGlobalColumnRange)(bitMaskMap),
            minCol = _getGlobalColumnRange.minCol,
            maxCol = _getGlobalColumnRange.maxCol;

        var selectedRows = [];
        var selectedHeaders = [];

        if (minCol === undefined || maxCol === undefined) {
          onSelectionChange({
            selectedRows: selectedRows,
            selectedHeaders: selectedHeaders
          });
          return;
        }

        Object.keys(bitMaskMap).map(function (r) {
          var rNumber = BigInt(r);
          if (bitMaskMap[r]) selectedRows.push(view[rNumber]);
        });
        (0, _range2["default"])(minCol, maxCol + 1).map(function (c) {
          if (headers[c] != null) selectedHeaders.push(headers[c]);
        });
        onSelectionChange({
          selectedRows: selectedRows,
          selectedHeaders: selectedHeaders
        });
      } // if (onSelectionChange) {
      //   const { x1, x2, y1, y2 } = normalizeSelection(this.state)
      //   const selectedRows = []
      //   const selectedHeaders = []
      //   const { view } = this.state
      //   for (let r = y1; r <= y2; r++) {
      //     if (view[r] != null) selectedRows.push(view[r])
      //   }
      //   for (let c = x1; c <= x2; c++) {
      //     if (headers[c] != null) selectedHeaders.push(headers[c])
      //   }
      //   onSelectionChange({ selectedRows, selectedHeaders })
      // }

    });

    _defineProperty(_assertThisInitialized(_this), "getSelectionInfo", function (_) {
      return _objectSpread({}, _this.state.previousRectangleSelection || {}, {
        rawPositions: {
          x1: (_this.state.previousRectangleSelection || {}).x1,
          x2: (_this.state.previousRectangleSelection || {}).x2,
          y1: (_this.state.previousRectangleSelection || {}).y1,
          y2: (_this.state.previousRectangleSelection || {}).y2
        }
      });
    });

    _defineProperty(_assertThisInitialized(_this), "isEditable", function (props) {
      var isEditable = _this.props.isEditable;
      return typeof isEditable === 'function' ? isEditable(props) : isEditable;
    });

    _defineProperty(_assertThisInitialized(_this), "processUpdate", function (_ref12) {
      var currentRow = _ref12.currentRow,
          row = _ref12.editedRow;
      var _this$props2 = _this.props,
          mapEditRow = _this$props2.mapEditRow,
          processEditedRow = _this$props2.processEditedRow; // console.log('procssing edited frow with', mapEditRow,processEditedRow)

      var editedRow = mapEditRow ? mapEditRow(row) : processEditedRow({
        currentRow: currentRow,
        editedRow: row
      }); // console.log('result is ',editedRow)

      return {
        originalRow: currentRow,
        currentRow: currentRow,
        editedRow: editedRow
      };
    });

    _defineProperty(_assertThisInitialized(_this), "commitRowEdit", function (editProps) {
      var currentRow = editProps.currentRow,
          row = editProps.editedRow;
      var dataDidUpdate = _this.props.dataDidUpdate;

      if (currentRow !== row) {
        var _this$processUpdate = _this.processUpdate({
          currentRow: currentRow,
          editedRow: row
        }),
            editedRow = _this$processUpdate.editedRow;

        if (_this.props.onEdit) {
          // expect new data to be passed down via props
          _this.props.onEdit(_objectSpread({}, editProps, {
            currentRow: currentRow,
            originalRow: currentRow,
            editedRow: editedRow
          }), _this.focusGrid);

          if (dataDidUpdate) {
            dataDidUpdate(_objectSpread({}, editProps, {
              currentRow: currentRow,
              originalRow: currentRow,
              editedRow: editedRow
            }));
          }
        } else {
          // console.log('***********adding stuff', currentRow, editedRow,'')
          // if edit info is controlled then there should not be state updates
          var updateState = _this.setEditInfo((0, _editEngine.updateRow)({
            editInfo: _this.editInfo(),
            currentRow: currentRow,
            editedRow: editedRow
          }));

          _this.setState(function (_) {
            return updateState ? _objectSpread({}, _this.generateViewProps(), {
              editingRow: undefined,
              editingColumn: undefined
            }) : {
              editingRow: undefined,
              editingColumn: undefined
            };
          }, function () {
            _this.focusGrid && _this.focusGrid();
            dataDidUpdate && updateState && dataDidUpdate(_objectSpread({}, editProps, {
              originalRow: currentRow,
              currentRow: currentRow,
              editedRow: editedRow
            }));
          });
        }
      }
    });

    _defineProperty(_assertThisInitialized(_this), "cancelEdit", function () {
      return _this.setState(function (_) {
        return {
          editingRow: undefined,
          editingColumn: undefined
        };
      }, function () {
        try {
          if (_this.props.onEditCancel != null) _this.props.onEditCancel();
        } finally {
          _this.focusGrid();
        }
      });
    });

    _defineProperty(_assertThisInitialized(_this), "cellDoubleClick", function (e) {
      var pos = (0, _utils.extractPosition)(e);
      var rowIndex = pos.rowIndex,
          columnIndex = pos.columnIndex;

      _this.edit(rowIndex, columnIndex);
    });

    _defineProperty(_assertThisInitialized(_this), "gridKeyDown", function (e) {
      var _ref13 = _this.state.previousRectangleSelection || {},
          columnIndex = _ref13.x2,
          rowIndex = _ref13.y2;

      var selectionValid = !(0, _isNil2["default"])(columnIndex) && !(0, _isNil2["default"])(rowIndex);

      if (selectionValid) {
        var isEditAttempt = !_this.isGridEditing() && !e.metaKey && !e.ctrlKey && (e.keyCode >= 32 && e.keyCode <= 126 || e.keyCode === 187 || e.keyCode === 189) && e.key.length === 1;

        if (isEditAttempt) {
          // console.log('attempting edit', {
          //   editingColumn: columnIndex,
          //   editingRow: rowIndex,
          //   initialEditChar: String.fromCharCode(e.keyCode),
          // })
          _this.edit(rowIndex, columnIndex);
        }

        if (!_this.isGridEditing()) {
          if (e.keyCode === 37) _this.selectLeft(e.shiftKey, e.ctrlKey);
          if (e.keyCode === 39) _this.selectRight(e.shiftKey, e.ctrlKey);
          if (e.keyCode === 38) _this.selectTop(e.shiftKey, e.ctrlKey);
          if (e.keyCode === 40) _this.selectBottom(e.shiftKey, e.ctrlKey);
          if (e.ctrlKey && e.keyCode === 65 && _this.props.selectionMode === 'multi') _this.selectAll();

          if (e.keyCode === 9) {
            e.preventDefault();
            e.shiftKey ? _this.selectLeft() : _this.selectRight();
          }

          if (e.keyCode === 46) {
            e.preventDefault();

            _this.deleteSelection();
          }
        }
      }
    });

    _defineProperty(_assertThisInitialized(_this), "focusGrid", function () {
      if (_this.clipboardHelper && _this.clipboardHelper.focus) {
        // console.log('clipboard focus available focusting')
        _this.clipboardHelper.focus();
      } else if (_this.gridContainer && _this.gridContainer.focus) {
        // console.log('grid focus available focusting')
        _this.gridContainer.focus();
      }
    });

    _defineProperty(_assertThisInitialized(_this), "cancelCellEdit", function () {
      _this.setState({
        editingColumn: undefined,
        editingRow: undefined
      }, _this.focusGrid);
    });

    _defineProperty(_assertThisInitialized(_this), "cellMouseDown", function (e) {
      var isShift = e.shiftKey;
      var isCtrl = e.ctrlKey || e.metaKey;
      var pos = (0, _utils.extractPosition)(e);
      var rowIndex = pos.rowIndex,
          columnIndex = pos.columnIndex;
      if (e.button === 2 && (0, _newSelectionUtils.isCellSelected)(rowIndex, columnIndex, _this.state)) return;

      _this.setState(function (_) {
        return _this.startSelectionState(rowIndex, columnIndex, _this.props.selectionMode === 'multi' && isShift, _this.props.selectionMode === 'multi' && isCtrl);
      }, _this.selectionChanged);
    });

    _defineProperty(_assertThisInitialized(_this), "cellMouseUp", function () {
      _this.selecting = false;

      _this.focusGrid();
    });

    _defineProperty(_assertThisInitialized(_this), "cellMouseEnter", function (e) {
      var pos = (0, _utils.extractPosition)(e);
      var rowIndex = pos.rowIndex,
          columnIndex = pos.columnIndex;
      var isSelecting = _this.selecting;

      _this.setState(function (_) {
        return _objectSpread({}, _this.hoverState(rowIndex, columnIndex), {}, _this.expandSelectionState(rowIndex, columnIndex, false, e.ctrlKey));
      }, isSelecting ? _this.selectionChanged : undefined);
    });

    _defineProperty(_assertThisInitialized(_this), "cellMouseLeave", function (_e) {
      _this.setState(function (_) {
        return _objectSpread({}, _this.hoverState());
      });
    });

    _defineProperty(_assertThisInitialized(_this), "columnHeaderClick", function (e) {
      var ident = (0, _utils.extractColIdent)(e);

      var header = _this.props.headers.filter(function (h) {
        return h.ident === ident;
      })[0];

      if (!(0, _isNil2["default"])(header)) {
        _this.toggleSort(header);
      }
    });

    _defineProperty(_assertThisInitialized(_this), "getRowProps", function (_ref14) {
      var key = _ref14.key,
          index = _ref14.index,
          _ref14$isHeader = _ref14.isHeader,
          isHeader = _ref14$isHeader === void 0 ? false : _ref14$isHeader,
          headers = _ref14.headers,
          width = _ref14.width,
          rowHeight = _ref14.rowHeight,
          headerRowHeight = _ref14.headerRowHeight,
          yOffSet = _ref14.yOffSet,
          xOffSet = _ref14.xOffSet,
          scroll = _ref14.scroll,
          scrollY = _ref14.scrollY;
      return {
        key: key || index,
        width: width === undefined || width === null ? (0, _utils.sumWidth)(headers) : width,
        height: isHeader ? headerRowHeight : rowHeightOf(index, rowHeight),
        colCount: headers.length,
        isHeader: isHeader,
        yOffSet: yOffSet,
        xOffSet: xOffSet,
        scroll: scroll,
        scrollY: scrollY
      };
    });

    _defineProperty(_assertThisInitialized(_this), "getCellProps", function (_ref15) {
      var _objectSpread2;

      var key = _ref15.key,
          rowIndex = _ref15.rowIndex,
          columnIndex = _ref15.columnIndex,
          header = _ref15.header,
          data = _ref15.data,
          rowHeight = _ref15.rowHeight,
          rest = _objectWithoutProperties(_ref15, ["key", "rowIndex", "columnIndex", "header", "data", "rowHeight"]);

      var _this$props3 = _this.props,
          selectionType = _this$props3.selectionType,
          hoverType = _this$props3.hoverType;
      return _objectSpread((_objectSpread2 = {}, _defineProperty(_objectSpread2, _constants.ROW_INDEX_ATTRIBUTE, rowIndex), _defineProperty(_objectSpread2, "key", key || rowIndex + '-x-' + columnIndex + '-' + header.ident), _defineProperty(_objectSpread2, _constants.COLUMN_INDEX_ATTRIBUTE, columnIndex), _defineProperty(_objectSpread2, "header", header), _defineProperty(_objectSpread2, "onMouseDown", _this.cellMouseDown), _defineProperty(_objectSpread2, "onMouseEnter", _this.cellMouseEnter), _defineProperty(_objectSpread2, "onMouseUp", _this.cellMouseUp), _defineProperty(_objectSpread2, "onMouseLeave", _this.cellMouseLeave), _defineProperty(_objectSpread2, "onDoubleClick", _this.cellDoubleClick), _defineProperty(_objectSpread2, "isSelected", selectionType === 'cell' ? (0, _newSelectionUtils.isCellSelected)(rowIndex, columnIndex, _this.state) : (0, _newSelectionUtils.isRowSelected)(rowIndex, _this.state)), _defineProperty(_objectSpread2, "isHovered", hoverType === 'cell' ? _this.state.hoveredRow === rowIndex && _this.state.hoveredColumn === columnIndex : _this.state.hoveredRow === rowIndex), _defineProperty(_objectSpread2, "invalidMessage", header.setInvalidMessage && header.setInvalidMessage({
        header: header,
        rowData: data[rowIndex],
        value: data[rowIndex][header.ident],
        rowIndex: rowIndex,
        data: data
      })), _defineProperty(_objectSpread2, "data", data), _defineProperty(_objectSpread2, "rowIndex", rowIndex), _defineProperty(_objectSpread2, "columnIndex", columnIndex), _defineProperty(_objectSpread2, "height", rowHeightOf(rowIndex, rowHeight)), _defineProperty(_objectSpread2, "width", header.width), _defineProperty(_objectSpread2, "alignment", header.alignment), _defineProperty(_objectSpread2, "isEditing", _this.isCellEditing(rowIndex, columnIndex)), _defineProperty(_objectSpread2, "commitRowEdit", _this.commitRowEdit), _defineProperty(_objectSpread2, "cancelEdit", _this.cancelCellEdit), _defineProperty(_objectSpread2, "selectRight", _this.selectRight), _defineProperty(_objectSpread2, "selectLeft", _this.selectLeft), _defineProperty(_objectSpread2, "selectTop", _this.selectTop), _defineProperty(_objectSpread2, "selectBottom", _this.selectBottom), _defineProperty(_objectSpread2, "altIndexes", _this.state.altIndexes), _defineProperty(_objectSpread2, "altBgColor", _this.props.altBgColor), _defineProperty(_objectSpread2, "fontSize", header.fontSize), _defineProperty(_objectSpread2, "fontWeight", header.fontWeight), _defineProperty(_objectSpread2, "backgroundColor", header.backgroundColor || _this.state.altIndexes && _this.state.altIndexes[rowIndex] && _this.props.altBgColor), _defineProperty(_objectSpread2, "hoverSelectionBackgroundColor", header.hoverSelectionBackgroundColor), _defineProperty(_objectSpread2, "hoverBackgroundColor", header.hoverBackgroundColor), _defineProperty(_objectSpread2, "selectionBackgroundColor", header.selectionBackgroundColor), _defineProperty(_objectSpread2, "validationErrorBackgroundColor", header.validationErrorBackgroundColor), _defineProperty(_objectSpread2, "hoverSelectionColor", header.hoverSelectionColor), _defineProperty(_objectSpread2, "hoverColor", header.hoverColor), _defineProperty(_objectSpread2, "selectionColor", header.selectionColor), _defineProperty(_objectSpread2, "color", header.color), _objectSpread2), rest);
    });

    _defineProperty(_assertThisInitialized(_this), "getGridContainerProps", function () {
      var _ref16 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
          width = _ref16.width,
          height = _ref16.height,
          _ref16$refKey = _ref16.refKey,
          refKey = _ref16$refKey === void 0 ? 'ref' : _ref16$refKey;

      return _defineProperty({
        width: width,
        height: height,
        onKeyDown: _this.gridKeyDown
      }, refKey, _this.gridContainerRefHandler);
    });

    _defineProperty(_assertThisInitialized(_this), "getColumnHeaderProps", function (_ref18) {
      var _objectSpread3;

      var key = _ref18.key,
          index = _ref18.index,
          header = _ref18.header,
          rest = _objectWithoutProperties(_ref18, ["key", "index", "header"]);

      return _objectSpread((_objectSpread3 = {
        key: key || index + '-x-' + header.ident,
        header: header,
        width: header.width
      }, _defineProperty(_objectSpread3, _constants.COL_IDENT_ATTRIBUTE, header.ident), _defineProperty(_objectSpread3, "onClick", _this.props.sortEnabled ? _this.columnHeaderClick : undefined), _defineProperty(_objectSpread3, "sortOrder", _this.props.sortEnabled ? sortOrderOf(header)(_this.sortOptions()) : undefined), _defineProperty(_objectSpread3, 'data-column-index', index), _objectSpread3), rest);
    });

    _defineProperty(_assertThisInitialized(_this), "getPagerProps", function (props) {
      return _objectSpread({}, props, {
        totalPages: _this.totalPages(),
        currentPage: _this.currentPage(),
        setCurrentPage: _this.setCurrentPage,
        incrementPage: _this.incrementPage,
        decrementPage: _this.decrementPage
      });
    });

    _defineProperty(_assertThisInitialized(_this), "getRowEditorProps", function (_) {
      var _ref19 = _this.state.previousRectangleSelection || {},
          y1 = _ref19.y1;

      var addWithSelected = _this.props.addWithSelected;
      return {
        onClose: _this.cancelEdit,
        commitEdit: _this.commitRowEdit,
        // TODO: add feature to pop up editor based on some row for add featrues
        showAdd: _this.props.showAdd,
        rowData: _this.props.showAdd ? addWithSelected ? _this.state.view[y1] : {} : _this.state.view[_this.state.editingRow],
        headers: _this.props.headers,
        isEditing: _this.isRowEditing()
      };
    });

    _defineProperty(_assertThisInitialized(_this), "getClipboardHelperProps", function () {
      var _ref21;

      var _ref20 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
          _ref20$refKey = _ref20.refKey,
          refKey = _ref20$refKey === void 0 ? 'ref' : _ref20$refKey;

      return _ref21 = {}, _defineProperty(_ref21, refKey, _this.clipboardHelperRefHandler), _defineProperty(_ref21, "style", {
        position: 'fixed',
        bottom: 0,
        right: 0,
        width: '100vw',
        height: '0px',
        border: 'none',
        outline: 'none'
      }), _defineProperty(_ref21, "onCopy", _this.onCopy), _defineProperty(_ref21, "onPaste", _this.onPaste), _ref21;
    });

    _defineProperty(_assertThisInitialized(_this), "gridContainerRefHandler", function (node) {
      return _this.gridContainer = node;
    });

    _defineProperty(_assertThisInitialized(_this), "clipboardHelperRefHandler", function (node) {
      return _this.clipboardHelper = node;
    });

    _defineProperty(_assertThisInitialized(_this), "onCopy", function (e) {
      var selection = _this.state;
      if (_this.isDebug()) console.log('copied selection', selection);
      var data = _this.state.view;
      var _this$props4 = _this.props,
          headers = _this$props4.headers,
          selectionType = _this$props4.selectionType;
      var selectedData = (0, _newSelectionUtils.getSelectedData)({
        headers: headers,
        data: data
      }, selection, selectionType);
      if (_this.isDebug()) console.log('copied data', selectedData);
      var rawClipboardData = (0, _clipboardUtils.toClipboardData)(selectedData);
      if (_this.isDebug()) console.log('copied clip board data', rawClipboardData);
      var clipboardInfo = (0, _data.fromNullable)(e.clipboardData).map(function (clipboard) {
        return {
          evt: e,
          clipboard: clipboard
        };
      });
      (0, _data.fromNullable)(_clipboardUtils.copyToClipboard).ap(clipboardInfo).ap((0, _data.Just)(rawClipboardData));
    });

    _defineProperty(_assertThisInitialized(_this), "pastedToBatchUpdate", function (_ref22) {
      var columnIndex = _ref22.columnIndex,
          rowIndex = _ref22.rowIndex,
          dataSet = _ref22.dataSet;
      if (_this.isDebug()) console.log('pasting to ', 'row[' + rowIndex + ']:col[' + columnIndex + ']', dataSet);
      var updatedData = [];
      var view = _this.state.view;
      var headers = _this.props.headers;

      for (var y = rowIndex, dy = 0; y < view.length && dy < dataSet.length; y++, dy++) {
        if (_this.isDebug()) console.log('pasting rowIndex from ', dy, ' to ', y);
        var dataSetRow = dataSet[dy];
        var currentRow = view[y];

        var editedRow = _objectSpread({}, currentRow);

        for (var x = columnIndex, dx = 0; x < headers.length && dx < dataSetRow.length; x++, dx++) {
          var header = headers[x];
          var ident = header.ident;

          if (_this.isEditable({
            header: header,
            rowData: currentRow
          })) {
            // TODO: hadle special cases for selection types as well as numbers
            // look to row editro
            var rawTxtContent = dataSetRow[dx];
            editedRow[ident] = header.type === 'num' ? (0, _clipboardUtils.normalizeCopiedContentForNumber)(rawTxtContent) : rawTxtContent;
          }
        }

        updatedData.push({
          currentRow: currentRow,
          editedRow: editedRow
        });
      } // console.log('final edit ops', updatedData)


      return updatedData;
    });

    _defineProperty(_assertThisInitialized(_this), "deleteSelection", function () {
      var bitMaskMap = _this.state.bitMaskMap;
      var _this$props5 = _this.props,
          headers = _this$props5.headers,
          selectionType = _this$props5.selectionType;
      var view = _this.state.view;
      if (!bitMaskMap || Object.keys(bitMaskMap).length === 0) return;

      var _getGlobalColumnRange2 = (0, _newSelectionUtils.getGlobalColumnRange)(bitMaskMap),
          minCol = _getGlobalColumnRange2.minCol,
          maxCol = _getGlobalColumnRange2.maxCol;

      if (minCol === undefined || maxCol === undefined) return;
      var rowKeys = Object.keys(bitMaskMap).map(function (r) {
        return Number(r);
      });
      var rows = (0, _range2["default"])(Math.min.apply(Math, _toConsumableArray(rowKeys)), Math.max.apply(Math, _toConsumableArray(rowKeys)) + 1);
      var cols = selectionType === 'cell' ? (0, _range2["default"])(minCol, maxCol + 1) : (0, _range2["default"])(0, headers.length);
      var updates = rows.map(function (rowIdx) {
        var currentRow = view[rowIdx];
        return {
          currentRow: currentRow,
          editedRow: _objectSpread({}, currentRow, {}, cols.filter(function (col) {
            return _this.isEditable({
              header: headers[col],
              rowData: currentRow
            }) && (selectionType === 'cell' ? (0, _newSelectionUtils.isCellSelected)(rowIdx, col, _this.state) : (0, _newSelectionUtils.isRowSelected)(rowIdx, _this.state));
          }).map(function (col) {
            return _defineProperty({}, headers[col].ident, null);
          }).reduce(function (a, b) {
            return _objectSpread({}, a, {}, b);
          }, {}))
        };
      }); // console.log('updates are ', updates)

      _this.batchUpdate(updates);
    });

    _defineProperty(_assertThisInitialized(_this), "batchUpdate", function (updates) {
      if (_this.isDebug()) console.log('batch updates are', updates);

      if (_this.props.onBatchUpdate) {
        if (_this.isDebug()) console.log('batch update'); // expect new data to be passed down via props

        _this.props.onBatchUpdate(updates.map(_this.processUpdate), _this.focusGrid);
      } else if (_this.props.onEdit) {
        console.warn('onEdit prop used without onBatchUpdate Please use createControlledEditProps to create necessary props.\n' + 'pasting multiple values will not work!!!!');

        for (var i = 0; i < updates.length; i++) {
          _this.props.onEdit(_this.processUpdate(updates[i]), _this.focusGrid);
        }
      } else {
        if (_this.isDebug()) console.log('self-controlled');

        var updateState = _this.setEditInfo((0, _editEngine.batchUpdateRow)({
          editInfo: _this.editInfo(),
          updates: updates.map(_this.processUpdate)
        }));

        _this.setState(function (_) {
          return updateState ? _objectSpread({}, _this.generateViewProps(), {
            editingRow: undefined,
            editingColumn: undefined
          }) : {
            editingRow: undefined,
            editingColumn: undefined
          };
        }, _this.focusGrid);
      }

      if (_this.props.dataDidUpdate) {
        _this.props.dataDidUpdate({
          mode: 'batched',
          editRecords: updates.map(_this.processUpdate)
        });
      }
    });

    _defineProperty(_assertThisInitialized(_this), "onPaste", function (e) {
      e.preventDefault();
      var selection = (0, _utils.fromEmpty)(_this.state.previousRectangleSelection || {});
      var clipboardData = (0, _clipboardUtils.fromPasteEvent)(e);
      (0, _data.Just)(_clipboardUtils.normalizePasteInfo).ap(selection).ap(clipboardData).map(_this.pastedToBatchUpdate).map(_this.batchUpdate).getOrElse('');
    });

    _defineProperty(_assertThisInitialized(_this), "isDebug", function () {
      return _this.context.debug;
    });

    return _this;
  }

  _createClass(Grid, [{
    key: "getChildContext",
    value: function getChildContext() {
      return _defineProperty({}, _constants.SCROLL_SYNC_CONTEXT, this.scrollSync);
    }
  }, {
    key: "componentDidMount",
    value: function componentDidMount() {
      window.document.body.addEventListener('mouseup', this.bodyMouseRelease);
      window.document.body.addEventListener('mouseleave', this.bodyMouseRelease);

      if (this.clipboardHelper && this.clipboardHelper.focus) {
        // console.log('found clipboard helper', this.clipboardHelper)
        this.clipboardHelper.focus();

        if (this.clipboardHelper.nodeName !== 'INPUT') {
          console.warn('clipboardHelper is not input. please render input with getClipboardHelperProps');
        }
      } else {
        console.warn('Please render an INPUT element with getClipboardHelperProps to support copy&paste.');
      }
    }
  }, {
    key: "componentWillUnmount",
    value: function componentWillUnmount() {
      window.document.body.removeEventListener('mouseleave', this.bodyMouseRelease);
      window.document.body.removeEventListener('mouseup', this.bodyMouseRelease);
    }
  }, {
    key: "componentDidUpdate",
    value: function componentDidUpdate(prevProps) {
      var _this2 = this;

      var data = prevProps.data,
          sortOptions = prevProps.sortOptions,
          fuzzyFilter = prevProps.fuzzyFilter,
          currentPage = prevProps.currentPage,
          editInfo = prevProps.editInfo;
      var nextProps = this.props;

      if (data !== nextProps.data || sortOptions !== nextProps.sortOptions || fuzzyFilter !== nextProps.fuzzyFilter || currentPage !== nextProps.currentPage || editInfo !== nextProps.editInfo) {
        // eslint-disable-next-line react/no-did-update-set-state
        this.setState(function (_ref25) {
          var editingRow = _ref25.editingRow,
              editingColumn = _ref25.editingColumn,
              currentPage = _ref25.currentPage;
          return _objectSpread({}, _this2.generateViewProps({
            data: data !== nextProps.data ? nextProps.data : data,
            sortOptions: sortOptions !== nextProps.sortO