"use strict";

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

var _typeof3 = require("@babel/runtime/helpers/typeof");

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

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

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

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

var _message2 = _interopRequireDefault(require("maycur-antd/lib/message"));

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 _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));

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

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

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

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

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

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

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

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

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

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

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 _ColumnSet = _interopRequireDefault(require("./ColumnSet"));

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"));

var _excluded = ["onResize", "width", "fixed"];

function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }

function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof3(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && 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 _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }

function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

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) { (0, _defineProperty2.default)(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; }

var prefix = _utils.default.prefixCls;
var MIN_WITH = 100;
var DEFAULT_PAGE_SIZE = 20;
/* title 宽度变动 */

var ResizeableTitle = function ResizeableTitle(props) {
  var onResize = props.onResize,
      width = props.width,
      fixed = props.fixed,
      restProps = (0, _objectWithoutProperties2.default)(props, _excluded);

  if (!width || fixed) {
    return /*#__PURE__*/_react.default.createElement("th", restProps);
  }

  return /*#__PURE__*/_react.default.createElement(_reactResizable.Resizable, {
    width: width,
    height: 0,
    onResize: onResize,
    minConstraints: [MIN_WITH, MIN_WITH]
  }, /*#__PURE__*/_react.default.createElement("th", restProps));
}; // 递归找到该key对应的column


var findColumn = function findColumn() {
  var columns = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
  var key = arguments.length > 1 ? arguments[1] : undefined;
  var len = columns.length;

  for (var i = 0; i < len; i++) {
    var _c = columns[i];

    if (_c.children && _c.children.length) {
      var res = findColumn(_c.children, key);
      if (res) return res;
    } else {
      if (_c.key === key) return _c;
    }
  }
}; // 递归修改对应column


var editColumn = function editColumn() {
  var columns = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
  var column = arguments.length > 1 ? arguments[1] : undefined;
  var dataPair = arguments.length > 2 ? arguments[2] : undefined;
  var len = columns.length;
  var dataIndex = column.dataIndex;

  for (var i = 0; i < len; i++) {
    var _c = columns[i];

    if (_c.children && _c.children.length) {
      var res = editColumn(_c.children, column, dataPair);
      if (res) return res;
    } else {
      if (_c.dataIndex === dataIndex) {
        var key = dataPair.key,
            value = dataPair.value;
        columns[i] = _objectSpread(_objectSpread({}, _c), {}, (0, _defineProperty2.default)({}, key, value));
        return true;
      }
    }
  }
};

var HocMkTable = function HocMkTable(option) {
  return function (WrapperComponent) {
    var defaultOption = {
      isFixHeader: false,
      resizeAble: false,
      disableLoad: false,
      hidePagination: false,
      firstDisplayColumns: [],
      isCrossPageSelect: false,
      doNotClearSelection: false,
      searchKey: 'keyword'
    };
    option = Object.assign(defaultOption, option);
    if (option.doNotClearSelection) option.isCrossPageSelect = true;
    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 /*#__PURE__*/function (_Component) {
      (0, _inherits2.default)(_class2, _Component);

      var _super = _createSuper(_class2);

      function _class2(_props) {
        var _this;

        (0, _classCallCheck2.default)(this, _class2);
        _this = _super.call(this, _props);

        _this.localeProcess = function () {
          _mkTranslate.default.getNameSpace('MK_Table').then(function (t) {
            _this.setState({
              t: t
            });
          });
        };

        _this.columnConvert = function (columns, displayColumns) {
          //注释原因： 先调用setColumns再调用generateColumnSet时会导致this中cacheKey等字段并没有赋值，无法记忆列表拖动后的顺序
          // const { cacheKey, getCachedByKey, ignoreColumnSet, defaultHidenKey } = this;  
          var cacheKey = _this.cacheKey || option.cacheKey;
          var getCachedByKey = _this.getCachedByKey || option.getCachedByKey;
          var ignoreColumnSet = _this.ignoreColumnSet || option.ignoreColumnSet; // const defaultHidenKey = this.defaultHidenKey || option.defaultHidenKey;

          var filters = _this.state.filters;
          var typeComponentMap = {
            'dateRange': _FilterDropDown.DateFilter,
            'search': _FilterDropDown.FuzzFilter,
            'checkbox': _FilterDropDown.CheckFilter,
            'department': _FilterDropDown.DepartmentPickerFilter,
            'numberRange': _FilterDropDown.NumberRangeFilter,
            'budgetment': _FilterDropDown.BudgetmentFilter,
            //预算组织筛选框
            'budgetSubject': _FilterDropDown.BudgetSubjectFilter,
            //预算科目筛选框
            'option': _FilterDropDown.OptionFilter,
            // 选项筛选框
            'tradingPartner': _FilterDropDown.TradingPartnerFilter,
            'customTagSelect': _FilterDropDown.CustomTagSelectFilter,
            // 自定义标签筛选
            'tree': _FilterDropDown.TreeFilter // 树选择

          };
          _this.columnMap = {};

          var loop = function loop(arr, isChild) {
            var columnPanel = [];

            _lodash.default.forEach(arr, function (col) {
              var colKey = col['dataIndex'] || col['key'];

              if (col.filterOption) {
                col.filterDropdown = function (_ref) {
                  var setSelectedKeys = _ref.setSelectedKeys,
                      selectedKeys = _ref.selectedKeys,
                      confirm = _ref.confirm,
                      clearFilters = _ref.clearFilters,
                      cancel = _ref.cancel,
                      clickedInBlank = _ref.clickedInBlank,
                      resetClickedInBlank = _ref.resetClickedInBlank;
                  var Cop = typeComponentMap[col.filterOption.type];
                  return /*#__PURE__*/_react.default.createElement(Cop, (0, _extends2.default)({}, col, col.filterOption.optionProps, {
                    setSelectedKeys: setSelectedKeys,
                    selectedKeys: selectedKeys,
                    confirm: confirm,
                    setFiltersMap: _this.setFiltersMap,
                    clearFilters: clearFilters,
                    columnModify: _this.columnModify,
                    columns: _this.state.columns,
                    cancel: cancel,
                    clickedInBlank: clickedInBlank,
                    resetClickedInBlank: resetClickedInBlank,
                    visible: _this.columnFiltersVisible[colKey]
                  }));
                };

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

              col.onFilterDropdownVisibleChange = function (v) {
                _this.syncColFilterVisible(colKey, v);
              };

              if (col.children && col.children.length) {
                col.children = loop(col.children, true).result;
              } // 只记录第一层列信息


              if (!isChild) {
                if (Array.isArray(ignoreColumnSet) && ignoreColumnSet.includes(col.dataIndex)) {
                  columnPanel.push({
                    label: typeof col.title === 'string' ? col.title : col.customTitle,
                    key: col.dataIndex,
                    ignore: true,
                    defaultHide: col.defaultHide
                  });
                } else {
                  columnPanel.push({
                    label: typeof col.title === 'string' ? col.title : col.customTitle,
                    key: col.dataIndex,
                    checked: (col === null || col === void 0 ? void 0 : col.checked) === false ? false : true,
                    defaultHide: col.defaultHide
                  });
                }
              }

              _this.columnMap[col.dataIndex] = col;
            });

            return {
              result: arr || [],
              columnPanel: columnPanel
            };
          };

          var _loop = loop(_lodash.default.cloneDeep(columns)),
              columnPanel = _loop.columnPanel;

          if (cacheKey && typeof getCachedByKey === 'function') {
            var cachedColumnPanel = _this.cachedColumnConvert(columnPanel);

            if (Array.isArray(cachedColumnPanel) && cachedColumnPanel.length > 0) {
              var result = [];
              cachedColumnPanel.forEach(function (item) {
                var findedIndex = _lodash.default.findIndex(columnPanel, function (o) {
                  return o.key === item.key;
                });

                if (findedIndex > -1 && !columnPanel[findedIndex].ignore) {
                  result.push(_objectSpread(_objectSpread({}, item), {}, {
                    label: columnPanel[findedIndex].label
                  }));
                  columnPanel.splice(findedIndex, 1);
                }
              }); // 读取缓存的剩下的列全都不在列表中显示

              columnPanel.forEach(function (item) {
                if (!item.ignore) item.checked = false;
              });
              result.push.apply(result, (0, _toConsumableArray2.default)(columnPanel));

              if (!_lodash.default.isEmpty(displayColumns)) {
                _lodash.default.forEach(result, function (item) {
                  if (!displayColumns.includes(item.key)) {
                    item.checked = false;
                  }
                });
              }

              _this.setState({
                columnPanel: result
              });

              return _this.getColumnsByPanel(result, true);
            } else {
              // 没有缓存信息 可能默认需要隐藏	
              columnPanel.forEach(function (item) {
                if (item.defaultHide) {
                  item.checked = false;
                }
              });
            }
          } else if (!_lodash.default.isEmpty(displayColumns)) {
            // 费用列表支持后端记忆
            _this.setState({
              columnPanel: displayColumns
            });

            var _this$getColumnsByPan = _this.getColumnsByPanel(displayColumns, true),
                _columns = _this$getColumnsByPan.columns,
                _tableMinWidth = _this$getColumnsByPan.tableMinWidth;

            return {
              columns: _columns,
              tableMinWidth: _tableMinWidth
            };
          }

          _this.setState({
            columnPanel: columnPanel
          });

          return _this.getColumnsByPanel(columnPanel, true);
        };

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

            _this.setState(function (_ref3) {
              var columns = _ref3.columns,
                  tableMinWidth = _ref3.tableMinWidth;
              var nextColumns = (0, _toConsumableArray2.default)(columns);
              nextColumns[index] = _objectSpread(_objectSpread({}, nextColumns[index]), {}, {
                width: size.width
              });

              _this.saveColumnsWith(nextColumns);

              return {
                columns: nextColumns
              };
            });
          };
        };

        _this.saveColumnsWith = _lodash.default.debounce(function (columns) {
          var setColumsWith = _this.props.setColumsWith;
          var _option = option,
              cacheColumnsWidth = _option.cacheColumnsWidth;

          if (cacheColumnsWidth && typeof setColumsWith === 'function') {
            setColumsWith(columns);
          }
        }, 1000);

        _this.onTableChange = function (pagination) {
          var filters = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
          var sorter = arguments.length > 2 ? arguments[2] : undefined;
          var extra = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
          var chgOption = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
          var columns = _this.state.columns;
          var currentFilters = _this.state.filters;
          var isFilterChange = false;
          var isClearSelection = true;

          if (option.doNotClearSelection) {
            isClearSelection = false;
          } else if (chgOption.doNotClearSelection) {
            isClearSelection = false;
          } else if (option.isCrossPageSelect) {
            _lodash.default.forEach(filters, function (v, k) {
              if (_lodash.default.has(currentFilters, k)) {
                if (!_lodash.default.isEqual(v, currentFilters[k])) {
                  isFilterChange = true;
                }
              }
            });
            /* 如果只是跨页选取，那么条件变动则需要清空 */


            isClearSelection = isFilterChange;
          }

          _lodash.default.forEach(filters, function (value, key) {
            // 改为递归查找
            var column = findColumn(columns, key);

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

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

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

          var loopModify = function loopModify(columns) {
            _lodash.default.forEach(columns, function (column) {
              if (column.children && column.children.length) {
                loopModify(column.children);
              } else {
                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
                  });
                }
              }
            });
          }; // 先loading, 否则调用onTableChange的方法loading会延迟出现


          _this.setLoadStatus(true);

          loopModify(columns);

          _this.setState({
            filters: filters,
            sorter: {
              field: sorter.field,
              order: sorter.order
            },
            pagination: _objectSpread({
              pageSize: DEFAULT_PAGE_SIZE,
              current: 1
            }, pagination),
            extra: extra
          }, function () {
            _this.dataFetch({
              isClearSelection: isClearSelection
            });
          });
        };

        _this.onPaginationChange = function () {
          var _pagination = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

          var pagination = _this.state.pagination;

          _this.setState({
            pagination: _objectSpread(_objectSpread({}, pagination || {}), _pagination)
          }, function () {
            var pageOptions = {
              isClearSelection: option.isCrossPageSelect ? false : true
            };

            _this.dataFetch(pageOptions);
          });
        };

        _this.columnModify = function (column, dataPair, withoutUpdateState) {
          if (column && dataPair) {
            var columns = _this.state.columns; // 改为递归查找并修改

            var isEdit = editColumn(columns, column, dataPair);

            if (isEdit && !withoutUpdateState) {
              // 只有在column被修改时才需要在最外层setState
              _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 () {
          if (_this.$filterBar) {
            var theFilters = _this.$filterBar.convertFilter(_this.state.filters);

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

        _this.clearSearch = function () {
          _this.search = (0, _defineProperty2.default)({}, 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.onTableChange(pagination, newFilter, sorter);
        };

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

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

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

          _this.setState({
            filtersMap: _objectSpread(_objectSpread({}, filtersMap), {}, (0, _defineProperty2.default)({}, key, filters))
          });
        };

        _this.generateTable = function (params) {
          /* 当前不支持列冻结的功能 */
          var _this$state3 = _this.state,
              columns = _this$state3.columns,
              loading = _this$state3.loading,
              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,
              _params$rowClickSelec = params.rowClickSelectable,
              rowClickSelectable = _params$rowClickSelec === void 0 ? false : _params$rowClickSelec,
              componentsBody = params.componentsBody,
              rowProps = params.rowProps,
              hidePagination = params.hidePagination,
              renderEmpty = params.renderEmpty;

          var pagination = _objectSpread(_objectSpread({}, _this.state.pagination), params.pagination);

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

          if (componentsBody) {
            _this.components.body = componentsBody;
          }

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

          var wrapOnRow = function wrapOnRow(record) {
            return _objectSpread(_objectSpread({}, rowProps), {}, {
              onClick: function onClick(e) {
                var currentSelectRows = (0, _toConsumableArray2.default)(_this.state.selectedRows),
                    currentSelectedRowKeys = (0, _toConsumableArray2.default)(_this.state.selectedRowKeys);

                if (selectAble) {
                  switch (rowSelectionOption.type) {
                    case 'radio':
                      currentSelectRows = [record];
                      currentSelectedRowKeys = [record[rowKey]];
                      break;

                    default:
                      if (rowClickSelectable) {
                        var removeData = _lodash.default.remove(currentSelectRows, function (val) {
                          return val[rowKey] === record[rowKey];
                        });

                        if (removeData.length === 0) {
                          currentSelectRows = [].concat((0, _toConsumableArray2.default)(currentSelectRows), [record]);
                        }

                        currentSelectedRowKeys = [];

                        _lodash.default.forEach(currentSelectRows, function (row) {
                          currentSelectedRowKeys.push(row[rowKey]);
                        }); // if (_.find(currentSelectRows, val => { return v[rowKey] === record[rowKey] })) {
                        //     currentSelectRows = this.modifySelectRows({ currentSelectRows, type: 'delete', rows: [record], rowKeys: [record[rowKey]] });
                        // } else {
                        //     currentSelectRows = this.modifySelectRows({ currentSelectRows, type: 'update', rows: [record], rowKeys: [record[rowKey]] });
                        // }
                        // currentSelectedRowKeys = [];
                        // _.forEach(currentSelectRows, row => {
                        //     currentSelectedRowKeys.push(row[rowKey]);
                        // });

                      }

                      break;
                  }

                  _this.setState({
                    selectedRows: currentSelectRows,
                    selectedRowKeys: currentSelectedRowKeys
                  });
                }

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

                  if (instanceOnRow && typeof instanceOnRow.onClick === 'function') {
                    instanceOnRow.onClick(e, {
                      selectedRows: currentSelectRows,
                      selectedRowKeys: currentSelectedRowKeys
                    });
                  }
                }
              }
            });
          };

          var onSelectionChange = rowSelectionOption.onSelectionChange,
              customMaintain = rowSelectionOption.customMaintain;
          _this.rowKey = rowKey;
          var rowSelection;

          if (customMaintain) {
            // 自己维护rowSelection
            rowSelection = rowSelectionOption;
          } else {
            rowSelection = _objectSpread(_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,
                        rowKey: rowKey
                      });
                    }

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

                    _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 /*#__PURE__*/_react.default.createElement("div", {
              className: tableCls,
              ref: function ref(_ref4) {
                _this.tableRef = _ref4;
              }
            }, /*#__PURE__*/_react.default.createElement(_table.FlexTable, (0, _extends2.default)({}, params, {
              onRow: wrapOnRow,
              key: tableId,
              rowSelection: selectAble ? rowSelection : selectAbleLock ? {
                selectedRowKeys: selectedRowKeys
              } : null,
              components: _this.components,
              columns: visibleColumns,
              scroll: tableScroll,
              pagination: hidePagination || option.hidePagination ? false : pagination,
              childrenColumnName: childrenColumnName,
              dataSource: dataSource,
              onChange: _this.onTableChange,
              loading: _objectSpread(_objectSpread({}, loadProps), {}, {
                spinning: loading
              }),
              locale: {
                emptyText: function emptyText() {
                  return isReady && renderEmpty ? renderEmpty() : /*#__PURE__*/_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 /*#__PURE__*/_react.default.createElement(_FilterStateBar.default, (0, _extends2.default)({
            filters: filters,
            filtersMap: filtersMap,
            columns: columns,
            totalCount: pagination.total ? pagination.total : dataSource.length,
            removeFilter: _this.removeSingleFilter,
            onRefFilterBar: _this.onRefFilterBar,
            fetchCustomFilterData: _this.fetchCustomFilterData
          }, props));
        };

        _this.generateColumnSet = function () {
          var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
          var _this$state5 = _this.state,
              columnPanel = _this$state5.columnPanel,
              t = _this$state5.t;
          var cacheKey = params.cacheKey,
              setCachedByKey = params.setCachedByKey,
              getCachedByKey = params.getCachedByKey,
              ignoreColumnSet = params.ignoreColumnSet,
              _params$keepLastItem = params.keepLastItem,
              keepLastItem = _params$keepLastItem === void 0 ? false : _params$keepLastItem,
              _params$ignoreColumnR = params.ignoreColumnRenderKey,
              ignoreColumnRenderKey = _params$ignoreColumnR === void 0 ? [] : _params$ignoreColumnR;
          _this.cacheKey = cacheKey ? cacheKey : option.cacheKey;
          _this.setCachedByKey = setCachedByKey ? setCachedByKey : option.setCachedByKey;
          _this.getCachedByKey = getCachedByKey ? getCachedByKey : option.getCachedByKey;
          _this.ignoreColumnSet = ignoreColumnSet ? ignoreColumnSet : option.ignoreColumnSet;
          _this.keepLastItem = keepLastItem ? keepLastItem : option.keepLastItem; // TODO 
          //在单据费用中新增ignoreColumnRenderKey字段，作用效果和ignoreColumnSet等同，之所以增加是因为费用列表场景特殊，第一列不允许拖动，但是提单时和流程中的第一列是不一样的所以只能在使用时传进数据

          var _ignoreColumnRenderKey = _lodash.default.concat(_this.ignoreColumnSet, ignoreColumnRenderKey);

          _lodash.default.forEach(columnPanel, function (item) {
            item.ignore = false;

            _lodash.default.forEach(_ignoreColumnRenderKey, function (citem) {
              if (item.key === citem) {
                item.ignore = true;
              }
            });
          });

          return /*#__PURE__*/_react.default.createElement(_ColumnSet.default, {
            dataSource: columnPanel,
            keepLastItem: keepLastItem,
            name: t('mkTable.columnVisible'),
            onEnd: function onEnd(panels, isNeedRefresh) {
              var columnsTreeData = [];

              _lodash.default.forEach(panels, function (col) {
                // 不需要记忆操作（费用列表）
                if (col.key === 'delete' || col.code === 'delete') {
                  return;
                }

                columnsTreeData.push(_objectSpread({}, col));
              });

              _this.wrappedComponent && _this.wrappedComponent.wrappedInstance && _this.wrappedComponent.wrappedInstance.setCacheInfo && _this.wrappedComponent.wrappedInstance.setCacheInfo('customColumns', columnsTreeData);

              var _this$getColumnsByPan2 = _this.getColumnsByPanel(panels),
                  columns = _this$getColumnsByPan2.columns,
                  tableMinWidth = _this$getColumnsByPan2.tableMinWidth,
                  hideCodeList = _this$getColumnsByPan2.hideCodeList;

              _this.setState({
                columnPanel: panels,
                columns: columns,
                tableMinWidth: tableMinWidth,
                hideColumnCodeList: hideCodeList
              }, function () {
                if (isNeedRefresh) _this.clearAll();
              });
            }
          });
        };

        _this.getColumnsByPanel = function (panels, isInit) {
          var _assertThisInitialize = (0, _assertThisInitialized2.default)(_this),
              cacheKey = _assertThisInitialize.cacheKey,
              setCachedByKey = _assertThisInitialize.setCachedByKey;

          var newColumns = [];
          var tableMinWidth = 0;
          var hideCodeList = []; // 新增需要隐藏的列

          if (typeof setCachedByKey === 'function') {
            if (Array.isArray(panels) && panels.length > 0 && !isInit) {
              // 初始化不需要缓存
              setCachedByKey(cacheKey, panels.filter(function (_ref5) {
                var ignore = _ref5.ignore;
                return !ignore;
              }));
            }
          }

          if (Array.isArray(panels) && panels.length > 0) {
            panels.forEach(function (item) {
              if (item && item.checked || !('checked' in item)) {
                var _c = _this.columnMap[item.key];

                if (_c) {
                  tableMinWidth += _c.width || _c.minWidth || MIN_WITH;
                  newColumns.push(_c);
                }
              } else if (item && !item.checked) {
                var _c2 = _this.columnMap[item.key];

                if (_c2) {
                  hideCodeList.push(_c2.key);
                }
              }
            });
          }

          return {
            columns: newColumns,
            tableMinWidth: tableMinWidth,
            hideCodeList: hideCodeList
          };
        };

        _this.searchTable = function (value) {
          var isClearSelection = true;

          if (option.doNotClearSelection) {
            isClearSelection = false;
          }

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

            _this.dataFetch({
              isClearSelection: isClearSelection
            });
          });
        };

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

        _this.generateSearch = function () {
          var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
          return /*#__PURE__*/_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 displayColumns = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
          var hideColumnCodeList = [];

          if (originColumns) {
            originColumns = _lodash.default.cloneDeep(originColumns);
            var initSorter = {},
                initFilter = {};

            var loopOriginColumns = function loopOriginColumns(arr) {
              _lodash.default.forEach(arr, function (column) {
                if (column.children && column.children.length) {
                  loopOriginColumns(column.children);
                } else {
                  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;
                  } else {
                    initFilter[column.dataIndex] = null;
                  }

                  if (displayColumns.length > 0) {
                    // 兼容之前后端记忆的数据
                    if ((0, _typeof2.default)(displayColumns[0]) === 'object') {
                      _lodash.default.forEach(displayColumns, function (item) {
                        if ('checked' in item && !item.checked) {
                          hideColumnCodeList.push(item.key);
                        }
                      });
                    } else if (!displayColumns.includes(column.dataIndex)) {
                      hideColumnCodeList.push(column.dataIndex);
                    }
                  } else 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';
                    var _render = column.render;

                    column.render = function (value, row, index) {
                      var renderValue = typeof _render === 'function' ? _render(value, row, index) : value;
                      return /*#__PURE__*/_react.default.createElement(_popover.default, {
                        content: renderValue,
                        trigger: "hover",
                        overlayClassName: "mkbs-table-cell-popover",
                        placement: "topLeft"
                      }, renderValue);
                    };
                  }
                }
              });
            };

            loopOriginColumns(originColumns);

            var _this$columnConvert = _this.columnConvert(originColumns, displayColumns),
                _this$columnConvert$c = _this$columnConvert.columns,
                columns = _this$columnConvert$c === void 0 ? [] : _this$columnConvert$c,
                tableMinWidth = _this$columnConvert.tableMinWidth; // const tableRefW = this.tableRef ? this.tableRef.getBoundingClientRect().width : 0;
            // if (columns.length > 0 && tableMinWidth < tableRefW) { // 表格列宽总和，小于实际表格应占有的宽度
            //     for (let i = columns.length - 1; i >= 0; i--) {
            //         if (columns[i].fixed || i === 0) {
            //             Reflect.deleteProperty(columns[i], 'width'); // 将这一列变为自适应
            //             break;
            //         }
            //     }
            // }


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

            _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,
              deleteNum = params.deleteNum;
          if (typeof _this.fetchDataSourceFn !== 'function') return;
          var _this$state6 = _this.state,
              filters = _this$state6.filters,
              pagination = _this$state6.pagination,
              sorter = _this$state6.sorter,
              extra = _this$state6.extra,
              prevDataSource = _this$state6.dataSource; // 删除个数等于当前页数量时，需要刷新前一页的数据

          if (deleteNum > 0 && prevDataSource && prevDataSource.length === deleteNum && pagination.current > 1) {
            pagination.current = pagination.current - 1;
          }

          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, extra);

          var dataSource;

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

            var _fnExeId = ++_this.fnExeId;

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

              if (_fnExeId !== _this.fnExeId) return;

              if (resp.code === 'success' && dataSourceTableId === _this.tableId) {
                dataSource = resp.data || [];

                _this.setState(function (_ref6) {
                  var pagination = _ref6.pagination,
                      selectedRowKeys = _ref6.selectedRowKeys;
                  var selectedInfo = {};
                  /* 如果触发需要清空所有选中的数据 */

                  if (isClearSelection) selectedInfo = _objectSpread(_objectSpread({}, _this.clearSelection()), {}, {
                    allFlag: false
                  });
                  return _objectSpread(_objectSpread({}, selectedInfo), {}, {
                    dataSource: dataSource,
                    pagination: _objectSpread(_objectSpread({}, pagination), {}, {
                      showQuickJumper: pagination.pageSize < resp.total,
                      total: resp.total
                    }),
                    isReady: true
                  });
                });
              }
            }, function () {
              _this.setLoadStatus(false);
            });
          } else {
            dataSource = fnExe; // 可能在 onTableChange 设置了loading为true

            _this.setLoadStatus(false);

            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) {
          var keepSelected = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;

          _this.setState(function (_ref7) {
            var selectAbleLock = _ref7.selectAbleLock,
                selectedRowKeys = _ref7.selectedRowKeys,
                selectAble = _ref7.selectAble;
            var newSelectedRowKeys = (0, _toConsumableArray2.default)(selectedRowKeys);

            if (selectAble !== val && !keepSelected) {
              newSelectedRowKeys = [];
            }

            return {
              selectAble: val ? true : false,
              selectedRowKeys: newSelectedRowKeys,
              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 _assertThisInitialize2 = (0, _assertThisInitialized2.default)(_this),
              rowKey = _assertThisInitialize2.rowKey;

          var _newSelectedRowKeys = [];
          var _newSelectedRows = [];
          var selectionSet = {};

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

              _newSelectedRows.push(item);
            });
            selectionSet = {
              selectedRowKeys: _newSelectedRowKeys,
              selectedRows: _newSelectedRows,
              allSelectedRows: _newSelectedRows
            };
          } else {
            selectionSet = _this.clearSelection();
          }

          _this.setState(_objectSpread(_objectSpread({}, selectionSet), {}, {
            allFlag: isAll
          }));
        };

        _this.clearSelection = function () {
          return {
            selectedRowKeys: [],
            selectedRows: [],
            allSelectedRows: [],
            canceledRowKeys: [],
            canceledRows: []
          };
        };

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

          var _assertThisInitialize3 = (0, _assertThisInitialized2.default)(_this),
              rowKey = _assertThisInitialize3.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 _option3 = option,
              childrenColumnName = _option3.childrenColumnName,
              parentKey = _option3.parentKey;

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

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

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

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

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

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

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

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

                var _childKeys = (parent[childrenColumnName] || []).map(function (_ref12) {
                  var key = _ref12[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((0, _toConsumableArray2.default)(selectedRowKeys), _addKeys),
                    selectedRows: [].concat((0, _toConsumableArray2.default)(selectedRows), _addRows)
                  });
                } else {
                  var _removeKeys = [pKey, _key];

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

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

        _this.onSelectAll = function (selected, selectedRows, changeRows) {
          var _assertThisInitialize4 = (0, _assertThisInitialized2.default)(_this),
              rowKey = _assertThisInitialize4.rowKey;

          var _this$state8 = _this.state,
              allSelectedRows = _this$state8.allSelectedRows,
              allFlag = _this$state8.allFlag,
              canceledRowKeys = _this$state8.canceledRowKeys,
              canceledRows = _this$state8.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 (_ref14) {
                var key = _ref14[rowKey];
                return key;
              }));
            } else {
              allSelectedRows = _this.removeFromCollection(changeRows, allSelectedRows, _this.rowKey, 'object');
            }
          } // 处理树形结构


          var _option4 = option,
              childrenColumnName = _option4.childrenColumnName;

          if (childrenColumnName) {
            if (selected) {
              var _isSelectedRows = option.isCrossPageSelect ? (0, _toConsumableArray2.default)(allSelectedRows) : selectedRows;

              var childrenRows = _isSelectedRows.map(function (_ref15) {
                var _ref15$childrenColumn = _ref15[childrenColumnName],
                    rows = _ref15$childrenColumn === void 0 ? [] : _ref15$childrenColumn;
                return rows;
              });

              var allRows = _isSelectedRows.concat.apply(_isSelectedRows, (0, _toConsumableArray2.default)(childrenRows));

              _this.setState({
                selectedRowKeys: allRows.map(function (_ref16) {
                  var key = _ref16[rowKey];
                  return key;
                }),
                selectedRows: allRows
              });
            } else {
              var _isSelectedRows2 = option.isCrossPageSelect ? (0, _toConsumableArray2.default)(allSelectedRows) : [];

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

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

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

          if (type === 'object') {
            return arr.filter(function (_ref19) {
              var key = _ref19[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,
              _operate$rowKey = operate.rowKey,
              rowKey = _operate$rowKey === void 0 ? '' : _operate$rowKey,
              rowKeys = operate.rowKeys;
          var result = null;

          var currentSelectedRowKeys = _lodash.default.map(currentSelectRows, function (row) {
            return row[rowKey];
          });

          var _update = function _update() {
            var _rebuildSelectRows = _lodash.default.unionWith(currentSelectRows, rows, _lodash.default.isEqual);

            var rebuildSelectRowKeys = _lodash.default.unionWith(currentSelectedRowKeys, rowKeys, _lodash.default.isEqual);

            result = getResult(rebuildSelectRowKeys, _rebuildSelectRows);
          };

          var _delete = function _delete() {
            var rebuildSelectRowKeys = _lodash.default.differenceWith(currentSelectedRowKeys, rowKeys, _lodash.default.isEqual);

            result = getResult(rebuildSelectRowKeys, currentSelectRows);
          };

          var getResult = function getResult(keys, rows) {
            var _result = [];

            _lodash.default.forEach(keys, function (item) {
              var data = _lodash.default.find(rows, (0, _defineProperty2.default)({}, rowKey, item));

              _result.push(data);
            });

            return _result;
          };

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

              break;

            case 'delete':
              _delete();

              break;

            default:
              break;
          }

          return result;
        };

        _this.customColumns = function () {
          var _this$state9 = _this.state,
              columns = _this$state9.columns,
              hideColumnCodeList = _this$state9.hideColumnCodeList,
              t = _this$state9.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 /*#__PURE__*/_react.default.createElement(_PopSelect.default, {
            options: columnsTreeData,
            defaultValue: defaultChecked,
            close: _this.setHideColumnCodeList,
            setTableColumns: _this.wrappedComponent && _this.wrappedComponent.wrappedInstance.setCacheInfo
          }, /*#__PURE__*/_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.onMouseDown = function (e) {
          _this.mouseDown = true;
        };

        _this.onMouseUp = function () {
          if (!_this.mouseDown) return;
          _this.mouseDown = false;
        };

        _this.onMouseMove = function (e) {
          var t = _this.state.t;

          if (_this.mouseDown && !_this.showMsg) {
            _this.showMsg = true;
            setTimeout(function () {
              _this.showMsg = false;
            }, 3000);

            _message2.default.info(t('mkTable.tip'), 3); //按住【Shift】滚动鼠标滑轮，可以快速滑动横向滚动条

          }
        };

        _this.addListenerToScrollBar = function () {
          if (_this.tableRef) {
            var container = _this.tableRef.getElementsByClassName('main-table');

            if (container && container.length) {
              var xScrollBar = container[0].getElementsByClassName('ps__thumb-x');
              _this.xScrollBar = xScrollBar && xScrollBar[0];
              _this.xScrollBar.onmousedown = _this.onMouseDown;
              _this.xScrollBar.onmouseup = _this.onMouseUp;
              _this.xScrollBar.onmousemove = _this.onMouseMove;
            }

            _this.tableRef.onmouseup = _this.onMouseUp; // 鼠标按键在非xScrollBar上松开时也需要触发
          }
        };

        _this.tableResize = function () {// if (this.tableRef) {
          // console.log('table width========', this.tableRef.getBoundingClientRect().width);
          // }
        };

        _this.isMac = function () {
          return /macintosh|mac os x/i.test(navigator.userAgent);
        };

        _this.syncColFilterVisible = function (key, visible) {
          console.log(key, visible);
          if (key) _this.columnFiltersVisible[key] = visible;
        };

        _this.componentDidUpdate = function () {
          if (!_this.tableRefInit && !_this.isMac()) {
            _this.tableRefInit = true;

            _this.addListenerToScrollBar();
          }
        };

        var _props$initState = _props.initState,
            initState = _props$initState === void 0 ? {} : _props$initState;
        _this.state = {
          columns: [],
          filters: {},
          dataSource: [],
          loading: false,
          loadProps: {
            indicator: /*#__PURE__*/_react.default.createElement(_icon.default, {
              type: "loading-3-quarters",
              style: {
                fontSize: 24
              },
              spin: true
            })
          },
          pagination: {
            pageSize: option && option.pageSize ? option.pageSize : DEFAULT_PAGE_SIZE,
            defaultPageSize: option && option.pageSize ? option.pageSize : DEFAULT_PAGE_SIZE,
            pageSizeOptions: defaultPageSizeOptions,
            showSizeChanger: true,
            total: 0,
            size: 'small'
          },
          allSelectedRows: [],
          //所有选中过的data列，支持跨页选取
          selectedRows: initState.selectedRows || [],
          selectedRowKeys: initState.selectedRowKeys || [],
          selectAble: initState.selectAble || false,
          selectAbleLock: false,
          sorter: {},
          hideColumnCodeList: [],
          allFlag: false,
          canceledRows: [],
          canceledRowKeys: [],
          tableMinWidth: 0,
          isReady: false,
          filtersMap: {},
          t: _mkTranslate.default.noop(),
          columnPanel: []
        };
        _this.components = {
          header: {
            cell: ResizeableTitle
          }
        };
        _this.fetchDataSourceFn = null;
        _this.tableRef = null;
        _this.forwardRef = _props.wrappedComponentRef ? _props.wrappedComponentRef : function (ref) {
          _this.wrappedComponent = ref;
        };
        _this.tableId = undefined;
        _this.search = (0, _defineProperty2.default)({}, option.searchKey, '');
        _this.originState = _lodash.default.cloneDeep(_this.state);
        _this.searchWordChange = _lodash.default.debounce(_this.searchTable, 800);

        _this.localeProcess();

        _this.onTableChange = _lodash.default.debounce(_this.onTableChange, 150, {
          leading: true
        });
        _this.fnExeId = 0; // 防止多次请求，前一次请求返回比后一次返回慢导致数据错误

        _this.columnFiltersVisible = {};
        return _this;
      }

      (0, _createClass2.default)(_class2, [{
        key: "cachedColumnConvert",
        value:
        /**
         * @description: 转换表格列缓存信息，为了解决用户自定义了“列表展示”，后续添加的列默认不展示的问题
         * @param {Array} columnPanel 列字段信息 
         * @return {Array} result 转换后的表格列信息
         */
        function cachedColumnConvert() {
          var columnPanel = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
          //注释原因： 先调用setColumns再调用generateColumnSet时会导致this中cacheKey等字段并没有赋值，无法记忆列表拖动后的顺序
          // const { cacheKey, getCachedByKey, setCachedByKey } = this;
          var cacheKey = this.cacheKey || option.cacheKey;
          var getCachedByKey = this.getCachedByKey || option.getCachedByKey;
          var setCachedByKey = this.setCachedByKey || option.setCachedByKey;
          var result = [];
          var cachedColumnPanel = getCachedByKey(cacheKey);
          if (_lodash.default.isEmpty(cachedColumnPanel)) return cachedColumnPanel;
          cachedColumnPanel.forEach(function (cachedColumn, index) {
            var _loop2 = function _loop2(i) {
              var currentColumn = columnPanel[i];
              var columnIndex = result.findIndex(function (item) {
                return item['key'] === currentColumn['key'];
              });
              if (columnIndex > -1) return "continue";
              var cachedColumnIndex = cachedColumnPanel.findIndex(function (item) {
                return item['key'] === currentColumn['key'];
              });

              if (cachedColumnIndex === -1 && !currentColumn.ignore) {
                result.push(currentColumn);
              }

              if (cachedColumn['key'] === currentColumn['key']) {
                result.push(_objectSpread(_objectSpread({}, currentColumn), cachedColumn));
              }

              ;
            };

            for (var i = 0; i < columnPanel.length; i++) {
              var _ret = _loop2(i);

              if (_ret === "continue") continue;
            }
          }); // 调整操作列位置因为需要操作列在最尾部（目前在这先规整一下）

          var operationColumn = _lodash.default.remove(result, function (item) {
            return item.key === 'delete';
          });

          if (!_lodash.default.isEmpty(operationColumn)) {
            result.push(operationColumn[0]);
          }

          if (typeof setCachedByKey === 'function') {
            setCachedByKey(cacheKey, result);
          }

          return result;
        }
        /* 控制table header的resize功能 */

      }, {
        key: "componentDidMount",
        value: function componentDidMount() {
          // mac上table的ScrollBar被自定义过了，导致shift+鼠标滚轮没有用，暂时先屏蔽掉
          if (this.tableRef && !this.isMac()) {
            this.tableRefInit = true;
            this.addListenerToScrollBar();
          } else {
            this.tableRefInit = false;
          }
        }
      }, {
        key: "render",
        value: function render() {
          return /*#__PURE__*/_react.default.createElement(WrapperComponent, (0, _extends2.default)({}, this.state, this.props, {
            generateTable: this.generateTable,
            generateFilter: this.generateFilter,
            generateSearch: this.generateSearch,
            generateColumnSet: this.generateColumnSet,
            dataFetch: this.dataFetch,
            setColumns: this.setColumns,
            setSelectAble: this.setSelectAble,
            setDataFetchFn: this.setDataFetchFn,
            resetSelectRows: this.resetSelectRows,
            customColumns: this.customColumns,
            setAllFlag: this.setAllFlag,
            onChange: this.onTableChange //命名存在问题，本意是筛选条件变化时出发的事件
            ,
            onFilterChange: this.onTableChange,
            onPaginationChange: this.onPaginationChange,
            clearAll: this.clearAll,
            clearSearch: this.clearSearch,
            searchEleRef: this.searchEl,
            ref: this.forwardRef
          }));
        }
      }]);
      return _class2;
    }(_react.Component);
  };
};
/**
 * @author 刀马，余旋，黄渊
 */


function MkTable() {
  return /*#__PURE__*/_react.default.createElement("div", null);
}

var _default = HocMkTable;
exports.default = _default;