choerodon-ui/pro/lib/table/TableStore.js

An enterprise-class UI design language and React-based implementation

"use strict";

var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getIdList = getIdList;
exports.mergeDefaultProps = mergeDefaultProps;
exports.normalizeColumns = normalizeColumns;
exports["default"] = exports.AGGREGATION_EXPAND_CELL_KEY = exports.CUSTOMIZED_KEY = exports.EXPAND_KEY = exports.DRAG_KEY = exports.ROW_NUMBER_KEY = exports.SELECTION_KEY = void 0;

var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));

var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));

var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));

var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));

var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));

var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));

var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));

var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));

var _tslib = require("tslib");

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

var _mobx = require("mobx");

var _sortBy = _interopRequireDefault(require("lodash/sortBy"));

var _debounce = _interopRequireDefault(require("lodash/debounce"));

var _isNil = _interopRequireDefault(require("lodash/isNil"));

var _isObject = _interopRequireDefault(require("lodash/isObject"));

var _isPlainObject = _interopRequireDefault(require("lodash/isPlainObject"));

var _isString = _interopRequireDefault(require("lodash/isString"));

var _isNumber = _interopRequireDefault(require("lodash/isNumber"));

var _measureScrollbar = _interopRequireDefault(require("../../../lib/_util/measureScrollbar"));

var _UnitConvertor = require("../../../lib/_util/UnitConvertor");

var _configure = require("../../../lib/configure");

var _TooltipUtils = require("../../../lib/_util/TooltipUtils");

var _icon = _interopRequireDefault(require("../../../lib/icon"));

var _isFunction = _interopRequireDefault(require("lodash/isFunction"));

var _Column = require("./Column");

var _CustomizationSettings = _interopRequireDefault(require("./customization-settings/CustomizationSettings"));

var _isFragment = _interopRequireDefault(require("../_util/isFragment"));

var _CheckBox = _interopRequireDefault(require("../check-box/CheckBox"));

var _Radio = _interopRequireDefault(require("../radio/Radio"));

var _enum = require("../data-set/enum");

var _enum2 = require("./enum");

var _EventManager = require("../_util/EventManager");

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

var _getReactNodeText = _interopRequireDefault(require("../_util/getReactNodeText"));

var _ColumnGroups = _interopRequireDefault(require("./ColumnGroups"));

var _autobind = _interopRequireDefault(require("../_util/autobind"));

var _enum3 = require("../core/enum");

var _localeContext = require("../locale-context");

var _CustomizationColumnHeader = _interopRequireDefault(require("./customization-settings/CustomizationColumnHeader"));

var _Dropdown = _interopRequireDefault(require("../dropdown/Dropdown"));

var _menu = _interopRequireDefault(require("../menu"));

var _treeUtils = require("../_util/treeUtils");

var SELECTION_KEY = '__selection-column__'; // TODO:Symbol

exports.SELECTION_KEY = SELECTION_KEY;
var ROW_NUMBER_KEY = '__row-number-column__'; // TODO:Symbol

exports.ROW_NUMBER_KEY = ROW_NUMBER_KEY;
var DRAG_KEY = '__drag-column__'; // TODO:Symbol

exports.DRAG_KEY = DRAG_KEY;
var EXPAND_KEY = '__expand-column__'; // TODO:Symbol

exports.EXPAND_KEY = EXPAND_KEY;
var CUSTOMIZED_KEY = '__customized-column__'; // TODO:Symbol

exports.CUSTOMIZED_KEY = CUSTOMIZED_KEY;
var AGGREGATION_EXPAND_CELL_KEY = '__aggregation-expand-cell__'; // TODO:Symbol

exports.AGGREGATION_EXPAND_CELL_KEY = AGGREGATION_EXPAND_CELL_KEY;

function columnFilter(column) {
  return Boolean(column);
} // function hasProperty<T>(target: T, property: string): (keyof T) is undefined {
//   return property in target;
// }


function getIdList(store) {
  var mouseBatchChooseStartId = store.mouseBatchChooseStartId,
      mouseBatchChooseEndId = store.mouseBatchChooseEndId,
      element = store.node.element,
      prefixCls = store.prefixCls;
  var rows = Array.from(element.querySelectorAll(".".concat(prefixCls, "-row")));
  var endId;
  var idList = [];
  rows.some(function (row) {
    var index = Number(row.dataset.index);

    if (!endId) {
      if (mouseBatchChooseStartId === index) {
        endId = mouseBatchChooseEndId;
      } else if (mouseBatchChooseEndId === index) {
        endId = mouseBatchChooseStartId;
      }
    }

    if (endId) {
      idList.push(index);
    }

    return endId === index;
  });
  return idList;
}

function getRowNumbers(record, dataSet, isTree) {
  if (record && dataSet) {
    var paging = dataSet.paging,
        currentPage = dataSet.currentPage,
        pageSize = dataSet.pageSize;
    var pageIndex = (isTree ? paging === 'server' : paging) ? (currentPage - 1) * pageSize : 0;

    if (isTree) {
      return record.path.map(function (r, index) {
        return r.indexInParent + 1 + (index === 0 ? pageIndex : 0);
      });
    }

    return [record.index + 1 + pageIndex];
  }

  return [0];
}

function hasCheckField(_ref, checkField) {
  var editor = _ref.editor,
      name = _ref.name,
      hidden = _ref.hidden;
  return !hidden && !!editor && checkField === name;
}

function _renderSelectionBox(_ref2) {
  var record = _ref2.record,
      store = _ref2.store;
  var dataSet = record.dataSet;

  if (dataSet) {
    var selection = dataSet.selection;

    var handleChange = function handleChange(value) {
      if (store.props.selectionMode === _enum2.SelectionMode.mousedown) {
        // 将处理逻辑交给 mousedown 的处理逻辑 不然会两次触发导致不被勾选上
        return;
      }

      if (value) {
        dataSet.select(record);
      } else {
        dataSet.unSelect(record);
      }
    };

    var handleClick = function handleClick(e) {
      (0, _EventManager.stopPropagation)(e);

      if (selection === _enum.DataSetSelection.multiple) {
        var lastSelected = store.lastSelected;

        if (lastSelected) {
          var nativeEvent = e.nativeEvent;
          var startIndex = -1;
          var endIndex = -1;

          if (nativeEvent.shiftKey) {
            var pointKeys = new Set([lastSelected.key, record.key]);
            dataSet.some(function (pointRecord, index) {
              if (pointKeys.has(pointRecord.key)) {
                if (startIndex === -1) {
                  startIndex = index;
                } else {
                  endIndex = index;
                  return true;
                }
              }

              return false;
            });
          }

          if (endIndex !== -1 && startIndex !== endIndex) {
            // Batch update selections
            var rangeRecords = dataSet.slice(startIndex, endIndex + 1);
            var changedRecords = [];
            var selectedKeys = new Set(dataSet.selected.map(function (selected) {
              return selected.key;
            }));

            if (record.isSelected) {
              rangeRecords.forEach(function (rangeRecord) {
                if (selectedKeys.has(rangeRecord.key)) {
                  changedRecords.push(rangeRecord);
                }
              });
              dataSet.batchUnSelect(changedRecords);
            } else {
              rangeRecords.forEach(function (rangeRecord) {
                if (!selectedKeys.has(rangeRecord.key)) {
                  changedRecords.push(rangeRecord);
                }
              });
              dataSet.batchSelect(changedRecords);
            }
          }
        }

        store.lastSelected = record;
      } else if (record.isSelected) {
        dataSet.unSelect(record);
      }
    };

    if (selection === _enum.DataSetSelection.multiple) {
      var batchSelectProps = {};
      var handleDragMouseUp = (0, _mobx.action)(function () {
        var mouseBatchChooseIdList = store.mouseBatchChooseIdList;

        if (store.mouseBatchChooseState) {
          store.mouseBatchChooseState = false;
          store.changeMouseBatchChooseIdList([]);
          var mouseBatchChooseStartId = store.mouseBatchChooseStartId,
              mouseBatchChooseEndId = store.mouseBatchChooseEndId;

          if (mouseBatchChooseStartId === mouseBatchChooseEndId) {
            return;
          }

          var startRecord = dataSet.findRecordById(mouseBatchChooseStartId);

          var _ref3 = startRecord || {},
              isSelected = _ref3.isSelected;

          if (isSelected) {
            dataSet.batchUnSelect(mouseBatchChooseIdList);
          } else {
            dataSet.batchSelect(mouseBatchChooseIdList);
          }
        }

        document.removeEventListener('pointerup', handleDragMouseUp);
      });

      if (store.useMouseBatchChoose) {
        batchSelectProps.onMouseDown = (0, _mobx.action)(function () {
          store.mouseBatchChooseStartId = record.id;
          store.mouseBatchChooseEndId = record.id;
          store.mouseBatchChooseState = true; // 为什么使用 pointerup
          // 因为需要对disabled的元素进行特殊处理
          // 因为状态的改变依赖 mouseup 而在disabled的元素上 无法触发mouseup事件
          // 导致状态无法进行修正
          // 以下两种方案通过 pointer-events:none 进行处理
          // https://stackoverflow.com/questions/322378/javascript-check-if-mouse-button-down
          // https://stackoverflow.com/questions/62081666/the-event-of-the-document-is-not-triggered-when-it-is-on-a-disabled-element
          // 而使用指针事件可以突破disabled的限制
          // https://stackoverflow.com/questions/62126515/how-to-get-the-state-of-the-mouse-through-javascript/62127845#62127845

          document.addEventListener('pointerup', handleDragMouseUp);
        });

        batchSelectProps.onMouseEnter = function () {
          if (store.mouseBatchChooseState) {
            store.mouseBatchChooseEndId = record.id;
            store.changeMouseBatchChooseIdList(getIdList(store));
          }
        };
      }

      return _react["default"].createElement(_CheckBox["default"], (0, _extends2["default"])({}, batchSelectProps, {
        checked: record.isSelected,
        onChange: handleChange,
        onClick: handleClick,
        disabled: !record.selectable,
        "data-selection-key": SELECTION_KEY,
        value: true
      }));
    }

    if (selection === _enum.DataSetSelection.single) {
      return _react["default"].createElement(_Radio["default"], {
        checked: record.isSelected,
        onChange: handleChange,
        onClick: handleClick,
        disabled: !record.selectable,
        "data-selection-key": SELECTION_KEY,
        value: true
      });
    }
  }
}

function mergeDefaultProps(originalColumns, tableAggregation, customizedColumns) {
  var parent = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
  var defaultKey = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : [0];
  var columnSort = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {
    left: 0,
    center: 0,
    right: 0
  };
  var columns = [];
  var leftColumns = [];
  var rightColumns = [];
  var hasAggregationColumn = false;
  originalColumns.forEach(function (column) {
    if ((0, _isPlainObject["default"])(column)) {
      var newColumn = (0, _objectSpread2["default"])({}, _Column.ColumnDefaultProps, {}, column);

      if ((0, _isNil["default"])((0, _utils.getColumnKey)(newColumn))) {
        newColumn.key = "anonymous-".concat(defaultKey[0]++);
      }

      var children = newColumn.children,
          aggregation = newColumn.aggregation;

      if (!hasAggregationColumn && aggregation) {
        hasAggregationColumn = true;
      }

      if (tableAggregation || !aggregation) {
        if (customizedColumns) {
          (0, _extends2["default"])(newColumn, customizedColumns[(0, _utils.getColumnKey)(newColumn).toString()]);
        }

        if (parent) {
          newColumn.lock = parent.lock;
        }

        if (children) {
          var _mergeDefaultProps = mergeDefaultProps(children, tableAggregation, customizedColumns, newColumn, defaultKey),
              _mergeDefaultProps2 = (0, _slicedToArray2["default"])(_mergeDefaultProps, 4),
              childrenColumns = _mergeDefaultProps2[1],
              childrenHasAffregationColumn = _mergeDefaultProps2[3];

          newColumn.children = childrenColumns;

          if (!hasAggregationColumn && childrenHasAffregationColumn) {
            hasAggregationColumn = childrenHasAffregationColumn;
          }
        }

        if (parent || !newColumn.lock) {
          if (newColumn.sort === undefined) {
            newColumn.sort = columnSort.center;
          }

          columnSort.center++;
          columns.push(newColumn);
        } else if (newColumn.lock === true || newColumn.lock === _enum2.ColumnLock.left) {
          if (newColumn.sort === undefined) {
            newColumn.sort = columnSort.left;
          }

          columnSort.left++;
          leftColumns.push(newColumn);
        } else {
          if (newColumn.sort === undefined) {
            newColumn.sort = columnSort.right;
          }

          columnSort.right++;
          rightColumns.push(newColumn);
        }
      } else if (children) {
        var _mergeDefaultProps3 = mergeDefaultProps(children, tableAggregation, customizedColumns, parent, defaultKey, parent ? undefined : columnSort),
            _mergeDefaultProps4 = (0, _slicedToArray2["default"])(_mergeDefaultProps3, 4),
            nodes = _mergeDefaultProps4[1],
            _childrenHasAffregationColumn = _mergeDefaultProps4[3];

        if (!hasAggregationColumn && _childrenHasAffregationColumn) {
          hasAggregationColumn = _childrenHasAffregationColumn;
        }

        if (parent) {
          parent.children = nodes;
        } else {
          nodes.forEach(function (node) {
            if (!node.lock) {
              columns.push(node);
            } else if (node.lock === true || node.lock === _enum2.ColumnLock.left) {
              leftColumns.push(node);
            } else {
              rightColumns.push(node);
            }
          });
        }
      }
    }
  }, []);

  if (parent) {
    return [[], (0, _sortBy["default"])(columns, function (_ref4) {
      var sort = _ref4.sort;
      return sort;
    }), [], hasAggregationColumn];
  }

  return [(0, _sortBy["default"])(leftColumns, function (_ref5) {
    var sort = _ref5.sort;
    return sort;
  }), (0, _sortBy["default"])(columns, function (_ref6) {
    var sort = _ref6.sort;
    return sort;
  }), (0, _sortBy["default"])(rightColumns, function (_ref7) {
    var sort = _ref7.sort;
    return sort;
  }), hasAggregationColumn];
}

function normalizeColumns(elements, tableAggregation, customizedColumns) {
  var parent = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
  var defaultKey = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : [0];
  var columnSort = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {
    left: 0,
    center: 0,
    right: 0
  };
  var columns = [];
  var leftColumns = [];
  var rightColumns = [];
  var hasAggregationColumn = false;

  var normalizeColumn = function normalizeColumn(element) {
    if ((0, _react.isValidElement)(element)) {
      var props = element.props,
          key = element.key,
          type = element.type;

      if ((0, _isFragment["default"])(element)) {
        var children = props.children;

        if (children) {
          _react.Children.forEach(children, normalizeColumn);
        }
      } else if (type.__PRO_TABLE_COLUMN) {
        var column = (0, _objectSpread2["default"])({}, props);

        if (key) {
          column.key = key;
        } else if ((0, _isNil["default"])((0, _utils.getColumnKey)(column))) {
          column.key = "anonymous-".concat(defaultKey[0]++);
        }

        var _children = column.children,
            aggregation = column.aggregation;

        if (!hasAggregationColumn && aggregation) {
          hasAggregationColumn = true;
        }

        if (tableAggregation || !aggregation) {
          if (customizedColumns) {
            (0, _extends2["default"])(column, customizedColumns[(0, _utils.getColumnKey)(column).toString()]);
          }

          if (parent) {
            column.lock = parent.lock;
          }

          var _normalizeColumns = normalizeColumns(_children, tableAggregation, customizedColumns, column, defaultKey),
              _normalizeColumns2 = (0, _slicedToArray2["default"])(_normalizeColumns, 4),
              childrenColumns = _normalizeColumns2[1],
              childrenHasAffregationColumn = _normalizeColumns2[3];

          column.children = childrenColumns;

          if (!hasAggregationColumn && childrenHasAffregationColumn) {
            hasAggregationColumn = childrenHasAffregationColumn;
          }

          if (parent || !column.lock) {
            if (column.sort === undefined) {
              column.sort = columnSort.center;
            }

            columnSort.center++;
            columns.push(column);
          } else if (column.lock === true || column.lock === _enum2.ColumnLock.left) {
            if (column.sort === undefined) {
              column.sort = columnSort.left;
            }

            columnSort.left++;
            leftColumns.push(column);
          } else {
            if (column.sort === undefined) {
              column.sort = columnSort.right;
            }

            columnSort.right++;
            rightColumns.push(column);
          }
        } else {
          var _normalizeColumns3 = normalizeColumns(_children, tableAggregation, customizedColumns, parent, defaultKey, parent ? undefined : columnSort),
              _normalizeColumns4 = (0, _slicedToArray2["default"])(_normalizeColumns3, 4),
              nodes = _normalizeColumns4[1],
              _childrenHasAffregationColumn2 = _normalizeColumns4[3];

          if (!hasAggregationColumn && _childrenHasAffregationColumn2) {
            hasAggregationColumn = _childrenHasAffregationColumn2;
          }

          if (parent) {
            parent.children = nodes;
          } else {
            nodes.forEach(function (node) {
              if (!node.lock) {
                columns.push(node);
              } else if (node.lock === true || node.lock === _enum2.ColumnLock.left) {
                leftColumns.push(node);
              } else {
                rightColumns.push(node);
              }
            });
          }
        }
      }
    }
  };

  _react.Children.forEach(elements, normalizeColumn);

  if (parent) {
    return [[], (0, _sortBy["default"])(columns, function (_ref8) {
      var sort = _ref8.sort;
      return sort;
    }), [], hasAggregationColumn];
  }

  return [(0, _sortBy["default"])(leftColumns, function (_ref9) {
    var sort = _ref9.sort;
    return sort;
  }), (0, _sortBy["default"])(columns, function (_ref10) {
    var sort = _ref10.sort;
    return sort;
  }), (0, _sortBy["default"])(rightColumns, function (_ref11) {
    var sort = _ref11.sort;
    return sort;
  }), hasAggregationColumn];
}

function getHeaderTexts(_x, _x2, _x3) {
  return _getHeaderTexts.apply(this, arguments);
}

function _getHeaderTexts() {
  _getHeaderTexts = (0, _asyncToGenerator2["default"])(
  /*#__PURE__*/
  _regenerator["default"].mark(function _callee3(dataSet, columns, aggregation) {
    var headers,
        column,
        _args3 = arguments;
    return _regenerator["default"].wrap(function _callee3$(_context3) {
      while (1) {
        switch (_context3.prev = _context3.next) {
          case 0:
            headers = _args3.length > 3 && _args3[3] !== undefined ? _args3[3] : [];
            column = columns.shift();

            if (!column) {
              _context3.next = 10;
              break;
            }

            _context3.t0 = headers;
            _context3.t1 = column.name;
            _context3.next = 7;
            return (0, _getReactNodeText["default"])((0, _utils.getHeader)(column, dataSet, aggregation));

          case 7:
            _context3.t2 = _context3.sent;
            _context3.t3 = {
              name: _context3.t1,
              label: _context3.t2
            };

            _context3.t0.push.call(_context3.t0, _context3.t3);

          case 10:
            if (!columns.length) {
              _context3.next = 13;
              break;
            }

            _context3.next = 13;
            return getHeaderTexts(dataSet, columns, aggregation, headers);

          case 13:
            return _context3.abrupt("return", headers);

          case 14:
          case "end":
            return _context3.stop();
        }
      }
    }, _callee3);
  }));
  return _getHeaderTexts.apply(this, arguments);
}

var TableStore =
/*#__PURE__*/
function () {
  function TableStore(node) {
    var _this = this;

    (0, _classCallCheck2["default"])(this, TableStore);
    this.editors = new Map();
    this.mouseBatchChooseStartId = 0;
    this.mouseBatchChooseEndId = 0;
    this.inBatchExpansion = false;
    this.performanceOn = false;
    this.timing = {
      renderStart: 0,
      renderEnd: 0
    };
    this.handleSelectAllChange = (0, _mobx.action)(function (value) {
      var _this$props = _this.props,
          dataSet = _this$props.dataSet,
          filter = _this$props.filter;
      var isSelectAll = value ? dataSet.currentSelected.length === dataSet.records.filter(function (record) {
        return record.selectable;
      }).length : !value;

      if (!isSelectAll) {
        dataSet.selectAll(filter);
      } else {
        dataSet.unSelectAll();

        if (_this.showCachedSelection) {
          dataSet.clearCachedSelected();
        }
      }
    });
    this.saveCustomizedDebounce = (0, _debounce["default"])(this.saveCustomized, 1000);
    (0, _mobx.runInAction)(function () {
      _this.scrollPosition = _enum2.ScrollPosition.left;
      _this.mouseBatchChooseIdList = [];
      _this.mouseBatchChooseState = false;
      _this.showCachedSelection = false;
      _this.lockColumnsHeadRowsHeight = {};
      _this.lockColumnsBodyRowsHeight = {};
      _this.lockColumnsFootRowsHeight = {};
      _this.node = node;
      _this.expandedRows = [];
      _this.lastScrollTop = 0;
      _this.customizedActiveKey = ['columns'];
      _this.leftOriginalColumns = [];
      _this.originalColumns = [];
      _this.rightOriginalColumns = [];
      _this.tempCustomized = {
        columns: {}
      };
      _this.customized = {
        columns: {}
      };

      _this.setProps(node.props);

      if (_this.customizable) {
        _this.loadCustomized().then(_this.handleLoadCustomized);
      } else {
        _this.initColumns();
      }
    });
  }

  (0, _createClass2["default"])(TableStore, [{
    key: "customizedColumnHeader",
    value: function customizedColumnHeader() {
      return _react["default"].createElement(_CustomizationColumnHeader["default"], {
        onHeaderClick: this.openCustomizationModal
      });
    }
  }, {
    key: "handleLoadCustomized",
    value: function handleLoadCustomized() {
      this.initColumns();
      var _this$props2 = this.props,
          onAggregationChange = _this$props2.onAggregationChange,
          aggregation = _this$props2.aggregation;
      var customAggregation = this.customized.aggregation;

      if (onAggregationChange && customAggregation !== undefined && customAggregation !== aggregation) {
        onAggregationChange(customAggregation);
      }
    }
  }, {
    key: "isBuiltInColumn",
    value: function isBuiltInColumn(_ref12) {
      var key = _ref12.key;

      if ((0, _isString["default"])(key)) {
        return [DRAG_KEY, SELECTION_KEY, ROW_NUMBER_KEY, CUSTOMIZED_KEY, EXPAND_KEY].includes(key);
      }
    }
  }, {
    key: "getColumnTooltip",
    value: function getColumnTooltip(column) {
      var tooltip = column.tooltip;

      if (tooltip) {
        return tooltip;
      }

      return (0, _TooltipUtils.getTooltip)('table-cell');
    }
  }, {
    key: "getColumnHeaders",
    value: function getColumnHeaders() {
      var leafNamedColumns = this.leafNamedColumns,
          dataSet = this.dataSet;
      return getHeaderTexts(dataSet, leafNamedColumns.slice(), this.aggregation);
    }
  }, {
    key: "showEditor",
    value: function showEditor(name) {
      this.currentEditorName = name;
    }
  }, {
    key: "setLastScrollTop",
    value: function setLastScrollTop(lastScrollTop) {
      this.lastScrollTop = lastScrollTop;
    }
  }, {
    key: "hideEditor",
    value: function hideEditor() {
      this.currentEditorName = undefined;
    }
  }, {
    key: "changeMouseBatchChooseIdList",
    value: function changeMouseBatchChooseIdList(idList) {
      this.mouseBatchChooseIdList = idList;
    }
  }, {
    key: "showNextEditor",
    value: function showNextEditor(name, reserve) {
      if (reserve) {
        this.dataSet.pre();
      } else {
        this.dataSet.next();
      }

      this.showEditor(name);
    }
  }, {
    key: "setProps",
    value: function setProps(props) {
      this.props = props;
      var showCachedSelection = props.showCachedSelection;

      if (showCachedSelection !== undefined) {
        this.showCachedSelection = showCachedSelection;
      }
    }
  }, {
    key: "updateProps",
    value: function updateProps(props) {
      var customizedCode = this.props.customizedCode;
      this.setProps(props);

      if (this.customizable) {
        if (customizedCode !== props.customizedCode) {
          this.loadCustomized().then(this.handleLoadCustomized);
          return;
        }

        var aggregation = props.aggregation;
        var customized = this.customized;

        if (!(0, _isNil["default"])(aggregation) && aggregation !== customized.aggregation) {
          customized.aggregation = aggregation;
          this.saveCustomized();
        }
      }

      this.initColumns();
    }
  }, {
    key: "initColumns",
    value: function initColumns() {
      var customized = this.customized,
          customizable = this.customizable,
          aggregation = this.aggregation,
          selectionColumn = this.selectionColumn;
      var _this$props3 = this.props,
          columns = _this$props3.columns,
          children = _this$props3.children,
          rowBoxPlacement = _this$props3.rowBoxPlacement;
      var customizedColumns = customizable ? customized.columns : undefined;

      var _ref13 = columns ? mergeDefaultProps(columns, aggregation, customizedColumns) : normalizeColumns(children, aggregation, customizedColumns),
          _ref14 = (0, _slicedToArray2["default"])(_ref13, 4),
          leftOriginalColumns = _ref14[0],
          originalColumns = _ref14[1],
          rightOriginalColumns = _ref14[2],
          hasAggregationColumn = _ref14[3];

      if ((0, _isNumber["default"])(rowBoxPlacement) && this.hasRowBox) {
        originalColumns.splice(rowBoxPlacement, 0, selectionColumn);
      }

      this.leftOriginalColumns = leftOriginalColumns;
      this.originalColumns = originalColumns;
      this.rightOriginalColumns = rightOriginalColumns;
      this.hasAggregationColumn = hasAggregationColumn;
    }
  }, {
    key: "isAggregationCellExpanded",
    value: function isAggregationCellExpanded(record, key) {
      var expandedKeys = record.getState(AGGREGATION_EXPAND_CELL_KEY);

      if (expandedKeys) {
        return expandedKeys.includes(key);
      }

      return false;
    }
  }, {
    key: "setAggregationCellExpanded",
    value: function setAggregationCellExpanded(record, key, expanded) {
      var expandedKeys = record.getState(AGGREGATION_EXPAND_CELL_KEY) || [];
      var index = expandedKeys.indexOf(key);

      if (expanded) {
        if (index === -1) {
          expandedKeys.push(key);
        }
      } else if (index !== -1) {
        expandedKeys.splice(index, 1);
      }

      record.setState(AGGREGATION_EXPAND_CELL_KEY, expandedKeys);
    }
  }, {
    key: "isRowExpanded",
    value: function isRowExpanded(record) {
      var _record$isExpanded = record.isExpanded,
          isExpanded = _record$isExpanded === void 0 ? this.expandedRows.indexOf(record.key) !== -1 : _record$isExpanded;
      return isExpanded && (!this.isTree || !record.parent || this.isRowExpanded(record.parent));
    }
    /**
     *
     * @param record 想修改的record
     * @param expanded 设置是否展开
     * @param disHandler 设置是否需要触发展开事件
     */

  }, {
    key: "setRowExpanded",
    value: function setRowExpanded(record, expanded, disHandler) {
      record.isExpanded = expanded;

      if (!this.inBatchExpansion) {
        var index = this.expandedRows.indexOf(record.key);

        if (expanded) {
          if (index === -1) {
            this.expandedRows.push(record.key);
          }
        } else if (index !== -1) {
          this.expandedRows.splice(index, 1);
        }
      }

      var onExpand = this.props.onExpand;

      if (onExpand && !disHandler) {
        onExpand(expanded, record);
      }

      if (expanded && this.canTreeLoadData) {
        this.onTreeNodeLoad({
          record: record
        });
      }
    }
  }, {
    key: "isRowPending",
    value: function isRowPending(record) {
      return record.pending === true;
    }
  }, {
    key: "setRowPending",
    value: function setRowPending(record, pending) {
      record.pending = pending;
    }
  }, {
    key: "isRowLoaded",
    value: function isRowLoaded(record) {
      return record.childrenLoaded === true;
    }
  }, {
    key: "setRowLoaded",
    value: function setRowLoaded(record, loaded) {
      record.childrenLoaded = loaded;
    }
  }, {
    key: "isRowHover",
    value: function isRowHover(record) {
      return this.hoverRow === record;
    }
  }, {
    key: "setRowHover",
    value: function setRowHover(record, hover) {
      this.hoverRow = hover ? record : undefined;
    }
  }, {
    key: "expandAll",
    value: function expandAll() {
      var _this2 = this;

      this.inBatchExpansion = true;
      this.expandedRows = this.dataSet.records.map(function (record) {
        _this2.setRowExpanded(record, true);

        return record.key;
      });
      this.inBatchExpansion = false;
    }
  }, {
    key: "collapseAll",
    value: function collapseAll() {
      var _this3 = this;

      this.inBatchExpansion = true;
      this.dataSet.records.forEach(function (record) {
        return _this3.setRowExpanded(record, false);
      });
      this.expandedRows = [];
      this.inBatchExpansion = false;
    }
  }, {
    key: "onTreeNodeLoad",
    value: function () {
      var _onTreeNodeLoad = (0, _asyncToGenerator2["default"])(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee(_ref15) {
        var record, _this$props4, dataSet, treeLoadData, treeAsync, promises;

        return _regenerator["default"].wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                record = _ref15.record;
                _this$props4 = this.props, dataSet = _this$props4.dataSet, treeLoadData = _this$props4.treeLoadData, treeAsync = _this$props4.treeAsync;
                promises = [];
                this.setRowPending(record, true);

                if (treeAsync && dataSet) {
                  promises.push(dataSet.queryMoreChild(record));
                }

                if (treeLoadData) {
                  promises.push(treeLoadData({
                    record: record,
                    dataSet: dataSet
                  }));
                }

                _context.prev = 6;
                _context.next = 9;
                return Promise.all(promises);

              case 9:
                this.setRowLoaded(record, true);

              case 10:
                _context.prev = 10;
                this.setRowPending(record, false);
                return _context.finish(10);

              case 13:
              case "end":
                return _context.stop();
            }
          }
        }, _callee, this, [[6,, 10, 13]]);
      }));

      function onTreeNodeLoad(_x4) {
        return _onTreeNodeLoad.apply(this, arguments);
      }

      return onTreeNodeLoad;
    }()
  }, {
    key: "renderSelectionBox",
    value: function renderSelectionBox(_ref16) {
      var record = _ref16.record;
      return _renderSelectionBox({
        record: record,
        store: this
      });
    }
  }, {
    key: "renderRowNumber",
    value: function renderRowNumber(_ref17) {
      var record = _ref17.record,
          dataSet = _ref17.dataSet;
      var isTree = this.isTree,
          rowNumber = this.props.rowNumber;
      var numbers = getRowNumbers(record, dataSet, isTree);
      var number = numbers.join('-');

      if (typeof rowNumber === 'function') {
        return rowNumber({
          record: record,
          dataSet: dataSet,
          text: number,
          pathNumbers: numbers
        });
      }

      return number;
    }
  }, {
    key: "renderDragBox",
    value: function renderDragBox(_ref18) {
      var record = _ref18.record;
      var rowDragRender = this.props.rowDragRender;

      if (rowDragRender && (0, _isFunction["default"])(rowDragRender.renderIcon)) {
        return rowDragRender.renderIcon({
          record: record
        });
      }

      return _react["default"].createElement(_icon["default"], {
        type: "baseline-drag_indicator"
      });
    }
  }, {
    key: "changeCustomizedColumnValue",
    value: function changeCustomizedColumnValue(column, value) {
      var columns = this.customized.columns;
      (0, _mobx.set)(column, value);
      var columnKey = (0, _utils.getColumnKey)(column).toString();
      var oldCustomized = (0, _mobx.get)(columns, columnKey);
      (0, _mobx.set)(columns, columnKey, (0, _objectSpread2["default"])({}, oldCustomized, {}, value));
      this.saveCustomizedDebounce();
    }
  }, {
    key: "saveCustomized",
    value: function saveCustomized(customized) {
      if (this.customizable && this.customizedLoaded) {
        var customizedCode = this.props.customizedCode;

        if (customized) {
          this.customized = customized;
        }

        if (customizedCode) {
          var tableCustomizedSave = (0, _configure.getConfig)('tableCustomizedSave') || (0, _configure.getConfig)('customizedSave');
          tableCustomizedSave(customizedCode, this.customized, 'Table');
        }
      }
    }
  }, {
    key: "openCustomizationModal",
    value: function openCustomizationModal(modal) {
      var element = this.node.element,
          height = this.height;

      if (height === undefined) {
        this.totalHeight = element.offsetHeight;
      }

      var customizedCode = this.props.customizedCode;
      var modalProps = {
        drawer: true,
        size: _enum3.Size.small,
        title: (0, _localeContext.$l)('Table', 'customization_settings'),
        children: _react["default"].createElement(_CustomizationSettings["default"], null),
        bodyStyle: {
          overflow: 'hidden auto',
          padding: 0
        }
      };

      if (customizedCode) {
        modalProps.okText = (0, _localeContext.$l)('Table', 'save_button');
      }

      modal.open(modalProps);
    }
  }, {
    key: "loadCustomized",
    value: function () {
      var _loadCustomized = (0, _asyncToGenerator2["default"])(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee2() {
        var _this4 = this;

        var customizedCode, tableCustomizedLoad, customized;
        return _regenerator["default"].wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                customizedCode = this.props.customizedCode;

                if (!(this.customizable && customizedCode)) {
                  _context2.next = 13;
                  break;
                }

                tableCustomizedLoad = (0, _configure.getConfig)('tableCustomizedLoad') || (0, _configure.getConfig)('customizedLoad');
                (0, _mobx.runInAction)(function () {
                  delete _this4.customizedLoaded;
                  _this4.loading = true;
                });
                _context2.prev = 4;
                _context2.next = 7;
                return tableCustomizedLoad(customizedCode, 'Table');

              case 7:
                customized = _context2.sent;
                (0, _mobx.runInAction)(function () {
                  _this4.customized = (0, _objectSpread2["default"])({
                    columns: {}
                  }, customized);
                });
                this.customizedLoaded = true;

              case 10:
                _context2.prev = 10;
                (0, _mobx.runInAction)(function () {
                  _this4.loading = false;
                });
                return _context2.finish(10);

              case 13:
              case "end":
                return _context2.stop();
            }
          }
        }, _callee2, this, [[4,, 10, 13]]);
      }));

      function loadCustomized() {
        return _loadCustomized.apply(this, arguments);
      }

      return loadCustomized;
    }()
  }, {
    key: "handleAllPageSelectionMenuClick",
    value: function handleAllPageSelectionMenuClick(_ref19) {
      var key = _ref19.key;
      var dataSet = this.dataSet;
      var isAllPageSelection = dataSet.isAllPageSelection;

      switch (key) {
        case 'current':
          {
            if (this.allChecked) {
              dataSet.unSelectAll();
            } else {
              var filter = this.props.filter;
              dataSet.selectAll(filter);
            }

            break;
          }

        case 'all':
          dataSet.setAllPageSelection(!isAllPageSelection);
          break;

        default:
      }
    }
  }, {
    key: "renderAllPageSelectionMenu",
    value: function renderAllPageSelectionMenu() {
      var isAllPageSelection = this.dataSet.isAllPageSelection,
          allChecked = this.allChecked,
          prefixCls = this.prefixCls;
      return _react["default"].createElement(_menu["default"], {
        prefixCls: "".concat(prefixCls, "-dropdown-menu"),
        onClick: this.handleAllPageSelectionMenuClick
      }, _react["default"].createElement(_menu["default"].Item, {
        key: "current"
      }, (0, _localeContext.$l)('Table', allChecked ? 'unselect_current_page' : 'select_current_page')), _react["default"].createElement(_menu["default"].Item, {
        key: "all"
      }, (0, _localeContext.$l)('Table', isAllPageSelection ? 'unselect_all_page' : 'select_all_page')));
    }
  }, {
    key: "multipleSelectionRenderer",
    value: function multipleSelectionRenderer() {
      var buttons = [_react["default"].createElement(_CheckBox["default"], {
        key: "selectAll",
        checked: this.allChecked,
        indeterminate: this.indeterminate,
        onChange: this.handleSelectAllChange,
        value: true
      })];

      if (this.props.showAllPageSelectionButton) {
        buttons.push(_react["default"].createElement(_Dropdown["default"], {
          key: "selectAllPage",
          overlay: this.renderAllPageSelectionMenu
        }, _react["default"].createElement(_icon["default"], {
          type: "baseline-arrow_drop_down"
        })));
      }

      return buttons;
    }
  }, {
    key: "bodyHeight",
    get: function get() {
      return this.virtual ? this.virtualHeight : this.calcBodyHeight;
    }
  }, {
    key: "stickyLeft",
    get: function get() {
      return [_enum2.ScrollPosition.right, _enum2.ScrollPosition.middle].includes(this.scrollPosition);
    }
  }, {
    key: "stickyRight",
    get: function get() {
      return [_enum2.ScrollPosition.left, _enum2.ScrollPosition.middle].includes(this.scrollPosition);
    }
  }, {
    key: "performanceEnabled",
    get: function get() {
      var performanceEnabled = (0, _configure.getConfig)('performanceEnabled');
      return performanceEnabled && performanceEnabled.Table;
    }
  }, {
    key: "dataSet",
    get: function get() {
      return this.props.dataSet;
    }
  }, {
    key: "prefixCls",
    get: function get() {
      var _this$props5 = this.props,
          suffixCls = _this$props5.suffixCls,
          prefixCls = _this$props5.prefixCls;
      return (0, _configure.getProPrefixCls)(suffixCls, prefixCls);
    }
  }, {
    key: "customizable",
    get: function get() {
      var customizedCode = this.props.customizedCode;

      if (customizedCode && (this.columnTitleEditable || this.columnDraggable || this.columnHideable)) {
        if ('customizable' in this.props) {
          return this.props.customizable;
        }

        return (0, _configure.getConfig)('tableCustomizable') || (0, _configure.getCustomizable)('Table');
      }

      return false;
    }
  }, {
    key: "aggregation",
    get: function get() {
      var aggregation = this.customized.aggregation;

      if (aggregation !== undefined) {
        return aggregation;
      }

      var propAggregation = this.props.aggregation;
      return propAggregation;
    }
  }, {
    key: "aggregationExpandType",
    get: function get() {
      return this.customized.aggregationExpandType || 'cell';
    }
  }, {
    key: "autoHeight",
    get: function get() {
      var autoHeight = this.props.autoHeight;

      if (autoHeight) {
        var defaultAutoHeight = {
          type: _enum2.TableAutoHeightType.minHeight,
          diff: (0, _configure.getConfig)('tableAutoHeightDiff') || 80
        };

        if ((0, _isObject["default"])(autoHeight)) {
          return (0, _objectSpread2["default"])({}, defaultAutoHeight, {}, autoHeight);
        }

        return defaultAutoHeight;
      }

      return undefined;
    }
  }, {
    key: "heightType",
    get: function get() {
      var tempHeightType = (0, _mobx.get)(this.tempCustomized, 'heightType');

      if (tempHeightType !== undefined) {
        return tempHeightType;
      }

      var heightType = this.customized.heightType;

      if (heightType !== undefined) {
        return heightType;
      }

      return this.originalHeightType;
    }
  }, {
    key: "originalHeightType",
    get: function get() {
      var _this$props6 = this.props,
          style = _this$props6.style,
          autoHeight = _this$props6.autoHeight;

      if (autoHeight) {
        return _enum2.TableHeightType.flex;
      }

      if (style) {
        var height = style.height;

        if ((0, _isString["default"])(height) && (0, _UnitConvertor.isCalcSize)(height)) {
          return _enum2.TableHeightType.flex;
        }

        if ((0, _isNumber["default"])((0, _UnitConvertor.toPx)(height))) {
          return _enum2.TableHeightType.fixed;
        }
      }

      return _enum2.TableHeightType.auto;
    }
  }, {
    key: "virtualCell",
    get: function get() {
      if ('virtualCell' in this.props) {
        return this.props.virtualCell;
      }

      return (0, _configure.getConfig)('tableVirtualCell');
    }
    /**
     * number 矫正虚拟滚动由于样式问题导致的高度不符问题
     */

  }, {
    key: "virtualRowHeight",
    get: function get() {
      var virtualRowHeight = this.props.virtualRowHeight;

      if (virtualRowHeight) {
        return virtualRowHeight;
      }

      return (0, _isNumber["default"])(this.rowHeight) ? this.rowHeight + 3 : 33;
    }
  }, {
    key: "virtual",
    get: function get() {
      if (this.height !== undefined && (0, _isNumber["default"])(this.virtualRowHeight)) {
        if ('virtual' in this.props) {
          return this.props.virtual;
        }

        return (0, _configure.getConfig)('tableVirtual');
      }

      return false;
    }
  }, {
    key: "virtualHeight",
    get: function get() {
      var virtualRowHeight = this.virtualRowHeight,
          data = this.data;
      return Math.round(data.length * virtualRowHeight);
    }
  }, {
    key: "virtualStartIndex",
    get: function get() {
      var virtualRowHeight = this.virtualRowHeight,
          lastScrollTop = this.lastScrollTop;
      return Math.max(Math.round(lastScrollTop / virtualRowHeight - 3), 0);
    }
  }, {
    key: "virtualEndIndex",
    get: function get() {
      var virtualRowHeight = this.virtualRowHeight,
          lastScrollTop = this.lastScrollTop,
          height = this.height,
          data = this.data;
      return Math.min(height !== undefined ? Math.round((lastScrollTop + height) / virtualRowHeight) + 3 : Infinity, data.length);
    }
  }, {
    key: "virtualTop",
    get: function get() {
      var virtualRowHeight = this.virtualRowHeight,
          virtualStartIndex = this.virtualStartIndex;
      return virtualStartIndex * virtualRowHeight;
    }
  }, {
    key: "virtualData",
    get: function get() {
      var data = this.data,
          virtual = this.virtual;

      if (virtual) {
        var virtualEndIndex = this.virtualEndIndex,
            virtualStartIndex = this.virtualStartIndex;
        return data.slice(virtualStartIndex, virtualEndIndex);
      }

      return data;
    }
  }, {
    key: "hidden",
    get: function get() {
      return this.styledHidden || this.props.hidden;
    }
  }, {
    key: "alwaysShowRowBox",
    get: function get() {
      if ('alwaysShowRowBox' in this.props) {
        return this.props.alwaysShowRowBox;
      }

      var alwaysShowRowBox = (0, _configure.getConfig)('tableAlwaysShowRowBox');

      if (typeof alwaysShowRowBox !== 'undefined') {
        return alwaysShowRowBox;
      }

      return false;
    }
  }, {
    key: "keyboard",
    get: function get() {
      if ('keyboard' in this.props) {
        return this.props.keyboard;
      }

      var keyboard = (0, _configure.getConfig)('tableKeyboard');

      if (typeof keyboard !== 'undefined') {
        return keyboard;
      }

      return false;
    }
  }, {
    key: "columnResizable",
    get: function get() {
      if (this.currentEditRecord) {
        return false;
      }

      if ('columnResizable' in this.props) {
        return this.props.columnResizable;
      }

      return (0, _configure.getConfig)('tableColumnResizable') !== false;
    }
  }, {
    key: "columnHideable",
    get: function get() {
      if ('columnHideable' in this.props) {
        return this.props.columnHideable;
      }

      return (0, _configure.getConfig)('tableColumnHideable') !== false;
    }
    /**
     * 表头支持编辑
     */

  }, {
    key: "columnTitleEditable",
    get: function get() {
      if ('columnTitleEditable' in this.props) {
        return this.props.columnTitleEditable;
      }

      return (0, _configure.getConfig)('tableColumnTitleEditable') === true;
    }
  }, {
    key: "pagination",
    get: function get() {
      if ('pagination' in this.props) {
        return this.props.pagination;
      }

      return (0, _configure.getConfig)('pagination');
    }
  }, {
    key: "dragColumnAlign",
    get: function get() {
      if ('dragColumnAlign' in this.props) {
        return this.props.dragColumnAlign;
      }

      return (0, _configure.getConfig)('tableDragColumnAlign');
    }
  }, {
    key: "columnDraggable",
    get: function get() {
      if ('columnDraggable' in this.props) {
        return this.props.columnDraggable;
      }

      if ('dragColumn' in this.props) {
        return this.props.dragColumn;
      }

      if ((0, _configure.getConfig)('tableColumnDraggable') === true) {
        return true;
      }

      return (0, _configure.getConfig)('tableDragColumn') === true;
    }
  }, {
    key: "rowDraggable",
    get: function get() {
      if (this.isTree) {
        return false;
      }

      if ('rowDraggable' in this.props) {
        return this.props.rowDraggable;
      }

      if ('dragRow' in this.props) {
        return this.props.dragRow;
      }

      if ((0, _configure.getConfig)('tableRowDraggable') === true) {
        return true;
      }

      return (0, _configure.getConfig)('tableDragRow') === true;
    }
  }, {
    key: "size",
    get: function get() {
      var size = this.customized.size;

      if (size !== undefined) {
        return size;
      }

      return this.props.size || _enum3.Size["default"];
    }
  }, {
    key: "rowHeight",
    get: function get() {
      var rowHeight = 30;

      if ('rowHeight' in this.props) {
        rowHeight = this.props.rowHeight;
      } else {
        var tableRowHeight = (0, _configure.getConfig)('tableRowHeight');

        if (typeof tableRowHeight !== 'undefined') {
          rowHeight = tableRowHeight;
        }
      }

      if ((0, _isNumber["default"])(rowHeight)) {
        switch (this.size) {
          case _enum3.Size.large:
            return rowHeight + 2;

          case _enum3.Size.small:
            return rowHeight - 2;

          default:
        }
      }

      return rowHeight;
    }
  }, {
    key: "autoFootHeight",
    get: function get() {
      if ('autoFootHeight' in this.props) {
        return this.props.autoFootHeight;
      }

      return false;
    }
  }, {
    key: "emptyText",
    get: function get() {
      return (0, _configure.getConfig)('renderEmpty')('Table');
    }
  }, {
    key: "highLightRow",
    get: function get() {
      if ('highLightRow' in this.props) {
        return this.props.highLightRow;
      }

      return (0, _configure.getConfig)('tableHighLightRow');
    }
  }, {
    key: "parityRow",
    get: function get() {
      var parityRow = this.customized.parityRow;

      if (parityRow !== undefined) {
        return parityRow;
      }

      if ('parityRow' in this.props) {
        return this.props.parityRow;
      }