vhb-table/lib/table/src/methods.js

一个基于 vue 的 PC 端表格组件，支持增删改查、虚拟列表、虚拟树、懒加载、快捷菜单、数据校验、树形结构、打印导出、表单渲染、数据分页、弹窗、自定义模板、渲染器、贼灵活的配置项、扩展接口等...

"use strict";

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

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

var _xeUtils = _interopRequireDefault(require("xe-utils"));

var _conf = _interopRequireDefault(require("../../v-h-b-table/src/conf"));

var _cell = _interopRequireDefault(require("./cell"));

var _vHBTable = _interopRequireDefault(require("../../v-h-b-table"));

var _util = require("./util");

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

var _dom = _interopRequireWildcard(require("../../tools/dom"));

var _formats = require("../../v-h-b-table/src/formats");

var _log = require("../../tools/log");

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 _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 _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 _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 _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 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) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

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 = 'VHB_TABLE_CUSTOM_COLUMN_WIDTH';
var visibleStorageKey = 'VHB_TABLE_CUSTOM_COLUMN_VISIBLE';
/**
 * 生成行的唯一主键
 */

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 (treeConfig) {
      throw new Error(_utils.default.getLog('vhb.error.noTree', ['merge-footer-items']));
    }

    if (!_xeUtils.default.isArray(merges)) {
      merges = [merges];
    }

    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 (treeConfig) {
      throw new Error(_utils.default.getLog('vhb.error.noTree', ['merge-cells']));
    }

    if (!_xeUtils.default.isArray(merges)) {
      merges = [merges];
    }

    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 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 scrollYLoad = (transform || !treeConfig) && !!sYOpts.enabled && sYOpts.gt > -1 && sYOpts.gt < fullData.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;
    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)('vhb.error.reqProp', ['table.tree-config.rowField']);
          }

          if (!treeOpts.parentField) {
            (0, _log.errLog)('vhb.error.reqProp', ['table.tree-config.parentField']);
          }

          if (!treeOpts.children) {
            (0, _log.errLog)('vhb.error.reqProp', ['tree-config.children']);
          }

          if (!treeOpts.mapChildren) {
            (0, _log.errLog)('vhb.error.reqProp', ['tree-config.mapChildren']);
          }

          if (treeOpts.children === treeOpts.mapChildren) {
            (0, _log.errLog)('vhb.error.errConflicts', ['tree-config.children', 'tree-config.mapChildren']);
          }

          fullData.forEach(function (row) {
            if (row[treeOpts.children] && row[treeOpts.children].length) {
              (0, _log.warnLog)('vhb.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.removeList = [];
    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)('vhb.error.reqProp', ['table.height | table.max-height | table.scroll-y={enabled: false}']);
        }

        if (!this.showOverflow) {
          (0, _log.warnLog)('vhb.error.reqProp', ['table.show-overflow']);
        }

        if (this.spanMethod) {
          (0, _log.warnLog)('vhb.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 () {
          // 是否变更虚拟滚动
          if (oldScrollYLoad === sYLoad) {
            (0, _util.restoreScrollLocation)(_this4, lastScrollLeft, lastScrollTop).then(resolve);
          } else {
            setTimeout(function () {
              return (0, _util.restoreScrollLocation)(_this4, lastScrollLeft, lastScrollTop).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)('vhb.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)('vhb.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;
    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 hasFixed;

    var handleFunc = function handleFunc(column, index, items, path, parent) {
      var colid = column.id,
          property = column.property,
          fixed = column.fixed,
          type = column.type,
          treeNode = column.treeNode;
      var rest = {
        column: column,
        colid: colid,
        index: index,
        items: items,
        parent: parent
      };

      if (property) {
        if (process.env.NODE_ENV === 'development') {
          if (fullColumnFieldData[property]) {
            (0, _log.warnLog)('vhb.error.colRepet', ['field', property]);
          }
        }

        fullColumnFieldData[property] = rest;
      }

      if (!hasFixed && fixed) {
        hasFixed = fixed;
      }

      if (treeNode) {
        if (process.env.NODE_ENV === 'development') {
          if (treeNodeColumn) {
            (0, _log.warnLog)('vhb.error.colRepet', ['tree-node', treeNode]);
          }
        }

        if (!treeNodeColumn) {
          treeNodeColumn = column;
        }
      } else if (type === 'expand') {
        if (process.env.NODE_ENV === 'development') {
          if (expandColumn) {
            (0, _log.warnLog)('vhb.error.colRepet', ['type', type]);
          }
        }

        if (!expandColumn) {
          expandColumn = column;
        }
      }

      if (process.env.NODE_ENV === 'development') {
        if (type === 'checkbox') {
          if (checkboxColumn) {
            (0, _log.warnLog)('vhb.error.colRepet', ['type', type]);
          }

          if (!checkboxColumn) {
            checkboxColumn = column;
          }
        } else if (type === 'radio') {
          if (radioColumn) {
            (0, _log.warnLog)('vhb.error.colRepet', ['type', type]);
          }

          if (!radioColumn) {
            radioColumn = column;
          }
        }
      }

      if (process.env.NODE_ENV === 'development') {
        if (_this12.showOverflow && column.showOverflow === false) {
          (0, _log.warnLog)('vhb.error.errConflicts', ["table.show-overflow=".concat(_this12.showOverflow), "column.show-overflow=".concat(column.showOverflow)]);
        }

        if (_this12.showHeaderOverflow && column.showHeaderOverflow === false) {
          (0, _log.warnLog)('vhb.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)('vhb.error.errConflicts', ["table.show-footer-overflow=".concat(_this12.showFooterOverflow), "column.show-footer-overflow=".concat(column.showFooterOverflow)]);
        }
      }

      if (isAllOverflow && column.showOverflow === false) {
        isAllOverflow = false;
      }

      if (fullColumnIdData[colid]) {
        (0, _log.errLog)('vhb.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)('vhb.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)('vhb.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)('vhb.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)('vhb.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)('vhb.error.delFunc', ['$getColumnIndex', 'getVMColumnIndex']);
    }

    return this.getVMColumnIndex(column);
  },

  /**
   * 判断是否为索引列
   * @param {ColumnInfo} column 列配置
   */
  isSeqColumn: function isSeqColumn(column) {
    return column && column.type === 'seq';
  },

  /**
   * 定义行数据中的列属性，如果不存在则定义
   * @param {Row} record 行数据
   */
  defineField: function defineField(record) {
    var radioOpts = this.radioOpts,
        checkboxOpts = this.checkboxOpts,
        treeConfig = this.treeConfig,
        treeOpts = this.treeOpts,
        expandOpts = this.expandOpts;
    var rowkey = (0, _util.getRowkey)(this);
    this.tableFullColumn.forEach(function (column) {
      var property = column.property,
          editRender = column.editRender;

      if (property && !_xeUtils.default.has(record, property)) {
        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, property, 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 _this13 = this;

    var treeConfig = this.treeConfig,
        treeOpts = this.treeOpts;

    var handleRrecord = function handleRrecord(record) {
      return _this13.defineField(Object.assign({}, record));
    };

    var rows = treeConfig ? _xeUtils.default.mapTree(records, handleRrecord, treeOpts) : records.map(handleRrecord);
    return this.$nextTick().then(function () {
      return rows;
    });
  },

  /**
   * 创建 Row|Rows 对象
   * 对于某些特殊场景需要对数据进行手动插入时可能会用到
   * @param {Array/Object} records 新数据
   */
  createRow: function createRow(records) {
    var _this14 = this;

    var isArr = _xeUtils.default.isArray(records);

    if (!isArr) {
      records = [records];
    }

    return this.$nextTick().then(function () {
      return _this14.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)('vhb.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) {
            throw new Error(_utils.default.getLog('vhb.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.property) {
            setCellValue(row, column, null);
          }
        });
      });
    }

    return this.$nextTick();
  },

  /**
   * 检查是否为临时行数据
   * @param {Row} row 行对象
   */
  isInsertByRow: function isInsertByRow(row) {
    return this.editStore.insertList.indexOf(row) > -1;
  },

  /**
   * 删除所有新增的临时数据
   * @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].property;

          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 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 property = checkboxOpts.checkField;
    var currTableData = isFull ? transform ? tableFullTreeData : tableFullData : transform ? afterTreeFullData : afterFullData;
    var rowList = [];

    if (property) {
      if (treeConfig) {
        rowList = _xeUtils.default.filterTree(currTableData, function (row) {
          return _xeUtils.default.get(row, property);
        }, {
          children: transform ? mapChildren : children
        });
      } else {
        rowList = currTableData.filter(function (row) {
          return _xeUtils.default.get(row, property);
        });
      }
    } else {
      var selection = this.selection;

      if (treeConfig) {
        rowList = _xeUtils.default.filterTree(currTableData, function (row) {
          return selection.indexOf(row) > -1;
        }, {
          children: transform ? mapChildren : children
        });
      } else {
        rowList = currTableData.filter(function (row) {
          return selection.indexOf(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 _this17 = this;

    var tableFullColumn = this.tableFullColumn,
        tableFullData = this.tableFullData,
        filterOpts = this.filterOpts,
        sortOpts = this.sortOpts,
        treeConfig = this.treeConfig,
        treeOpts = this.treeOpts,
        tableFullTreeData = this.tableFullTreeData;
    var allRemoteFilter = filterOpts.remote,
        allFilterMethod = filterOpts.filterMethod;
    var allRemoteSort = sortOpts.remote,
        allSortMethod = sortOpts.sortMethod,
        sortMultiple = sortOpts.multiple,
        chronological = sortOpts.chronological;
    var transform = treeOpts.transform;
    var tableData = [];
    var tableTree = [];
    var filterColumns = [];
    var orderColumns = [];
    tableFullColumn.forEach(function (column) {
      var property = column.property,
          sortable = column.sortable,
          order = column.order,
          filters = column.filters;

      if (!allRemoteFilter && filters && filters.length) {
        var valueList = [];
        var itemList = [];
        filters.forEach(function (item) {
          if (item.checked) {
            itemList.push(item);
            valueList.push(item.value);
          }
        });

        if (itemList.length) {
          filterColumns.push({
            column: column,
            valueList: valueList,
            itemList: itemList
          });
        }
      }

      if (!allRemoteSort && sortable && order) {
        orderColumns.push({
          column: column,
          field: column.property,
          property: property,
          order: order,
          sortTime: column.sortTime
        });
      }
    });

    if (sortMultiple && chronological && orderColumns.length > 1) {
      orderColumns = _xeUtils.default.orderBy(orderColumns, 'sortTime');
    }

    if (filterColumns.length) {
      var handleFilter = function handleFilter(row) {
        return filterColumns.every(function (_ref) {
          var column = _ref.column,
              valueList = _ref.valueList,
              itemList = _ref.itemList;

          if (valueList.length && !allRemoteFilter) {
            var filterMethod = column.filterMethod,
                filterRender = column.filterRender;
            var compConf = filterRender ? _vHBTable.default.renderer.get(filterRender.name) : null;
            var compFilterMethod = compConf && compConf.renderFilter ? compConf.filterMethod : null;
            var defaultFilterMethod = compConf ? compConf.defaultFilterMethod : null;

            var cellValue = _utils.default.getCellValue(row, column);

            if (filterMethod) {
              return itemList.some(function (item) {
                return filterMethod({
                  value: item.value,
                  option: item,
                  cellValue: cellValue,
                  row: row,
                  column: column,
                  $table: _th