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

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

import _regeneratorRuntime from "@babel/runtime/regenerator";
import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
import _createClass from "@babel/runtime/helpers/createClass";
import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
import _objectSpread from "@babel/runtime/helpers/objectSpread2";
import _extends from "@babel/runtime/helpers/extends";
import { __decorate } from "tslib";
import React, { Children, isValidElement } from 'react';
import { action, computed, get as _get, observable, runInAction, set } from 'mobx';
import sortBy from 'lodash/sortBy';
import debounce from 'lodash/debounce';
import isNil from 'lodash/isNil';
import isObject from 'lodash/isObject';
import isPlainObject from 'lodash/isPlainObject';
import isString from 'lodash/isString';
import isNumber from 'lodash/isNumber';
import defaultTo from 'lodash/defaultTo';
import measureScrollbar from '../../../es/_util/measureScrollbar';
import { isCalcSize, toPx } from '../../../es/_util/UnitConvertor';
import Icon from '../../../es/icon';
import isFunction from 'lodash/isFunction';
import noop from 'lodash/noop';
import { ColumnDefaultProps, defaultAggregationRenderer } from './Column';
import CustomizationSettings from './customization-settings/CustomizationSettings';
import isFragment from '../_util/isFragment';
import ObserverCheckBox from '../check-box/CheckBox';
import ObserverRadio from '../radio/Radio';
import { DataSetSelection } from '../data-set/enum';
import { ColumnAlign, ColumnLock, DragColumnAlign, GroupType, RowBoxPlacement, ScrollPosition, SelectionMode, TableAutoHeightType, TableColumnTooltip, TableEditMode, TableHeightType, TableMode } from './enum';
import { stopPropagation } from '../_util/EventManager';
import { getColumnKey, getHeader } from './utils';
import getReactNodeText from '../_util/getReactNodeText';
import ColumnGroups from './ColumnGroups';
import autobind from '../_util/autobind';
import { Size } from '../core/enum';
import { $l } from '../locale-context';
import CustomizationColumnHeader from './customization-settings/CustomizationColumnHeader';
import Dropdown from '../dropdown/Dropdown';
import Menu from '../menu';
import { treeSome } from '../_util/treeUtils';
import { getIf, normalizeGroups } from '../data-set/utils';
import BatchRunner from '../_util/BatchRunner';
import { LabelLayout } from '../form/enum';
export var SELECTION_KEY = '__selection-column__'; // TODO:Symbol

export var ROW_NUMBER_KEY = '__row-number-column__'; // TODO:Symbol

export var DRAG_KEY = '__drag-column__'; // TODO:Symbol

export var EXPAND_KEY = '__expand-column__'; // TODO:Symbol

export var CUSTOMIZED_KEY = '__customized-column__'; // TODO:Symbol

export var AGGREGATION_EXPAND_CELL_KEY = '__aggregation-expand-cell__'; // TODO:Symbol

export var BODY_EXPANDED = '__body_expanded__'; // TODO:Symbol

export var VIRTUAL_ROOT_MARGIN = 50;

function columnFilter(column) {
  return Boolean(column);
}

function getOverScanCount(tableStore, index, next) {
  var rowMetaData = tableStore.rowMetaData;

  if (rowMetaData) {
    var count = 0;
    var height = 0;

    while (height < VIRTUAL_ROOT_MARGIN) {
      index += next ? 1 : -1;
      var metaData = rowMetaData[index];

      if (!metaData) {
        return count;
      }

      height += metaData.height;
      count++;
    }

    return count;
  }

  return Math.ceil(VIRTUAL_ROOT_MARGIN / tableStore.virtualRowHeight);
}

function getItemMetadata(rowMetaData, index, tableStore) {
  var lastMeasuredIndex = tableStore.lastMeasuredIndex;

  if (index > lastMeasuredIndex) {
    tableStore.lastMeasuredIndex = index;
  }

  return rowMetaData[index];
}

function findNearestItemBinarySearch(rowMetaData, tableStore, high, low, offset) {
  while (low <= high) {
    var middle = low + Math.floor((high - low) / 2);
    var item = getItemMetadata(rowMetaData, middle, tableStore);

    if (!item) {
      return 0;
    }

    var currentOffset = item.offset;

    if (currentOffset === offset) {
      return middle;
    }

    if (currentOffset < offset) {
      low = middle + 1;
    }

    if (currentOffset > offset) {
      high = middle - 1;
    }
  }

  if (low > 0) {
    return low - 1;
  }

  return 0;
}

function overOffset(rowMetaData, tableStore, index, offset) {
  var item = getItemMetadata(rowMetaData, index, tableStore);

  if (item) {
    return item.offset < offset;
  }

  return false;
}

function findNearestItemExponentialSearch(rowMetaData, tableStore, index, offset) {
  var virtualEstimatedRows = tableStore.virtualEstimatedRows;
  var interval = 1;

  while (index < virtualEstimatedRows && overOffset(rowMetaData, tableStore, index, offset)) {
    index += interval;
    interval *= 2;
  }

  return findNearestItemBinarySearch(rowMetaData, tableStore, Math.min(index, virtualEstimatedRows - 1), Math.floor(index / 2), offset);
}

function getVisibleStartIndex(tableStore) {
  var getLastScrollTop = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function () {
    return tableStore.lastScrollTop;
  };
  var height = tableStore.height,
      virtualEstimatedRows = tableStore.virtualEstimatedRows;

  if (height === undefined || !virtualEstimatedRows) {
    return 0;
  }

  var lastScrollTop = getLastScrollTop();
  var virtualRowHeight = tableStore.virtualRowHeight,
      rowMetaData = tableStore.rowMetaData;

  if (rowMetaData) {
    if (!rowMetaData.length) {
      return 0;
    }

    var lastMeasuredIndex = tableStore.lastMeasuredIndex;
    var lastRowMetaData = lastMeasuredIndex > 0 ? rowMetaData[lastMeasuredIndex] : undefined;
    var lastMeasuredItemOffset = lastRowMetaData ? lastRowMetaData.offset : 0;

    if (lastMeasuredItemOffset >= lastScrollTop) {
      return findNearestItemBinarySearch(rowMetaData, tableStore, lastMeasuredIndex, 0, lastScrollTop);
    }

    return findNearestItemExponentialSearch(rowMetaData, tableStore, Math.max(0, lastMeasuredIndex), lastScrollTop);
  }

  return Math.max(0, Math.min(virtualEstimatedRows, Math.floor(lastScrollTop / virtualRowHeight)));
}

function getVisibleEndIndex(tableStore) {
  var getVirtualVisibleStartIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function () {
    return tableStore.virtualVisibleStartIndex;
  };
  var getLastScrollTop = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function () {
    return tableStore.lastScrollTop;
  };
  var height = tableStore.height,
      virtualEstimatedRows = tableStore.virtualEstimatedRows;

  if (height === undefined) {
    return virtualEstimatedRows;
  }

  var virtualVisibleStartIndex = getVirtualVisibleStartIndex();
  var virtualRowHeight = tableStore.virtualRowHeight,
      rowMetaData = tableStore.rowMetaData;

  if (rowMetaData) {
    if (!rowMetaData.length) {
      return 0;
    }

    var itemMetadata = getItemMetadata(rowMetaData, virtualVisibleStartIndex, tableStore);

    if (!itemMetadata) {
      return 0;
    }

    var maxOffset = getLastScrollTop() + height;
    var offset = itemMetadata.offset + itemMetadata.height;
    var stopIndex = virtualVisibleStartIndex;

    while (stopIndex < virtualEstimatedRows - 1 && offset < maxOffset) {
      stopIndex++;
      var item = getItemMetadata(rowMetaData, stopIndex, tableStore);

      if (item) {
        offset += item.height;
      }
    }

    return stopIndex;
  }

  var numVisibleItems = Math.ceil(height / virtualRowHeight);
  return Math.max(0, Math.min(virtualEstimatedRows, virtualVisibleStartIndex + numVisibleItems));
}

function getStartIndex(tableStore) {
  var getVirtualVisibleStartIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function () {
    return tableStore.virtualVisibleStartIndex;
  };
  var virtualVisibleStartIndex = getVirtualVisibleStartIndex();
  return Math.max(0, virtualVisibleStartIndex - getOverScanCount(tableStore, virtualVisibleStartIndex));
}

function getEndIndex(tableStore) {
  var getVirtualVisibleEndIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function () {
    return tableStore.virtualVisibleEndIndex;
  };
  var virtualVisibleEndIndex = getVirtualVisibleEndIndex();
  var virtualEstimatedRows = tableStore.virtualEstimatedRows;
  return Math.min(virtualEstimatedRows, virtualVisibleEndIndex + getOverScanCount(tableStore, virtualVisibleEndIndex));
}

export 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) {
    if (record.isCached) {
      return [];
    }

    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 === SelectionMode.mousedown) {
        // 将处理逻辑交给 mousedown 的处理逻辑 不然会两次触发导致不被勾选上
        return;
      }

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

    var handleClick = function handleClick(e) {
      stopPropagation(e);

      if (selection === 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 === DataSetSelection.multiple) {
      var batchSelectProps = {};
      var handleDragMouseUp = 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 = 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.createElement(ObserverCheckBox, _extends({}, batchSelectProps, {
        checked: record.isSelected,
        onChange: handleChange,
        onClick: handleClick,
        disabled: !record.selectable,
        "data-selection-key": SELECTION_KEY,
        labelLayout: LabelLayout.none,
        value: true
      }));
    }

    if (selection === DataSetSelection.single) {
      return React.createElement(ObserverRadio, {
        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 (isPlainObject(column)) {
      var newColumn = _objectSpread({}, ColumnDefaultProps, {}, column);

      if (isNil(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) {
          _extends(newColumn, customizedColumns[getColumnKey(newColumn).toString()]);
        }

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

        if (children) {
          var _mergeDefaultProps = mergeDefaultProps(children, tableAggregation, customizedColumns, newColumn, defaultKey),
              _mergeDefaultProps2 = _slicedToArray(_mergeDefaultProps, 4),
              childrenColumns = _mergeDefaultProps2[1],
              childrenHasAggregationColumn = _mergeDefaultProps2[3];

          newColumn.children = childrenColumns;

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

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

          columnSort.center++;
          columns.push(newColumn);
        } else if (newColumn.lock === true || newColumn.lock === 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 = _slicedToArray(_mergeDefaultProps3, 4),
            leftNodes = _mergeDefaultProps4[0],
            nodes = _mergeDefaultProps4[1],
            rightNodes = _mergeDefaultProps4[2],
            _childrenHasAggregationColumn = _mergeDefaultProps4[3];

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

        if (parent) {
          parent.children = [].concat(_toConsumableArray(leftNodes), _toConsumableArray(nodes), _toConsumableArray(rightNodes));
        } else {
          leftColumns.push.apply(leftColumns, _toConsumableArray(leftNodes));
          columns.push.apply(columns, _toConsumableArray(nodes));
          rightColumns.push.apply(rightColumns, _toConsumableArray(rightNodes));
        }
      }
    }
  }, []);

  if (parent) {
    return [[], sortBy(columns, function (_ref4) {
      var sort = _ref4.sort;
      return sort;
    }), [], hasAggregationColumn];
  }

  return [sortBy(leftColumns, function (_ref5) {
    var sort = _ref5.sort;
    return sort;
  }), sortBy(columns, function (_ref6) {
    var sort = _ref6.sort;
    return sort;
  }), sortBy(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 (isValidElement(element)) {
      var props = element.props,
          key = element.key,
          type = element.type;

      if (isFragment(element)) {
        var children = props.children;

        if (children) {
          Children.forEach(children, normalizeColumn);
        }
      } else if (type.__PRO_TABLE_COLUMN) {
        var column = _objectSpread({}, props);

        if (key) {
          column.key = key;
        } else if (isNil(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) {
            _extends(column, customizedColumns[getColumnKey(column).toString()]);
          }

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

          var _normalizeColumns = normalizeColumns(_children, tableAggregation, customizedColumns, column, defaultKey),
              _normalizeColumns2 = _slicedToArray(_normalizeColumns, 4),
              childrenColumns = _normalizeColumns2[1],
              childrenHasAggregationColumn = _normalizeColumns2[3];

          column.children = childrenColumns;

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

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

            columnSort.center++;
            columns.push(column);
          } else if (column.lock === true || column.lock === 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 = _slicedToArray(_normalizeColumns3, 4),
              leftNodes = _normalizeColumns4[0],
              nodes = _normalizeColumns4[1],
              rightNodes = _normalizeColumns4[2],
              _childrenHasAggregationColumn2 = _normalizeColumns4[3];

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

          if (parent) {
            parent.children = [].concat(_toConsumableArray(leftNodes), _toConsumableArray(nodes), _toConsumableArray(rightNodes));
          } else {
            leftColumns.push.apply(leftColumns, _toConsumableArray(leftNodes));
            columns.push.apply(columns, _toConsumableArray(nodes));
            rightColumns.push.apply(rightColumns, _toConsumableArray(rightNodes));
          }
        }
      }
    }
  };

  Children.forEach(elements, normalizeColumn);

  if (parent) {
    return [[], sortBy(columns, function (_ref8) {
      var sort = _ref8.sort;
      return sort;
    }), [], hasAggregationColumn];
  }

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

function getColumnGroupedColumns(groups, customizedColumns) {
  var groupedColumns = [];
  var hasAggregation = false;
  groups.forEach(function (group) {
    var name = group.name,
        type = group.type,
        columnProps = group.columnProps;

    if (type === GroupType.column) {
      var column = _objectSpread({}, ColumnDefaultProps, {
        lock: ColumnLock.left
      }, columnProps, {
        draggable: false,
        hideable: false,
        key: "__group-".concat(name),
        name: name,
        __tableGroup: group
      });

      if (customizedColumns) {
        _extends(column, customizedColumns[getColumnKey(column).toString()]);
      }

      groupedColumns.push(column);

      if (columnProps && !hasAggregation && columnProps.aggregation) {
        hasAggregation = true;
      }
    }
  });
  return [groupedColumns, hasAggregation];
}

function getHeaderGroupedColumns(groups, tableGroups, columns, dataSet, groupedColumns, customizedColumns, parentKey) {
  var generatedColumns = new Set();
  var headerUsed = false;
  groups.forEach(function (group) {
    var name = group.name,
        subGroups = group.subGroups,
        value = group.value;
    var key = parentKey ? "".concat(parentKey, "-").concat(value) : value;
    var subColumns = subGroups.length ? getHeaderGroupedColumns(subGroups, tableGroups, columns, dataSet, groupedColumns, customizedColumns, key) : columns;
    var tableGroup = tableGroups.find(function ($tableGroup) {
      return name === $tableGroup.name;
    });

    if (tableGroup) {
      var columnProps = tableGroup.columnProps,
          groupName = tableGroup.name,
          hidden = tableGroup.hidden;

      if (hidden) {
        subColumns.forEach(function (col) {
          var __originalKey = getColumnKey(col);

          var colKey = "".concat(key, "-").concat(__originalKey);

          var newCol = _objectSpread({}, col, {
            key: colKey,
            __tableGroup: tableGroup,
            __group: group,
            __originalKey: __originalKey
          });

          if (customizedColumns) {
            _extends(newCol, customizedColumns[colKey]);
          }

          generatedColumns.add(newCol);
        });
      } else {
        var length = groupedColumns.length;

        if (length && !headerUsed) {
          headerUsed = true;
          var header = getHeader(_objectSpread({}, columnProps, {
            name: groupName,
            dataSet: dataSet,
            group: group
          }));

          if (header) {
            var oldColumn = groupedColumns[length - 1];
            var newKey = "".concat(key, "-").concat(getColumnKey(oldColumn));

            var newColumn = _objectSpread({}, columnProps, {
              lock: ColumnLock.left,
              titleEditable: false,
              draggable: false,
              hideable: false,
              key: newKey,
              header: header,
              children: [oldColumn],
              __tableGroup: tableGroup
            });

            if (customizedColumns) {
              _extends(newColumn, customizedColumns[newKey]);
            }

            groupedColumns[length - 1] = newColumn;
          }
        }

        var renderer = columnProps && columnProps.renderer || defaultAggregationRenderer;

        var column = _objectSpread({}, columnProps, {
          titleEditable: false,
          key: key,
          headerStyle: columnProps && columnProps.style,
          header: function header() {
            return renderer({
              dataSet: dataSet,
              record: group.totalRecords[0],
              name: groupName,
              text: value,
              value: value,
              headerGroup: group
            });
          },
          children: subColumns.map(function (col) {
            var __originalKey = getColumnKey(col);

            var colKey = "".concat(key, "-").concat(__originalKey);

            var newCol = _objectSpread({}, col, {
              key: colKey,
              __originalKey: __originalKey
            });

            if (customizedColumns) {
              _extends(newCol, customizedColumns[__originalKey]);
            }

            return newCol;
          }).sort(function (_ref12, _ref13) {
            var _ref12$sort = _ref12.sort,
                sort = _ref12$sort === void 0 ? Infinity : _ref12$sort;
            var _ref13$sort = _ref13.sort,
                sort2 = _ref13$sort === void 0 ? Infinity : _ref13$sort;
            return sort - sort2;
          }),
          __tableGroup: tableGroup,
          __group: group
        });

        if (customizedColumns) {
          _extends(column, customizedColumns[getColumnKey(column).toString()]);
        }

        generatedColumns.add(column);
      }
    } else if (subColumns.length) {
      subColumns.forEach(function (column) {
        return generatedColumns.add(column);
      });
    }
  });
  return _toConsumableArray(generatedColumns);
}

export function normalizeGroupColumns(tableStore, columns, children, aggregation, customizedColumns) {
  var headerTableGroups = tableStore.headerTableGroups,
      groups = tableStore.groups,
      dataSet = tableStore.dataSet;
  var hasHeaderGroup = headerTableGroups.length > 0;
  var generatedColumns = columns ? mergeDefaultProps(columns, aggregation, customizedColumns) : normalizeColumns(children, aggregation, customizedColumns);

  var _generatedColumns = _slicedToArray(generatedColumns, 4),
      leftOriginalColumns = _generatedColumns[0],
      originalColumns = _generatedColumns[1],
      rightOriginalColumns = _generatedColumns[2],
      hasAggregationColumn = _generatedColumns[3];

  var _ref14 = groups.length ? getColumnGroupedColumns(groups, customizedColumns) : [[], false],
      _ref15 = _slicedToArray(_ref14, 2),
      columnGroupedColumns = _ref15[0],
      hasAggregationColumnGroup = _ref15[1];

  if (hasHeaderGroup) {
    return [columnGroupedColumns, getHeaderGroupedColumns(tableStore.groupedDataWithHeader, headerTableGroups, [].concat(_toConsumableArray(leftOriginalColumns), _toConsumableArray(originalColumns), _toConsumableArray(rightOriginalColumns)), dataSet, columnGroupedColumns, customizedColumns), [], hasAggregationColumnGroup || hasAggregationColumn];
  }

  return [[].concat(_toConsumableArray(columnGroupedColumns), _toConsumableArray(leftOriginalColumns)), originalColumns, rightOriginalColumns, hasAggregationColumnGroup || hasAggregationColumn];
}

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

function _getHeaderTexts() {
  _getHeaderTexts = _asyncToGenerator(
  /*#__PURE__*/
  _regeneratorRuntime.mark(function _callee3(dataSet, columns, aggregation) {
    var headers,
        column,
        _args3 = arguments;
    return _regeneratorRuntime.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 getReactNodeText(getHeader(_objectSpread({}, column, {
              dataSet: dataSet,
              aggregation: 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);
}

function autoHeightToStyle(autoHeight) {
  var parentPaddingTop = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
  var type = autoHeight.type,
      diff = autoHeight.diff;
  var height = "calc(100% - ".concat(diff + parentPaddingTop, "px)");

  if (type === TableAutoHeightType.minHeight) {
    return {
      height: height
    };
  }

  return {
    maxHeight: height
  };
}

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

    _classCallCheck(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.lastMeasuredIndex = 0;
    this.handleSelectAllChange = 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 = debounce(this.saveCustomized, 1000);
    this.stopScroll = debounce(action(function () {
      _this.scrolling = false;
    }), 300);
    runInAction(function () {
      _this.scrollPosition = ScrollPosition.left;
      _this.mouseBatchChooseIdList = [];
      _this.mouseBatchChooseState = false;
      _this.showCachedSelection = false;
      _this.lockColumnsHeadRowsHeight = {};
      _this.lockColumnsBodyRowsHeight = {};
      _this.lockColumnsFootRowsHeight = {};
      _this.node = node;
      _this.expandedRows = [];
      _this.screenHeight = typeof window === 'undefined' ? 0 : document.documentElement.clientHeight;
      _this.headerHeight = 0;
      _this.footerHeight = 0;
      _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();
      }
    });
  }

  _createClass(TableStore, [{
    key: "customizedColumnHeader",
    value: function customizedColumnHeader() {
      return React.createElement(CustomizationColumnHeader, {
        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(_ref16) {
      var key = _ref16.key;

      if (isString(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 this.node.context.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) {
      if (this.virtual) {
        this.lastScrollTop = lastScrollTop;
        this.startScroll();
      }
    }
  }, {
    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 (!isNil(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;
      var _this$props3 = this.props,
          columns = _this$props3.columns,
          children = _this$props3.children;
      var customizedColumns = customizable ? customized.columns : undefined;

      var _normalizeGroupColumn = normalizeGroupColumns(this, columns, children, aggregation, customizedColumns),
          _normalizeGroupColumn2 = _slicedToArray(_normalizeGroupColumn, 4),
          leftOriginalColumns = _normalizeGroupColumn2[0],
          originalColumns = _normalizeGroupColumn2[1],
          rightOriginalColumns = _normalizeGroupColumn2[2],
          hasAggregationColumn = _normalizeGroupColumn2[3];

      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.get(key);
      }
    }
  }, {
    key: "setAggregationCellExpanded",
    value: function setAggregationCellExpanded(record, key, expanded) {
      var expandedKeys = record.getState(AGGREGATION_EXPAND_CELL_KEY) || observable.map();
      expandedKeys.set(key, expanded);
      record.setState(AGGREGATION_EXPAND_CELL_KEY, expandedKeys);
    }
  }, {
    key: "setBodyExpanded",
    value: function setBodyExpanded(isBodyExpanded) {
      var _this$props4 = this.props,
          bodyExpanded = _this$props4.bodyExpanded,
          _this$props4$onBodyEx = _this$props4.onBodyExpand,
          onBodyExpand = _this$props4$onBodyEx === void 0 ? noop : _this$props4$onBodyEx;

      if (bodyExpanded === undefined) {
        this.dataSet.setState(BODY_EXPANDED, isBodyExpanded);
      }

      onBodyExpand(isBodyExpanded);
    }
  }, {
    key: "isGroupExpanded",
    value: function isGroupExpanded(group) {
      return group.isExpanded && (!group.parent || this.isGroupExpanded(group.parent));
    }
  }, {
    key: "setGroupExpanded",
    value: function setGroupExpanded(group, isExpanded) {
      group.isExpanded = isExpanded;
    }
  }, {
    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 = _asyncToGenerator(
      /*#__PURE__*/
      _regeneratorRuntime.mark(function _callee(_ref17) {
        var record, _this$props5, dataSet, treeLoadData, treeAsync, promises;

        return _regeneratorRuntime.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                record = _ref17.record;
                _this$props5 = this.props, dataSet = _this$props5.dataSet, treeLoadData = _this$props5.treeLoadData, treeAsync = _this$props5.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(_ref18) {
      var record = _ref18.record;
      return _renderSelectionBox({
        record: record,
        store: this
      });
    }
  }, {
    key: "renderRowNumber",
    value: function renderRowNumber(_ref19) {
      var record = _ref19.record,
          dataSet = _ref19.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(_ref20) {
      var record = _ref20.record;
      var rowDragRender = this.props.rowDragRender;

      if (rowDragRender && isFunction(rowDragRender.renderIcon)) {
        return rowDragRender.renderIcon({
          record: record
        });
      }

      return React.createElement(Icon, {
        type: "baseline-drag_indicator"
      });
    }
  }, {
    key: "changeCustomizedColumnValue",
    value: function changeCustomizedColumnValue(column, value) {
      var columns = this.customized.columns;
      set(column, value);
      var columnKey = getColumnKey(column).toString();

      var oldCustomized = _get(columns, columnKey);

      set(columns, columnKey, _objectSpread({}, 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 = this.getConfig('tableCustomizedSave') || this.getConfig('customizedSave');
          tableCustomizedSave(customizedCode, this.customized, 'Table');
        }
      }
    }
  }, {
    key: "openCustomizationModal",
    value: function openCustomizationModal(modal) {
      var customizedCode = this.props.customizedCode;
      var modalProps = {
        drawer: true,
        size: Size.small,
        title: $l('Table', 'customization_settings'),
        children: React.createElement(CustomizationSettings, null),
        bodyStyle: {
          overflow: 'hidden auto',
          padding: 0
        }
      };

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

      modal.open(modalProps);
    }
  }, {
    key: "loadCustomized",
    value: function () {
      var _loadCustomized = _asyncToGenerator(
      /*#__PURE__*/
      _regeneratorRuntime.mark(function _callee2() {
        var _this4 = this;

        var customizedCode, tableCustomizedLoad, customized;
        return _regeneratorRuntime.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 = this.getConfig('tableCustomizedLoad') || this.getConfig('customizedLoad');
                runInAction(function () {
                  delete _this4.customizedLoaded;
                  _this4.loading = true;
                });
                _context2.prev = 4;
                _context2.next = 7;
                return tableCustomizedLoad(customizedCode, 'Table');

              case 7:
                customized = _context2.sent;
                runInAction(function () {
                  _this4.customized = _objectSpread({
                    columns: {}
                  }, customized);
                });
                this.customizedLoaded = true;

              case 10:
                _context2.prev = 10;
                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(_ref21) {
      var key = _ref21.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.createElement(Menu, {
        prefixCls: "".concat(prefixCls, "-dropdown-menu"),
        onClick: this.handleAllPageSelectionMenuClick
      }, React.createElement(Menu.Item, {
        key: "current"
      }, $l('Table', allChecked ? 'unselect_current_page' : 'select_current_page')), React.createElement(Menu.Item, {
        key: "all"
      }, $l('Table', isAllPageSelection ? 'unselect_all_page' : 'select_all_page')));
    }
  }, {
    key: "getConfig",
    value: function getConfig(key) {
      return this.node.getContextC