maycur-business/lib/MkTable/MkTable.jsx

maycur business react components of web

"use strict";

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

require("maycur-antd/lib/icon/style/css");

var _icon = _interopRequireDefault(require("maycur-antd/lib/icon"));

require("maycur-antd/lib/button/style/css");

var _button = _interopRequireDefault(require("maycur-antd/lib/button"));

require("maycur-antd/lib/popover/style/css");

var _popover = _interopRequireDefault(require("maycur-antd/lib/popover"));

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

var _table = require("maycur-antd/lib/table");

var _reactResizable = require("react-resizable");

var _lodash = _interopRequireDefault(require("lodash"));

var _classnames = _interopRequireDefault(require("classnames"));

var _FilterDropDown = require("./FilterDropDown");

var _FilterStateBar = _interopRequireDefault(require("./FilterStateBar"));

var _PopSelect = _interopRequireDefault(require("./PopSelect/PopSelect"));

var _RcTable = _interopRequireDefault(require("../lib/RcTable"));

var _MkSearch = _interopRequireDefault(require("../MkSearch"));

var _Empty = _interopRequireDefault(require("../Empty"));

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

require("maycur-antd/lib/table/style/css");

var _mkTranslate = _interopRequireDefault(require("../utils/mkTranslate"));

function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

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

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

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

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

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

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

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

function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

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

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

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

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

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

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

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

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

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

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

var prefix = _utils["default"].prefixCls;
/* title 宽度变动 */

var ResizeableTitle = function ResizeableTitle(props) {
  var onResize = props.onResize,
      width = props.width,
      restProps = _objectWithoutProperties(props, ["onResize", "width"]);

  if (!width) {
    return _react["default"].createElement("th", restProps);
  }

  return _react["default"].createElement(_reactResizable.Resizable, {
    width: width,
    height: 0,
    onResize: onResize
  }, _react["default"].createElement("th", restProps));
};

var MkTable = function MkTable(option) {
  return function (WrapperComponent) {
    var _temp;

    var defaultOption = {
      isFixHeader: false,
      resizeAble: false,
      disableLoad: false,
      hidePagination: false,
      firstDisplayColumns: [],
      isCrossPageSelect: false,
      searchKey: 'keyword'
    };
    option = Object.assign(defaultOption, option);
    var defaultPageSizeOptions = [10, 20, 50, 100];

    if (option.pageSize && defaultPageSizeOptions.indexOf(option.pageSize) < 0) {
      defaultPageSizeOptions.push(option.pageSize);
      defaultPageSizeOptions.sort(function (a, b) {
        return a - b;
      });
    }

    _lodash["default"].forEach(defaultPageSizeOptions, function (val, index) {
      defaultPageSizeOptions[index] = val + '';
    });

    return _temp =
    /*#__PURE__*/
    function (_Component) {
      _inherits(_temp, _Component);

      function _temp(_props) {
        var _this;

        _classCallCheck(this, _temp);

        _this = _possibleConstructorReturn(this, _getPrototypeOf(_temp).call(this, _props));

        _this.localeProcess = function () {
          _mkTranslate["default"].getNameSpace('MkTable').then(function (t) {
            _this.setState({
              t: t
            });
          });
        };

        _this.columnConvert = function (columns) {
          var filters = _this.state.filters;

          var cloneColumns = _lodash["default"].cloneDeep(columns);

          var typeComponentMap = {
            'dateRange': _FilterDropDown.DateFilter,
            'search': _FilterDropDown.FuzzFilter,
            'checkbox': _FilterDropDown.CheckFilter,
            'department': _FilterDropDown.DepartmentPickerFilter,
            'numberRange': _FilterDropDown.NumberRangeFilter,
            'budgetment': _FilterDropDown.BudgetmentFilter,
            //预算组织筛选框
            'budgetSubject': _FilterDropDown.BudgetSubjectFilter //预算科目筛选框

          };
          /* 设置内置的column属性 */

          _lodash["default"].forEach(cloneColumns, function (col) {
            if (col.filterOption) {
              col.filterDropdown = function (_ref) {
                var setSelectedKeys = _ref.setSelectedKeys,
                    selectedKeys = _ref.selectedKeys,
                    confirm = _ref.confirm,
                    clearFilters = _ref.clearFilters;
                var Cop = typeComponentMap[col.filterOption.type];
                return _react["default"].createElement(Cop, _extends({}, col, {
                  setSelectedKeys: setSelectedKeys,
                  selectedKeys: selectedKeys,
                  confirm: confirm,
                  setFiltersMap: _this.setFiltersMap,
                  clearFilters: clearFilters,
                  columnModify: _this.columnModify,
                  columns: _this.state.columns
                }));
              };

              col.filteredValue = filters[col.filterKey || col.key] || null;
            }
          });

          return cloneColumns || [];
        };

        _this.handleResize = function (index) {
          return function (e, _ref2) {
            var size = _ref2.size;

            _this.setState(function (_ref3) {
              var columns = _ref3.columns;

              var nextColumns = _toConsumableArray(columns);

              nextColumns[index] = _objectSpread({}, nextColumns[index], {
                width: size.width
              });
              return {
                columns: nextColumns
              };
            });
          };
        };

        _this.onChange = function (pagination, filters, sorter) {
          var columns = _this.state.columns;
          var currentFilters = _this.state.filters;
          var isClearSelection = false;
          if (!_lodash["default"].isEqual(currentFilters, filters)) isClearSelection = true;

          _lodash["default"].forEach(filters, function (value, key) {
            // if (value) {
            var column = _lodash["default"].find(columns, {
              key: key
            });

            _this.columnModify(column, {
              key: 'filteredValue',
              value: value
            }); // }

          });

          _lodash["default"].forEach(currentFilters, function (value, key) {
            // 如果当前筛选中不存在新的筛选，需要将这部分置为空
            if (!filters[key]) {
              var column = _lodash["default"].find(columns, {
                key: key
              });

              _this.columnModify(column, {
                key: 'filteredValue',
                value: null
              });
            }
          });

          _lodash["default"].forEach(columns, function (column) {
            if (sorter && sorter.field && column.key === sorter.field) {
              _this.columnModify(column, {
                key: 'sortOrder',
                value: sorter.order
              });
            } else if (column.sortOrder) {
              _this.columnModify(column, {
                key: 'sortOrder',
                value: false
              });
            }
          });

          _this.setState({
            filters: filters,
            sorter: {
              field: sorter.field,
              order: sorter.order
            },
            pagination: pagination
          }, function () {
            _this.dataFetch({
              isClearSelection: isClearSelection
            });
          });
        };

        _this.columnModify = function (column, dataPair) {
          if (column) {
            var columns = _this.state.columns;

            var idx = _lodash["default"].findIndex(columns, {
              dataIndex: column.dataIndex
            });

            if (dataPair && idx > -1) {
              var key = dataPair.key,
                  value = dataPair.value; // column[key] = value;

              column = _objectSpread({}, column, _defineProperty({}, key, value));
              columns[idx] = column;

              _this.setState({
                columns: columns
              });
            }
          }
        };

        _this.filterChangeNotice = function () {
          var filterChange = _this.props.filterChange;
          var filters = _this.state.filters;

          if (filterChange && typeof filterChange === 'function') {
            filterChange(filters);
          }
        };

        _this.clearAll = function () {
          var theFilters = _this.$filterBar.convertFilter(_this.state.filters);

          _this.$filterBar.clear(theFilters);
        };

        _this.clearSearch = function () {
          _this.search = _defineProperty({}, option.searchKey, '');
        };

        _this.removeSingleFilter = function (filterKeys) {
          var _this$state = _this.state,
              filters = _this$state.filters,
              pagination = _this$state.pagination,
              sorter = _this$state.sorter;

          var newFilter = _lodash["default"].cloneDeep(filters);
          /* 不要直接对state中的属性做delete操作（会导致无法正常render组件），clone一个来处理*/


          if (_lodash["default"].isArray(filterKeys)) {
            _lodash["default"].forEach(filterKeys, function (key) {
              newFilter[key] = null;
            });
          } else {
            newFilter[filterKeys] = null;
          }

          _this.onChange(pagination, newFilter, sorter);
        };

        _this.fetchCustomFilterData = function (filter) {
          var _this$state2 = _this.state,
              pagination = _this$state2.pagination,
              sorter = _this$state2.sorter;

          _this.onChange(pagination, filter, sorter);
        };

        _this.setFiltersMap = function (key, filters) {
          var filtersMap = _this.state.filtersMap;

          _this.setState({
            filtersMap: _objectSpread({}, filtersMap, _defineProperty({}, key, filters))
          });
        };

        _this.generateTable = function (params) {
          /* 当前不支持列冻结的功能 */
          var _this$state3 = _this.state,
              columns = _this$state3.columns,
              loading = _this$state3.loading,
              pagination = _this$state3.pagination,
              dataSource = _this$state3.dataSource,
              selectedRowKeys = _this$state3.selectedRowKeys,
              selectAble = _this$state3.selectAble,
              selectAbleLock = _this$state3.selectAbleLock,
              loadProps = _this$state3.loadProps,
              hideColumnCodeList = _this$state3.hideColumnCodeList,
              tableMinWidth = _this$state3.tableMinWidth,
              isReady = _this$state3.isReady;
          var rowKey = params.rowKey,
              scroll = params.scroll,
              _params$rowSelection = params.rowSelection,
              rowSelectionOption = _params$rowSelection === void 0 ? {} : _params$rowSelection,
              data = params.data,
              _params$tableId = params.tableId,
              tableId = _params$tableId === void 0 ? 'tableId' : _params$tableId,
              onRow = params.onRow;
          var _option = option,
              isCrossPageSelect = _option.isCrossPageSelect,
              childrenColumnName = _option.childrenColumnName;

          if (data && data.length > 0) {
            dataSource = data;
          }

          var wrapOnRow = function wrapOnRow(record) {
            return {
              onClick: function onClick(e) {
                if (rowSelectionOption.type && rowSelectionOption.type === 'radio') {
                  _this.setState({
                    selectedRows: [record],
                    selectedRowKeys: [record[rowKey]]
                  });
                }

                if (typeof onRow === 'function') {
                  var instanceOnRow = onRow(record);

                  if (instanceOnRow && _typeof(instanceOnRow.onClick)) {
                    instanceOnRow.onClick(e);
                  }
                }
              }
            };
          };

          var onSelectionChange = rowSelectionOption.onSelectionChange;
          _this.rowKey = rowKey;

          var rowSelection = _objectSpread({}, rowSelectionOption, {
            onChange: function onChange(selectedRowKeys, selectedRows) {
              if (childrenColumnName) return;
              /* 注意：onChange中的selectedRows，因为antd不支持跨页选取，所以selectedRows只包含当前页选中的数据 */

              var currentSelectRows = [],
                  currentSelectedRowKeys = [];

              if (isCrossPageSelect) {
                /* 跨页选取 */
                if (rowSelectionOption.type !== 'radio') {
                  var unSelectedRows = _lodash["default"].differenceWith(dataSource, selectedRows, _lodash["default"].isEqual);

                  var unSelectedRowKeys = _lodash["default"].map(unSelectedRows, function (row) {
                    return row[rowKey];
                  });

                  currentSelectRows = _lodash["default"].cloneDeep(_this.state.selectedRows);

                  if (selectedRows.length > 0) {
                    currentSelectRows = _this.modifySelectRows({
                      currentSelectRows: currentSelectRows,
                      type: 'update',
                      rows: selectedRows,
                      rowKeys: selectedRowKeys
                    });
                  }

                  if (unSelectedRows.length > 0) {
                    currentSelectRows = _this.modifySelectRows({
                      currentSelectRows: currentSelectRows,
                      type: 'delete',
                      rows: unSelectedRows,
                      rowKeys: unSelectedRowKeys
                    });
                  }

                  _lodash["default"].forEach(currentSelectRows, function (row) {
                    currentSelectedRowKeys.push(row[rowKey]);
                  });
                } else {
                  currentSelectRows = selectedRows;
                  currentSelectedRowKeys = selectedRowKeys;
                }
              } else {
                /* 非跨页选取 */
                currentSelectRows = selectedRows;
                currentSelectedRowKeys = selectedRowKeys;
              }

              _this.setState({
                selectedRows: currentSelectRows,
                selectedRowKeys: currentSelectedRowKeys
              }, function () {
                if (typeof onSelectionChange === 'function') {
                  onSelectionChange(currentSelectedRowKeys, currentSelectRows);
                }
              });
            },
            onSelect: function onSelect(record, selected, selectedRows, nativeEvent) {
              _this.onSelect(record, selected);
            },
            onSelectAll: function onSelectAll(selected, selectedRows, changeRows) {
              _this.onSelectAll(selected, selectedRows, changeRows);
            },
            selectedRowKeys: selectedRowKeys
          });

          var visibleColumns = _lodash["default"].filter(columns, function (col) {
            return !hideColumnCodeList.includes(col.dataIndex);
          });

          var tableCls = (0, _classnames["default"])("".concat(prefix, "-mktable-container"), {
            'table-empty': !dataSource || dataSource && dataSource.length === 0,
            'enable-scroll-x': !(scroll && scroll.x),
            'row-clickable': typeof onRow === 'function',
            'fix-header': option.isFixHeader
          });
          var tableScroll = {};
          tableScroll = _lodash["default"].assign({}, option.isFixHeader ? {
            y: true,
            x: tableMinWidth
          } : {});

          if (_this.tableId && _this.tableId !== tableId) {
            _this.tableReset();

            _this.tableId = tableId;
            return null;
          } else {
            _this.tableId = tableId;
            return _react["default"].createElement("div", {
              className: tableCls,
              ref: function ref(_ref4) {
                _this.tableRef = _ref4;
              }
            }, _react["default"].createElement(_table.FlexTable, _extends({}, params, {
              onRow: wrapOnRow,
              key: tableId,
              rowSelection: selectAble ? rowSelection : selectAbleLock ? {
                selectedRowKeys: selectedRowKeys
              } : null,
              components: _this.components,
              columns: visibleColumns,
              scroll: tableScroll,
              pagination: option.hidePagination ? false : pagination,
              childrenColumnName: childrenColumnName,
              dataSource: dataSource,
              onChange: _this.onChange,
              loading: _objectSpread({}, loadProps, {
                spinning: loading
              }),
              locale: {
                emptyText: function emptyText() {
                  return isReady && _react["default"].createElement(_Empty["default"], null);
                }
              },
              OptionTable: _RcTable["default"]
            })));
          }
        };

        _this.generateFilter = function () {
          var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
          var _this$state4 = _this.state,
              filters = _this$state4.filters,
              columns = _this$state4.columns,
              dataSource = _this$state4.dataSource,
              pagination = _this$state4.pagination,
              filtersMap = _this$state4.filtersMap;
          return _react["default"].createElement(_FilterStateBar["default"], _extends({
            filters: filters,
            filtersMap: filtersMap,
            columns: columns,
            totalCount: pagination.total ? pagination.total : dataSource.length,
            removeFilter: _this.removeSingleFilter,
            onRefFilterBar: _this.onRefFilterBar,
            fetchCustomFilterData: _this.fetchCustomFilterData
          }, props));
        };

        _this.searchTable = function (value) {
          _this.setState({
            pagination: _objectSpread({}, _this.state.pagination, {
              current: 1
            })
          }, function () {
            _this.search = _defineProperty({}, option.searchKey, value);

            _this.dataFetch();
          });
        };

        _this.setRef = function (el) {
          _this.searchEl = el;
        };

        _this.generateSearch = function () {
          var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
          return _react["default"].createElement(_MkSearch["default"], {
            type: "gray",
            animate: props.animate,
            wrappedWidth: props.wrappedWidth,
            placeholder: props.placeholder,
            style: props.style,
            setRef: _this.setRef,
            onSearch: _this.searchTable,
            onChange: function onChange(e) {
              return _this.searchWordChange(e.target.value);
            }
          });
        };

        _this.onRefFilterBar = function (ref) {
          _this.$filterBar = ref;
        };

        _this.setColumns = function (originColumns) {
          var columns = [],
              hideColumnCodeList = [];
          var tableMinWidth = 0;
          originColumns = _lodash["default"].cloneDeep(originColumns);

          if (originColumns) {
            var initSorter = {},
                initFilter = {};

            _lodash["default"].forEach(originColumns, function (column) {
              if (column.sortOrder) {
                initSorter.field = column.dataIndex;
                initSorter.order = column.sortOrder;
              } // 修复 filteredValue值为布尔值时，默认筛选没有被选中的 bug


              if (column.filteredValue || typeof column.filteredValue === 'boolean') {
                initFilter[column.dataIndex] = column.filteredValue;
              }

              if (option.firstDisplayColumns.length > 0 && !option.firstDisplayColumns.includes(column.dataIndex)) {
                hideColumnCodeList.push(column.dataIndex);
              }

              if (column.fixed && !column.width) {
                column.fixed = false;
              }

              if (column.popover) {
                column.className = 'td-ellipsis';

                column.render = function (value, row) {
                  return _react["default"].createElement(_popover["default"], {
                    content: value,
                    trigger: "hover",
                    overlayClassName: 'mkbs-table-cell-popover',
                    placement: "topLeft"
                  }, value);
                };
              }

              tableMinWidth += Number(column.width || column.minWidth || 100);
            });

            columns = _this.columnConvert(originColumns);

            if (option.resizeAble) {
              columns = columns.map(function (col, index) {
                return _objectSpread({}, col, {
                  onHeaderCell: function onHeaderCell(column) {
                    return {
                      width: column.width,
                      onResize: _this.handleResize(index)
                    };
                  }
                });
              });
            }

            _this.setState({
              columns: columns,
              sorter: initSorter,
              filters: initFilter,
              hideColumnCodeList: hideColumnCodeList,
              tableMinWidth: tableMinWidth
            });
          }
        };

        _this.setLoadStatus = function (status) {
          var loading = option.disableLoad ? false : status;

          _this.setState({
            loading: loading
          });
        };

        _this.dataFetch = function () {
          var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
          var isClearSelection = params.isClearSelection;
          if (typeof _this.fetchDataSourceFn !== 'function') return;
          var _this$state5 = _this.state,
              filters = _this$state5.filters,
              pagination = _this$state5.pagination,
              sorter = _this$state5.sorter;
          var dataSourceTableId = _this.tableId;

          var fnExe = _this.fetchDataSourceFn(filters, {
            pageSize: pagination.pageSize,
            current: pagination.current ? pagination.current : 1
          }, {
            field: sorter.field,
            order: sorter.order === 'descend' ? 'desc' : 'asc'
          }, _this.search);

          var dataSource;

          if (fnExe && fnExe.then) {
            _this.setLoadStatus(true);

            fnExe.then(function (resp) {
              _this.setLoadStatus(false);

              if (resp.code === 'success' && dataSourceTableId === _this.tableId) {
                dataSource = resp.data || [];
                /* 如果触发需要清空所有选中的数据 */

                if (isClearSelection) _this.setAllFlag(false);

                _this.setState(function (_ref5) {
                  var pagination = _ref5.pagination,
                      selectedRowKeys = _ref5.selectedRowKeys;
                  var newSelectedRowKeys = [];
                  var newSelectedRows = [];

                  if (!isClearSelection) {
                    newSelectedRows = _lodash["default"].filter(dataSource, function (item) {
                      if (selectedRowKeys.includes(item[_this.rowKey])) {
                        newSelectedRowKeys.push(item[_this.rowKey]);
                        return true;
                      } else {
                        return false;
                      }
                    });
                  }

                  return {
                    dataSource: dataSource,
                    selectedRows: newSelectedRows,
                    selectedRowKeys: newSelectedRowKeys,
                    pagination: _objectSpread({}, pagination, {
                      showQuickJumper: pagination.pageSize < resp.total,
                      total: resp.total
                    }),
                    isReady: true
                  };
                });
              }
            }, function () {
              _this.setLoadStatus(false);
            });
          } else {
            dataSource = fnExe;

            if (dataSource && _lodash["default"].isArray(dataSource)) {
              _this.setState({
                dataSource: dataSource,
                isReady: true
              });
            }
          }
        };

        _this.setDataFetchFn = function (fn) {
          if (typeof fn === 'function') {
            _this.fetchDataSourceFn = fn;
          }
        };

        _this.setSelectAble = function (val) {
          _this.setState(function (_ref6) {
            var selectAbleLock = _ref6.selectAbleLock,
                selectedRowKeys = _ref6.selectedRowKeys,
                selectAble = _ref6.selectAble;
            return {
              selectAble: val ? true : false,
              selectedRowKeys: selectAble !== val ? [] : selectedRowKeys,
              selectAbleLock: selectAble !== val ? true : selectAbleLock
            };
          });
          /* selectedRowKeys在table组件中需要延后执行,antd的table组件当前在移除checkbox行选择的时候，是无法移除选中状态 */


          setTimeout(function () {
            _this.setState({
              selectAbleLock: false
            });
          }, 100);
        };

        _this.setAllFlag = function (isAll) {
          var dataSource = _this.state.dataSource;

          var _assertThisInitialize = _assertThisInitialized(_this),
              rowKey = _assertThisInitialize.rowKey;

          var _newSelectedRowKeys = [];
          var _newSelectedRows = [];

          if (isAll) {
            dataSource.forEach(function (item) {
              _newSelectedRowKeys.push(item[rowKey]);

              _newSelectedRows.push(item);
            });

            _this.setState({
              selectedRowKeys: _newSelectedRowKeys,
              selectedRows: _newSelectedRows,
              allSelectedRows: _newSelectedRows
            });
          } else {
            _this.setState({
              selectedRowKeys: [],
              selectedRows: [],
              allSelectedRows: [],
              canceledRowKeys: [],
              canceledRows: []
            });
          }

          _this.setState({
            allFlag: isAll
          });
        };

        _this.onSelect = function (record, selected) {
          var _this$state6 = _this.state,
              allSelectedRows = _this$state6.allSelectedRows,
              selectedRowKeys = _this$state6.selectedRowKeys,
              selectedRows = _this$state6.selectedRows,
              allFlag = _this$state6.allFlag,
              canceledRowKeys = _this$state6.canceledRowKeys,
              canceledRows = _this$state6.canceledRows;

          var _assertThisInitialize2 = _assertThisInitialized(_this),
              rowKey = _assertThisInitialize2.rowKey;

          if (selected) {
            // 如果是全选状态下
            if (allFlag) {
              canceledRows = _this.removeFromCollection([record], canceledRows, rowKey, 'object');
              canceledRowKeys = _this.removeFromCollection([record], canceledRowKeys, rowKey, 'string');
            } else {
              allSelectedRows.push(record);
            }
          } else {
            if (allFlag) {
              canceledRowKeys.push(record[rowKey]);
              canceledRows.push(record);
            } else {
              allSelectedRows = _this.removeFromCollection([record], allSelectedRows, rowKey, 'object');
            }
          }

          var _option2 = option,
              childrenColumnName = _option2.childrenColumnName,
              parentKey = _option2.parentKey;

          if (childrenColumnName) {
            var isParent = record[childrenColumnName] === undefined || !!record[childrenColumnName];

            if (isParent) {
              // 父级被选中/取消
              var childRows = record[childrenColumnName] || [];
              var childKeys = childRows.map(function (_ref7) {
                var key = _ref7[rowKey];
                return key;
              });

              if (selected) {
                // 如果选中父级，先找出之前未选中的子集并添加
                var addKeys = childKeys.filter(function (key) {
                  return !selectedRowKeys.includes(key);
                });
                var addRows = [];

                if (addKeys.length) {
                  addRows = childRows.filter(function (_ref8) {
                    var key = _ref8[rowKey];
                    return addKeys.includes(key);
                  });
                }

                addKeys.push(record[rowKey]);
                addRows.push(record);

                _this.setState({
                  selectedRowKeys: [].concat(_toConsumableArray(selectedRowKeys), _toConsumableArray(addKeys)),
                  selectedRows: [].concat(_toConsumableArray(selectedRows), _toConsumableArray(addRows))
                });
              } else {
                // 取消父级选中，则需要删除之前选中的所有子集 
                var removeKeys = [].concat(_toConsumableArray(childKeys), [record[rowKey]]);

                _this.setState({
                  selectedRowKeys: selectedRowKeys.filter(function (key) {
                    return !removeKeys.includes(key);
                  }),
                  selectedRows: selectedRows.filter(function (_ref9) {
                    var key = _ref9[rowKey];
                    return !removeKeys.includes(key);
                  })
                });
              }
            } else {
              // 子集被选中/取消
              var dataSource = _this.state.dataSource;
              var _pKey = record[parentKey];
              var parent = dataSource.find(function (_ref10) {
                var key = _ref10[rowKey];
                return key === _pKey;
              });
              var pKey = parent[rowKey];

              if (parent) {
                var _key = record[rowKey];

                var _childKeys = (parent[childrenColumnName] || []).map(function (_ref11) {
                  var key = _ref11[rowKey];
                  return key;
                });

                if (selected) {
                  // 如果被选中，需要找到该父级下的所有子集是否被选中,全部选中则选中父级
                  var _addKeys = [_key];
                  var _addRows = [record];

                  if (_childKeys.every(function (key) {
                    return key === _key || selectedRowKeys.includes(key);
                  })) {
                    _addKeys.push(pKey);

                    _addRows.push(parent);
                  }

                  _this.setState({
                    selectedRowKeys: [].concat(_toConsumableArray(selectedRowKeys), _addKeys),
                    selectedRows: [].concat(_toConsumableArray(selectedRows), _addRows)
                  });
                } else {
                  var _removeKeys = [pKey, _key];

                  _this.setState({
                    selectedRowKeys: selectedRowKeys.filter(function (key) {
                      return !_removeKeys.includes(key);
                    }),
                    selectedRows: selectedRows.filter(function (_ref12) {
                      var key = _ref12[rowKey];
                      return !_removeKeys.includes(key);
                    })
                  });
                }
              }
            }
          }

          _this.setState({
            allSelectedRows: allSelectedRows,
            canceledRowKeys: canceledRowKeys,
            canceledRows: canceledRows
          });
        };

        _this.onSelectAll = function (selected, selectedRows, changeRows) {
          var _assertThisInitialize3 = _assertThisInitialized(_this),
              rowKey = _assertThisInitialize3.rowKey;

          var _this$state7 = _this.state,
              allSelectedRows = _this$state7.allSelectedRows,
              allFlag = _this$state7.allFlag,
              canceledRowKeys = _this$state7.canceledRowKeys,
              canceledRows = _this$state7.canceledRows;

          if (selected) {
            // 如果是全选状态下
            if (allFlag) {
              canceledRows = _this.removeFromCollection(changeRows, canceledRows, rowKey, 'object');
              canceledRowKeys = _this.removeFromCollection(changeRows, canceledRowKeys, rowKey, 'string');
            } else {
              allSelectedRows = allSelectedRows.concat(changeRows);
            }
          } else {
            if (allFlag) {
              canceledRows = canceledRows.concat(changeRows);
              canceledRowKeys = canceledRows.concat(changeRows.map(function (_ref13) {
                var key = _ref13[rowKey];
                return key;
              }));
            } else {
              allSelectedRows = _this.removeFromCollection(changeRows, allSelectedRows, _this.rowKey, 'object');
            }
          } // 处理树形结构


          var _option3 = option,
              childrenColumnName = _option3.childrenColumnName;

          if (childrenColumnName) {
            if (selected) {
              var dataSource = _this.state.dataSource;
              var childrenRows = dataSource.map(function (_ref14) {
                var _ref14$childrenColumn = _ref14[childrenColumnName],
                    rows = _ref14$childrenColumn === void 0 ? [] : _ref14$childrenColumn;
                return rows;
              });
              var allRows = dataSource.concat.apply(dataSource, _toConsumableArray(childrenRows));

              _this.setState({
                selectedRowKeys: allRows.map(function (_ref15) {
                  var key = _ref15[rowKey];
                  return key;
                }),
                selectedRows: allRows
              });
            } else {
              _this.setState({
                selectedRowKeys: [],
                selectedRows: []
              });
            }
          }

          _this.setState({
            allSelectedRows: allSelectedRows,
            canceledRows: canceledRows,
            canceledRowKeys: canceledRowKeys
          });
        };

        _this.removeFromCollection = function (records, collection, rowKey, type) {
          var keys = records.map(function (_ref16) {
            var key = _ref16[rowKey];
            return key;
          });
          var arr = collection || [];

          if (type === 'object') {
            return arr.filter(function (_ref17) {
              var key = _ref17[rowKey];
              return !keys.includes(key);
            });
          } else return arr.filter(function (key) {
            return !keys.includes(key);
          });
        };

        _this.resetSelectRows = function () {
          _this.setState({
            selectedRows: [],
            selectedRowKeys: [],
            allSelectedRows: []
          });
        };

        _this.modifySelectRows = function (operate) {
          var type = operate.type,
              rows = operate.rows,
              currentSelectRows = operate.currentSelectRows;
          var result = null;

          var _update = function _update() {
            var rebuildSelectRows = _lodash["default"].unionWith(currentSelectRows, rows, _lodash["default"].isEqual);

            result = rebuildSelectRows;
          };

          var _delete = function _delete() {
            var rebuildSelectRows = _lodash["default"].differenceWith(currentSelectRows, rows, _lodash["default"].isEqual);

            result = rebuildSelectRows;
          };

          switch (type) {
            case 'update':
              _update();

              break;

            case 'delete':
              _delete();

              break;

            default:
              break;
          }

          return result;
        };

        _this.customColumns = function () {
          var _this$state8 = _this.state,
              columns = _this$state8.columns,
              hideColumnCodeList = _this$state8.hideColumnCodeList,
              t = _this$state8.t;
          var columnsTreeData = [],
              defaultChecked = [];

          _lodash["default"].forEach(columns, function (col) {
            if (!col.meanLess) {
              columnsTreeData.push({
                code: col.dataIndex,
                name: col.title
              });

              if (!hideColumnCodeList.includes(col.dataIndex)) {
                defaultChecked.push({
                  code: col.dataIndex,
                  name: col.title
                });
              }
            }
          });

          return _react["default"].createElement(_PopSelect["default"], {
            options: columnsTreeData,
            defaultValue: defaultChecked,
            close: _this.setHideColumnCodeList
          }, _react["default"].createElement(_button["default"], {
            size: "default",
            type: "default"
          }, t('mkTable.btn')));
        };

        _this.setHideColumnCodeList = function (data) {
          var columns = _this.state.columns;
          var hideColumnCodeList = [];

          _lodash["default"].forEach(columns, function (col) {
            var findIndex = _lodash["default"].findIndex(data, {
              code: col.dataIndex
            });

            if (findIndex === -1 && !col.meanLess) {
              hideColumnCodeList.push(col.dataIndex);
            }
          });

          _this.setState({
            hideColumnCodeList: hideColumnCodeList
          });
        };

        _this.tableReset = function () {
          _this.setState(function () {
            return _this.originState;
          });
        };

        _this.state = {
          columns: [],
          filters: {},
          dataSource: [],
          loading: false,
          loadProps: {
            indicator: _react["default"].createElement(_icon["default"], {
              type: "loading-3-quarters",
              style: {
                fontSize: 24
              },
              spin: true
            })
          },
          pagination: {
            pageSize: option && option.pageSize ? option.pageSize : 20,
            defaultPageSize: option && option.pageSize ? option.pageSize : 20,
            // showTotal: (total) => {
            //     return <span>总数{total}条</span>
            // },
            pageSizeOptions: defaultPageSizeOptions,
            showSizeChanger: true,
            total: 0,
            size: 'small'
          },
          allSelectedRows: [],
          //所有选中过的data列，支持跨页选取
          selectedRows: [],
          selectedRowKeys: [],
          selectAble: false,
          selectAbleLock: false,
          sorter: {},
          hideColumnCodeList: [],
          allFlag: false,
          canceledRows: [],
          canceledRowKeys: [],
          tableMinWidth: 0,
          isReady: false,
          filtersMap: {},
          t: _mkTranslate["default"].noop()
        };
        _this.components = {
          header: {
            cell: ResizeableTitle
          }
        };
        _this.fetchDataSourceFn = null;
        _this.tableRef = null;
        _this.wrappedComponent = null;
        _this.tableId = undefined;
        _this.search = _defineProperty({}, option.searchKey, '');
        _this.originState = _lodash["default"].cloneDeep(_this.state);
        _this.searchWordChange = _lodash["default"].debounce(_this.searchTable, 800);

        _this.localeProcess();

        return _this;
      }

      _createClass(_temp, [{
        key: "setTableState",

        /* 设置table的local state，抛给Wrapper组件使用 */
        value: function setTableState() {}
        /* 设置table可选与否 */

      }, {
        key: "render",
        value: function render() {
          var _this2 = this;

          return _react["default"].createElement(WrapperComponent, _extends({
            generateTable: this.generateTable,
            generateFilter: this.generateFilter,
            generateSearch: this.generateSearch,
            dataFetch: this.dataFetch,
            setColumns: this.setColumns,
            setSelectAble: this.setSelectAble,
            setDataFetchFn: this.setDataFetchFn,
            resetSelectRows: this.resetSelectRows,
            customColumns: this.customColumns,
            setAllFlag: this.setAllFlag,
            onChange: this.onChange,
            clearAll: this.clearAll,
            clearSearch: this.clearSearch,
            searchEleRef: this.searchEl,
            ref: function ref(_ref18) {
              return _this2.wrappedComponent = _ref18;
            }
          }, this.state, this.props));
        }
      }]);

      return _temp;
    }(_react.Component), _temp;
  };
};

var _default = MkTable;
exports["default"] = _default;