vxe-table-select-area/lib/table/src/methods.js

一个基于 vxe-table 的可区域选中复制、粘贴的组件

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;
var _xeUtils = _interopRequireDefault(require("xe-utils"));
var _conf = _interopRequireDefault(require("../../v-x-e-table/src/conf"));
var _cell = _interopRequireDefault(require("./cell"));
var _vXETable = _interopRequireDefault(require("../../v-x-e-table"));
var _util = require("./util");
var _utils = _interopRequireWildcard(require("../../tools/utils"));
var _dom = _interopRequireWildcard(require("../../tools/dom"));
var _formats = require("../../v-x-e-table/src/formats");
var _log = require("../../tools/log");
var _vn = require("../../tools/vn");
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 || _typeof(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 _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
function _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i["return"] && (_r = _i["return"](), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
var setCellValue = _utils["default"].setCellValue,
  hasChildrenList = _utils["default"].hasChildrenList,
  getColumnList = _utils["default"].getColumnList;
var calcHeight = _dom["default"].calcHeight,
  hasClass = _dom["default"].hasClass,
  addClass = _dom["default"].addClass,
  removeClass = _dom["default"].removeClass,
  getEventTargetNode = _dom["default"].getEventTargetNode,
  isNodeElement = _dom["default"].isNodeElement;
var isWebkit = _dom.browse['-webkit'] && !_dom.browse.edge;
var debounceScrollYDuration = _dom.browse.msie ? 80 : 20;
var resizableStorageKey = 'VXE_TABLE_CUSTOM_COLUMN_WIDTH';
var visibleStorageKey = 'VXE_TABLE_CUSTOM_COLUMN_VISIBLE';
var fixedStorageKey = 'VXE_TABLE_CUSTOM_COLUMN_FIXED';
var orderStorageKey = 'VXE_TABLE_CUSTOM_COLUMN_ORDER';

/**
 * 生成行的唯一主键
 */
function getRowUniqueId() {
  return _xeUtils["default"].uniqueId('row_');
}
function eqCellValue(row1, row2, field) {
  var val1 = _xeUtils["default"].get(row1, field);
  var val2 = _xeUtils["default"].get(row2, field);
  if ((0, _utils.eqEmptyValue)(val1) && (0, _utils.eqEmptyValue)(val2)) {
    return true;
  }
  if (_xeUtils["default"].isString(val1) || _xeUtils["default"].isNumber(val1)) {
    return '' + val1 === '' + val2;
  }
  return _xeUtils["default"].isEqual(val1, val2);
}
function getNextSortOrder(_vm, column) {
  var orders = _vm.sortOpts.orders;
  var currOrder = column.order || null;
  var oIndex = orders.indexOf(currOrder) + 1;
  return orders[oIndex < orders.length ? oIndex : 0];
}
function getCustomStorageMap(key) {
  var version = _conf["default"].version;
  var rest = _xeUtils["default"].toStringJSON(localStorage.getItem(key));
  return rest && rest._v === version ? rest : {
    _v: version
  };
}
function getRecoverRow(_vm, list) {
  var fullAllDataRowMap = _vm.fullAllDataRowMap;
  return list.filter(function (row) {
    return fullAllDataRowMap.has(row);
  });
}
function handleReserveRow(_vm, reserveRowMap) {
  var fullDataRowIdData = _vm.fullDataRowIdData;
  var reserveList = [];
  _xeUtils["default"].each(reserveRowMap, function (item, rowid) {
    if (fullDataRowIdData[rowid] && reserveList.indexOf(fullDataRowIdData[rowid].row) === -1) {
      reserveList.push(fullDataRowIdData[rowid].row);
    }
  });
  return reserveList;
}
function computeVirtualX(_vm) {
  var $refs = _vm.$refs,
    visibleColumn = _vm.visibleColumn;
  var tableBody = $refs.tableBody;
  var tableBodyElem = tableBody ? tableBody.$el : null;
  if (tableBodyElem) {
    var scrollLeft = tableBodyElem.scrollLeft,
      clientWidth = tableBodyElem.clientWidth;
    var endWidth = scrollLeft + clientWidth;
    var toVisibleIndex = -1;
    var cWidth = 0;
    var visibleSize = 0;
    for (var colIndex = 0, colLen = visibleColumn.length; colIndex < colLen; colIndex++) {
      cWidth += visibleColumn[colIndex].renderWidth;
      if (toVisibleIndex === -1 && scrollLeft < cWidth) {
        toVisibleIndex = colIndex;
      }
      if (toVisibleIndex >= 0) {
        visibleSize++;
        if (cWidth > endWidth) {
          break;
        }
      }
    }
    return {
      toVisibleIndex: Math.max(0, toVisibleIndex),
      visibleSize: Math.max(8, visibleSize)
    };
  }
  return {
    toVisibleIndex: 0,
    visibleSize: 8
  };
}
function computeVirtualY(_vm) {
  var $refs = _vm.$refs,
    vSize = _vm.vSize,
    rowHeightMaps = _vm.rowHeightMaps;
  var tableHeader = $refs.tableHeader,
    tableBody = $refs.tableBody;
  var tableBodyElem = tableBody ? tableBody.$el : null;
  if (tableBodyElem) {
    var tableHeaderElem = tableHeader ? tableHeader.$el : null;
    var rowHeight = 0;
    var firstTrElem;
    firstTrElem = tableBodyElem.querySelector('tr');
    if (!firstTrElem && tableHeaderElem) {
      firstTrElem = tableHeaderElem.querySelector('tr');
    }
    if (firstTrElem) {
      rowHeight = firstTrElem.clientHeight;
    }
    if (!rowHeight) {
      rowHeight = rowHeightMaps[vSize || 'default'];
    }
    var visibleSize = Math.max(8, Math.ceil(tableBodyElem.clientHeight / rowHeight) + 2);
    return {
      rowHeight: rowHeight,
      visibleSize: visibleSize
    };
  }
  return {
    rowHeight: 0,
    visibleSize: 8
  };
}
function calculateMergerOffserIndex(list, offsetItem, type) {
  for (var mcIndex = 0, len = list.length; mcIndex < len; mcIndex++) {
    var mergeItem = list[mcIndex];
    var startIndex = offsetItem.startIndex,
      endIndex = offsetItem.endIndex;
    var mergeStartIndex = mergeItem[type];
    var mergeSpanNumber = mergeItem[type + 'span'];
    var mergeEndIndex = mergeStartIndex + mergeSpanNumber;
    if (mergeStartIndex < startIndex && startIndex < mergeEndIndex) {
      offsetItem.startIndex = mergeStartIndex;
    }
    if (mergeStartIndex < endIndex && endIndex < mergeEndIndex) {
      offsetItem.endIndex = mergeEndIndex;
    }
    if (offsetItem.startIndex !== startIndex || offsetItem.endIndex !== endIndex) {
      mcIndex = -1;
    }
  }
}
function setMerges(_vm, merges, mList, rowList) {
  if (merges) {
    var treeConfig = _vm.treeConfig,
      visibleColumn = _vm.visibleColumn;
    if (!_xeUtils["default"].isArray(merges)) {
      merges = [merges];
    }
    if (treeConfig && merges.length) {
      (0, _log.errLog)('vxe.error.noTree', ['merge-cells | merge-footer-items']);
    }
    merges.forEach(function (item) {
      var row = item.row,
        col = item.col,
        rowspan = item.rowspan,
        colspan = item.colspan;
      if (rowList && _xeUtils["default"].isNumber(row)) {
        row = rowList[row];
      }
      if (_xeUtils["default"].isNumber(col)) {
        col = visibleColumn[col];
      }
      if ((rowList ? row : _xeUtils["default"].isNumber(row)) && col && (rowspan || colspan)) {
        rowspan = _xeUtils["default"].toNumber(rowspan) || 1;
        colspan = _xeUtils["default"].toNumber(colspan) || 1;
        if (rowspan > 1 || colspan > 1) {
          var mcIndex = _xeUtils["default"].findIndexOf(mList, function (item) {
            return item._row === row && item._col === col;
          });
          var mergeItem = mList[mcIndex];
          if (mergeItem) {
            mergeItem.rowspan = rowspan;
            mergeItem.colspan = colspan;
            mergeItem._rowspan = rowspan;
            mergeItem._colspan = colspan;
          } else {
            var mergeRowIndex = rowList ? rowList.indexOf(row) : row;
            var mergeColIndex = visibleColumn.indexOf(col);
            mList.push({
              row: mergeRowIndex,
              col: mergeColIndex,
              rowspan: rowspan,
              colspan: colspan,
              _row: row,
              _col: col,
              _rowspan: rowspan,
              _colspan: colspan
            });
          }
        }
      }
    });
  }
}
function removeMerges(_vm, merges, mList, rowList) {
  var rest = [];
  if (merges) {
    var treeConfig = _vm.treeConfig,
      visibleColumn = _vm.visibleColumn;
    if (!_xeUtils["default"].isArray(merges)) {
      merges = [merges];
    }
    if (treeConfig && merges.length) {
      (0, _log.errLog)('vxe.error.noTree', ['merge-cells | merge-footer-items']);
    }
    merges.forEach(function (item) {
      var row = item.row,
        col = item.col;
      if (rowList && _xeUtils["default"].isNumber(row)) {
        row = rowList[row];
      }
      if (_xeUtils["default"].isNumber(col)) {
        col = visibleColumn[col];
      }
      var mcIndex = _xeUtils["default"].findIndexOf(mList, function (item) {
        return item._row === row && item._col === col;
      });
      if (mcIndex > -1) {
        var rItems = mList.splice(mcIndex, 1);
        rest.push(rItems[0]);
      }
    });
  }
  return rest;
}
function clearAllSort(_vm) {
  _vm.tableFullColumn.forEach(function (column) {
    column.order = null;
  });
}
function getOrderField(_vm, column) {
  var sortBy = column.sortBy,
    sortType = column.sortType;
  return function (row) {
    var cellValue;
    if (sortBy) {
      cellValue = _xeUtils["default"].isFunction(sortBy) ? sortBy({
        row: row,
        column: column
      }) : _xeUtils["default"].get(row, sortBy);
    } else {
      cellValue = _vm.getCellLabel(row, column);
    }
    if (!sortType || sortType === 'auto') {
      return isNaN(cellValue) ? cellValue : _xeUtils["default"].toNumber(cellValue);
    } else if (sortType === 'number') {
      return _xeUtils["default"].toNumber(cellValue);
    } else if (sortType === 'string') {
      return _xeUtils["default"].toValueString(cellValue);
    }
    return cellValue;
  };
}
var Methods = {
  callSlot: function callSlot(slotFunc, params, h, vNodes) {
    if (slotFunc) {
      var $xegrid = this.$xegrid;
      if ($xegrid) {
        return $xegrid.callSlot(slotFunc, params, h, vNodes);
      }
      if (_xeUtils["default"].isFunction(slotFunc)) {
        return (0, _vn.getSlotVNs)(slotFunc.call(this, params, h, vNodes));
      }
    }
    return [];
  },
  /**
   * 获取父容器元素
   */
  getParentElem: function getParentElem() {
    var $el = this.$el,
      $xegrid = this.$xegrid;
    return $xegrid ? $xegrid.$el.parentNode : $el.parentNode;
  },
  /**
   * 获取父容器的高度
   */
  getParentHeight: function getParentHeight() {
    var $el = this.$el,
      $xegrid = this.$xegrid,
      height = this.height;
    var parentElem = $el.parentNode;
    var parentPaddingSize = height === 'auto' ? (0, _dom.getPaddingTopBottomSize)(parentElem) : 0;
    return Math.floor($xegrid ? $xegrid.getParentHeight() : _xeUtils["default"].toNumber(getComputedStyle(parentElem).height) - parentPaddingSize);
  },
  /**
   * 获取需要排除的高度
   * 但渲染表格高度时，需要排除工具栏或分页等相关组件的高度
   * 如果存在表尾合计滚动条，则需要排除滚动条高度
   */
  getExcludeHeight: function getExcludeHeight() {
    var $xegrid = this.$xegrid;
    return $xegrid ? $xegrid.getExcludeHeight() : 0;
  },
  /**
   * 重置表格的一切数据状态
   */
  clearAll: function clearAll() {
    return (0, _util.clearTableAllStatus)(this);
  },
  /**
   * 同步 data 数据（即将废弃）
   * 如果用了该方法，那么组件将不再记录增删改的状态，只能自行实现对应逻辑
   * 对于某些特殊的场景，比如深层树节点元素发生变动时可能会用到
   */
  syncData: function syncData() {
    var _this = this;
    return this.$nextTick().then(function () {
      _this.tableData = [];
      return _this.$nextTick().then(function () {
        return _this.loadTableData(_this.tableFullData);
      });
    });
  },
  /**
   * 手动处理数据，用于手动排序与筛选
   * 对于手动更改了排序、筛选...等条件后需要重新处理数据时可能会用到
   */
  updateData: function updateData() {
    var _this2 = this;
    var scrollXLoad = this.scrollXLoad,
      scrollYLoad = this.scrollYLoad;
    return this.handleTableData(true).then(function () {
      _this2.updateFooter();
      _this2.checkSelectionStatus();
      if (scrollXLoad || scrollYLoad) {
        if (scrollXLoad) {
          _this2.updateScrollXSpace();
        }
        if (scrollYLoad) {
          _this2.updateScrollYSpace();
        }
        return _this2.refreshScroll();
      }
    }).then(function () {
      _this2.updateCellAreas();
      return _this2.recalculate(true);
    }).then(function () {
      // 存在滚动行为未结束情况
      setTimeout(function () {
        return _this2.recalculate();
      }, 50);
    });
  },
  handleTableData: function handleTableData(force) {
    var _this3 = this;
    var scrollYLoad = this.scrollYLoad,
      scrollYStore = this.scrollYStore,
      fullDataRowIdData = this.fullDataRowIdData,
      afterFullData = this.afterFullData;
    var fullList = afterFullData;
    // 是否进行数据处理
    if (force) {
      // 更新数据，处理筛选和排序
      this.updateAfterFullData();
      // 如果为虚拟树，将树结构拍平
      fullList = this.handleVirtualTreeToList();
    }
    var tableData = scrollYLoad ? fullList.slice(scrollYStore.startIndex, scrollYStore.endIndex) : fullList.slice(0);
    tableData.forEach(function (row, $index) {
      var rowid = (0, _util.getRowid)(_this3, row);
      var rest = fullDataRowIdData[rowid];
      if (rest) {
        rest.$index = $index;
      }
    });
    this.tableData = tableData;
    return this.$nextTick();
  },
  updateScrollYStatus: function updateScrollYStatus(fullData) {
    var treeConfig = this.treeConfig,
      treeOpts = this.treeOpts,
      sYOpts = this.sYOpts;
    var transform = treeOpts.transform;
    var allList = fullData || this.tableFullData;
    // 如果gt为0，则总是启用
    var scrollYLoad = (transform || !treeConfig) && !!sYOpts.enabled && sYOpts.gt > -1 && (sYOpts.gt === 0 || sYOpts.gt <= allList.length);
    this.scrollYLoad = scrollYLoad;
    return scrollYLoad;
  },
  /**
   * 加载表格数据
   * @param {Array} datas 数据
   */
  loadTableData: function loadTableData(datas) {
    var _this4 = this;
    var keepSource = this.keepSource,
      treeConfig = this.treeConfig,
      treeOpts = this.treeOpts,
      editStore = this.editStore,
      scrollYStore = this.scrollYStore,
      scrollXStore = this.scrollXStore,
      lastScrollLeft = this.lastScrollLeft,
      lastScrollTop = this.lastScrollTop,
      oldScrollYLoad = this.scrollYLoad,
      sXOpts = this.sXOpts,
      sYOpts = this.sYOpts;
    var treeData = [];
    var fullData = datas ? datas.slice(0) : [];
    if (treeConfig) {
      // 树结构自动转换
      if (treeOpts.transform) {
        if (process.env.NODE_ENV === 'development') {
          if (!treeOpts.rowField) {
            (0, _log.errLog)('vxe.error.reqProp', ['table.tree-config.rowField']);
          }
          if (!treeOpts.parentField) {
            (0, _log.errLog)('vxe.error.reqProp', ['table.tree-config.parentField']);
          }
          if (!treeOpts.children) {
            (0, _log.errLog)('vxe.error.reqProp', ['tree-config.children']);
          }
          if (!treeOpts.mapChildren) {
            (0, _log.errLog)('vxe.error.reqProp', ['tree-config.mapChildren']);
          }
          if (treeOpts.children === treeOpts.mapChildren) {
            (0, _log.errLog)('vxe.error.errConflicts', ['tree-config.children', 'tree-config.mapChildren']);
          }
          fullData.forEach(function (row) {
            if (row[treeOpts.children] && row[treeOpts.children].length) {
              (0, _log.warnLog)('vxe.error.errConflicts', ['tree-config.transform', "row.".concat(treeOpts.children)]);
            }
          });
        }
        treeData = _xeUtils["default"].toArrayTree(fullData, {
          key: treeOpts.rowField,
          parentKey: treeOpts.parentField,
          children: treeOpts.children,
          mapChildren: treeOpts.mapChildren
        });
        fullData = treeData.slice(0);
      } else {
        treeData = fullData.slice(0);
      }
    }
    scrollYStore.startIndex = 0;
    scrollYStore.endIndex = 1;
    scrollXStore.startIndex = 0;
    scrollXStore.endIndex = 1;
    editStore.insertList = [];
    editStore.insertMaps = {};
    editStore.removeList = [];
    editStore.removeMaps = {};
    var sYLoad = this.updateScrollYStatus(fullData);
    this.scrollYLoad = sYLoad;
    // 全量数据
    this.tableFullData = fullData;
    this.tableFullTreeData = treeData;
    // 缓存数据
    this.cacheRowMap(true);
    // 原始数据
    this.tableSynchData = datas;
    // 克隆原数据，用于显示编辑状态，与编辑值做对比
    if (keepSource) {
      this.tableSourceData = _xeUtils["default"].clone(fullData, true);
    }
    if (process.env.NODE_ENV === 'development') {
      if (sYLoad) {
        if (!(this.height || this.maxHeight)) {
          (0, _log.errLog)('vxe.error.reqProp', ['table.height | table.max-height | table.scroll-y={enabled: false}']);
        }
        if (!this.showOverflow) {
          (0, _log.warnLog)('vxe.error.reqProp', ['table.show-overflow']);
        }
        if (this.spanMethod) {
          (0, _log.warnLog)('vxe.error.scrollErrProp', ['table.span-method']);
        }
      }
    }
    if (this.clearCellAreas && this.mouseConfig) {
      this.clearCellAreas();
      this.clearCopyCellArea();
    }
    this.clearMergeCells();
    this.clearMergeFooterItems();
    this.handleTableData(true);
    this.updateFooter();
    return this.$nextTick().then(function () {
      _this4.updateHeight();
      _this4.updateStyle();
    }).then(function () {
      _this4.computeScrollLoad();
    }).then(function () {
      // 是否启用了虚拟滚动
      if (sYLoad) {
        scrollYStore.endIndex = scrollYStore.visibleSize;
      }
      _this4.handleReserveStatus();
      _this4.checkSelectionStatus();
      return new Promise(function (resolve) {
        _this4.$nextTick().then(function () {
          return _this4.recalculate();
        }).then(function () {
          var targetScrollLeft = lastScrollLeft;
          var targetScrollTop = lastScrollTop;
          // 是否在更新数据之后自动滚动重置滚动条
          if (sXOpts.scrollToLeftOnChange) {
            targetScrollLeft = 0;
          }
          if (sYOpts.scrollToTopOnChange) {
            targetScrollTop = 0;
          }
          // 是否变更虚拟滚动
          if (oldScrollYLoad === sYLoad) {
            (0, _util.restoreScrollLocation)(_this4, targetScrollLeft, targetScrollTop).then(resolve);
          } else {
            setTimeout(function () {
              return (0, _util.restoreScrollLocation)(_this4, targetScrollLeft, targetScrollTop).then(resolve);
            });
          }
        });
      });
    });
  },
  /**
   * 重新加载数据，不会清空表格状态
   * @param {Array} datas 数据
   */
  loadData: function loadData(datas) {
    var _this5 = this;
    var inited = this.inited,
      initStatus = this.initStatus;
    return this.loadTableData(datas).then(function () {
      _this5.inited = true;
      _this5.initStatus = true;
      if (!initStatus) {
        _this5.handleLoadDefaults();
      }
      if (!inited) {
        _this5.handleInitDefaults();
      }
      return _this5.recalculate();
    });
  },
  /**
   * 重新加载数据，会清空表格状态
   * @param {Array} datas 数据
   */
  reloadData: function reloadData(datas) {
    var _this6 = this;
    var inited = this.inited;
    return this.clearAll().then(function () {
      _this6.inited = true;
      _this6.initStatus = true;
      return _this6.loadTableData(datas);
    }).then(function () {
      _this6.handleLoadDefaults();
      if (!inited) {
        _this6.handleInitDefaults();
      }
      return _this6.recalculate();
    });
  },
  /**
   * 局部加载行数据并恢复到初始状态
   * 对于行数据需要局部更改的场景中可能会用到
   * @param {Row} row 行对象
   * @param {Object} record 新数据
   * @param {String} field 字段名
   */
  reloadRow: function reloadRow(row, record, field) {
    var keepSource = this.keepSource,
      tableSourceData = this.tableSourceData,
      tableData = this.tableData;
    if (keepSource) {
      var rowIndex = this.getRowIndex(row);
      var oRow = tableSourceData[rowIndex];
      if (oRow && row) {
        if (field) {
          var newValue = _xeUtils["default"].get(record || row, field);
          _xeUtils["default"].set(row, field, newValue);
          _xeUtils["default"].set(oRow, field, newValue);
        } else {
          var newRecord = _xeUtils["default"].clone(_objectSpread({}, record), true);
          _xeUtils["default"].destructuring(oRow, Object.assign(row, newRecord));
        }
      }
      this.tableData = tableData.slice(0);
    } else {
      if (process.env.NODE_ENV === 'development') {
        (0, _log.warnLog)('vxe.error.reqProp', ['keep-source']);
      }
    }
    return this.$nextTick();
  },
  /**
   * 加载列配置
   * 对于表格列需要重载、局部递增场景下可能会用到
   * @param {ColumnInfo} columns 列配置
   */
  loadColumn: function loadColumn(columns) {
    var _this7 = this;
    var collectColumn = _xeUtils["default"].mapTree(columns, function (column) {
      return _cell["default"].createColumn(_this7, column);
    }, {
      children: 'children'
    });
    return this.handleColumn(collectColumn);
  },
  /**
   * 加载列配置并恢复到初始状态
   * 对于表格列需要重载、局部递增场景下可能会用到
   * @param {ColumnInfo} columns 列配置
   */
  reloadColumn: function reloadColumn(columns) {
    var _this8 = this;
    return this.clearAll().then(function () {
      return _this8.loadColumn(columns);
    });
  },
  handleColumn: function handleColumn(collectColumn) {
    var _this9 = this;
    this.collectColumn = collectColumn;
    var tableFullColumn = getColumnList(collectColumn);
    this.tableFullColumn = tableFullColumn;
    this.cacheColumnMap();
    this.restoreCustomStorage();
    this.parseColumns().then(function () {
      if (_this9.scrollXLoad) {
        _this9.loadScrollXData(true);
      }
    });
    this.clearMergeCells();
    this.clearMergeFooterItems();
    this.handleTableData(true);
    if (process.env.NODE_ENV === 'development') {
      if ((this.scrollXLoad || this.scrollYLoad) && this.expandColumn) {
        (0, _log.warnLog)('vxe.error.scrollErrProp', ['column.type=expand']);
      }
    }
    return this.$nextTick().then(function () {
      if (_this9.$toolbar) {
        _this9.$toolbar.syncUpdate({
          collectColumn: collectColumn,
          $table: _this9
        });
      }
      return _this9.recalculate();
    });
  },
  /**
   * 更新数据行的 Map
   * 牺牲数据组装的耗时，用来换取使用过程中的流畅
   */
  cacheRowMap: function cacheRowMap(source) {
    var _this10 = this;
    var treeConfig = this.treeConfig,
      treeOpts = this.treeOpts,
      tableFullData = this.tableFullData,
      fullDataRowMap = this.fullDataRowMap,
      fullAllDataRowMap = this.fullAllDataRowMap,
      tableFullTreeData = this.tableFullTreeData;
    var fullDataRowIdData = this.fullDataRowIdData,
      fullAllDataRowIdData = this.fullAllDataRowIdData;
    var rowkey = (0, _util.getRowkey)(this);
    var isLazy = treeConfig && treeOpts.lazy;
    var handleCache = function handleCache(row, index, items, path, parent, nodes) {
      var rowid = (0, _util.getRowid)(_this10, row);
      var seq = treeConfig && path ? (0, _util.toTreePathSeq)(path) : index + 1;
      var level = nodes ? nodes.length - 1 : 0;
      if ((0, _utils.eqEmptyValue)(rowid)) {
        rowid = getRowUniqueId();
        _xeUtils["default"].set(row, rowkey, rowid);
      }
      if (isLazy && row[treeOpts.hasChild] && _xeUtils["default"].isUndefined(row[treeOpts.children])) {
        row[treeOpts.children] = null;
      }
      var rest = {
        row: row,
        rowid: rowid,
        seq: seq,
        index: treeConfig && parent ? -1 : index,
        _index: -1,
        $index: -1,
        items: items,
        parent: parent,
        level: level
      };
      if (source) {
        fullDataRowIdData[rowid] = rest;
        fullDataRowMap.set(row, rest);
      }
      fullAllDataRowIdData[rowid] = rest;
      fullAllDataRowMap.set(row, rest);
    };
    if (source) {
      fullDataRowIdData = this.fullDataRowIdData = {};
      fullDataRowMap.clear();
    }
    fullAllDataRowIdData = this.fullAllDataRowIdData = {};
    fullAllDataRowMap.clear();
    if (treeConfig) {
      _xeUtils["default"].eachTree(tableFullTreeData, handleCache, treeOpts);
    } else {
      tableFullData.forEach(handleCache);
    }
  },
  loadTreeChildren: function loadTreeChildren(row, childRecords) {
    var _this11 = this;
    var keepSource = this.keepSource,
      tableSourceData = this.tableSourceData,
      treeOpts = this.treeOpts,
      fullDataRowIdData = this.fullDataRowIdData,
      fullDataRowMap = this.fullDataRowMap,
      fullAllDataRowMap = this.fullAllDataRowMap,
      fullAllDataRowIdData = this.fullAllDataRowIdData;
    var transform = treeOpts.transform,
      children = treeOpts.children,
      mapChildren = treeOpts.mapChildren;
    var rest = fullAllDataRowIdData[(0, _util.getRowid)(this, row)];
    var parentLevel = rest ? rest.level : 0;
    return this.createData(childRecords).then(function (rows) {
      if (keepSource) {
        var rowid = (0, _util.getRowid)(_this11, row);
        var matchObj = _xeUtils["default"].findTree(tableSourceData, function (item) {
          return rowid === (0, _util.getRowid)(_this11, item);
        }, treeOpts);
        if (matchObj) {
          matchObj.item[children] = _xeUtils["default"].clone(rows, true);
        }
      }
      _xeUtils["default"].eachTree(rows, function (childRow, index, items, path, parent, nodes) {
        var rowid = (0, _util.getRowid)(_this11, childRow);
        var rest = {
          row: childRow,
          rowid: rowid,
          seq: -1,
          index: index,
          _index: -1,
          $index: -1,
          items: items,
          parent: parent,
          level: parentLevel + nodes.length
        };
        fullDataRowIdData[rowid] = rest;
        fullDataRowMap.set(childRow, rest);
        fullAllDataRowIdData[rowid] = rest;
        fullAllDataRowMap.set(childRow, rest);
      }, treeOpts);
      row[children] = rows;
      if (transform) {
        row[mapChildren] = rows;
      }
      _this11.updateAfterDataIndex();
      return rows;
    });
  },
  /**
   * 更新数据列的 Map
   * 牺牲数据组装的耗时，用来换取使用过程中的流畅
   */
  cacheColumnMap: function cacheColumnMap() {
    var _this12 = this;
    var tableFullColumn = this.tableFullColumn,
      collectColumn = this.collectColumn,
      fullColumnMap = this.fullColumnMap,
      showOverflow = this.showOverflow,
      columnOpts = this.columnOpts,
      rowOpts = this.rowOpts;
    var fullColumnIdData = this.fullColumnIdData = {};
    var fullColumnFieldData = this.fullColumnFieldData = {};
    var isGroup = collectColumn.some(hasChildrenList);
    var isAllOverflow = !!showOverflow;
    var expandColumn;
    var treeNodeColumn;
    var checkboxColumn;
    var radioColumn;
    var htmlColumn;
    var hasFixed;
    var handleFunc = function handleFunc(column, index, items, path, parent) {
      var colid = column.id,
        field = column.field,
        fixed = column.fixed,
        type = column.type,
        treeNode = column.treeNode;
      var rest = {
        column: column,
        colid: colid,
        index: index,
        items: items,
        parent: parent
      };
      if (field) {
        if (process.env.NODE_ENV === 'development') {
          if (fullColumnFieldData[field]) {
            (0, _log.warnLog)('vxe.error.colRepet', ['field', field]);
          }
        }
        fullColumnFieldData[field] = rest;
      }
      if (!hasFixed && fixed) {
        hasFixed = fixed;
      }
      if (!htmlColumn && type === 'html') {
        htmlColumn = column;
      }
      if (treeNode) {
        if (process.env.NODE_ENV === 'development') {
          if (treeNodeColumn) {
            (0, _log.warnLog)('vxe.error.colRepet', ['tree-node', treeNode]);
          }
        }
        if (!treeNodeColumn) {
          treeNodeColumn = column;
        }
      } else if (type === 'expand') {
        if (process.env.NODE_ENV === 'development') {
          if (expandColumn) {
            (0, _log.warnLog)('vxe.error.colRepet', ['type', type]);
          }
        }
        if (!expandColumn) {
          expandColumn = column;
        }
      }
      if (process.env.NODE_ENV === 'development') {
        if (type === 'checkbox') {
          if (checkboxColumn) {
            (0, _log.warnLog)('vxe.error.colRepet', ['type', type]);
          }
          if (!checkboxColumn) {
            checkboxColumn = column;
          }
        } else if (type === 'radio') {
          if (radioColumn) {
            (0, _log.warnLog)('vxe.error.colRepet', ['type', type]);
          }
          if (!radioColumn) {
            radioColumn = column;
          }
        }
      }
      if (process.env.NODE_ENV === 'development') {
        if (_this12.showOverflow && column.showOverflow === false) {
          (0, _log.warnLog)('vxe.error.errConflicts', ["table.show-overflow=".concat(_this12.showOverflow), "column.show-overflow=".concat(column.showOverflow)]);
        }
        if (_this12.showHeaderOverflow && column.showHeaderOverflow === false) {
          (0, _log.warnLog)('vxe.error.errConflicts', ["table.show-header-overflow=".concat(_this12.showHeaderOverflow), "column.show-header-overflow=".concat(column.showHeaderOverflow)]);
        }
        if (_this12.showFooterOverflow && column.showFooterOverflow === false) {
          (0, _log.warnLog)('vxe.error.errConflicts', ["table.show-footer-overflow=".concat(_this12.showFooterOverflow), "column.show-footer-overflow=".concat(column.showFooterOverflow)]);
        }
      }
      if (process.env.NODE_ENV === 'development') {
        if (htmlColumn) {
          if (!columnOpts.useKey) {
            (0, _log.errLog)('vxe.error.reqProp', ['column-config.useKey', 'column.type=html']);
          }
          if (!rowOpts.useKey) {
            (0, _log.errLog)('vxe.error.reqProp', ['row-config.useKey', 'column.type=html']);
          }
        }
      }
      if (isAllOverflow && column.showOverflow === false) {
        isAllOverflow = false;
      }
      if (fullColumnIdData[colid]) {
        (0, _log.errLog)('vxe.error.colRepet', ['colId', colid]);
      }
      fullColumnIdData[colid] = rest;
      fullColumnMap.set(column, rest);
    };
    fullColumnMap.clear();
    if (isGroup) {
      _xeUtils["default"].eachTree(collectColumn, function (column, index, items, path, parent, nodes) {
        column.level = nodes.length;
        handleFunc(column, index, items, path, parent);
      });
    } else {
      tableFullColumn.forEach(handleFunc);
    }
    if (process.env.NODE_ENV === 'development') {
      if (expandColumn && this.mouseOpts.area) {
        (0, _log.errLog)('vxe.error.errConflicts', ['mouse-config.area', 'column.type=expand']);
      }
    }
    this.isGroup = isGroup;
    this.treeNodeColumn = treeNodeColumn;
    this.expandColumn = expandColumn;
    this.isAllOverflow = isAllOverflow;
  },
  /**
   * 根据 tr 元素获取对应的 row 信息
   * @param {Element} tr 元素
   */
  getRowNode: function getRowNode(tr) {
    if (tr) {
      var fullAllDataRowIdData = this.fullAllDataRowIdData;
      var rowid = tr.getAttribute('rowid');
      var rest = fullAllDataRowIdData[rowid];
      if (rest) {
        return {
          rowid: rest.rowid,
          item: rest.row,
          index: rest.index,
          items: rest.items,
          parent: rest.parent
        };
      }
    }
    return null;
  },
  /**
   * 根据 th/td 元素获取对应的 column 信息
   * @param {Element} cell 元素
   */
  getColumnNode: function getColumnNode(cell) {
    if (cell) {
      var fullColumnIdData = this.fullColumnIdData;
      var colid = cell.getAttribute('colid');
      var rest = fullColumnIdData[colid];
      if (rest) {
        return {
          colid: rest.colid,
          item: rest.column,
          index: rest.index,
          items: rest.items,
          parent: rest.parent
        };
      }
    }
    return null;
  },
  /**
   * 根据 row 获取序号
   * @param {Row} row 行对象
   */
  getRowSeq: function getRowSeq(row) {
    var fullDataRowIdData = this.fullDataRowIdData;
    if (row) {
      var rowid = (0, _util.getRowid)(this, row);
      var rest = fullDataRowIdData[rowid];
      if (rest) {
        return rest.seq;
      }
    }
    return -1;
  },
  /**
   * 根据 row 获取相对于 data 中的索引
   * @param {Row} row 行对象
   */
  getRowIndex: function getRowIndex(row) {
    return this.fullDataRowMap.has(row) ? this.fullDataRowMap.get(row).index : -1;
  },
  /**
   * 根据 row 获取相对于当前数据中的索引
   * @param {Row} row 行对象
   */
  getVTRowIndex: function getVTRowIndex(row) {
    return this.afterFullData.indexOf(row);
  },
  // 在 v3 中废弃
  _getRowIndex: function _getRowIndex(row) {
    if (process.env.NODE_ENV === 'development') {
      (0, _log.warnLog)('vxe.error.delFunc', ['_getRowIndex', 'getVTRowIndex']);
    }
    return this.getVTRowIndex(row);
  },
  /**
   * 根据 row 获取渲染中的虚拟索引
   * @param {Row} row 行对象
   */
  getVMRowIndex: function getVMRowIndex(row) {
    return this.tableData.indexOf(row);
  },
  // 在 v3 中废弃
  $getRowIndex: function $getRowIndex(row) {
    if (process.env.NODE_ENV === 'development') {
      (0, _log.warnLog)('vxe.error.delFunc', ['$getRowIndex', 'getVMRowIndex']);
    }
    return this.getVMRowIndex(row);
  },
  /**
   * 根据 column 获取相对于 columns 中的索引
   * @param {ColumnInfo} column 列配置
   */
  getColumnIndex: function getColumnIndex(column) {
    return this.fullColumnMap.has(column) ? this.fullColumnMap.get(column).index : -1;
  },
  /**
   * 根据 column 获取相对于当前表格列中的索引
   * @param {ColumnInfo} column 列配置
   */
  getVTColumnIndex: function getVTColumnIndex(column) {
    return this.visibleColumn.indexOf(column);
  },
  // 在 v3 中废弃
  _getColumnIndex: function _getColumnIndex(column) {
    if (process.env.NODE_ENV === 'development') {
      (0, _log.warnLog)('vxe.error.delFunc', ['_getColumnIndex', 'getVTColumnIndex']);
    }
    return this.getVTColumnIndex(column);
  },
  /**
   * 根据 column 获取渲染中的虚拟索引
   * @param {ColumnInfo} column 列配置
   */
  getVMColumnIndex: function getVMColumnIndex(column) {
    return this.tableColumn.indexOf(column);
  },
  // 在 v3 中废弃
  $getColumnIndex: function $getColumnIndex(column) {
    if (process.env.NODE_ENV === 'development') {
      (0, _log.warnLog)('vxe.error.delFunc', ['$getColumnIndex', 'getVMColumnIndex']);
    }
    return this.getVMColumnIndex(column);
  },
  /**
   * 判断是否为索引列
   * @param {ColumnInfo} column 列配置
   */
  isSeqColumn: function isSeqColumn(column) {
    return column && column.type === 'seq';
  },
  /**
   * 定义行数据中的列属性，如果不存在则定义
   * @param {Row} records 行数据
   */
  defineField: function defineField(records) {
    var _this13 = this;
    var radioOpts = this.radioOpts,
      checkboxOpts = this.checkboxOpts,
      treeConfig = this.treeConfig,
      treeOpts = this.treeOpts,
      expandOpts = this.expandOpts;
    var rowkey = (0, _util.getRowkey)(this);
    if (!_xeUtils["default"].isArray(records)) {
      records = [records || {}];
    }
    return records.map(function (record) {
      _this13.tableFullColumn.forEach(function (column) {
        var field = column.field,
          editRender = column.editRender;
        if (field && !_xeUtils["default"].has(record, field)) {
          var cellValue = null;
          if (editRender) {
            var defaultValue = editRender.defaultValue;
            if (_xeUtils["default"].isFunction(defaultValue)) {
              cellValue = defaultValue({
                column: column
              });
            } else if (!_xeUtils["default"].isUndefined(defaultValue)) {
              cellValue = defaultValue;
            }
          }
          _xeUtils["default"].set(record, field, cellValue);
        }
      });
      var otherFields = [radioOpts.labelField, checkboxOpts.checkField, checkboxOpts.labelField, expandOpts.labelField];
      otherFields.forEach(function (key) {
        if (key && (0, _utils.eqEmptyValue)(_xeUtils["default"].get(record, key))) {
          _xeUtils["default"].set(record, key, null);
        }
      });
      if (treeConfig && treeOpts.lazy && _xeUtils["default"].isUndefined(record[treeOpts.children])) {
        record[treeOpts.children] = null;
      }
      // 必须有行数据的唯一主键，可以自行设置；也可以默认生成一个随机数
      if ((0, _utils.eqEmptyValue)(_xeUtils["default"].get(record, rowkey))) {
        _xeUtils["default"].set(record, rowkey, getRowUniqueId());
      }
      return record;
    });
  },
  /**
   * 创建 data 对象
   * 对于某些特殊场景可能会用到，会自动对数据的字段名进行检测，如果不存在就自动定义
   * @param {Array} records 新数据
   */
  createData: function createData(records) {
    var _this14 = this;
    return this.$nextTick().then(function () {
      return _this14.defineField(records);
    });
  },
  /**
   * 创建 Row|Rows 对象
   * 对于某些特殊场景需要对数据进行手动插入时可能会用到
   * @param {Array/Object} records 新数据
   */
  createRow: function createRow(records) {
    var isArr = _xeUtils["default"].isArray(records);
    if (!isArr) {
      records = [records];
    }
    return this.createData(records).then(function (rows) {
      return isArr ? rows : rows[0];
    });
  },
  /**
   * 还原数据
   * 如果不传任何参数，则还原整个表格
   * 如果传 row 则还原一行
   * 如果传 rows 则还原多行
   * 如果还额外传了 field 则还原指定的单元格数据
   */
  revertData: function revertData(rows, field) {
    var _this15 = this;
    var keepSource = this.keepSource,
      tableSourceData = this.tableSourceData,
      treeConfig = this.treeConfig;
    if (!keepSource) {
      if (process.env.NODE_ENV === 'development') {
        (0, _log.warnLog)('vxe.error.reqProp', ['keep-source']);
      }
      return this.$nextTick();
    }
    var targetRows = rows;
    if (rows) {
      if (!_xeUtils["default"].isArray(rows)) {
        targetRows = [rows];
      }
    } else {
      targetRows = _xeUtils["default"].toArray(this.getUpdateRecords());
    }
    if (targetRows.length) {
      targetRows.forEach(function (row) {
        if (!_this15.isInsertByRow(row)) {
          var rowIndex = _this15.getRowIndex(row);
          if (treeConfig && rowIndex === -1) {
            (0, _log.errLog)('vxe.error.noTree', ['revertData']);
          }
          var oRow = tableSourceData[rowIndex];
          if (oRow && row) {
            if (field) {
              _xeUtils["default"].set(row, field, _xeUtils["default"].clone(_xeUtils["default"].get(oRow, field), true));
            } else {
              _xeUtils["default"].destructuring(row, _xeUtils["default"].clone(oRow, true));
            }
          }
        }
      });
    }
    if (rows) {
      return this.$nextTick();
    }
    return this.reloadData(tableSourceData);
  },
  /**
   * 清空单元格内容
   * 如果不创参数，则清空整个表格内容
   * 如果传 row 则清空一行内容
   * 如果传 rows 则清空多行内容
   * 如果还额外传了 field 则清空指定单元格内容
   * @param {Array/Row} rows 行数据
   * @param {String} field 字段名
   */
  clearData: function clearData(rows, field) {
    var tableFullData = this.tableFullData,
      visibleColumn = this.visibleColumn;
    if (!arguments.length) {
      rows = tableFullData;
    } else if (rows && !_xeUtils["default"].isArray(rows)) {
      rows = [rows];
    }
    if (field) {
      rows.forEach(function (row) {
        return _xeUtils["default"].set(row, field, null);
      });
    } else {
      rows.forEach(function (row) {
        visibleColumn.forEach(function (column) {
          if (column.field) {
            setCellValue(row, column, null);
          }
        });
      });
    }
    return this.$nextTick();
  },
  /**
   * 检查是否为临时行数据
   * @param {Row} row 行对象
   */
  isInsertByRow: function isInsertByRow(row) {
    var editStore = this.editStore;
    var rowid = (0, _util.getRowid)(this, row);
    return editStore.insertList.length && editStore.insertMaps[rowid];
  },
  /**
   * 删除所有新增的临时数据
   * @returns
   */
  removeInsertRow: function removeInsertRow() {
    return this.remove(this.editStore.insertList);
  },
  /**
   * 检查行或列数据是否发生改变
   * @param {Row} row 行对象
   * @param {String} field 字段名
   */
  isUpdateByRow: function isUpdateByRow(row, field) {
    var _this16 = this;
    var visibleColumn = this.visibleColumn,
      keepSource = this.keepSource,
      treeConfig = this.treeConfig,
      treeOpts = this.treeOpts,
      tableSourceData = this.tableSourceData,
      fullDataRowIdData = this.fullDataRowIdData;
    if (keepSource) {
      var oRow, property;
      var rowid = (0, _util.getRowid)(this, row);
      // 新增的数据不需要检测
      if (!fullDataRowIdData[rowid]) {
        return false;
      }
      if (treeConfig) {
        var children = treeOpts.children;
        var matchObj = _xeUtils["default"].findTree(tableSourceData, function (item) {
          return rowid === (0, _util.getRowid)(_this16, item);
        }, treeOpts);
        row = Object.assign({}, row, _defineProperty({}, children, null));
        if (matchObj) {
          oRow = Object.assign({}, matchObj.item, _defineProperty({}, children, null));
        }
      } else {
        var oRowIndex = fullDataRowIdData[rowid].index;
        oRow = tableSourceData[oRowIndex];
      }
      if (oRow) {
        if (arguments.length > 1) {
          return !eqCellValue(oRow, row, field);
        }
        for (var index = 0, len = visibleColumn.length; index < len; index++) {
          property = visibleColumn[index].field;
          if (property && !eqCellValue(oRow, row, property)) {
            return true;
          }
        }
      }
    }
    return false;
  },
  /**
   * 获取表格的可视列，也可以指定索引获取列
   * @param {Number} columnIndex 索引
   */
  getColumns: function getColumns(columnIndex) {
    var columns = this.visibleColumn;
    return _xeUtils["default"].isUndefined(columnIndex) ? columns.slice(0) : columns[columnIndex];
  },
  /**
   * 根据列的唯一主键获取列
   * @param {String} colid 列主键
   */
  getColumnById: function getColumnById(colid) {
    var fullColumnIdData = this.fullColumnIdData;
    return fullColumnIdData[colid] ? fullColumnIdData[colid].column : null;
  },
  /**
   * 根据列的字段名获取列
   * @param {String} field 字段名
   */
  getColumnByField: function getColumnByField(field) {
    var fullColumnFieldData = this.fullColumnFieldData;
    return fullColumnFieldData[field] ? fullColumnFieldData[field].column : null;
  },
  /**
   * 获取当前表格的列
   * 收集到的全量列、全量表头列、处理条件之后的全量表头列、当前渲染中的表头列
   */
  getTableColumn: function getTableColumn() {
    return {
      collectColumn: this.collectColumn.slice(0),
      fullColumn: this.tableFullColumn.slice(0),
      visibleColumn: this.visibleColumn.slice(0),
      tableColumn: this.tableColumn.slice(0)
    };
  },
  /**
   * 获取数据，和 data 的行为一致，也可以指定索引获取数据
   */
  getData: function getData(rowIndex) {
    var tableSynchData = this.data || this.tableSynchData;
    return _xeUtils["default"].isUndefined(rowIndex) ? tableSynchData.slice(0) : tableSynchData[rowIndex];
  },
  /**
   * 用于多选行，获取已选中的数据
   */
  getCheckboxRecords: function getCheckboxRecords(isFull) {
    var _this17 = this;
    var tableFullData = this.tableFullData,
      afterFullData = this.afterFullData,
      treeConfig = this.treeConfig,
      treeOpts = this.treeOpts,
      checkboxOpts = this.checkboxOpts,
      tableFullTreeData = this.tableFullTreeData,
      afterTreeFullData = this.afterTreeFullData;
    var transform = treeOpts.transform,
      children = treeOpts.children,
      mapChildren = treeOpts.mapChildren;
    var checkField = checkboxOpts.checkField;
    var currTableData = isFull ? transform ? tableFullTreeData : tableFullData : transform ? afterTreeFullData : afterFullData;
    var rowList = [];
    if (checkField) {
      if (treeConfig) {
        rowList = _xeUtils["default"].filterTree(currTableData, function (row) {
          return _xeUtils["default"].get(row, checkField);
        }, {
          children: transform ? mapChildren : children
        });
      } else {
        rowList = currTableData.filter(function (row) {
          return _xeUtils["default"].get(row, checkField);
        });
      }
    } else {
      var selection = this.selection;
      if (treeConfig) {
        rowList = _xeUtils["default"].filterTree(currTableData, function (row) {
          return _this17.findRowIndexOf(selection, row) > -1;
        }, {
          children: transform ? mapChildren : children
        });
      } else {
        rowList = currTableData.filter(function (row) {
          return _this17.findRowIndexOf(selection, row) > -1;
        });
      }
    }
    return rowList;
  },
  /**
   * 如果为虚拟树，将树结构拍平
   * @returns
   */
  handleVirtualTreeToList: function handleVirtualTreeToList() {
    var treeOpts = this.treeOpts,
      treeConfig = this.treeConfig,
      treeExpandeds = this.treeExpandeds,
      afterTreeFullData = this.afterTreeFullData,
      afterFullData = this.afterFullData;
    if (treeConfig && treeOpts.transform) {
      var fullData = [];
      var expandMaps = new Map();
      _xeUtils["default"].eachTree(afterTreeFullData, function (row, index, items, path, parent) {
        if (!parent || expandMaps.has(parent) && treeExpandeds.indexOf(parent) > -1) {
          expandMaps.set(row, 1);
          fullData.push(row);
        }
      }, {
        children: treeOpts.mapChildren
      });
      this.afterFullData = fullData;
      this.updateScrollYStatus(fullData);
      return fullData;
    }
    return afterFullData;
  },
  /**
   * 获取处理后全量的表格数据
   * 如果存在筛选条件，继续处理
   */
  updateAfterFullData: function updateAfterFullData() {
    var _this18 = this;
    var tableFullColumn = this.tableFullColumn,
      tableFullData = this.tableFullData,
      filterOpts = this.filterOpts,
      sortOpts = this.sortOpts,
      treeConfig = this.treeConfig,
      treeOpts = this.treeOpts,
      tableFullTreeData = this.tableFull