vxe-table-ro-test/lib/table/src/table.js

一个基于 vue 的 PC 端表格组件，支持增删改查、虚拟树、列拖拽，懒加载、快捷菜单、数据校验、树形结构、打印、导入导出、自定义模板、渲染器、JSON 配置式...

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
var _vue = require("vue");
var _xeUtils = _interopRequireDefault(require("xe-utils"));
var _dom = require("../../ui/src/dom");
var _utils = require("../../ui/src/utils");
var _ui = require("../../ui");
var _cell = _interopRequireDefault(require("./cell"));
var _body = _interopRequireDefault(require("./body"));
var _header = _interopRequireDefault(require("./header"));
var _footer = _interopRequireDefault(require("./footer"));
var _props = _interopRequireDefault(require("./props"));
var _emits = _interopRequireDefault(require("./emits"));
var _util = require("./util");
var _vn = require("../../ui/src/vn");
var _log = require("../../ui/src/log");
var _panel = _interopRequireDefault(require("../module/custom/panel"));
var _panel2 = _interopRequireDefault(require("../module/filter/panel"));
var _importPanel = _interopRequireDefault(require("../module/export/import-panel"));
var _exportPanel = _interopRequireDefault(require("../module/export/export-panel"));
var _panel3 = _interopRequireDefault(require("../module/menu/panel"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
const {
  getConfig,
  getI18n,
  renderer,
  formats,
  createEvent,
  globalResize,
  interceptor,
  hooks,
  globalEvents,
  GLOBAL_EVENT_KEYS,
  useFns
} = _ui.VxeUI;
const isWebkit = _dom.browse['-webkit'] && !_dom.browse.edge;
const customStorageKey = 'VXE_CUSTOM_STORE';
var _default = exports.default = (0, _vue.defineComponent)({
  name: 'VxeTable',
  props: _props.default,
  emits: _emits.default,
  setup(props, context) {
    const {
      slots,
      emit
    } = context;
    const xID = _xeUtils.default.uniqueId();
    // 使用已安装的组件，如果未安装则不渲染
    const VxeUILoadingComponent = _ui.VxeUI.getComponent('VxeLoading');
    const VxeUITooltipComponent = _ui.VxeUI.getComponent('VxeTooltip');
    const $xeTabs = (0, _vue.inject)('$xeTabs', null);
    const {
      computeSize
    } = useFns.useSize(props);
    const reactData = (0, _vue.reactive)({
      isCalcColumn: false,
      // 低性能的静态列
      staticColumns: [],
      // 渲染的列分组
      tableGroupColumn: [],
      // 可视区渲染的列
      tableColumn: [],
      // 渲染中的数据
      tableData: [],
      // 是否启用了横向 X 可视渲染方式加载
      scrollXLoad: false,
      // 是否启用了纵向 Y 可视渲染方式加载
      scrollYLoad: false,
      // 是否存在纵向滚动条
      overflowY: true,
      // 是否存在横向滚动条
      overflowX: false,
      // 纵向滚动条的宽度
      scrollbarWidth: 0,
      // 横向滚动条的高度
      scrollbarHeight: 0,
      // 最后滚动时间戳
      lastScrollTime: 0,
      // 行高
      rowHeight: 0,
      // 表格父容器的高度
      parentHeight: 0,
      // 是否使用分组表头
      isGroup: false,
      isAllOverflow: false,
      // 复选框属性，是否全选
      isAllSelected: false,
      // 复选框属性，有选中且非全选状态
      isIndeterminate: false,
      // 复选框属性，已选中的行集合
      selectCheckboxMaps: {},
      // 当前行
      currentRow: null,
      // 单选框属性，选中列
      currentColumn: null,
      // 单选框属性，选中行
      selectRadioRow: null,
      // 表尾合计数据
      footerTableData: [],
      // 展开列信息
      expandColumn: null,
      // 树节点列信息
      treeNodeColumn: null,
      hasFixedColumn: false,
      // 已展开的行集合
      rowExpandedMaps: {},
      // 懒加载中的展开行的集合
      rowExpandLazyLoadedMaps: {},
      // 已展开树节点集合
      treeExpandedMaps: {},
      // 懒加载中的树节点的集合
      treeExpandLazyLoadedMaps: {},
      // 树节点不确定状态的集合
      treeIndeterminateMaps: {},
      // 合并单元格的对象集
      mergeList: [],
      // 合并表尾数据的对象集
      mergeFooterList: [],
      // 刷新列标识，当列筛选被改变时，触发表格刷新数据
      upDataFlag: 0,
      // 刷新列标识，当列的特定属性被改变时，触发表格刷新列
      reColumnFlag: 0,
      // 已标记的对象集
      pendingRowMaps: {},
      // 已标记的行
      pendingRowList: [],
      // 初始化标识
      initStore: {
        filter: false,
        import: false,
        export: false,
        custom: false
      },
      // 自定义列相关的信息
      customStore: {
        btnEl: null,
        isAll: false,
        isIndeterminate: false,
        activeBtn: false,
        activeWrapper: false,
        visible: false,
        maxHeight: 0,
        oldSortMaps: {},
        oldFixedMaps: {},
        oldVisibleMaps: {}
      },
      customColumnList: [],
      // 当前选中的筛选列
      filterStore: {
        isAllSelected: false,
        isIndeterminate: false,
        style: null,
        options: [],
        column: null,
        multiple: false,
        visible: false,
        maxHeight: null
      },
      // 存放列相关的信息
      columnStore: {
        leftList: [],
        centerList: [],
        rightList: [],
        resizeList: [],
        pxList: [],
        pxMinList: [],
        autoMinList: [],
        scaleList: [],
        scaleMinList: [],
        autoList: [],
        remainList: []
      },
      // 存放快捷菜单的信息
      ctxMenuStore: {
        selected: null,
        visible: false,
        showChild: false,
        selectChild: null,
        list: [],
        style: null
      },
      // 存放可编辑相关信息
      editStore: {
        indexs: {
          columns: []
        },
        titles: {
          columns: []
        },
        // 选中源
        selected: {
          row: null,
          column: null
        },
        // 已复制源
        copyed: {
          cut: false,
          rows: [],
          columns: []
        },
        // 激活
        actived: {
          row: null,
          column: null
        },
        // 当前被强制聚焦单元格，只会在鼠标点击后算聚焦
        focused: {
          row: null,
          column: null
        },
        insertMaps: {},
        removeMaps: {}
      },
      // 存放 tooltip 相关信息
      tooltipStore: {
        row: null,
        column: null,
        content: null,
        visible: false,
        currOpts: {}
      },
      // 存放数据校验相关信息
      validStore: {
        visible: false
      },
      validErrorMaps: {},
      // 导入相关信息
      importStore: {
        inited: false,
        file: null,
        type: '',
        modeList: [],
        typeList: [],
        filename: '',
        visible: false
      },
      importParams: {
        mode: '',
        types: null,
        message: true
      },
      // 导出相关信息
      exportStore: {
        inited: false,
        name: '',
        modeList: [],
        typeList: [],
        columns: [],
        isPrint: false,
        hasFooter: false,
        hasMerge: false,
        hasTree: false,
        hasColgroup: false,
        visible: false
      },
      exportParams: {
        filename: '',
        sheetName: '',
        mode: '',
        type: '',
        isColgroup: false,
        isMerge: false,
        isAllExpand: false,
        useStyle: false,
        original: false,
        message: true,
        isHeader: false,
        isFooter: false
      },
      scrollVMLoading: false,
      _isResize: false,
      _isLoading: false
    });
    const internalData = {
      tZindex: 0,
      elemStore: {},
      // 存放横向 X 虚拟滚动相关的信息
      scrollXStore: {
        offsetSize: 0,
        visibleSize: 0,
        startIndex: 0,
        endIndex: 0
      },
      // 存放纵向 Y 虚拟滚动相关信息
      scrollYStore: {
        rowHeight: 0,
        offsetSize: 0,
        visibleSize: 0,
        startIndex: 0,
        endIndex: 0
      },
      // 表格宽度
      tableWidth: 0,
      // 表格高度
      tableHeight: 0,
      // 表头高度
      headerHeight: 0,
      // 表尾高度
      footerHeight: 0,
      customHeight: 0,
      customMinHeight: 0,
      customMaxHeight: 0,
      // 当前 hover 行
      hoverRow: null,
      // 最后滚动位置
      lastScrollLeft: 0,
      lastScrollTop: 0,
      // 单选框属性，已选中保留的行
      radioReserveRow: null,
      // 复选框属性，已选中保留的行集合
      checkboxReserveRowMap: {},
      // 行数据，已展开保留的行集合
      rowExpandedReserveRowMap: {},
      // 树结构数据，已展开保留的行集合
      treeExpandedReserveRowMap: {},
      // 树结构数据，不确定状态的集合
      treeIndeterminateRowMaps: {},
      // 列表完整数据、条件处理后
      tableFullData: [],
      afterFullData: [],
      afterTreeFullData: [],
      // 列表条件处理后数据集合
      afterFullRowMaps: {},
      // 树结构完整数据、条件处理后
      tableFullTreeData: [],
      tableSynchData: [],
      tableSourceData: [],
      // 收集的列配置（带分组）
      collectColumn: [],
      // 完整所有列（不带分组）
      tableFullColumn: [],
      // 渲染所有列
      visibleColumn: [],
      // 总的缓存数据集
      fullAllDataRowIdData: {},
      // 渲染中缓存数据
      sourceDataRowIdData: {},
      fullDataRowIdData: {},
      fullColumnIdData: {},
      fullColumnFieldData: {},
      // 列选取状态
      columnStatusMaps: {},
      // 行选取状态
      rowStatusMaps: {},
      inited: false,
      tooltipTimeout: null,
      initStatus: false,
      isActivated: false
    };
    let tableMethods = {};
    let tablePrivateMethods = {};
    const refElem = (0, _vue.ref)();
    const refTooltip = (0, _vue.ref)();
    const refCommTooltip = (0, _vue.ref)();
    const refValidTooltip = (0, _vue.ref)();
    const refTableMenu = (0, _vue.ref)();
    const refTableFilter = (0, _vue.ref)();
    const refTableCustom = (0, _vue.ref)();
    const refTableHeader = (0, _vue.ref)();
    const refTableBody = (0, _vue.ref)();
    const refTableFooter = (0, _vue.ref)();
    const refTableLeftHeader = (0, _vue.ref)();
    const refTableLeftBody = (0, _vue.ref)();
    const refTableLeftFooter = (0, _vue.ref)();
    const refTableRightHeader = (0, _vue.ref)();
    const refTableRightBody = (0, _vue.ref)();
    const refTableRightFooter = (0, _vue.ref)();
    const refLeftContainer = (0, _vue.ref)();
    const refRightContainer = (0, _vue.ref)();
    const refCellResizeBar = (0, _vue.ref)();
    const refEmptyPlaceholder = (0, _vue.ref)();
    const $xeGrid = (0, _vue.inject)('$xeGrid', null);
    let $xeToolbar;
    const computeTableId = (0, _vue.computed)(() => {
      const {
        id
      } = props;
      if (id) {
        if (_xeUtils.default.isFunction(id)) {
          return `${id({
            $table: $xeTable,
            $grid: $xeGrid
          }) || ''}`;
        }
        return `${id}`;
      }
      return '';
    });
    const computeValidOpts = (0, _vue.computed)(() => {
      return Object.assign({}, getConfig().table.validConfig, props.validConfig);
    });
    const computeSXOpts = (0, _vue.computed)(() => {
      return Object.assign({}, getConfig().table.scrollX, props.scrollX);
    });
    const computeSYOpts = (0, _vue.computed)(() => {
      return Object.assign({}, getConfig().table.scrollY, props.scrollY);
    });
    const computeRowHeightMaps = (0, _vue.computed)(() => {
      return {
        default: 48,
        medium: 44,
        small: 40,
        mini: 36
      };
    });
    const computeColumnOpts = (0, _vue.computed)(() => {
      return Object.assign({}, getConfig().table.columnConfig, props.columnConfig);
    });
    const computeRowOpts = (0, _vue.computed)(() => {
      return Object.assign({}, getConfig().table.rowConfig, props.rowConfig);
    });
    const computeResizeOpts = (0, _vue.computed)(() => {
      return Object.assign({}, getConfig().table.resizeConfig, props.resizeConfig);
    });
    const computeResizableOpts = (0, _vue.computed)(() => {
      return Object.assign({}, getConfig().table.resizableConfig, props.resizableConfig);
    });
    const computeSeqOpts = (0, _vue.computed)(() => {
      return Object.assign({
        startIndex: 0
      }, getConfig().table.seqConfig, props.seqConfig);
    });
    const computeRadioOpts = (0, _vue.computed)(() => {
      return Object.assign({}, getConfig().table.radioConfig, props.radioConfig);
    });
    const computeCheckboxOpts = (0, _vue.computed)(() => {
      return Object.assign({}, getConfig().table.checkboxConfig, props.checkboxConfig);
    });
    let computeTooltipOpts = (0, _vue.ref)();
    computeTooltipOpts = (0, _vue.computed)(() => {
      return Object.assign({}, getConfig().tooltip, getConfig().table.tooltipConfig, props.tooltipConfig);
    });
    const computeTipConfig = (0, _vue.computed)(() => {
      const tooltipOpts = computeTooltipOpts.value;
      return Object.assign({}, tooltipOpts);
    });
    const computeValidTipOpts = (0, _vue.computed)(() => {
      const tooltipOpts = computeTooltipOpts.value;
      return Object.assign({
        isArrow: false
      }, tooltipOpts);
    });
    const computeEditOpts = (0, _vue.computed)(() => {
      return Object.assign({}, getConfig().table.editConfig, props.editConfig);
    });
    const computeSortOpts = (0, _vue.computed)(() => {
      return Object.assign({
        orders: ['asc', 'desc', null]
      }, getConfig().table.sortConfig, props.sortConfig);
    });
    const computeFilterOpts = (0, _vue.computed)(() => {
      return Object.assign({}, getConfig().table.filterConfig, props.filterConfig);
    });
    const computeMouseOpts = (0, _vue.computed)(() => {
      return Object.assign({}, getConfig().table.mouseConfig, props.mouseConfig);
    });
    const computeAreaOpts = (0, _vue.computed)(() => {
      return Object.assign({}, getConfig().table.areaConfig, props.areaConfig);
    });
    const computeKeyboardOpts = (0, _vue.computed)(() => {
      return Object.assign({}, getConfig().table.keyboardConfig, props.keyboardConfig);
    });
    const computeClipOpts = (0, _vue.computed)(() => {
      return Object.assign({}, getConfig().table.clipConfig, props.clipConfig);
    });
    const computeFNROpts = (0, _vue.computed)(() => {
      return Object.assign({}, getConfig().table.fnrConfig, props.fnrConfig);
    });
    const computeMenuOpts = (0, _vue.computed)(() => {
      return Object.assign({}, getConfig().table.menuConfig, props.menuConfig);
    });
    const computeHeaderMenu = (0, _vue.computed)(() => {
      const menuOpts = computeMenuOpts.value;
      const headerOpts = menuOpts.header;
      return headerOpts && headerOpts.options ? headerOpts.options : [];
    });
    const computeBodyMenu = (0, _vue.computed)(() => {
      const menuOpts = computeMenuOpts.value;
      const bodyOpts = menuOpts.body;
      return bodyOpts && bodyOpts.options ? bodyOpts.options : [];
    });
    const computeFooterMenu = (0, _vue.computed)(() => {
      const menuOpts = computeMenuOpts.value;
      const footerOpts = menuOpts.footer;
      return footerOpts && footerOpts.options ? footerOpts.options : [];
    });
    const computeIsMenu = (0, _vue.computed)(() => {
      const menuOpts = computeMenuOpts.value;
      const headerMenu = computeHeaderMenu.value;
      const bodyMenu = computeBodyMenu.value;
      const footerMenu = computeFooterMenu.value;
      return !!(props.menuConfig && (0, _utils.isEnableConf)(menuOpts) && (headerMenu.length || bodyMenu.length || footerMenu.length));
    });
    const computeMenuList = (0, _vue.computed)(() => {
      const {
        ctxMenuStore
      } = reactData;
      const rest = [];
      ctxMenuStore.list.forEach(list => {
        list.forEach(item => {
          rest.push(item);
        });
      });
      return rest;
    });
    const computeExportOpts = (0, _vue.computed)(() => {
      return Object.assign({}, getConfig().table.exportConfig, props.exportConfig);
    });
    const computeImportOpts = (0, _vue.computed)(() => {
      return Object.assign({}, getConfig().table.importConfig, props.importConfig);
    });
    const computePrintOpts = (0, _vue.computed)(() => {
      return Object.assign({}, getConfig().table.printConfig, props.printConfig);
    });
    const computeExpandOpts = (0, _vue.computed)(() => {
      return Object.assign({}, getConfig().table.expandConfig, props.expandConfig);
    });
    const computeTreeOpts = (0, _vue.computed)(() => {
      return Object.assign({}, getConfig().table.treeConfig, props.treeConfig);
    });
    const computeEmptyOpts = (0, _vue.computed)(() => {
      return Object.assign({}, getConfig().table.emptyRender, props.emptyRender);
    });
    const computeLoadingOpts = (0, _vue.computed)(() => {
      return Object.assign({}, getConfig().table.loadingConfig, props.loadingConfig);
    });
    const computeCellOffsetWidth = (0, _vue.computed)(() => {
      return props.border ? Math.max(2, Math.ceil(reactData.scrollbarWidth / reactData.tableColumn.length)) : 1;
    });
    const computeCustomOpts = (0, _vue.computed)(() => {
      return Object.assign({}, getConfig().table.customConfig, props.customConfig);
    });
    const computeAutoWidthColumnList = (0, _vue.computed)(() => {
      const {
        visibleColumn
      } = internalData;
      const {
        tableColumn
      } = reactData;
      return tableColumn.length || visibleColumn.length ? visibleColumn.filter(column => column.width === 'auto' || column.minWidth === 'auto') : [];
    });
    const computeFixedColumnSize = (0, _vue.computed)(() => {
      const {
        collectColumn
      } = internalData;
      let fixedSize = 0;
      // 只判断第一层
      collectColumn.forEach(column => {
        if (column.renderFixed) {
          fixedSize++;
        }
      });
      return fixedSize;
    });
    const computeIsMaxFixedColumn = (0, _vue.computed)(() => {
      const fixedColumnSize = computeFixedColumnSize.value;
      const columnOpts = computeColumnOpts.value;
      const {
        maxFixedSize
      } = columnOpts;
      if (maxFixedSize) {
        return fixedColumnSize >= maxFixedSize;
      }
      return false;
    });
    const computeTableBorder = (0, _vue.computed)(() => {
      const {
        border
      } = props;
      if (border === true) {
        return 'full';
      }
      if (border) {
        return border;
      }
      return 'default';
    });
    const computeIsAllCheckboxDisabled = (0, _vue.computed)(() => {
      const {
        treeConfig
      } = props;
      const {
        tableData
      } = reactData;
      const {
        tableFullData
      } = internalData;
      const checkboxOpts = computeCheckboxOpts.value;
      const {
        strict,
        checkMethod
      } = checkboxOpts;
      if (strict) {
        if (tableData.length || tableFullData.length) {
          if (checkMethod) {
            if (treeConfig) {
              // 暂时不支持树形结构
            }
            // 如果所有行都被禁用
            return tableFullData.every(row => !checkMethod({
              row
            }));
          }
          return false;
        }
        return true;
      }
      return false;
    });
    const refMaps = {
      refElem,
      refTooltip,
      refValidTooltip,
      refTableFilter,
      refTableCustom,
      refTableMenu,
      refTableHeader,
      refTableBody,
      refTableFooter,
      refTableLeftHeader,
      refTableLeftBody,
      refTableLeftFooter,
      refTableRightHeader,
      refTableRightBody,
      refTableRightFooter,
      refLeftContainer,
      refRightContainer,
      refCellResizeBar
    };
    const computeMaps = {
      computeSize,
      computeTableId,
      computeValidOpts,
      computeSXOpts,
      computeSYOpts,
      computeColumnOpts,
      computeRowOpts,
      computeResizeOpts,
      computeResizableOpts,
      computeSeqOpts,
      computeRadioOpts,
      computeCheckboxOpts,
      computeTooltipOpts,
      computeEditOpts,
      computeSortOpts,
      computeFilterOpts,
      computeMouseOpts,
      computeAreaOpts,
      computeKeyboardOpts,
      computeClipOpts,
      computeFNROpts,
      computeHeaderMenu,
      computeBodyMenu,
      computeFooterMenu,
      computeIsMenu,
      computeMenuOpts,
      computeExportOpts,
      computeImportOpts,
      computePrintOpts,
      computeExpandOpts,
      computeTreeOpts,
      computeEmptyOpts,
      computeLoadingOpts,
      computeCustomOpts,
      computeFixedColumnSize,
      computeIsMaxFixedColumn,
      computeIsAllCheckboxDisabled
    };
    const $xeTable = {
      xID,
      props: props,
      context,
      reactData,
      internalData,
      getRefMaps: () => refMaps,
      getComputeMaps: () => computeMaps,
      xegrid: $xeGrid
    };
    const eqCellValue = (row1, row2, field) => {
      const val1 = _xeUtils.default.get(row1, field);
      const 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);
    };
    const getNextSortOrder = column => {
      const sortOpts = computeSortOpts.value;
      const {
        orders
      } = sortOpts;
      const currOrder = column.order || null;
      const oIndex = orders.indexOf(currOrder) + 1;
      return orders[oIndex < orders.length ? oIndex : 0];
    };
    const getCustomStorageMap = id => {
      const version = getConfig().version;
      const rest = _xeUtils.default.toStringJSON(localStorage.getItem(customStorageKey) || '');
      const maps = rest && rest._v === version ? rest : {
        _v: version
      };
      return (id ? maps[id] : maps) || {};
    };
    const setCustomStorageMap = (id, data) => {
      const version = getConfig().version;
      const maps = getCustomStorageMap();
      maps[id] = data || undefined;
      maps._v = version;
      localStorage.setItem(customStorageKey, _xeUtils.default.toJSONString(maps));
    };
    const getRecoverRowMaps = keyMaps => {
      const {
        fullAllDataRowIdData
      } = internalData;
      const restKeys = {};
      _xeUtils.default.each(keyMaps, (row, rowid) => {
        if (fullAllDataRowIdData[rowid]) {
          restKeys[rowid] = row;
        }
      });
      return restKeys;
    };
    const handleReserveRow = reserveRowMap => {
      const {
        fullDataRowIdData
      } = internalData;
      const reserveList = [];
      _xeUtils.default.each(reserveRowMap, (item, rowid) => {
        if (fullDataRowIdData[rowid] && $xeTable.findRowIndexOf(reserveList, fullDataRowIdData[rowid].row) === -1) {
          reserveList.push(fullDataRowIdData[rowid].row);
        }
      });
      return reserveList;
    };
    const computeVirtualX = () => {
      const {
        visibleColumn
      } = internalData;
      const tableBody = refTableBody.value;
      const tableBodyElem = tableBody ? tableBody.$el : null;
      if (tableBodyElem) {
        const {
          scrollLeft,
          clientWidth
        } = tableBodyElem;
        const endWidth = scrollLeft + clientWidth;
        let toVisibleIndex = -1;
        let cWidth = 0;
        let visibleSize = 0;
        for (let 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(6, visibleSize)
        };
      }
      return {
        toVisibleIndex: 0,
        visibleSize: 6
      };
    };
    const computeVirtualY = () => {
      const tableHeader = refTableHeader.value;
      const tableBody = refTableBody.value;
      const tableBodyElem = tableBody ? tableBody.$el : null;
      const vSize = computeSize.value;
      const rowHeightMaps = computeRowHeightMaps.value;
      if (tableBodyElem) {
        const tableHeaderElem = tableHeader ? tableHeader.$el : null;
        let rowHeight = 0;
        let firstTrElem;
        firstTrElem = tableBodyElem.querySelector('tr');
        if (!firstTrElem && tableHeaderElem) {
          firstTrElem = tableHeaderElem.querySelector('tr');
        }
        if (firstTrElem) {
          rowHeight = firstTrElem.clientHeight;
        }
        if (!rowHeight) {
          rowHeight = rowHeightMaps[vSize || 'default'];
        }
        const visibleSize = Math.max(8, Math.ceil(tableBodyElem.clientHeight / rowHeight) + 2);
        return {
          rowHeight,
          visibleSize
        };
      }
      return {
        rowHeight: 0,
        visibleSize: 8
      };
    };
    const calculateMergerOffsetIndex = (list, offsetItem, type) => {
      for (let mcIndex = 0, len = list.length; mcIndex < len; mcIndex++) {
        const mergeItem = list[mcIndex];
        const {
          startIndex,
          endIndex
        } = offsetItem;
        const mergeStartIndex = mergeItem[type];
        const mergeSpanNumber = mergeItem[type + 'span'];
        const 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;
        }
      }
    };
    const setMerges = (merges, mList, rowList) => {
      if (merges) {
        const {
          treeConfig
        } = props;
        const {
          visibleColumn
        } = internalData;
        if (!_xeUtils.default.isArray(merges)) {
          merges = [merges];
        }
        if (treeConfig && merges.length) {
          (0, _log.errLog)('vxe.error.noTree', ['merge-cells | merge-footer-items']);
        }
        merges.forEach(item => {
          let {
            row,
            col,
            rowspan,
            colspan
          } = item;
          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) {
              const mcIndex = _xeUtils.default.findIndexOf(mList, item => (item._row === row || (0, _util.getRowid)($xeTable, item._row) === (0, _util.getRowid)($xeTable, row)) && (item._col.id === col || item._col.id === col.id));
              const mergeItem = mList[mcIndex];
              if (mergeItem) {
                mergeItem.rowspan = rowspan;
                mergeItem.colspan = colspan;
                mergeItem._rowspan = rowspan;
                mergeItem._colspan = colspan;
              } else {
                const mergeRowIndex = rowList ? $xeTable.findRowIndexOf(rowList, row) : row;
                const mergeColIndex = tableMethods.getVTColumnIndex(col);
                mList.push({
                  row: mergeRowIndex,
                  col: mergeColIndex,
                  rowspan,
                  colspan,
                  _row: row,
                  _col: col,
                  _rowspan: rowspan,
                  _colspan: colspan
                });
              }
            }
          }
        });
      }
    };
    const removeMerges = (merges, mList, rowList) => {
      const rest = [];
      if (merges) {
        const {
          treeConfig
        } = props;
        const {
          visibleColumn
        } = internalData;
        if (!_xeUtils.default.isArray(merges)) {
          merges = [merges];
        }
        if (treeConfig && merges.length) {
          (0, _log.errLog)('vxe.error.noTree', ['merge-cells | merge-footer-items']);
        }
        merges.forEach(item => {
          let {
            row,
            col
          } = item;
          if (rowList && _xeUtils.default.isNumber(row)) {
            row = rowList[row];
          }
          if (_xeUtils.default.isNumber(col)) {
            col = visibleColumn[col];
          }
          const mcIndex = _xeUtils.default.findIndexOf(mList, item => (item._row === row || (0, _util.getRowid)($xeTable, item._row) === (0, _util.getRowid)($xeTable, row)) && (item._col.id === col || item._col.id === col.id));
          if (mcIndex > -1) {
            const rItems = mList.splice(mcIndex, 1);
            rest.push(rItems[0]);
          }
        });
      }
      return rest;
    };
    const clearAllSort = () => {
      const {
        tableFullColumn
      } = internalData;
      tableFullColumn.forEach(column => {
        column.order = null;
      });
    };
    const calcHeight = key => {
      const {
        parentHeight
      } = reactData;
      const val = props[key];
      let num = 0;
      if (val) {
        if (val === '100%' || val === 'auto') {
          num = parentHeight;
        } else {
          const excludeHeight = $xeTable.getExcludeHeight();
          if ((0, _dom.isScale)(val)) {
            num = Math.floor((_xeUtils.default.toInteger(val) || 1) / 100 * parentHeight);
          } else {
            num = _xeUtils.default.toNumber(val);
          }
          num = Math.max(40, num - excludeHeight);
        }
      }
      return num;
    };
    const handleCustomRestore = storeData => {
      let {
        collectColumn
      } = internalData;
      const {
        resizableData,
        sortData,
        visibleData,
        fixedData
      } = storeData;
      let hasCustomSort = false;
      // 处理还原
      if (resizableData || sortData || visibleData || fixedData) {
        _xeUtils.default.eachTree(collectColumn, (column, index, items, path, parent) => {
          const colKey = column.getKey();
          // 支持一级
          if (!parent) {
            if (fixedData && fixedData[colKey]) {
              column.fixed = fixedData[colKey];
            }
            if (sortData && _xeUtils.default.isNumber(sortData[colKey])) {
              hasCustomSort = true;
              column.renderSortNumber = sortData[colKey];
            }
          }
          if (resizableData && _xeUtils.default.isNumber(resizableData[colKey])) {
            column.resizeWidth = resizableData[colKey];
          }
          if (visibleData && _xeUtils.default.isBoolean(visibleData[colKey])) {
            column.visible = visibleData[colKey];
          }
        });
        // 如果自定义了顺序
        if (hasCustomSort) {
          collectColumn = _xeUtils.default.orderBy(collectColumn, 'renderSortNumber');
          internalData.collectColumn = collectColumn;
          internalData.tableFullColumn = getColumnList(collectColumn);
        }
      }
    };
    /**
     * 还原自定义列操作状态
     */
    const restoreCustomStorage = () => {
      const {
        customConfig
      } = props;
      const tableId = computeTableId.value;
      const customOpts = computeCustomOpts.value;
      const {
        storage,
        restoreStore
      } = customOpts;
      const isAllCustom = storage === true;
      const storageOpts = isAllCustom ? {} : Object.assign({}, storage || {});
      const isCustomResizable = isAllCustom || storageOpts.resizable;
      const isCustomVisible = isAllCustom || storageOpts.visible;
      const isCustomFixed = isAllCustom || storageOpts.fixed;
      const isCustomSort = isAllCustom || storageOpts.sort;
      if (customConfig && (isCustomResizable || isCustomVisible || isCustomFixed || isCustomSort)) {
        if (!tableId) {
          (0, _log.errLog)('vxe.error.reqProp', ['id']);
          return;
        }
        const storeData = getCustomStorageMap(tableId);
        if (restoreStore) {
          return Promise.resolve(restoreStore({
            id: tableId,
            type: 'restore',
            storeData
          })).then(storeData => {
            if (!storeData) {
              return;
            }
            return handleCustomRestore(storeData);
          }).catch(e => e);
        } else {
          return handleCustomRestore(storeData);
        }
      }
    };
    /**
     * 更新数据列的 Map
     * 牺牲数据组装的耗时，用来换取使用过程中的流畅
     */
    const cacheColumnMap = () => {
      const {
        tableFullColumn,
        collectColumn
      } = internalData;
      const fullColumnIdData = internalData.fullColumnIdData = {};
      const fullColumnFieldData = internalData.fullColumnFieldData = {};
      const mouseOpts = computeMouseOpts.value;
      const columnOpts = computeColumnOpts.value;
      const rowOpts = computeRowOpts.value;
      const isGroup = collectColumn.some(_utils.hasChildrenList);
      let isAllOverflow = !!props.showOverflow;
      let expandColumn;
      let treeNodeColumn;
      let checkboxColumn;
      let radioColumn;
      let htmlColumn;
      let hasFixed;
      const handleFunc = (column, index, items, path, parent) => {
        const {
          id: colid,
          field,
          fixed,
          type,
          treeNode
        } = column;
        const rest = {
          column,
          colid,
          index,
          items,
          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 (isAllOverflow && column.showOverflow === false) {
          isAllOverflow = false;
        }
        if (fullColumnIdData[colid]) {
          (0, _log.errLog)('vxe.error.colRepet', ['colId', colid]);
        }
        fullColumnIdData[colid] = rest;
      };
      if (isGroup) {
        _xeUtils.default.eachTree(collectColumn, (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 && mouseOpts.area) {
          (0, _log.errLog)('vxe.error.errConflicts', ['mouse-config.area', 'column.type=expand']);
        }
      }
      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']);
          }
        }
      }
      reactData.isGroup = isGroup;
      reactData.treeNodeColumn = treeNodeColumn;
      reactData.expandColumn = expandColumn;
      reactData.isAllOverflow = isAllOverflow;
    };
    const updateHeight = () => {
      internalData.customHeight = calcHeight('height');
      internalData.customMinHeight = calcHeight('minHeight');
      internalData.customMaxHeight = calcHeight('maxHeight');
    };
    const calcCellWidth = () => {
      const {
        tableData
      } = reactData;
      const autoWidthColumnList = computeAutoWidthColumnList.value;
      if (!tableData.length || !autoWidthColumnList.length) {
        reactData.isCalcColumn = false;
        return (0, _vue.nextTick)();
      }
      reactData.isCalcColumn = true;
      return (0, _vue.nextTick)().then(() => {
        const el = refElem.value;
        if (el) {
          autoWidthColumnList.forEach(column => {
            const cellElList = el.querySelectorAll(`.vxe-header--column.${column.id}>.vxe-cell,.vxe-body--column.${column.id}>.vxe-cell,.vxe-footer--column.${column.id}>.vxe-cell`);
            const firstCellEl = cellElList[0];
            let paddingSize = 0;
            if (firstCellEl) {
              const cellStyle = getComputedStyle(firstCellEl);
              paddingSize = Math.floor(_xeUtils.default.toNumber(cellStyle.paddingLeft) + _xeUtils.default.toNumber(cellStyle.paddingRight)) + 2;
            }
            let colWidth = column.renderAutoWidth - paddingSize;
            _xeUtils.default.arrayEach(cellElList, itemEl => {
              const cellEl = itemEl;
              const thElem = cellEl.parentNode;
              let titleWidth = 0;
              if (`${thElem.tagName}`.toLowerCase() === 'th') {
                _xeUtils.default.arrayEach(cellEl.children, btnEl => {
                  titleWidth += btnEl.offsetWidth + 1;
                });
              } else {
                const labelEl = cellEl.firstChild;
                if (labelEl) {
                  titleWidth = labelEl.offsetWidth;
                }
              }
              if (titleWidth) {
                colWidth = Math.max(colWidth, Math.ceil(titleWidth) + 4);
              }
            });
            column.renderAutoWidth = colWidth + paddingSize;
          });
          tablePrivateMethods.analyColumnWidth();
        }
        reactData.isCalcColumn = false;
      });
    };
    /**
     * 列宽算法
     * 支持 px、%、固定 混合分配
     * 支持动态列表调整分配
     * 支持自动分配偏移量
     */
    const autoCellWidth = () => {
      const tableHeader = refTableHeader.value;
      const tableBody = refTableBody.value;
      const tableFooter = refTableFooter.value;
      const bodyElem = tableBody ? tableBody.$el : null;
      const headerElem = tableHeader ? tableHeader.$el : null;
      const footerElem = tableFooter ? tableFooter.$el : null;
      if (!bodyElem) {
        return;
      }
      let tableWidth = 0;
      const minCellWidth = 40; // 列宽最少限制 40px
      const bodyWidth = bodyElem.clientWidth - 1;
      let remainWidth = bodyWidth;
      let meanWidth = remainWidth / 100;
      const {
        fit
      } = props;
      const {
        columnStore
      } = reactData;
      const {
        resizeList,
        pxMinList,
        autoMinList,
        pxList,
        scaleList,
        scaleMinList,
        autoList,
        remainList
      } = columnStore;
      // 最小宽
      pxMinList.forEach(column => {
        const minWidth = _xeUtils.default.toInteger(column.minWidth);
        tableWidth += minWidth;
        column.renderWidth = minWidth;
      });
      // 最小自适应
      autoMinList.forEach(column => {
        const scaleWidth = Math.max(60, _xeUtils.default.toInteger(column.renderAutoWidth));
        tableWidth += scaleWidth;
        column.renderWidth = scaleWidth;
      });
      // 最小百分比
      scaleMinList.forEach(column => {
        const scaleWidth = Math.floor(_xeUtils.default.toInteger(column.minWidth) * meanWidth);
        tableWidth += scaleWidth;
        column.renderWidth = scaleWidth;
      });
      // 固定百分比
      scaleList.forEach(column => {
        const scaleWidth = Math.floor(_xeUtils.default.toInteger(column.width) * meanWidth);
        tableWidth += scaleWidth;
        column.renderWidth = scaleWidth;
      });
      // 固定宽
      pxList.forEach(column => {
        const width = _xeUtils.default.toInteger(column.width);
        tableWidth += width;
        column.renderWidth = width;
      });
      // 自适应宽
      autoList.forEach(column => {
        const width = Math.max(60, _xeUtils.default.toInteger(column.renderAutoWidth));
        tableWidth += width;
        column.renderWidth = width;
      });
      // 调整了列宽
      resizeList.forEach(column => {
        const width = _xeUtils.default.toInteger(column.resizeWidth);
        tableWidth += width;
        column.renderWidth = width;
      });
      remainWidth -= tableWidth;
      meanWidth = remainWidth > 0 ? Math.floor(remainWidth / (scaleMinList.length + pxMinList.length + autoMinList.length + remainList.length)) : 0;
      if (fit) {
        if (remainWidth > 0) {
          scaleMinList.concat(pxMinList).concat(autoMinList).forEach(column => {
            tableWidth += meanWidth;
            column.renderWidth += meanWidth;
          });
        }
      } else {
        meanWidth = minCellWidth;
      }
      // 剩余均分
      remainList.forEach(column => {
        const width = Math.max(meanWidth, minCellWidth);
        column.renderWidth = width;
        tableWidth += width;
      });
      if (fit) {
        /**
         * 偏移量算法
         * 如果所有列足够放的情况下，从最后动态列开始分配
         */
        const dynamicList = scaleList.concat(scaleMinList).concat(pxMinList).concat(autoMinList).concat(remainList);
        let dynamicSize = dynamicList.length - 1;
        if (dynamicSize > 0) {
          let odiffer = bodyWidth - tableWidth;
          if (odiffer > 0) {
            while (odiffer > 0 && dynamicSize >= 0) {
              odiffer--;
              dynamicList[dynamicSize--].renderWidth++;
            }
            tableWidth = bodyWidth;
          }
        }
      }
      const tableHeight = bodyElem.offsetHeight;
      const overflowY = bodyElem.scrollHeight > bodyElem.clientHeight;
      let scrollbarWidth = 0;
      if (overflowY) {
        scrollbarWidth = Math.max(bodyElem.offsetWidth - bodyElem.clientWidth, 0);
      }
      reactData.scrollbarWidth = scrollbarWidth;
      reactData.overflowY = overflowY;
      internalData.tableWidth = tableWidth;
      internalData.tableHeight = tableHeight;
      let headerHeight = 0;
      if (headerElem) {
        headerHeight = headerElem.clientHeight;
        (0, _vue.nextTick)(() => {
          // 检测是否同步滚动
          if (headerElem && bodyElem && headerElem.scrollLeft !== bodyElem.scrollLeft) {
            headerElem.scrollLeft = bodyElem.scrollLeft;
          }
        });
      }
      internalData.headerHeight = headerHeight;
      let overflowX = false;
      let footerHeight = 0;
      let scrollbarHeight = 0;
      if (footerElem) {
        footerHeight = footerElem.offsetHeight;
        overflowX = tableWidth > footerElem.clientWidth;
        scrollbarHeight = Math.max(footerHeight - footerElem.clientHeight, 0);
      } else {
        overflowX = tableWidth > bodyWidth;
        scrollbarHeight = Math.max(tableHeight - bodyElem.clientHeight, 0);
      }
      internalData.footerHeight = footerHeight;
      reactData.overflowX = overflowX;
      reactData.scrollbarHeight = scrollbarHeight;
      updateHeight();
      reactData.parentHeight = Math.max(internalData.headerHeight + footerHeight + 20, tablePrivateMethods.getParentHeight());
      if (overflowX) {
        tablePrivateMethods.checkScrolling();
      }
    };
    const getOrderField = column => {
      const {
        sortBy,
        sortType
      } = column;
      return row => {
        let cellValue;
        if (sortBy) {
          cellValue = _xeUtils.default.isFunction(sortBy) ? sortBy({
            row,
            column
          }) : _xeUtils.default.get(row, sortBy);
        } else {
          cellValue = tableMethods.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;
      };
    };
    /**
     * 预编译
     * 对渲染中的数据提前解析序号及索引。牺牲提前编译耗时换取渲染中额外损耗，使运行时更加流畅
     */
    const updateAfterDataIndex = () => {
      const {
        treeConfig
      } = props;
      const {
        afterFullData,
        fullDataRowIdData,
        fullAllDataRowIdData
      } = internalData;
      const {
        afterTreeFullData
      } = internalData;
      const treeOpts = computeTreeOpts.value;
      const childrenField = treeOpts.children || treeOpts.childrenField;
      const fullMaps = {};
      if (treeConfig) {
        _xeUtils.default.eachTree(afterTreeFullData, (row, index, items, path) => {
          const rowid = (0, _util.getRowid)($xeTable, row);
          const allrest = fullAllDataRowIdData[rowid];
          const seq = path.map((num, i) => i % 2 === 0 ? Number(num) + 1 : '.').join('');
          if (allrest) {
            allrest.seq = seq;
            allrest._index = index;
          } else {
            const rest = {
              row,
              rowid,
              seq,
              index: -1,
              $index: -1,
              _index: index,
              items: [],
              parent: null,
              level: 0
            };
            fullAllDataRowIdData[rowid] = rest;
            fullDataRowIdData[rowid] = rest;
          }
          fullMaps[rowid] = row;
        }, {
          children: treeOpts.transform ? treeOpts.mapChildrenField : childrenField
        });
      } else {
        afterFullData.forEach((row, index) => {
          const rowid = (0, _util.getRowid)($xeTable, row);
          const allrest = fullAllDataRowIdData[rowid];
          const seq = index + 1;
          if (allrest) {
            allrest.seq = seq;
            allrest._index = index;
          } else {
            const rest = {
              row,
              rowid,
              seq,
              index: -1,
              $index: -1,
              _index: index,
              items: [],
              parent: null,
              level: 0
            };
            fullAllDataRowIdData[rowid] = rest;
            fullDataRowIdData[rowid] = rest;
          }
          fullMaps[rowid] = row;
        });
      }
      internalData.afterFullRowMaps = fullMaps;
    };
    /**
     * 如果为虚拟树，将树结构拍平
     * @returns
     */
    const handleVirtualTreeToList = () => {
      const {
        treeConfig
      } = props;
      const {
        treeExpandedMaps
      } = reactData;
      const treeOpts = computeTreeOpts.value;
      const childrenField = treeOpts.children || treeOpts.childrenField;
      if (treeConfig && treeOpts.transform) {
        const fullData = [];
        const expandMaps = {};
        _xeUtils.default.eachTree(internalData.afterTreeFullData, (row, index, items, path, parent) => {
          const rowid = (0, _util.getRowid)($xeTable, row);
          const parentRowid = (0, _util.getRowid)($xeTable, parent);
          if (!parent || expandMaps[parentRowid] && treeExpandedMaps[parentRowid]) {
            expandMaps[rowid] = 1;
            fullData.push(row);
          }
        }, {
          children: childrenField
        });
        internalData.afterFullData = fullData;
        updateScrollYStatus(fullData);
        return fullData;
      }
      return internalData.afterFullData;
    };
    /**
     * 获取处理后全量的表格数据
     * 如果存在筛选条件，继续处理
     */
    const updateAfterFullData = () => {
      const {
        treeConfig
      } = props;
      const {
        tableFullColumn,
        tableFullData,
        tableFullTreeData
      } = internalData;
      const filterOpts = computeFilterOpts.value;
      const sortOpts = computeSortOpts.value;
      const treeOpts = computeTreeOpts.value;
      const childrenField = treeOpts.children || treeOpts.childrenField;
      const {
        transform
      } = treeOpts;
      const {
        remote: allRemoteFilter,
        filterMethod: allFilterMethod
      } = filterOpts;
      const {
        remote: allRemoteSort,
        sortMethod: allSortMethod,
        multiple: sortMultiple,
        chronological
      } = sortOpts;
      let tableData = [];
      let tableTree = [];
      // 处理列
      if (!allRemoteFilter || !allRemoteSort) {
        const filterColumns = [];
        let orderColumns = [];
        tableFullColumn.forEach(column => {
          const {
            field,
            sortable,
            order,
            filters
          } = column;
          if (!allRemoteFilter && filters && filters.length) {
            const valueList = [];
            const itemList = [];
            filters.forEach(item => {
              if (item.checked) {
                itemList.push(item);
                valueList.push(item.value);
              }
            });
            if (itemList.length) {
              filterColumns.push({
                column,
                valueList,
                itemList
              });
            }
          }
          if (!allRemoteSort && sortable && order) {
            orderColumns.push({
              column,
              field,
              property: field,
              order: order,
              sortTime: column.sortTime
            });
          }
        });
        if (sortMultiple && chronological && orderColumns.length > 1) {
          orderColumns = _xeUtils.default.orderBy(orderColumns, 'sortTime');
        }
        // 处理筛选
        // 支持单列、多列、组合筛选
        if (!allRemoteFilter && filterColumns.length) {
          const handleFilter = row => {
            return filterColumns.every(({
              column,
              valueList,
              itemList
            }) => {
              const {
                filterMethod,
                filterRender
              } = column;
              const compConf = (0, _utils.isEnableConf)(filterRender) ? renderer.get(filterRender.name) : null;
              const compFilterMethod = compConf ? compConf.tableFilterMethod || compConf.filterMethod : null;
              const tdFilterMethod = compConf ? compConf.tableFilterDefa