vxe-pc-ui 3.15.28 → 3.16.0

package/lib/tree/src/tree.js

@@ -1,3952 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _comp = require("../../ui/src/comp");
-var _xeUtils = _interopRequireDefault(require("xe-utils"));
-var _ui = require("../../ui");
-var _util = require("./util");
-var _log = require("../../ui/src/log");
-var _vn = require("../../ui/src/vn");
-var _store = require("./store");
-var _dom = require("../../ui/src/dom");
-var _utils = require("../../ui/src/utils");
-var _anime = require("../../ui/src/anime");
-var _loading = _interopRequireDefault(require("../../loading"));
-var _tooltip = _interopRequireDefault(require("../../tooltip"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _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(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
-function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
-function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
-function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
-function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-var _createComponentLog = (0, _log.createComponentLog)('tree'),
-  warnLog = _createComponentLog.warnLog,
-  errLog = _createComponentLog.errLog;
-var menus = _ui.VxeUI.menus,
-  getConfig = _ui.VxeUI.getConfig,
-  getI18n = _ui.VxeUI.getI18n,
-  getIcon = _ui.VxeUI.getIcon;
-var crossTreeDragNodeObj = null;
-/**
- * 生成节点的唯一主键
- */
-function getNodeUniqueId() {
-  return _xeUtils.default.uniqueId('node_');
-}
-function handleSetExpand(nodeid, expanded, expandedMaps) {
-  if (expanded) {
-    if (!expandedMaps[nodeid]) {
-      expandedMaps[nodeid] = true;
-    }
-  } else {
-    if (expandedMaps[nodeid]) {
-      delete expandedMaps[nodeid];
-    }
-  }
-}
-function handleScrollTo($xeTree, scrollLeft, scrollTop) {
-  var reactData = $xeTree.reactData;
-  var scrollBodyElem = $xeTree.$refs.refVirtualWrapper;
-  if (scrollLeft) {
-    if (!_xeUtils.default.isNumber(scrollLeft)) {
-      scrollTop = scrollLeft.top;
-      scrollLeft = scrollLeft.left;
-    }
-  }
-  if (scrollBodyElem) {
-    if (_xeUtils.default.isNumber(scrollLeft)) {
-      scrollBodyElem.scrollLeft = scrollLeft;
-    }
-    if (_xeUtils.default.isNumber(scrollTop)) {
-      scrollBodyElem.scrollTop = scrollTop;
-    }
-  }
-  if (reactData.scrollYLoad) {
-    return new Promise(function (resolve) {
-      setTimeout(function () {
-        $xeTree.$nextTick(function () {
-          resolve();
-        });
-      }, 50);
-    });
-  }
-  return $xeTree.$nextTick();
-}
-function handleNodeDragEndClearStatus($xeTree) {
-  clearNodeDragData($xeTree);
-  clearCrossTreeDragStatus($xeTree);
-  $xeTree.recalculate();
-}
-function clearNodeDropOrigin($xeTree) {
-  var el = $xeTree.$refs.refElem;
-  if (el) {
-    var clss = 'node--drag-origin';
-    _xeUtils.default.arrayEach(el.querySelectorAll(".".concat(clss)), function (elem) {
-      elem.draggable = false;
-      (0, _dom.removeClass)(elem, clss);
-    });
-  }
-}
-function updateNodeDropOrigin($xeTree, node) {
-  var el = $xeTree.$refs.refElem;
-  if (el) {
-    var clss = 'node--drag-origin';
-    var nodeid = $xeTree.getNodeId(node);
-    _xeUtils.default.arrayEach(el.querySelectorAll(".vxe-tree--node-wrapper[nodeid=\"".concat(nodeid, "\"]")), function (elem) {
-      (0, _dom.addClass)(elem, clss);
-    });
-  }
-}
-function updateNodeDropTipContent($xeTree, itemEl) {
-  var reactData = $xeTree.reactData;
-  var dragNode = reactData.dragNode;
-  var dragOpts = $xeTree.computeDragOpts;
-  var tooltipMethod = dragOpts.tooltipMethod;
-  var rTooltipMethod = tooltipMethod;
-  var tipContent = '';
-  if (rTooltipMethod) {
-    var rtParams = {
-      $tree: $xeTree,
-      node: dragNode
-    };
-    tipContent = "".concat(rTooltipMethod(rtParams) || '');
-  } else {
-    tipContent = getI18n('vxe.tree.dragTip', [itemEl.textContent || '']);
-  }
-  reactData.dragTipText = tipContent;
-}
-function hideDropTip($xeTree) {
-  var rdTipEl = $xeTree.$refs.refDragTipElem;
-  var rdLineEl = $xeTree.$refs.refDragNodeLineElem;
-  if (rdTipEl) {
-    rdTipEl.style.display = '';
-  }
-  if (rdLineEl) {
-    rdLineEl.style.display = '';
-  }
-}
-function clearCrossTreeDragStatus($xeTree) {
-  var crossTreeDragNodeInfo = (0, _store.getCrossTreeDragNodeInfo)($xeTree);
-  crossTreeDragNodeObj = null;
-  crossTreeDragNodeInfo.node = null;
-}
-function clearDragStatus($xeTree) {
-  var reactData = $xeTree.reactData;
-  var dragNode = reactData.dragNode;
-  if (dragNode) {
-    hideDropTip($xeTree);
-    clearNodeDropOrigin($xeTree);
-    clearCrossTreeDragStatus($xeTree);
-    reactData.dragNode = null;
-  }
-}
-function showDropTip($xeTree, evnt, itemEl, showLine, dragPos) {
-  var internalData = $xeTree.internalData;
-  var wrapperEl = $xeTree.$refs.refElem;
-  if (!wrapperEl) {
-    return;
-  }
-  var prevDragToChild = internalData.prevDragToChild;
-  var wrapperRect = wrapperEl.getBoundingClientRect();
-  var wrapperHeight = wrapperEl.clientHeight;
-  if (itemEl) {
-    var rdLineEl = $xeTree.$refs.refDragNodeLineElem;
-    if (rdLineEl) {
-      if (showLine) {
-        var trRect = itemEl.getBoundingClientRect();
-        var itemHeight = itemEl.clientHeight;
-        var offsetTop = Math.max(1, trRect.y - wrapperRect.y);
-        if (offsetTop + itemHeight > wrapperHeight) {
-          itemHeight = wrapperHeight - offsetTop;
-        }
-        rdLineEl.style.display = 'block';
-        rdLineEl.style.top = "".concat(offsetTop, "px");
-        rdLineEl.style.height = "".concat(itemHeight, "px");
-        rdLineEl.setAttribute('drag-pos', dragPos);
-        rdLineEl.setAttribute('drag-to-child', prevDragToChild ? 'y' : 'n');
-      } else {
-        rdLineEl.style.display = '';
-      }
-    }
-  }
-  var rdTipEl = $xeTree.$refs.refDragTipElem;
-  if (rdTipEl) {
-    rdTipEl.style.display = 'block';
-    rdTipEl.style.top = "".concat(Math.min(wrapperEl.clientHeight - wrapperEl.scrollTop - rdTipEl.clientHeight, evnt.clientY - wrapperRect.y), "px");
-    rdTipEl.style.left = "".concat(Math.min(wrapperEl.clientWidth - wrapperEl.scrollLeft - rdTipEl.clientWidth - 1, evnt.clientX - wrapperRect.x), "px");
-    rdTipEl.setAttribute('drag-status', showLine ? prevDragToChild ? 'sub' : 'normal' : 'disabled');
-  }
-}
-function clearNodeDragData($xeTree) {
-  var reactData = $xeTree.reactData;
-  var internalData = $xeTree.internalData;
-  var wrapperEl = $xeTree.$refs.refElem;
-  var dtClss = ['.vxe-tree--node-wrapper'];
-  hideDropTip($xeTree);
-  clearNodeDropOrigin($xeTree);
-  (0, _anime.clearRowAnimate)(wrapperEl, dtClss);
-  internalData.prevDragToChild = false;
-  reactData.dragNode = null;
-}
-function handleNodeDragSwapEvent($xeTree, evnt, dragNode, prevDragNode, prevDragPos, prevDragToChild) {
-  var props = $xeTree;
-  var reactData = $xeTree.reactData;
-  var internalData = $xeTree.internalData;
-  var transform = props.transform;
-  var nodeMaps = internalData.nodeMaps,
-    treeFullData = internalData.treeFullData,
-    afterVisibleList = internalData.afterVisibleList;
-  var dragConfig = $xeTree.computeDragOpts;
-  var animation = dragConfig.animation,
-    isCrossDrag = dragConfig.isCrossDrag,
-    isPeerDrag = dragConfig.isPeerDrag,
-    isSelfToChildDrag = dragConfig.isSelfToChildDrag,
-    dragEndMethod = dragConfig.dragEndMethod,
-    dragToChildMethod = dragConfig.dragToChildMethod;
-  var dEndMethod = dragEndMethod || (dragConfig ? dragConfig.dragEndMethod : null);
-  var keyField = $xeTree.computeKeyField;
-  var parentField = $xeTree.computeParentField;
-  var childrenField = $xeTree.computeChildrenField;
-  var mapChildrenField = $xeTree.computeMapChildrenField;
-  var dragOffsetIndex = prevDragPos === 'bottom' ? 1 : 0;
-  var el = $xeTree.$refs.refElem;
-  var errRest = {
-    status: false
-  };
-  if (!(el && prevDragNode && dragNode)) {
-    handleNodeDragEndClearStatus($xeTree);
-    return Promise.resolve(errRest);
-  }
-  // 判断是否有拖动
-  if (prevDragNode !== dragNode) {
-    var dragParams = {
-      oldNode: dragNode,
-      newNode: prevDragNode,
-      dragNode: dragNode,
-      dragPos: prevDragPos,
-      dragToChild: !!prevDragToChild,
-      offsetIndex: dragOffsetIndex
-    };
-    var dragNodeid = $xeTree.getNodeId(dragNode);
-    var dragNodeRest = nodeMaps[dragNodeid] || {};
-    var _dragNodeIndex = dragNodeRest._index;
-    var newNodeid = $xeTree.getNodeId(prevDragNode);
-    var dragNodeHeight = 0;
-    var dragOffsetTop = -1;
-    if (animation) {
-      var prevItemEl = el.querySelector(".vxe-tree--node-wrapper[nodeid=\"".concat(newNodeid, "\"]"));
-      var oldItemEl = el.querySelector(".vxe-tree--node-wrapper[nodeid=\"".concat(dragNodeid, "\"]"));
-      var targetItemEl = prevItemEl || oldItemEl;
-      if (targetItemEl) {
-        dragNodeHeight = targetItemEl.offsetHeight;
-      }
-      if (oldItemEl) {
-        dragOffsetTop = oldItemEl.offsetTop;
-      }
-    }
-    var oafIndex = -1;
-    var nafIndex = -1;
-    var oldAllMaps = {};
-    var isSelfToChildStatus = false;
-    var oldRest = dragNodeRest;
-    var newRest = nodeMaps[newNodeid];
-    if (transform) {
-      if (oldRest && newRest) {
-        var oldLevel = oldRest.level;
-        var newLevel = newRest.level;
-        _xeUtils.default.eachTree([dragNode], function (item) {
-          oldAllMaps[$xeTree.getNodeId(item)] = item;
-        }, {
-          children: mapChildrenField
-        });
-        if (oldLevel && newLevel) {
-          // 子到子
-          if (isPeerDrag && !isCrossDrag) {
-            if (oldRest.item[parentField] !== newRest.item[parentField]) {
-              // 非同级
-              handleNodeDragEndClearStatus($xeTree);
-              return errRest;
-            }
-          } else {
-            if (!isCrossDrag) {
-              handleNodeDragEndClearStatus($xeTree);
-              return errRest;
-            }
-            if (oldAllMaps[newNodeid]) {
-              isSelfToChildStatus = true;
-              if (!(isCrossDrag && isSelfToChildDrag)) {
-                if (_ui.VxeUI.modal) {
-                  _ui.VxeUI.modal.message({
-                    status: 'error',
-                    content: getI18n('vxe.error.treeDragChild')
-                  });
-                }
-                handleNodeDragEndClearStatus($xeTree);
-                return errRest;
-              }
-            }
-          }
-        } else if (oldLevel) {
-          // 子到根
-          if (!isCrossDrag) {
-            handleNodeDragEndClearStatus($xeTree);
-            return errRest;
-          }
-        } else if (newLevel) {
-          // 根到子
-          if (!isCrossDrag) {
-            handleNodeDragEndClearStatus($xeTree);
-            return errRest;
-          }
-          if (oldAllMaps[newNodeid]) {
-            isSelfToChildStatus = true;
-            if (!(isCrossDrag && isSelfToChildDrag)) {
-              if (_ui.VxeUI.modal) {
-                _ui.VxeUI.modal.message({
-                  status: 'error',
-                  content: getI18n('vxe.error.treeDragChild')
-                });
-              }
-              handleNodeDragEndClearStatus($xeTree);
-              return errRest;
-            }
-          }
-        } else {
-          // 根到根
-        }
-      }
-    }
-    var isDragToChildFlag = isSelfToChildDrag && dragToChildMethod ? dragToChildMethod(dragParams) : prevDragToChild;
-    return Promise.resolve(dEndMethod ? dEndMethod(dragParams) : true).then(function (status) {
-      if (!status) {
-        return errRest;
-      }
-      if (transform) {
-        // 移出源位置
-        if (oldRest && newRest) {
-          var fullList = _xeUtils.default.toTreeArray(internalData.afterTreeList, {
-            updated: false,
-            key: keyField,
-            parentKey: parentField,
-            children: mapChildrenField
-          });
-          // 移出
-          var otfIndex = $xeTree.findNodeIndexOf(fullList, dragNode);
-          fullList.splice(otfIndex, 1);
-          // 插入
-          var ptfIndex = $xeTree.findNodeIndexOf(fullList, prevDragNode);
-          var ntfIndex = ptfIndex + dragOffsetIndex;
-          fullList.splice(ntfIndex, 0, dragNode);
-          // 改变层级
-          if (isSelfToChildStatus && isCrossDrag && isSelfToChildDrag) {
-            _xeUtils.default.each(dragNode[childrenField], function (childNode) {
-              childNode[parentField] = dragNode[parentField];
-            });
-          }
-          dragNode[parentField] = isDragToChildFlag ? prevDragNode[keyField] : prevDragNode[parentField];
-          internalData.treeFullData = _xeUtils.default.toArrayTree(fullList, {
-            key: keyField,
-            parentKey: parentField,
-            children: childrenField,
-            mapChildren: mapChildrenField
-          });
-        }
-      } else {
-        // 移出
-        oafIndex = $xeTree.findNodeIndexOf(afterVisibleList, dragNode);
-        var _otfIndex = $xeTree.findNodeIndexOf(treeFullData, dragNode);
-        afterVisibleList.splice(oafIndex, 1);
-        treeFullData.splice(_otfIndex, 1);
-        // 插入
-        var pafIndex = $xeTree.findNodeIndexOf(afterVisibleList, prevDragNode);
-        var _ptfIndex = $xeTree.findNodeIndexOf(treeFullData, prevDragNode);
-        nafIndex = pafIndex + dragOffsetIndex;
-        var _ntfIndex = _ptfIndex + dragOffsetIndex;
-        afterVisibleList.splice(nafIndex, 0, dragNode);
-        treeFullData.splice(_ntfIndex, 0, dragNode);
-      }
-      $xeTree.cacheNodeMap();
-      $xeTree.handleData(transform);
-      if (!transform) {
-        $xeTree.updateAfterDataIndex();
-      }
-      $xeTree.updateCheckboxStatus();
-      if (reactData.scrollYLoad) {
-        $xeTree.updateYSpace();
-      }
-      if (evnt) {
-        $xeTree.dispatchEvent('node-dragend', {
-          oldNode: dragNode,
-          newNode: prevDragNode,
-          dragNode: dragNode,
-          dragPos: prevDragPos,
-          dragToChild: isDragToChildFlag,
-          offsetIndex: dragOffsetIndex,
-          _index: {
-            newIndex: nafIndex,
-            oldIndex: oafIndex
-          }
-        }, evnt);
-      }
-      return $xeTree.$nextTick().then(function () {
-        if (animation) {
-          var treeList = reactData.treeList;
-          var _nodeMaps = internalData.nodeMaps;
-          var _dragNodeRest = _nodeMaps[dragNodeid];
-          var _newNodeIndex = _dragNodeRest._index;
-          var firstNode = treeList[0];
-          var firstNodeRest = _nodeMaps[$xeTree.getNodeId(firstNode)];
-          var wrapperEl = el;
-          if (firstNodeRest) {
-            var _firstNodeIndex = firstNodeRest._index;
-            var _lastNodeIndex = _firstNodeIndex + treeList.length;
-            var rsIndex = -1;
-            var reIndex = -1;
-            var offsetRate = 1;
-            if (_dragNodeIndex < _firstNodeIndex) {
-              // 从上往下虚拟拖拽
-              rsIndex = 0;
-              reIndex = _newNodeIndex - _firstNodeIndex;
-            } else if (_dragNodeIndex > _lastNodeIndex) {
-              // 从下往上虚拟拖拽
-              var $newNodeIndex = _dragNodeRest.$index;
-              rsIndex = $newNodeIndex + 1;
-              reIndex = treeList.length;
-              offsetRate = -1;
-            } else {
-              if (_newNodeIndex > _dragNodeIndex) {
-                // 从上往下拖拽
-                rsIndex = _dragNodeIndex - _firstNodeIndex;
-                reIndex = rsIndex + _newNodeIndex - _dragNodeIndex;
-              } else {
-                // 从下往上拖拽
-                rsIndex = _newNodeIndex - _firstNodeIndex;
-                reIndex = rsIndex + _dragNodeIndex - _newNodeIndex + 1;
-                offsetRate = -1;
-              }
-            }
-            var dragRangeList = treeList.slice(rsIndex, reIndex);
-            if (dragRangeList.length) {
-              var dtClss = [];
-              dragRangeList.forEach(function (item) {
-                var nodeid = $xeTree.getNodeId(item);
-                dtClss.push(".vxe-tree--node-wrapper[nodeid=\"".concat(nodeid, "\"]"));
-              });
-              var dtTrList = wrapperEl.querySelectorAll(dtClss.join(','));
-              (0, _anime.moveRowAnimateToTb)(dtTrList, offsetRate * dragNodeHeight);
-            }
-          }
-          var drClss = [".vxe-tree--node-wrapper[nodeid=\"".concat(dragNodeid, "\"]")];
-          var newDtTrList = wrapperEl.querySelectorAll(drClss.join(','));
-          var newTrEl = newDtTrList[0];
-          if (dragOffsetTop > -1 && newTrEl) {
-            (0, _anime.moveRowAnimateToTb)(newDtTrList, dragOffsetTop - newTrEl.offsetTop);
-          }
-        }
-        $xeTree.recalculate();
-      }).then(function () {
-        return {
-          status: true
-        };
-      });
-    }).catch(function () {
-      return errRest;
-    }).then(function (rest) {
-      handleNodeDragEndClearStatus($xeTree);
-      return rest;
-    });
-  }
-  handleNodeDragEndClearStatus($xeTree);
-  return Promise.resolve(errRest);
-}
-function handleVisibleOrCheckMode(mode, isExistChild, nLevel) {
-  if (mode) {
-    if (mode === 'first') {
-      return !nLevel;
-    }
-    if (mode === 'last') {
-      return !isExistChild;
-    }
-  }
-  return true;
-}
-function insertTreeNode($xeTree, newRecords, isAppend) {
-  var internalData = $xeTree.internalData;
-  var treeFullData = internalData.treeFullData,
-    nodeMaps = internalData.nodeMaps;
-  var keyField = $xeTree.computeKeyField;
-  var parentField = $xeTree.computeParentField;
-  var childrenField = $xeTree.computeChildrenField;
-  var mapChildrenField = $xeTree.computeMapChildrenField;
-  var funcName = isAppend ? 'push' : 'unshift';
-  newRecords.forEach(function (item) {
-    var parentNodeId = item[parentField];
-    var nodeid = $xeTree.getNodeId(item);
-    var matchObj = parentNodeId ? _xeUtils.default.findTree(treeFullData, function (item) {
-      return parentNodeId === item[keyField];
-    }, {
-      children: mapChildrenField
-    }) : null;
-    var itemRest = (0, _util.getItemCacheObj)(item);
-    if (matchObj) {
-      var parentItem = matchObj.item;
-      var parentRest = nodeMaps[$xeTree.getNodeId(parentItem)];
-      var parentLevel = parentRest ? parentRest.level : 0;
-      var pChilds = parentItem[childrenField];
-      var pMapChilds = parentItem[mapChildrenField];
-      if (!_xeUtils.default.isArray(pChilds)) {
-        pChilds = parentItem[childrenField] = [];
-      }
-      if (!_xeUtils.default.isArray(pMapChilds)) {
-        pMapChilds = parentItem[mapChildrenField] = [];
-      }
-      itemRest.parent = parentItem;
-      itemRest.items = pChilds;
-      itemRest.level = parentLevel;
-      pChilds[funcName](item);
-      pMapChilds[funcName](item);
-    } else {
-      if (parentNodeId) {
-        warnLog('vxe.error.unableInsert');
-      }
-      treeFullData[funcName](item);
-    }
-    nodeMaps[nodeid] = itemRest;
-  });
-}
-function createInternalData() {
-  return {
-    // initialized: false,
-    // lastFilterValue: '',
-    treeFullData: [],
-    afterTreeList: [],
-    afterVisibleList: [],
-    nodeMaps: {},
-    selectCheckboxMaps: {},
-    indeterminateNodeMaps: {},
-    treeExpandedMaps: {},
-    treeExpandLazyLoadedMaps: {},
-    lastScrollLeft: 0,
-    lastScrollTop: 0,
-    scrollYStore: {
-      startIndex: 0,
-      endIndex: 0,
-      visibleSize: 0,
-      offsetSize: 0,
-      rowHeight: 0
-    },
-    removeNodeMaps: {},
-    insertNodeMaps: {},
-    // prevDragNode: null,
-    // prevDragToChild: false,
-    // prevDragPos: ''
-    lastScrollTime: 0
-    // hpTimeout: undefined
-  };
-}
-function createReactData() {
-  return {
-    parentHeight: 0,
-    customHeight: 0,
-    customMinHeight: 0,
-    customMaxHeight: 0,
-    currentNode: null,
-    scrollYLoad: false,
-    bodyHeight: 0,
-    topSpaceHeight: 0,
-    selectRadioKey: null,
-    treeList: [],
-    updateExpandedFlag: 1,
-    updateCheckboxFlag: 1,
-    insertNodeFlag: 1,
-    removeNodeFlag: 1,
-    dragNode: null,
-    dragTipText: '',
-    isCrossDragNode: false,
-    tooltipStore: {
-      visible: false,
-      node: null
-    }
-  };
-}
-var _default2 = exports.default = /* define-vxe-component start */(0, _comp.defineVxeComponent)({
-  name: 'VxeTree',
-  mixins: [_ui.globalMixins.sizeMixin],
-  props: {
-    data: Array,
-    autoResize: {
-      type: Boolean,
-      default: function _default() {
-        return getConfig().tree.autoResize;
-      }
-    },
-    height: [String, Number],
-    maxHeight: {
-      type: [String, Number],
-      default: function _default() {
-        return getConfig().tree.maxHeight;
-      }
-    },
-    minHeight: {
-      type: [String, Number],
-      default: function _default() {
-        return getConfig().tree.minHeight;
-      }
-    },
-    loading: Boolean,
-    loadingConfig: Object,
-    accordion: {
-      type: Boolean,
-      default: function _default() {
-        return getConfig().tree.accordion;
-      }
-    },
-    childrenField: {
-      type: String,
-      default: function _default() {
-        return getConfig().tree.childrenField;
-      }
-    },
-    valueField: {
-      type: String,
-      default: function _default() {
-        return getConfig().tree.valueField;
-      }
-    },
-    keyField: {
-      type: String,
-      default: function _default() {
-        return getConfig().tree.keyField;
-      }
-    },
-    parentField: {
-      type: String,
-      default: function _default() {
-        return getConfig().tree.parentField;
-      }
-    },
-    titleField: {
-      type: String,
-      default: function _default() {
-        return getConfig().tree.titleField;
-      }
-    },
-    hasChildField: {
-      type: String,
-      default: function _default() {
-        return getConfig().tree.hasChildField;
-      }
-    },
-    mapChildrenField: {
-      type: String,
-      default: function _default() {
-        return getConfig().tree.mapChildrenField;
-      }
-    },
-    transform: Boolean,
-    // 已废弃
-    isCurrent: Boolean,
-    // 已废弃
-    isHover: Boolean,
-    expandAll: Boolean,
-    expandNodeKeys: Array,
-    showLine: {
-      type: Boolean,
-      default: function _default() {
-        return getConfig().tree.showLine;
-      }
-    },
-    trigger: String,
-    indent: {
-      type: Number,
-      default: function _default() {
-        return getConfig().tree.indent;
-      }
-    },
-    showRadio: {
-      type: Boolean,
-      default: function _default() {
-        return getConfig().tree.showRadio;
-      }
-    },
-    checkNodeKey: [String, Number],
-    radioConfig: Object,
-    showCheckbox: {
-      type: Boolean,
-      default: function _default() {
-        return getConfig().tree.showCheckbox;
-      }
-    },
-    checkNodeKeys: Array,
-    checkboxConfig: Object,
-    nodeConfig: Object,
-    lazy: Boolean,
-    visibleMethod: Function,
-    toggleMethod: Function,
-    loadMethod: Function,
-    showOverflow: {
-      type: Boolean,
-      default: function _default() {
-        return getConfig().tree.showOverflow;
-      }
-    },
-    tooltipConfig: Object,
-    drag: {
-      type: Boolean,
-      default: function _default() {
-        return getConfig().tree.drag;
-      }
-    },
-    dragConfig: Object,
-    menuConfig: Object,
-    showIcon: {
-      type: Boolean,
-      default: true
-    },
-    iconOpen: {
-      type: String,
-      default: function _default() {
-        return getConfig().tree.iconOpen;
-      }
-    },
-    iconClose: {
-      type: String,
-      default: function _default() {
-        return getConfig().tree.iconClose;
-      }
-    },
-    iconLoaded: {
-      type: String,
-      default: function _default() {
-        return getConfig().tree.iconLoaded;
-      }
-    },
-    rootParentValue: {
-      type: [String, Number],
-      default: function _default() {
-        return getConfig().tree.rootParentValue;
-      }
-    },
-    rootValues: {
-      type: Array,
-      default: function _default() {
-        return getConfig().tree.rootValues;
-      }
-    },
-    filterValue: [String, Number],
-    filterConfig: Object,
-    size: {
-      type: String,
-      default: function _default() {
-        return getConfig().tree.size || getConfig().size;
-      }
-    },
-    virtualYConfig: Object
-  },
-  provide: function provide() {
-    var $xeTree = this;
-    return {
-      $xeTree: $xeTree
-    };
-  },
-  data: function data() {
-    var xID = _xeUtils.default.uniqueId();
-    var reactData = createReactData();
-    return Object.assign(Object.assign({}, {}), {
-      xID: xID,
-      reactData: reactData,
-      crossTreeDragNodeInfo: _store.crossTreeDragNodeGlobal,
-      hFlag: 0,
-      dataFlag: 0
-    });
-  },
-  computed: Object.assign(Object.assign({}, {}), {
-    computeTitleField: function computeTitleField() {
-      var $xeTree = this;
-      var props = $xeTree;
-      return props.titleField || 'title';
-    },
-    computeKeyField: function computeKeyField() {
-      var $xeTree = this;
-      var props = $xeTree;
-      return props.keyField || 'id';
-    },
-    computeValueField: function computeValueField() {
-      var $xeTree = this;
-      var props = $xeTree;
-      var keyField = $xeTree.computeKeyField;
-      return props.valueField || keyField;
-    },
-    computeParentField: function computeParentField() {
-      var $xeTree = this;
-      var props = $xeTree;
-      return props.parentField || 'parentId';
-    },
-    computeChildrenField: function computeChildrenField() {
-      var $xeTree = this;
-      var props = $xeTree;
-      return props.childrenField || 'children';
-    },
-    computeMapChildrenField: function computeMapChildrenField() {
-      var $xeTree = this;
-      var props = $xeTree;
-      return props.mapChildrenField || 'mapChildren';
-    },
-    computeHasChildField: function computeHasChildField() {
-      var $xeTree = this;
-      var props = $xeTree;
-      return props.hasChildField || 'hasChild';
-    },
-    computeVirtualYOpts: function computeVirtualYOpts() {
-      var $xeTree = this;
-      var props = $xeTree;
-      return Object.assign({}, getConfig().tree.virtualYConfig, props.virtualYConfig);
-    },
-    computeIsNodeCurrent: function computeIsNodeCurrent() {
-      var $xeTree = this;
-      var props = $xeTree;
-      var nodeOpts = $xeTree.computeNodeOpts;
-      var isCurrent = nodeOpts.isCurrent;
-      if (_xeUtils.default.isBoolean(isCurrent)) {
-        return isCurrent;
-      }
-      return props.isCurrent;
-    },
-    computeIsNodeHover: function computeIsNodeHover() {
-      var $xeTree = this;
-      var props = $xeTree;
-      var nodeOpts = $xeTree.computeNodeOpts;
-      var isHover = nodeOpts.isHover;
-      if (_xeUtils.default.isBoolean(isHover)) {
-        return isHover;
-      }
-      return props.isHover;
-    },
-    computeRadioOpts: function computeRadioOpts() {
-      var $xeTree = this;
-      var props = $xeTree;
-      return Object.assign({
-        showIcon: true
-      }, getConfig().tree.radioConfig, props.radioConfig);
-    },
-    computeCheckboxOpts: function computeCheckboxOpts() {
-      var $xeTree = this;
-      var props = $xeTree;
-      return Object.assign({
-        showIcon: true
-      }, getConfig().tree.checkboxConfig, props.checkboxConfig);
-    },
-    computeNodeOpts: function computeNodeOpts() {
-      var $xeTree = this;
-      var props = $xeTree;
-      return Object.assign({}, getConfig().tree.nodeConfig, props.nodeConfig);
-    },
-    computeLoadingOpts: function computeLoadingOpts() {
-      var $xeTree = this;
-      var props = $xeTree;
-      return Object.assign({}, getConfig().tree.loadingConfig, props.loadingConfig);
-    },
-    computeDragOpts: function computeDragOpts() {
-      var $xeTree = this;
-      var props = $xeTree;
-      return Object.assign({}, getConfig().tree.dragConfig, props.dragConfig);
-    },
-    computeTooltipOpts: function computeTooltipOpts() {
-      var $xeTree = this;
-      var props = $xeTree;
-      return Object.assign({}, getConfig().tree.tooltipConfig, props.tooltipConfig);
-    },
-    computeMenuOpts: function computeMenuOpts() {
-      var $xeTree = this;
-      var props = $xeTree;
-      return Object.assign({}, getConfig().tree.menuConfig, props.menuConfig);
-    },
-    computeTreeStyle: function computeTreeStyle() {
-      var $xeTree = this;
-      var props = $xeTree;
-      var reactData = $xeTree.reactData;
-      var indent = props.indent;
-      var customHeight = reactData.customHeight,
-        customMinHeight = reactData.customMinHeight,
-        customMaxHeight = reactData.customMaxHeight;
-      var checkboxOpts = $xeTree.computeCheckboxOpts;
-      var nodeStyle = checkboxOpts.nodeStyle;
-      var stys = {};
-      if (customHeight) {
-        stys.height = (0, _dom.toCssUnit)(customHeight);
-      }
-      if (customMinHeight) {
-        stys.minHeight = (0, _dom.toCssUnit)(customMinHeight);
-      }
-      if (customMaxHeight) {
-        stys.maxHeight = (0, _dom.toCssUnit)(customMaxHeight);
-      }
-      if (indent) {
-        stys['--vxe-ui-tree-node-indent'] = (0, _dom.toCssUnit)(indent);
-      }
-      if (nodeStyle) {
-        var indeterminateColor = nodeStyle.indeterminateColor,
-          checkedColor = nodeStyle.checkedColor;
-        if (indeterminateColor) {
-          stys['--vxe-ui-tree-node-checkbox-indeterminate-color'] = indeterminateColor;
-        }
-        if (checkedColor) {
-          stys['--vxe-ui-tree-node-checkbox-checked-color'] = checkedColor;
-        }
-      }
-      return stys;
-    },
-    computeFilterOpts: function computeFilterOpts() {
-      var $xeTree = this;
-      var props = $xeTree;
-      return Object.assign({}, getConfig().tree.filterConfig, props.filterConfig);
-    }
-  }),
-  methods: {
-    //
-    // Method
-    //
-    dispatchEvent: function dispatchEvent(type, params, evnt) {
-      var $xeTree = this;
-      $xeTree.$emit(type, (0, _ui.createEvent)(evnt, {
-        $tree: $xeTree
-      }, params));
-    },
-    getNodeId: function getNodeId(node) {
-      var $xeTree = this;
-      if (!node) {
-        return '';
-      }
-      var valueField = $xeTree.computeValueField;
-      var nodeKey = _xeUtils.default.get(node, valueField);
-      return (0, _utils.enModelValue)(nodeKey);
-    },
-    getNodeById: function getNodeById(nodeid) {
-      var $xeTree = this;
-      var internalData = $xeTree.internalData;
-      var nodeMaps = internalData.nodeMaps;
-      if (nodeid) {
-        var nodeItem = nodeMaps[nodeid];
-        if (nodeItem) {
-          return nodeItem.item;
-        }
-      }
-      return null;
-    },
-    isExpandByNode: function isExpandByNode(node) {
-      var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var updateExpandedFlag = reactData.updateExpandedFlag;
-      var treeExpandedMaps = internalData.treeExpandedMaps;
-      var nodeid = $xeTree.getNodeId(node);
-      return !!(updateExpandedFlag && treeExpandedMaps[nodeid]);
-    },
-    isCheckedByRadioNodeId: function isCheckedByRadioNodeId(nodeid) {
-      var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      var selectRadioKey = reactData.selectRadioKey;
-      return selectRadioKey === nodeid;
-    },
-    isCheckedByRadioNode: function isCheckedByRadioNode(node) {
-      var $xeTree = this;
-      return $xeTree.isCheckedByRadioNodeId($xeTree.getNodeId(node));
-    },
-    isCheckedByCheckboxNodeId: function isCheckedByCheckboxNodeId(nodeid) {
-      var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var updateCheckboxFlag = reactData.updateCheckboxFlag;
-      var selectCheckboxMaps = internalData.selectCheckboxMaps;
-      return !!(updateCheckboxFlag && selectCheckboxMaps[nodeid]);
-    },
-    isCheckedByCheckboxNode: function isCheckedByCheckboxNode(node) {
-      var $xeTree = this;
-      return $xeTree.isCheckedByCheckboxNodeId($xeTree.getNodeId(node));
-    },
-    isIndeterminateByCheckboxNodeid: function isIndeterminateByCheckboxNodeid(nodeid) {
-      var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var updateCheckboxFlag = reactData.updateCheckboxFlag;
-      var indeterminateNodeMaps = internalData.indeterminateNodeMaps;
-      return !!(updateCheckboxFlag && indeterminateNodeMaps[nodeid]);
-    },
-    isIndeterminateByCheckboxNode: function isIndeterminateByCheckboxNode(node) {
-      var $xeTree = this;
-      return $xeTree.isIndeterminateByCheckboxNodeid($xeTree.getNodeId(node));
-    },
-    emitCheckboxMode: function emitCheckboxMode(value) {
-      var $xeTree = this;
-      $xeTree.$emit('update:checkNodeKeys', value);
-    },
-    emitRadioMode: function emitRadioMode(value) {
-      var $xeTree = this;
-      $xeTree.$emit('update:checkNodeKey', value);
-    },
-    setRadioNode: function setRadioNode(node) {
-      var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      if (node) {
-        var nodeid = $xeTree.getNodeId(node);
-        reactData.selectRadioKey = nodeid;
-        $xeTree.emitRadioMode((0, _utils.deModelValue)(nodeid));
-      } else {
-        $xeTree.emitRadioMode(null);
-      }
-      return $xeTree.$nextTick();
-    },
-    setCheckboxNode: function setCheckboxNode(nodeList, checked) {
-      var $xeTree = this;
-      if (nodeList) {
-        if (!_xeUtils.default.isArray(nodeList)) {
-          nodeList = [nodeList];
-        }
-        $xeTree.handleCheckedCheckboxNode(nodeList, checked);
-      }
-      $xeTree.emitCheckboxMode($xeTree.getCheckboxNodeIds());
-      return $xeTree.$nextTick();
-    },
-    setCheckboxByNodeId: function setCheckboxByNodeId(nodeKeys, checked) {
-      var $xeTree = this;
-      $xeTree.handleSetCheckboxByNodeId(nodeKeys, checked);
-      $xeTree.emitCheckboxMode($xeTree.getCheckboxNodeIds());
-      return $xeTree.$nextTick();
-    },
-    handleSetCheckboxByNodeId: function handleSetCheckboxByNodeId(nodeKeys, checked) {
-      var $xeTree = this;
-      var internalData = $xeTree.internalData;
-      var nodeMaps = internalData.nodeMaps;
-      if (nodeKeys) {
-        if (!_xeUtils.default.isArray(nodeKeys)) {
-          nodeKeys = [nodeKeys];
-        }
-        var nodeList = [];
-        nodeKeys.forEach(function (nodeKey) {
-          var nodeid = (0, _utils.enModelValue)(nodeKey);
-          var nodeItem = nodeMaps[nodeid];
-          if (nodeItem) {
-            nodeList.push(nodeItem.item);
-          }
-        });
-        $xeTree.handleCheckedCheckboxNode(nodeList, checked);
-      }
-      return $xeTree.$nextTick();
-    },
-    handleCheckedCheckboxNode: function handleCheckedCheckboxNode(nodeList, checked) {
-      var $xeTree = this;
-      var props = $xeTree;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var transform = props.transform;
-      var selectCheckboxMaps = internalData.selectCheckboxMaps;
-      var mapChildrenField = $xeTree.computeMapChildrenField;
-      var childrenField = $xeTree.computeChildrenField;
-      var checkboxOpts = $xeTree.computeCheckboxOpts;
-      var checkStrictly = checkboxOpts.checkStrictly;
-      var handleSelect = function handleSelect(node) {
-        var nodeid = $xeTree.getNodeId(node);
-        if (checked) {
-          if (!selectCheckboxMaps[nodeid]) {
-            selectCheckboxMaps[nodeid] = node;
-          }
-        } else {
-          if (selectCheckboxMaps[nodeid]) {
-            delete selectCheckboxMaps[nodeid];
-          }
-        }
-      };
-      if (checkStrictly) {
-        nodeList.forEach(handleSelect);
-      } else {
-        _xeUtils.default.eachTree(nodeList, handleSelect, {
-          children: transform ? mapChildrenField : childrenField
-        });
-      }
-      reactData.updateCheckboxFlag++;
-      $xeTree.updateCheckboxStatus();
-    },
-    updateCheckboxChecked: function updateCheckboxChecked(nodeKeys) {
-      var $xeTree = this;
-      var internalData = $xeTree.internalData;
-      internalData.selectCheckboxMaps = {};
-      $xeTree.handleSetCheckboxByNodeId(nodeKeys, true);
-    },
-    handleSetExpand: function handleSetExpand(nodeid, expanded, expandedMaps) {
-      if (expanded) {
-        if (!expandedMaps[nodeid]) {
-          expandedMaps[nodeid] = true;
-        }
-      } else {
-        if (expandedMaps[nodeid]) {
-          delete expandedMaps[nodeid];
-        }
-      }
-    },
-    getParentElem: function getParentElem() {
-      var $xeTree = this;
-      var el = $xeTree.$refs.refElem;
-      return el ? el.parentElement : null;
-    },
-    calcTreeHeight: function calcTreeHeight(key) {
-      var $xeTree = this;
-      var props = $xeTree;
-      var reactData = $xeTree.reactData;
-      var parentHeight = reactData.parentHeight;
-      var val = props[key];
-      var num = 0;
-      if (val) {
-        if (val === '100%' || val === 'auto') {
-          num = parentHeight;
-        } else {
-          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);
-        }
-      }
-      return num;
-    },
-    updateHeight: function updateHeight() {
-      var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      reactData.customHeight = $xeTree.calcTreeHeight('height');
-      reactData.customMinHeight = $xeTree.calcTreeHeight('minHeight');
-      reactData.customMaxHeight = $xeTree.calcTreeHeight('maxHeight');
-      // 如果启用虚拟滚动，默认高度
-      if (reactData.scrollYLoad && !(reactData.customHeight || reactData.customMinHeight)) {
-        reactData.customHeight = 300;
-      }
-    },
-    createNode: function createNode(records) {
-      var $xeTree = this;
-      var valueField = $xeTree.computeValueField;
-      return Promise.resolve(records.map(function (obj) {
-        var item = Object.assign({}, obj);
-        var nodeid = $xeTree.getNodeId(item);
-        if (!nodeid) {
-          nodeid = getNodeUniqueId();
-          _xeUtils.default.set(item, valueField, nodeid);
-        }
-        return item;
-      }));
-    },
-    cacheNodeMap: function cacheNodeMap() {
-      var $xeTree = this;
-      var internalData = $xeTree.internalData;
-      var treeFullData = internalData.treeFullData;
-      var valueField = $xeTree.computeValueField;
-      var childrenField = $xeTree.computeChildrenField;
-      var keyMaps = {};
-      _xeUtils.default.eachTree(treeFullData, function (item, index, items, path, parenItem, nodes) {
-        var nodeid = $xeTree.getNodeId(item);
-        if (!nodeid) {
-          nodeid = getNodeUniqueId();
-          _xeUtils.default.set(item, valueField, nodeid);
-        }
-        keyMaps[nodeid] = {
-          item: item,
-          index: index,
-          $index: -1,
-          _index: -1,
-          items: items,
-          parent: parenItem,
-          nodes: nodes,
-          level: nodes.length - 1,
-          treeIndex: index,
-          lineCount: 0,
-          treeLoaded: false
-        };
-      }, {
-        children: childrenField
-      });
-      internalData.nodeMaps = keyMaps;
-    },
-    updateAfterDataIndex: function updateAfterDataIndex() {
-      var $xeTree = this;
-      var props = $xeTree;
-      var internalData = $xeTree.internalData;
-      var transform = props.transform;
-      var afterTreeList = internalData.afterTreeList,
-        nodeMaps = internalData.nodeMaps;
-      var childrenField = $xeTree.computeChildrenField;
-      var mapChildrenField = $xeTree.computeMapChildrenField;
-      var vtIndex = 0;
-      _xeUtils.default.eachTree(afterTreeList, function (item, index, items, path, parenItem, nodes) {
-        var nodeid = $xeTree.getNodeId(item);
-        var nodeItem = nodeMaps[nodeid];
-        if (nodeItem) {
-          nodeItem.items = items;
-          nodeItem.treeIndex = index;
-          nodeItem._index = vtIndex;
-        } else {
-          var rest = {
-            item: item,
-            index: index,
-            $index: -1,
-            _index: vtIndex,
-            items: items,
-            parent: parenItem,
-            nodes: nodes,
-            level: nodes.length - 1,
-            treeIndex: index,
-            lineCount: 0,
-            treeLoaded: false
-          };
-          nodeMaps[nodeid] = rest;
-        }
-        vtIndex++;
-      }, {
-        children: transform ? mapChildrenField : childrenField
-      });
-    },
-    updateAfterFullData: function updateAfterFullData() {
-      var $xeTree = this;
-      var props = $xeTree;
-      var internalData = $xeTree.internalData;
-      var transform = props.transform,
-        filterValue = props.filterValue;
-      var treeFullData = internalData.treeFullData,
-        lastFilterValue = internalData.lastFilterValue;
-      var titleField = $xeTree.computeTitleField;
-      var childrenField = $xeTree.computeChildrenField;
-      var mapChildrenField = $xeTree.computeMapChildrenField;
-      var filterOpts = $xeTree.computeFilterOpts;
-      var autoExpandAll = filterOpts.autoExpandAll,
-        beforeFilterMethod = filterOpts.beforeFilterMethod,
-        filterMethod = filterOpts.filterMethod,
-        afterFilterMethod = filterOpts.afterFilterMethod;
-      var fullList = treeFullData;
-      var treeList = fullList;
-      var filterStr = '';
-      if (filterValue || filterValue === 0) {
-        filterStr = "".concat(filterValue);
-        var handleSearch = filterMethod ? function (item) {
-          return filterMethod({
-            $tree: $xeTree,
-            node: item,
-            filterValue: filterStr
-          });
-        } : function (item) {
-          return String(item[titleField]).toLowerCase().indexOf(filterStr.toLowerCase()) > -1;
-        };
-        var bafParams = {
-          $tree: $xeTree,
-          filterValue: filterStr
-        };
-        if (beforeFilterMethod) {
-          beforeFilterMethod(bafParams);
-        }
-        if (transform) {
-          treeList = _xeUtils.default.searchTree(treeFullData, handleSearch, {
-            original: true,
-            isEvery: true,
-            children: childrenField,
-            mapChildren: mapChildrenField
-          });
-          fullList = treeList;
-        } else {
-          fullList = treeFullData.filter(handleSearch);
-        }
-        internalData.lastFilterValue = filterStr;
-        $xeTree.$nextTick(function () {
-          // 筛选时自动展开
-          if (autoExpandAll) {
-            $xeTree.setAllExpandNode(true).then(function () {
-              if (afterFilterMethod) {
-                afterFilterMethod(bafParams);
-              }
-            });
-          } else {
-            if (afterFilterMethod) {
-              afterFilterMethod(bafParams);
-            }
-          }
-        });
-      } else {
-        if (transform) {
-          treeList = _xeUtils.default.searchTree(treeFullData, function () {
-            return true;
-          }, {
-            original: true,
-            isEvery: true,
-            children: childrenField,
-            mapChildren: mapChildrenField
-          });
-          fullList = treeList;
-          if (lastFilterValue) {
-            var _bafParams = {
-              $tree: $xeTree,
-              filterValue: filterStr
-            };
-            if (beforeFilterMethod) {
-              beforeFilterMethod(_bafParams);
-            }
-            // 取消筛选时自动收起
-            $xeTree.$nextTick(function () {
-              if (autoExpandAll) {
-                $xeTree.clearAllExpandNode().then(function () {
-                  if (afterFilterMethod) {
-                    afterFilterMethod(_bafParams);
-                  }
-                });
-              } else {
-                if (afterFilterMethod) {
-                  afterFilterMethod(_bafParams);
-                }
-              }
-            });
-          }
-        }
-        internalData.lastFilterValue = '';
-      }
-      internalData.afterVisibleList = fullList;
-      internalData.afterTreeList = treeList;
-      $xeTree.updateAfterDataIndex();
-    },
-    /**
-     * 如果为虚拟树、则将树结构拍平
-     */
-    handleTreeToList: function handleTreeToList() {
-      var $xeTree = this;
-      var props = $xeTree;
-      var internalData = $xeTree.internalData;
-      var transform = props.transform;
-      var afterTreeList = internalData.afterTreeList,
-        treeExpandedMaps = internalData.treeExpandedMaps;
-      var mapChildrenField = $xeTree.computeMapChildrenField;
-      var expandMaps = {};
-      if (transform) {
-        var fullData = [];
-        _xeUtils.default.eachTree(afterTreeList, function (item, index, items, path, parentNode) {
-          var nodeid = $xeTree.getNodeId(item);
-          var parentNodeid = $xeTree.getNodeId(parentNode);
-          if (!parentNode || expandMaps[parentNodeid] && treeExpandedMaps[parentNodeid]) {
-            expandMaps[nodeid] = 1;
-            fullData.push(item);
-          }
-        }, {
-          children: mapChildrenField
-        });
-        $xeTree.updateScrollYStatus(fullData);
-        internalData.afterVisibleList = fullData;
-        return fullData;
-      }
-      return internalData.afterVisibleList;
-    },
-    handleData: function handleData(force) {
-      var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var scrollYLoad = reactData.scrollYLoad;
-      var scrollYStore = internalData.scrollYStore,
-        nodeMaps = internalData.nodeMaps;
-      var fullList = internalData.afterVisibleList;
-      if (force) {
-        // 更新数据，处理筛选和排序
-        $xeTree.updateAfterFullData();
-        // 如果为虚拟树，将树结构拍平
-        fullList = $xeTree.handleTreeToList();
-      }
-      var treeList = scrollYLoad ? fullList.slice(scrollYStore.startIndex, scrollYStore.endIndex) : fullList.slice(0);
-      treeList.forEach(function (item, $index) {
-        var nodeid = $xeTree.getNodeId(item);
-        var itemRest = nodeMaps[nodeid];
-        if (itemRest) {
-          itemRest.$index = $index;
-        }
-      });
-      reactData.treeList = treeList;
-    },
-    triggerSearchEvent: _xeUtils.default.debounce(function () {
-      var $xeSelect = this;
-      $xeSelect.handleData(true);
-    }, 350, {
-      trailing: true
-    }),
-    loadData: function loadData(list) {
-      var $xeTree = this;
-      var props = $xeTree;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var expandAll = props.expandAll,
-        expandNodeKeys = props.expandNodeKeys,
-        transform = props.transform,
-        rootParentValue = props.rootParentValue,
-        rootValues = props.rootValues;
-      var initialized = internalData.initialized,
-        scrollYStore = internalData.scrollYStore;
-      var keyField = $xeTree.computeKeyField;
-      var parentField = $xeTree.computeParentField;
-      var childrenField = $xeTree.computeChildrenField;
-      var fullData = transform ? _xeUtils.default.toArrayTree(list, {
-        key: keyField,
-        parentKey: parentField,
-        mapChildren: childrenField,
-        rootParentValue: rootParentValue,
-        rootValues: rootValues
-      }) : list ? list.slice(0) : [];
-      internalData.treeFullData = fullData;
-      internalData.insertNodeMaps = {};
-      reactData.insertNodeFlag++;
-      internalData.removeNodeMaps = {};
-      reactData.removeNodeFlag++;
-      Object.assign(scrollYStore, {
-        startIndex: 0,
-        endIndex: 1,
-        visibleSize: 0
-      });
-      var sYLoad = $xeTree.updateScrollYStatus(fullData);
-      $xeTree.cacheNodeMap();
-      $xeTree.handleData(true);
-      if (sYLoad) {
-        if (!(props.height || props.maxHeight)) {
-          errLog('vxe.error.reqProp', ['height | max-height | virtual-y-config.enabled=false']);
-        }
-      }
-      return $xeTree.computeScrollLoad().then(function () {
-        if (!initialized) {
-          if (list && list.length) {
-            internalData.initialized = true;
-            if (expandAll) {
-              $xeTree.setAllExpandNode(true);
-            } else if (expandNodeKeys && expandNodeKeys.length) {
-              $xeTree.setExpandByNodeId(expandNodeKeys, true);
-            }
-            $xeTree.handleSetCheckboxByNodeId(props.checkNodeKeys || [], true);
-          }
-        }
-        $xeTree.updateHeight();
-        $xeTree.refreshScroll();
-      });
-    },
-    updateScrollYStatus: function updateScrollYStatus(fullData) {
-      var $xeTree = this;
-      var props = $xeTree;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var transform = props.transform;
-      var virtualYOpts = $xeTree.computeVirtualYOpts;
-      var allList = fullData || internalData.treeFullData;
-      // 如果gt为0，则总是启用
-      var scrollYLoad = !!transform && !!virtualYOpts.enabled && virtualYOpts.gt > -1 && (virtualYOpts.gt === 0 || virtualYOpts.gt < allList.length);
-      reactData.scrollYLoad = scrollYLoad;
-      return scrollYLoad;
-    },
-    updateYSpace: function updateYSpace() {
-      var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var scrollYLoad = reactData.scrollYLoad;
-      var scrollYStore = internalData.scrollYStore,
-        afterVisibleList = internalData.afterVisibleList;
-      reactData.bodyHeight = scrollYLoad ? afterVisibleList.length * scrollYStore.rowHeight : 0;
-      reactData.topSpaceHeight = scrollYLoad ? Math.max(scrollYStore.startIndex * scrollYStore.rowHeight, 0) : 0;
-    },
-    updateYData: function updateYData() {
-      var $xeTree = this;
-      $xeTree.handleData();
-      $xeTree.updateYSpace();
-    },
-    computeScrollLoad: function computeScrollLoad() {
-      var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      return $xeTree.$nextTick().then(function () {
-        var scrollYLoad = reactData.scrollYLoad;
-        var scrollYStore = internalData.scrollYStore;
-        var virtualBodyElem = $xeTree.$refs.refVirtualBody;
-        var virtualYOpts = $xeTree.computeVirtualYOpts;
-        var rowHeight = 0;
-        var firstItemElem;
-        if (virtualBodyElem) {
-          if (!firstItemElem) {
-            firstItemElem = virtualBodyElem.children[0];
-          }
-        }
-        if (firstItemElem) {
-          rowHeight = firstItemElem.offsetHeight;
-        }
-        rowHeight = Math.max(20, rowHeight);
-        scrollYStore.rowHeight = rowHeight;
-        // 计算 Y 逻辑
-        if (scrollYLoad) {
-          var scrollBodyElem = $xeTree.$refs.refVirtualWrapper;
-          var visibleYSize = Math.max(8, scrollBodyElem ? Math.ceil(scrollBodyElem.clientHeight / rowHeight) : 0);
-          var offsetYSize = Math.max(0, Math.min(2, _xeUtils.default.toNumber(virtualYOpts.oSize)));
-          scrollYStore.offsetSize = offsetYSize;
-          scrollYStore.visibleSize = visibleYSize;
-          scrollYStore.endIndex = Math.max(scrollYStore.startIndex, visibleYSize + offsetYSize, scrollYStore.endIndex);
-          $xeTree.updateYData();
-        } else {
-          $xeTree.updateYSpace();
-        }
-      });
-    },
-    /**
-     * 如果有滚动条，则滚动到对应的位置
-     */
-    scrollTo: function scrollTo(scrollLeft, scrollTop) {
-      var $xeTree = this;
-      return handleScrollTo($xeTree, scrollLeft, scrollTop);
-    },
-    scrollToNode: function scrollToNode(node) {
-      var $xeTree = this;
-      return $xeTree.scrollToNodeId($xeTree.getNodeId(node));
-    },
-    scrollToNodeId: function scrollToNodeId(nodeid) {
-      var $xeTree = this;
-      var props = $xeTree;
-      var internalData = $xeTree.internalData;
-      var transform = props.transform;
-      var scrollYStore = internalData.scrollYStore,
-        afterTreeList = internalData.afterTreeList;
-      var childrenField = $xeTree.computeChildrenField;
-      var mapChildrenField = $xeTree.computeMapChildrenField;
-      var scrollBodyElem = $xeTree.$refs.refVirtualWrapper;
-      if (nodeid && scrollBodyElem) {
-        if (transform) {
-          var matchObj = _xeUtils.default.findTree(afterTreeList, function (item) {
-            return $xeTree.getNodeId(item) === nodeid;
-          }, {
-            children: transform ? mapChildrenField : childrenField
-          });
-          if (matchObj) {
-            return $xeTree.setExpandNode(matchObj.nodes, true).then(function () {
-              var itemIndex = _xeUtils.default.findIndexOf(internalData.afterVisibleList, function (item) {
-                return $xeTree.getNodeId(item) === nodeid;
-              });
-              if (itemIndex > -1) {
-                var targetTop = Math.max(0, (itemIndex - 1) * scrollYStore.rowHeight);
-                return handleScrollTo($xeTree, scrollBodyElem.scrollLeft, targetTop);
-              }
-            });
-          }
-        } else {
-          var itemEl = scrollBodyElem.querySelector(".vxe-tree--node-wrapper[nodeid=\"".concat(nodeid, "\"]"));
-          if (itemEl) {
-            return handleScrollTo($xeTree, scrollBodyElem.scrollLeft, itemEl.offsetTop);
-          }
-        }
-      }
-      return $xeTree.recalculate();
-    },
-    /**
-     * 刷新滚动条
-     */
-    refreshScroll: function refreshScroll() {
-      var $xeTree = this;
-      var internalData = $xeTree.internalData;
-      var lastScrollLeft = internalData.lastScrollLeft,
-        lastScrollTop = internalData.lastScrollTop;
-      return $xeTree.clearScroll().then(function () {
-        if (lastScrollLeft || lastScrollTop) {
-          internalData.lastScrollLeft = 0;
-          internalData.lastScrollTop = 0;
-          return scrollTo(lastScrollLeft, lastScrollTop);
-        }
-      });
-    },
-    /**
-     * 重新计算列表
-     */
-    recalculate: function recalculate() {
-      var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var scrollYStore = internalData.scrollYStore;
-      var rowHeight = scrollYStore.rowHeight;
-      var el = $xeTree.$refs.refElem;
-      if (el && el.clientWidth && el.clientHeight) {
-        var parentEl = $xeTree.getParentElem();
-        var headerWrapperEl = $xeTree.$refs.refHeaderWrapperElem;
-        var footerWrapperEl = $xeTree.$refs.refFooterWrapperElem;
-        var headHeight = headerWrapperEl ? headerWrapperEl.clientHeight : 0;
-        var footHeight = footerWrapperEl ? footerWrapperEl.clientHeight : 0;
-        if (parentEl) {
-          var parentPaddingSize = (0, _dom.getPaddingTopBottomSize)(parentEl);
-          reactData.parentHeight = Math.max(headHeight + footHeight + rowHeight, parentEl.clientHeight - parentPaddingSize - headHeight - footHeight);
-        }
-        $xeTree.updateHeight();
-        return $xeTree.computeScrollLoad().then(function () {
-          $xeTree.updateHeight();
-          $xeTree.updateYSpace();
-        });
-      }
-      return $xeTree.$nextTick();
-    },
-    getFullData: function getFullData() {
-      var $xeTree = this;
-      var internalData = $xeTree.internalData;
-      var treeFullData = internalData.treeFullData;
-      return treeFullData.slice(0);
-    },
-    loadYData: function loadYData() {
-      var $xeTree = this;
-      var internalData = $xeTree.internalData;
-      var scrollYStore = internalData.scrollYStore;
-      var startIndex = scrollYStore.startIndex,
-        endIndex = scrollYStore.endIndex,
-        visibleSize = scrollYStore.visibleSize,
-        offsetSize = scrollYStore.offsetSize,
-        rowHeight = scrollYStore.rowHeight;
-      var scrollBodyElem = $xeTree.$refs.refVirtualWrapper;
-      if (!scrollBodyElem) {
-        return;
-      }
-      var scrollTop = scrollBodyElem.scrollTop;
-      var toVisibleIndex = Math.floor(scrollTop / rowHeight);
-      var offsetStartIndex = Math.max(0, toVisibleIndex - 1 - offsetSize);
-      var offsetEndIndex = toVisibleIndex + visibleSize + offsetSize;
-      if (toVisibleIndex <= startIndex || toVisibleIndex >= endIndex - visibleSize - 1) {
-        if (startIndex !== offsetStartIndex || endIndex !== offsetEndIndex) {
-          scrollYStore.startIndex = offsetStartIndex;
-          scrollYStore.endIndex = offsetEndIndex;
-          $xeTree.updateYData();
-        }
-      }
-    },
-    scrollEvent: function scrollEvent(evnt) {
-      var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var scrollBodyElem = evnt.target;
-      var scrollTop = scrollBodyElem.scrollTop;
-      var scrollLeft = scrollBodyElem.scrollLeft;
-      var isX = scrollLeft !== internalData.lastScrollLeft;
-      var isY = scrollTop !== internalData.lastScrollTop;
-      internalData.lastScrollTop = scrollTop;
-      internalData.lastScrollLeft = scrollLeft;
-      if (reactData.scrollYLoad) {
-        $xeTree.loadYData();
-      }
-      internalData.lastScrollTime = Date.now();
-      $xeTree.dispatchEvent('scroll', {
-        scrollLeft: scrollLeft,
-        scrollTop: scrollTop,
-        isX: isX,
-        isY: isY
-      }, evnt);
-    },
-    clearScroll: function clearScroll() {
-      var $xeTree = this;
-      var internalData = $xeTree.internalData;
-      var scrollBodyElem = $xeTree.$refs.refVirtualWrapper;
-      if (scrollBodyElem) {
-        scrollBodyElem.scrollTop = 0;
-        scrollBodyElem.scrollLeft = 0;
-      }
-      internalData.lastScrollTop = 0;
-      internalData.lastScrollLeft = 0;
-      return $xeTree.$nextTick();
-    },
-    handleInsertNodeAt: function handleInsertNodeAt(records, targetNodeOrNodeid, isInsertNextNode) {
-      var $xeTree = this;
-      var props = $xeTree;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var transform = props.transform;
-      var treeFullData = internalData.treeFullData,
-        nodeMaps = internalData.nodeMaps,
-        removeNodeMaps = internalData.removeNodeMaps,
-        insertNodeMaps = internalData.insertNodeMaps;
-      var keyField = $xeTree.computeKeyField;
-      var parentField = $xeTree.computeParentField;
-      var childrenField = $xeTree.computeChildrenField;
-      var mapChildrenField = $xeTree.computeMapChildrenField;
-      if (!transform) {
-        errLog('vxe.error.reqSupportProp', ['insert() | insertAt() | insertNextAt()', 'transform']);
-        return Promise.resolve({
-          node: null,
-          nodes: []
-        });
-      }
-      if (!_xeUtils.default.isArray(records)) {
-        records = [records];
-      }
-      var targetNode = targetNodeOrNodeid;
-      if (_xeUtils.default.isString(targetNodeOrNodeid) || _xeUtils.default.isNumber(targetNodeOrNodeid)) {
-        var nodeRest = nodeMaps[targetNodeOrNodeid];
-        if (nodeRest) {
-          targetNode = nodeRest.item;
-        }
-      }
-      if (!records.length) {
-        return Promise.resolve({
-          node: null,
-          nodes: []
-        });
-      }
-      var newRecords = records.map(function (record) {
-        return _xeUtils.default.assign(_defineProperty(_defineProperty({}, mapChildrenField, []), childrenField, []), record);
-      });
-      var treeRecords = _xeUtils.default.toArrayTree(newRecords, {
-        key: keyField,
-        parentKey: parentField,
-        children: childrenField
-      });
-      if (_xeUtils.default.eqNull(targetNode)) {
-        insertTreeNode($xeTree, newRecords, false);
-      } else {
-        if (targetNode === -1) {
-          insertTreeNode($xeTree, newRecords, true);
-        } else {
-          var matchMapObj = _xeUtils.default.findTree(treeFullData, function (item) {
-            return targetNode[keyField] === item[keyField];
-          }, {
-            children: mapChildrenField
-          });
-          if (matchMapObj) {
-            var parentNode = matchMapObj.parent;
-            var parentMapChilds = parentNode ? parentNode[mapChildrenField] : treeFullData;
-            var parentRest = nodeMaps[$xeTree.getNodeId(parentNode)];
-            var parentLevel = parentRest ? parentRest.level : 0;
-            treeRecords.forEach(function (item, i) {
-              if (parentNode) {
-                if (item[parentField] !== parentNode[keyField]) {
-                  errLog('vxe.error.errProp', ["".concat(parentField, "=").concat(item[parentField]), "".concat(parentField, "=").concat(parentNode[keyField])]);
-                  item[parentField] = parentNode[keyField];
-                }
-              } else {
-                if (item[parentField] !== null) {
-                  if (!_xeUtils.default.eqNull(item[parentField])) {
-                    errLog('vxe.error.errProp', ["".concat(parentField, "=").concat(item[parentField]), 'null']);
-                  }
-                  item[parentField] = null;
-                }
-              }
-              var targetIndex = matchMapObj.index + i;
-              if (isInsertNextNode) {
-                targetIndex = targetIndex + 1;
-              }
-              parentMapChilds.splice(targetIndex, 0, item);
-            });
-            _xeUtils.default.eachTree(treeRecords, function (item) {
-              var nodeid = $xeTree.getNodeId(item);
-              var nodeRest = (0, _util.getItemCacheObj)(item);
-              nodeRest.level = parentLevel;
-              if (item[childrenField]) {
-                item[mapChildrenField] = item[childrenField];
-              }
-              nodeMaps[nodeid] = nodeRest;
-            }, {
-              children: childrenField
-            });
-            // 源
-            if (parentNode) {
-              var matchObj = _xeUtils.default.findTree(treeFullData, function (item) {
-                return targetNode[keyField] === item[keyField];
-              }, {
-                children: childrenField
-              });
-              if (matchObj) {
-                var parentChilds = matchObj.items;
-                var targetIndex = matchObj.index;
-                if (isInsertNextNode) {
-                  targetIndex = targetIndex + 1;
-                }
-                parentChilds.splice.apply(parentChilds, [targetIndex, 0].concat(_toConsumableArray(treeRecords)));
-              }
-            }
-          } else {
-            warnLog('vxe.error.unableInsert');
-            insertTreeNode($xeTree, newRecords, true);
-          }
-        }
-      }
-      var handleStatus = function handleStatus(newItem) {
-        var nodeid = $xeTree.getNodeId(newItem);
-        // 如果是被删除的数据，则还原状态
-        if (removeNodeMaps[nodeid]) {
-          delete removeNodeMaps[nodeid];
-          if (insertNodeMaps[nodeid]) {
-            delete insertNodeMaps[nodeid];
-          }
-        } else {
-          insertNodeMaps[nodeid] = newItem;
-        }
-      };
-      _xeUtils.default.eachTree(treeRecords, handleStatus, {
-        children: mapChildrenField
-      });
-      reactData.removeNodeFlag++;
-      reactData.insertNodeFlag++;
-      $xeTree.cacheNodeMap();
-      $xeTree.handleData(true);
-      $xeTree.updateAfterDataIndex();
-      $xeTree.updateCheckboxStatus();
-      if (reactData.scrollYLoad) {
-        $xeTree.updateYSpace();
-      }
-      return $xeTree.$nextTick().then(function () {
-        return {
-          node: newRecords.length ? newRecords[newRecords.length - 1] : null,
-          nodes: newRecords
-        };
-      });
-    },
-    insert: function insert(records) {
-      var $xeTree = this;
-      return $xeTree.handleInsertNodeAt(records, null);
-    },
-    insertAt: function insertAt(records, targetNodeOrNodeid) {
-      var $xeTree = this;
-      return $xeTree.handleInsertNodeAt(records, targetNodeOrNodeid);
-    },
-    insertNextAt: function insertNextAt(records, targetNodeOrNodeid) {
-      var $xeTree = this;
-      return $xeTree.handleInsertNodeAt(records, targetNodeOrNodeid, true);
-    },
-    handleInsertChildNodeAt: function handleInsertChildNodeAt(records, parentNodeOrParentId, targetNodeOrNodeid, isInsertNextNode) {
-      var $xeTree = this;
-      var props = $xeTree;
-      var internalData = $xeTree.internalData;
-      var transform = props.transform;
-      var nodeMaps = internalData.nodeMaps;
-      var keyField = $xeTree.computeKeyField;
-      var parentField = $xeTree.computeParentField;
-      if (!transform) {
-        errLog('vxe.error.reqSupportProp', ['insertChild() | insertChildAt() | insertChildNextAt()', 'transform']);
-        return Promise.resolve({
-          node: null,
-          nodes: []
-        });
-      }
-      if (!_xeUtils.default.isArray(records)) {
-        records = [records];
-      }
-      var parentNode = parentNodeOrParentId;
-      if (_xeUtils.default.isString(parentNodeOrParentId) || _xeUtils.default.isNumber(parentNodeOrParentId)) {
-        var nodeRest = nodeMaps[parentNodeOrParentId];
-        if (nodeRest) {
-          parentNode = nodeRest.item;
-        }
-      }
-      return $xeTree.handleInsertNodeAt(records.map(function (item) {
-        return Object.assign({}, item, _defineProperty({}, parentField, parentNode[keyField]));
-      }), targetNodeOrNodeid, isInsertNextNode);
-    },
-    insertChild: function insertChild(records, parentNodeOrParentId) {
-      var $xeTree = this;
-      return $xeTree.handleInsertChildNodeAt(records, parentNodeOrParentId, null);
-    },
-    insertChildAt: function insertChildAt(records, parentNodeOrParentId, targetNode) {
-      var $xeTree = this;
-      return $xeTree.handleInsertChildNodeAt(records, parentNodeOrParentId, targetNode);
-    },
-    insertChildNextAt: function insertChildNextAt(records, parentNodeOrParentId, targetNode) {
-      var $xeTree = this;
-      return $xeTree.handleInsertChildNodeAt(records, parentNodeOrParentId, targetNode, true);
-    },
-    getInsertRecords: function getInsertRecords() {
-      var $xeTree = this;
-      var internalData = $xeTree.internalData;
-      var insertNodeMaps = internalData.insertNodeMaps;
-      var insertRecords = [];
-      _xeUtils.default.each(insertNodeMaps, function (item) {
-        insertRecords.push(item);
-      });
-      return insertRecords;
-    },
-    isInsertByNode: function isInsertByNode(node) {
-      var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var nodeid = $xeTree.getNodeId(node);
-      return !!reactData.insertNodeFlag && !!internalData.insertNodeMaps[nodeid];
-    },
-    remove: function remove(nodes) {
-      var $xeTree = this;
-      var props = $xeTree;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var transform = props.transform;
-      var treeFullData = internalData.treeFullData,
-        insertNodeMaps = internalData.insertNodeMaps,
-        removeNodeMaps = internalData.removeNodeMaps;
-      var childrenField = $xeTree.computeChildrenField;
-      var mapChildrenField = $xeTree.computeMapChildrenField;
-      if (!transform) {
-        errLog('vxe.error.reqSupportProp', ['remove()', 'transform']);
-        return Promise.resolve({
-          node: null,
-          nodes: []
-        });
-      }
-      var delList = [];
-      if (!nodes) {
-        nodes = treeFullData;
-      } else if (!_xeUtils.default.isArray(nodes)) {
-        nodes = [nodes];
-      }
-      if (!nodes.length) {
-        return Promise.resolve({
-          node: null,
-          nodes: []
-        });
-      }
-      // 如果是新增，则保存记录
-      nodes.forEach(function (item) {
-        if (!$xeTree.isInsertByNode(item)) {
-          var nodeid = $xeTree.getNodeId(item);
-          removeNodeMaps[nodeid] = item;
-        }
-      });
-      // 从数据源中移除
-      if (treeFullData === nodes) {
-        nodes = delList = treeFullData.slice(0);
-        internalData.treeFullData = [];
-      } else {
-        nodes.forEach(function (item) {
-          var nodeid = $xeTree.getNodeId(item);
-          var matchMapObj = _xeUtils.default.findTree(treeFullData, function (item) {
-            return nodeid === $xeTree.getNodeId(item);
-          }, {
-            children: mapChildrenField
-          });
-          if (matchMapObj) {
-            var rItems = matchMapObj.items.splice(matchMapObj.index, 1);
-            delList.push(rItems[0]);
-          }
-          var matchObj = _xeUtils.default.findTree(treeFullData, function (item) {
-            return nodeid === $xeTree.getNodeId(item);
-          }, {
-            children: childrenField
-          });
-          if (matchObj) {
-            var _rItems = matchObj.items.splice(matchObj.index, 1);
-            delList.push(_rItems[0]);
-          }
-        });
-      }
-      // 从新增中移除已删除的数据
-      nodes.forEach(function (item) {
-        var nodeid = $xeTree.getNodeId(item);
-        if (insertNodeMaps[nodeid]) {
-          delete insertNodeMaps[nodeid];
-        }
-      });
-      reactData.removeNodeFlag++;
-      reactData.insertNodeFlag++;
-      $xeTree.cacheNodeMap();
-      $xeTree.handleData(true);
-      $xeTree.updateAfterDataIndex();
-      $xeTree.updateCheckboxStatus();
-      if (reactData.scrollYLoad) {
-        $xeTree.updateYSpace();
-      }
-      return $xeTree.$nextTick().then(function () {
-        return $xeTree.recalculate();
-      }).then(function () {
-        return {
-          node: delList.length ? delList[delList.length - 1] : null,
-          nodes: delList
-        };
-      });
-    },
-    getRemoveRecords: function getRemoveRecords() {
-      var $xeTree = this;
-      var internalData = $xeTree.internalData;
-      var removeNodeMaps = internalData.removeNodeMaps;
-      var removeRecords = [];
-      _xeUtils.default.each(removeNodeMaps, function (item) {
-        removeRecords.push(item);
-      });
-      return removeRecords;
-    },
-    isRemoveByNode: function isRemoveByNode(node) {
-      var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var nodeid = $xeTree.getNodeId(node);
-      return !!reactData.removeNodeFlag && !!internalData.removeNodeMaps[nodeid];
-    },
-    handleNodeMousedownEvent: function handleNodeMousedownEvent(evnt, node) {
-      var $xeTree = this;
-      var props = $xeTree;
-      var internalData = $xeTree.internalData;
-      var drag = props.drag;
-      var nodeMaps = internalData.nodeMaps;
-      var targetEl = evnt.currentTarget;
-      var dragConfig = $xeTree.computeDragOpts;
-      var trigger = dragConfig.trigger,
-        isCrossDrag = dragConfig.isCrossDrag,
-        isPeerDrag = dragConfig.isPeerDrag,
-        disabledMethod = dragConfig.disabledMethod;
-      var nodeid = $xeTree.getNodeId(node);
-      var triggerTreeNode = (0, _dom.getEventTargetNode)(evnt, targetEl, 'vxe-tree--node-item-switcher').flag;
-      var isNodeDrag = false;
-      if (drag) {
-        isNodeDrag = trigger === 'node';
-      }
-      if (!triggerTreeNode) {
-        var params = {
-          node: node,
-          $tree: $xeTree
-        };
-        var itemRest = nodeMaps[nodeid];
-        if (isNodeDrag && (isCrossDrag || isPeerDrag || itemRest && !itemRest.level) && !(disabledMethod && disabledMethod(params))) {
-          $xeTree.handleNodeDragMousedownEvent(evnt, {
-            node: node
-          });
-        }
-      }
-    },
-    handleNodeClickEvent: function handleNodeClickEvent(evnt, node) {
-      var $xeTree = this;
-      var props = $xeTree;
-      var reactData = $xeTree.reactData;
-      var showRadio = props.showRadio,
-        showCheckbox = props.showCheckbox,
-        trigger = props.trigger;
-      var radioOpts = $xeTree.computeRadioOpts;
-      var checkboxOpts = $xeTree.computeCheckboxOpts;
-      var isNodeCurrent = $xeTree.computeIsNodeCurrent;
-      var triggerCurrent = false;
-      var triggerRadio = false;
-      var triggerCheckbox = false;
-      var triggerExpand = false;
-      if (isNodeCurrent) {
-        triggerCurrent = true;
-        $xeTree.changeCurrentEvent(evnt, node);
-      } else if (reactData.currentNode) {
-        reactData.currentNode = null;
-      }
-      if (trigger === 'node') {
-        triggerExpand = true;
-        $xeTree.toggleExpandEvent(evnt, node);
-      }
-      if (showRadio && radioOpts.trigger === 'node') {
-        triggerRadio = true;
-        $xeTree.changeRadioEvent(evnt, node);
-      }
-      if (showCheckbox && checkboxOpts.trigger === 'node') {
-        triggerCheckbox = true;
-        $xeTree.changeCheckboxEvent(evnt, node);
-      }
-      $xeTree.dispatchEvent('node-click', {
-        node: node,
-        triggerCurrent: triggerCurrent,
-        triggerRadio: triggerRadio,
-        triggerCheckbox: triggerCheckbox,
-        triggerExpand: triggerExpand
-      }, evnt);
-    },
-    handleNodeDblclickEvent: function handleNodeDblclickEvent(evnt, node) {
-      var $xeTree = this;
-      $xeTree.dispatchEvent('node-dblclick', {
-        node: node
-      }, evnt);
-    },
-    handleNodeMouseenterEvent: function handleNodeMouseenterEvent(evnt, node) {
-      var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var $tooltip = $xeTree.$refs.refTooltip;
-      if (!$tooltip) {
-        return;
-      }
-      var tooltipStore = reactData.tooltipStore;
-      var tipTimeout = internalData.tipTimeout;
-      var nodeEl = evnt.currentTarget;
-      var tooltipOpts = $xeTree.computeTooltipOpts;
-      var showAll = tooltipOpts.showAll,
-        contentMethod = tooltipOpts.contentMethod;
-      if (tipTimeout) {
-        clearTimeout(tipTimeout);
-        internalData.tipTimeout = undefined;
-      }
-      var titleEl = nodeEl.querySelector('.vxe-tree--node-item-title');
-      var tipOverEl = nodeEl.querySelector('.vxe-tree--node-item-wrapper');
-      if (!tipOverEl) {
-        return;
-      }
-      var cellText = _xeUtils.default.toString(tipOverEl.textContent).trim();
-      var isOver = tipOverEl.scrollWidth > tipOverEl.clientWidth;
-      var isShow = false;
-      var customContent = null;
-      var content = '';
-      if (contentMethod) {
-        customContent = contentMethod({
-          node: node,
-          $event: evnt,
-          $tree: $xeTree
-        });
-      }
-      // 是否全部展示
-      if (showAll) {
-        // 如果为 null 默认显示
-        if (_xeUtils.default.eqNull(customContent)) {
-          isShow = true;
-          content = cellText;
-        } else if (customContent !== '' && customContent !== false) {
-          // 如果为 '' | false 则不显示
-          isShow = true;
-          content = '' + customContent;
-        }
-      } else {
-        // 如果为 null 使用默认逻辑
-        if (_xeUtils.default.eqNull(customContent)) {
-          isShow = isOver;
-          content = cellText;
-        } else if (customContent !== '' && customContent !== false) {
-          // 如果为 '' | false 则不显示
-          isShow = true;
-          content = '' + customContent;
-        } else {
-          content = cellText;
-        }
-      }
-      if (isShow && content) {
-        var tipContent = (0, _utils.getText)(content);
-        tooltipStore.visible = true;
-        tooltipStore.node = node;
-        if ($tooltip.open) {
-          $tooltip.open((isOver ? tipOverEl : titleEl) || tipOverEl, tipContent);
-        }
-      }
-    },
-    handleNodeMouseleaveEvent: function handleNodeMouseleaveEvent() {
-      var $xeTree = this;
-      var internalData = $xeTree.internalData;
-      var $tooltip = $xeTree.$refs.refTooltip;
-      var tooltipOpts = $xeTree.computeTooltipOpts;
-      if ($tooltip && $tooltip.setActived) {
-        $tooltip.setActived(false);
-      }
-      if (tooltipOpts.enterable) {
-        internalData.tipTimeout = setTimeout(function () {
-          $tooltip = $xeTree.$refs.refTooltip;
-          if ($tooltip && $tooltip.isActived && !$tooltip.isActived()) {
-            $xeTree.closeTooltip();
-          }
-          internalData.tipTimeout = undefined;
-        }, tooltipOpts.leaveDelay);
-      } else {
-        $xeTree.closeTooltip();
-      }
-    },
-    closeTooltip: function closeTooltip() {
-      var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      var tooltipStore = reactData.tooltipStore;
-      if (tooltipStore.visible) {
-        tooltipStore.visible = false;
-        tooltipStore.node = null;
-        var $tooltip = $xeTree.$refs.refTooltip;
-        if ($tooltip) {
-          $tooltip.close();
-        }
-      }
-      return $xeTree.$nextTick();
-    },
-    handleContextmenuEvent: function handleContextmenuEvent(evnt, node) {
-      var $xeTree = this;
-      var props = $xeTree;
-      var reactData = $xeTree.reactData;
-      var menuConfig = props.menuConfig;
-      var isNodeCurrent = $xeTree.computeIsNodeCurrent;
-      var menuOpts = $xeTree.computeMenuOpts;
-      if (menuConfig ? (0, _utils.isEnableConf)(menuOpts) : menuOpts.enabled) {
-        var options = menuOpts.options,
-          visibleMethod = menuOpts.visibleMethod;
-        if (!visibleMethod || visibleMethod({
-          $tree: $xeTree,
-          options: options,
-          node: node
-        })) {
-          if (isNodeCurrent) {
-            $xeTree.changeCurrentEvent(evnt, node);
-          } else if (reactData.currentNode) {
-            reactData.currentNode = null;
-          }
-          if (_ui.VxeUI.contextMenu) {
-            _ui.VxeUI.contextMenu.openByEvent(evnt, {
-              options: options,
-              events: {
-                optionClick: function optionClick(eventParams) {
-                  var option = eventParams.option;
-                  var gMenuOpts = menus.get(option.code);
-                  var tmMethod = gMenuOpts ? gMenuOpts.treeMenuMethod : null;
-                  var params = {
-                    menu: option,
-                    node: node,
-                    $event: evnt,
-                    $tree: $xeTree,
-                    /**
-                     * @@deprecated
-                     */
-                    option: option
-                  };
-                  if (tmMethod) {
-                    tmMethod(params, evnt);
-                  }
-                  $xeTree.dispatchEvent('menu-click', params, eventParams.$event);
-                }
-              }
-            });
-          }
-        }
-      }
-      $xeTree.dispatchEvent('node-menu', {
-        node: node
-      }, evnt);
-    },
-    handleAsyncTreeExpandChilds: function handleAsyncTreeExpandChilds(node) {
-      var $xeTree = this;
-      var props = $xeTree;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var checkboxOpts = $xeTree.computeCheckboxOpts;
-      var loadMethod = props.loadMethod;
-      var checkStrictly = checkboxOpts.checkStrictly;
-      return new Promise(function (resolve) {
-        if (loadMethod) {
-          var nodeMaps = internalData.nodeMaps;
-          var nodeid = $xeTree.getNodeId(node);
-          var nodeItem = nodeMaps[nodeid];
-          internalData.treeExpandLazyLoadedMaps[nodeid] = true;
-          Promise.resolve(loadMethod({
-            $tree: $xeTree,
-            node: node
-          })).then(function (childRecords) {
-            var treeExpandLazyLoadedMaps = internalData.treeExpandLazyLoadedMaps;
-            nodeItem.treeLoaded = true;
-            if (treeExpandLazyLoadedMaps[nodeid]) {
-              treeExpandLazyLoadedMaps[nodeid] = false;
-            }
-            if (!_xeUtils.default.isArray(childRecords)) {
-              childRecords = [];
-            }
-            if (childRecords) {
-              return $xeTree.loadChildrenNode(node, childRecords).then(function (childNodes) {
-                var treeExpandedMaps = internalData.treeExpandedMaps;
-                if (childNodes.length && !treeExpandedMaps[nodeid]) {
-                  treeExpandedMaps[nodeid] = true;
-                }
-                reactData.updateExpandedFlag++;
-                // 如果当前节点已选中，则展开后子节点也被选中
-                if (!checkStrictly && $xeTree.isCheckedByCheckboxNodeId(nodeid)) {
-                  $xeTree.handleCheckedCheckboxNode(childNodes, true);
-                }
-                $xeTree.dispatchEvent('load-success', {
-                  node: node,
-                  data: childRecords
-                }, new Event('load-success'));
-                return $xeTree.$nextTick();
-              });
-            } else {
-              $xeTree.dispatchEvent('load-success', {
-                node: node,
-                data: childRecords
-              }, new Event('load-success'));
-            }
-          }).catch(function (e) {
-            var treeExpandLazyLoadedMaps = internalData.treeExpandLazyLoadedMaps;
-            nodeItem.treeLoaded = false;
-            if (treeExpandLazyLoadedMaps[nodeid]) {
-              treeExpandLazyLoadedMaps[nodeid] = false;
-            }
-            $xeTree.dispatchEvent('load-error', {
-              node: node,
-              data: e
-            }, new Event('load-error'));
-          }).finally(function () {
-            $xeTree.handleTreeToList();
-            $xeTree.handleData();
-            return $xeTree.recalculate();
-          });
-        } else {
-          resolve();
-        }
-      });
-    },
-    /**
-     * 展开与收起树节点
-     * @param nodeList
-     * @param expanded
-     * @returns
-     */
-    handleBaseTreeExpand: function handleBaseTreeExpand(nodeList, expanded) {
-      var $xeTree = this;
-      var props = $xeTree;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var lazy = props.lazy,
-        accordion = props.accordion,
-        toggleMethod = props.toggleMethod;
-      var treeExpandLazyLoadedMaps = internalData.treeExpandLazyLoadedMaps,
-        treeExpandedMaps = internalData.treeExpandedMaps;
-      var nodeMaps = internalData.nodeMaps;
-      var childrenField = $xeTree.computeChildrenField;
-      var hasChildField = $xeTree.computeHasChildField;
-      var result = [];
-      var validNodes = toggleMethod ? nodeList.filter(function (node) {
-        return toggleMethod({
-          $tree: $xeTree,
-          expanded: expanded,
-          node: node
-        });
-      }) : nodeList;
-      if (accordion) {
-        validNodes = validNodes.length ? [validNodes[validNodes.length - 1]] : [];
-        // 同一级只能展开一个
-        var nodeid = $xeTree.getNodeId(validNodes[0]);
-        var nodeItem = nodeMaps[nodeid];
-        if (nodeItem) {
-          nodeItem.items.forEach(function (item) {
-            var itemNodeId = $xeTree.getNodeId(item);
-            if (treeExpandedMaps[itemNodeId]) {
-              delete treeExpandedMaps[itemNodeId];
-            }
-          });
-        }
-      }
-      var expandNodes = [];
-      if (expanded) {
-        validNodes.forEach(function (item) {
-          var itemNodeId = $xeTree.getNodeId(item);
-          if (!treeExpandedMaps[itemNodeId]) {
-            var _nodeItem = nodeMaps[itemNodeId];
-            var isLoad = lazy && item[hasChildField] && !_nodeItem.treeLoaded && !treeExpandLazyLoadedMaps[itemNodeId];
-            // 是否使用懒加载
-            if (isLoad) {
-              result.push($xeTree.handleAsyncTreeExpandChilds(item));
-            } else {
-              if (item[childrenField] && item[childrenField].length) {
-                treeExpandedMaps[itemNodeId] = true;
-                expandNodes.push(item);
-              }
-            }
-          }
-        });
-      } else {
-        validNodes.forEach(function (item) {
-          var itemNodeId = $xeTree.getNodeId(item);
-          if (treeExpandedMaps[itemNodeId]) {
-            delete treeExpandedMaps[itemNodeId];
-            expandNodes.push(item);
-          }
-        });
-      }
-      reactData.updateExpandedFlag++;
-      $xeTree.handleTreeToList();
-      $xeTree.handleData();
-      return Promise.all(result).then(function () {
-        return $xeTree.recalculate();
-      });
-    },
-    toggleExpandEvent: function toggleExpandEvent(evnt, node) {
-      var $xeTree = this;
-      var props = $xeTree;
-      var internalData = $xeTree.internalData;
-      var lazy = props.lazy;
-      var treeExpandedMaps = internalData.treeExpandedMaps,
-        treeExpandLazyLoadedMaps = internalData.treeExpandLazyLoadedMaps;
-      var nodeid = $xeTree.getNodeId(node);
-      var expanded = !treeExpandedMaps[nodeid];
-      evnt.stopPropagation();
-      if (!lazy || !treeExpandLazyLoadedMaps[nodeid]) {
-        $xeTree.handleBaseTreeExpand([node], expanded);
-      }
-      $xeTree.dispatchEvent('node-expand', {
-        node: node,
-        expanded: expanded
-      }, evnt);
-    },
-    updateCheckboxStatus: function updateCheckboxStatus() {
-      var $xeTree = this;
-      var props = $xeTree;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var transform = props.transform;
-      var selectCheckboxMaps = internalData.selectCheckboxMaps,
-        indeterminateNodeMaps = internalData.indeterminateNodeMaps,
-        afterTreeList = internalData.afterTreeList;
-      var childrenField = $xeTree.computeChildrenField;
-      var mapChildrenField = $xeTree.computeMapChildrenField;
-      var checkboxOpts = $xeTree.computeCheckboxOpts;
-      var checkStrictly = checkboxOpts.checkStrictly,
-        checkMethod = checkboxOpts.checkMethod;
-      if (!checkStrictly) {
-        var childNodeMaps = {};
-        var childNodeList = [];
-        _xeUtils.default.eachTree(afterTreeList, function (node) {
-          var nodeid = $xeTree.getNodeId(node);
-          var childList = node[childrenField];
-          if (childList && childList.length && !childNodeMaps[nodeid]) {
-            childNodeMaps[nodeid] = 1;
-            childNodeList.unshift([node, nodeid, childList]);
-          }
-        }, {
-          children: transform ? mapChildrenField : childrenField
-        });
-        childNodeList.forEach(function (vals) {
-          var node = vals[0];
-          var nodeid = vals[1];
-          var childList = vals[2];
-          var sLen = 0; // 已选
-          var hLen = 0; // 半选
-          var vLen = 0; // 有效子行
-          var cLen = childList.length; // 子行
-          childList.forEach(checkMethod ? function (item) {
-            var childNodeid = $xeTree.getNodeId(item);
-            var isSelect = selectCheckboxMaps[childNodeid];
-            if (checkMethod({
-              $tree: $xeTree,
-              node: item
-            })) {
-              if (isSelect) {
-                sLen++;
-              } else if (indeterminateNodeMaps[childNodeid]) {
-                hLen++;
-              }
-              vLen++;
-            } else {
-              if (isSelect) {
-                sLen++;
-              } else if (indeterminateNodeMaps[childNodeid]) {
-                hLen++;
-              }
-            }
-          } : function (item) {
-            var childNodeid = $xeTree.getNodeId(item);
-            var isSelect = selectCheckboxMaps[childNodeid];
-            if (isSelect) {
-              sLen++;
-            } else if (indeterminateNodeMaps[childNodeid]) {
-              hLen++;
-            }
-            vLen++;
-          });
-          var isSelected = false;
-          if (cLen > 0) {
-            if (vLen > 0) {
-              isSelected = (sLen > 0 || hLen > 0) && sLen >= vLen;
-            } else {
-              // 如果存在子项禁用
-              if (sLen > 0 && sLen >= vLen) {
-                isSelected = true;
-              } else if (selectCheckboxMaps[nodeid]) {
-                isSelected = true;
-              } else {
-                isSelected = false;
-              }
-            }
-          } else {
-            // 如果无子项
-            isSelected = selectCheckboxMaps[nodeid];
-          }
-          var halfSelect = !isSelected && (sLen > 0 || hLen > 0);
-          if (isSelected) {
-            selectCheckboxMaps[nodeid] = node;
-            if (indeterminateNodeMaps[nodeid]) {
-              delete indeterminateNodeMaps[nodeid];
-            }
-          } else {
-            if (selectCheckboxMaps[nodeid]) {
-              delete selectCheckboxMaps[nodeid];
-            }
-            if (halfSelect) {
-              indeterminateNodeMaps[nodeid] = node;
-            } else {
-              if (indeterminateNodeMaps[nodeid]) {
-                delete indeterminateNodeMaps[nodeid];
-              }
-            }
-          }
-        });
-        reactData.updateCheckboxFlag++;
-      }
-    },
-    changeCheckboxEvent: function changeCheckboxEvent(evnt, node) {
-      var $xeTree = this;
-      var props = $xeTree;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      evnt.preventDefault();
-      evnt.stopPropagation();
-      var transform = props.transform;
-      var selectCheckboxMaps = internalData.selectCheckboxMaps,
-        nodeMaps = internalData.nodeMaps;
-      var childrenField = $xeTree.computeChildrenField;
-      var mapChildrenField = $xeTree.computeMapChildrenField;
-      var checkboxOpts = $xeTree.computeCheckboxOpts;
-      var checkStrictly = checkboxOpts.checkStrictly,
-        checkMode = checkboxOpts.checkMode,
-        checkMethod = checkboxOpts.checkMethod;
-      var nodeid = $xeTree.getNodeId(node);
-      var childList = _xeUtils.default.get(node, childrenField);
-      var isExistChild = childList && childList.length > 0;
-      var nodeItem = nodeMaps[nodeid] || {};
-      var nLevel = nodeItem.level;
-      var isDisabled = checkMethod ? !checkMethod({
-        $tree: $xeTree,
-        node: node
-      }) : !handleVisibleOrCheckMode(checkMode, isExistChild, nLevel);
-      if (isDisabled) {
-        return;
-      }
-      var isChecked = false;
-      if (selectCheckboxMaps[nodeid]) {
-        delete selectCheckboxMaps[nodeid];
-      } else {
-        isChecked = true;
-        selectCheckboxMaps[nodeid] = node;
-      }
-      if (!checkStrictly) {
-        _xeUtils.default.eachTree(_xeUtils.default.get(node, transform ? mapChildrenField : childrenField), function (childNode) {
-          var childNodeid = $xeTree.getNodeId(childNode);
-          if (isChecked) {
-            if (!selectCheckboxMaps[childNodeid]) {
-              selectCheckboxMaps[childNodeid] = true;
-            }
-          } else {
-            if (selectCheckboxMaps[childNodeid]) {
-              delete selectCheckboxMaps[childNodeid];
-            }
-          }
-        }, {
-          children: transform ? mapChildrenField : childrenField
-        });
-      }
-      reactData.updateCheckboxFlag++;
-      $xeTree.updateCheckboxStatus();
-      var nodeids = _xeUtils.default.keys(selectCheckboxMaps);
-      var value = nodeids.map(_utils.deModelValue);
-      $xeTree.emitCheckboxMode(value);
-      $xeTree.dispatchEvent('checkbox-change', {
-        node: node,
-        value: value,
-        checked: isChecked
-      }, evnt);
-    },
-    changeCurrentEvent: function changeCurrentEvent(evnt, node) {
-      var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      evnt.preventDefault();
-      var nodeOpts = $xeTree.computeNodeOpts;
-      var currentMethod = nodeOpts.currentMethod,
-        trigger = nodeOpts.trigger;
-      var childrenField = $xeTree.computeChildrenField;
-      var childList = _xeUtils.default.get(node, childrenField);
-      var hasChild = childList && childList.length;
-      var isDisabled = !!currentMethod;
-      if (trigger === 'child') {
-        if (hasChild) {
-          return;
-        }
-      } else if (trigger === 'parent') {
-        if (!hasChild) {
-          return;
-        }
-      }
-      if (currentMethod) {
-        isDisabled = !currentMethod({
-          node: node
-        });
-      }
-      if (isDisabled) {
-        return;
-      }
-      var isChecked = true;
-      reactData.currentNode = node;
-      $xeTree.dispatchEvent('current-change', {
-        node: node,
-        checked: isChecked
-      }, evnt);
-    },
-    changeRadioEvent: function changeRadioEvent(evnt, node) {
-      var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      evnt.preventDefault();
-      evnt.stopPropagation();
-      var nodeMaps = internalData.nodeMaps;
-      var radioOpts = $xeTree.computeRadioOpts;
-      var childrenField = $xeTree.computeChildrenField;
-      var checkMode = radioOpts.checkMode,
-        checkMethod = radioOpts.checkMethod;
-      var nodeid = $xeTree.getNodeId(node);
-      var childList = _xeUtils.default.get(node, childrenField);
-      var isExistChild = childList && childList.length > 0;
-      var nodeItem = nodeMaps[nodeid] || {};
-      var nLevel = nodeItem.level;
-      var isDisabled = checkMethod ? !checkMethod({
-        $tree: $xeTree,
-        node: node
-      }) : !handleVisibleOrCheckMode(checkMode, isExistChild, nLevel);
-      if (isDisabled) {
-        return;
-      }
-      var isChecked = true;
-      var value = (0, _utils.deModelValue)(nodeid);
-      reactData.selectRadioKey = nodeid;
-      $xeTree.emitRadioMode(value);
-      $xeTree.dispatchEvent('radio-change', {
-        node: node,
-        value: value,
-        checked: isChecked
-      }, evnt);
-    },
-    handleGlobalResizeEvent: function handleGlobalResizeEvent() {
-      var $xeTree = this;
-      var el = $xeTree.$refs.refElem;
-      if (!el || !el.clientWidth) {
-        return;
-      }
-      $xeTree.recalculate();
-    },
-    reloadData: function reloadData(data) {
-      var $xeTree = this;
-      return $xeTree.loadData(data || []);
-    },
-    clearCurrentNode: function clearCurrentNode() {
-      var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      reactData.currentNode = null;
-      return $xeTree.$nextTick();
-    },
-    getCurrentNodeId: function getCurrentNodeId() {
-      var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      var currentNode = reactData.currentNode;
-      if (currentNode) {
-        return (0, _utils.deModelValue)($xeTree.getNodeId(currentNode));
-      }
-      return null;
-    },
-    getCurrentNode: function getCurrentNode() {
-      var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var currentNode = reactData.currentNode;
-      var nodeMaps = internalData.nodeMaps;
-      if (currentNode) {
-        var nodeItem = nodeMaps[$xeTree.getNodeId(currentNode)];
-        if (nodeItem) {
-          return nodeItem.item;
-        }
-      }
-      return null;
-    },
-    setCurrentNodeId: function setCurrentNodeId(nodeKey) {
-      var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var nodeMaps = internalData.nodeMaps;
-      var nodeItem = nodeMaps[(0, _utils.enModelValue)(nodeKey)];
-      reactData.currentNode = nodeItem ? nodeItem.item : null;
-      return $xeTree.$nextTick();
-    },
-    setCurrentNode: function setCurrentNode(node) {
-      var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      reactData.currentNode = node;
-      return $xeTree.$nextTick();
-    },
-    clearRadioNode: function clearRadioNode() {
-      var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      reactData.selectRadioKey = null;
-      $xeTree.emitRadioMode(null);
-      return $xeTree.$nextTick();
-    },
-    getRadioNodeId: function getRadioNodeId() {
-      var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      return reactData.selectRadioKey || null;
-    },
-    getRadioNode: function getRadioNode() {
-      var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var selectRadioKey = reactData.selectRadioKey;
-      var nodeMaps = internalData.nodeMaps;
-      if (selectRadioKey) {
-        var nodeItem = nodeMaps[selectRadioKey];
-        if (nodeItem) {
-          return nodeItem.item;
-        }
-      }
-      return null;
-    },
-    setRadioNodeId: function setRadioNodeId(nodeKey) {
-      var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      reactData.selectRadioKey = (0, _utils.enModelValue)(nodeKey);
-      $xeTree.emitRadioMode(nodeKey);
-      return $xeTree.$nextTick();
-    },
-    getCheckboxNodeIds: function getCheckboxNodeIds() {
-      var $xeTree = this;
-      var internalData = $xeTree.internalData;
-      var selectCheckboxMaps = internalData.selectCheckboxMaps;
-      var nodeKeys = [];
-      _xeUtils.default.each(selectCheckboxMaps, function (item, nodeId) {
-        nodeKeys.push((0, _utils.deModelValue)(nodeId));
-      });
-      return nodeKeys;
-    },
-    getCheckboxNodes: function getCheckboxNodes() {
-      var $xeTree = this;
-      var internalData = $xeTree.internalData;
-      var nodeMaps = internalData.nodeMaps,
-        selectCheckboxMaps = internalData.selectCheckboxMaps;
-      var list = [];
-      _xeUtils.default.each(selectCheckboxMaps, function (item, nodeid) {
-        var nodeItem = nodeMaps[nodeid];
-        if (nodeItem) {
-          list.push(nodeItem.item);
-        }
-      });
-      return list;
-    },
-    clearCheckboxNode: function clearCheckboxNode() {
-      var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      internalData.indeterminateNodeMaps = {};
-      internalData.selectCheckboxMaps = {};
-      reactData.updateCheckboxFlag++;
-      $xeTree.updateCheckboxStatus();
-      $xeTree.emitCheckboxMode([]);
-      return $xeTree.$nextTick().then(function () {
-        return {
-          checkNodeKeys: [],
-          checkNodes: []
-        };
-      });
-    },
-    setAllCheckboxNode: function setAllCheckboxNode(checked) {
-      var $xeTree = this;
-      var props = $xeTree;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var transform = props.transform;
-      var selectMaps = {};
-      var childrenField = $xeTree.computeChildrenField;
-      var mapChildrenField = $xeTree.computeMapChildrenField;
-      var checkKeys = [];
-      var checkNodes = [];
-      if (checked) {
-        _xeUtils.default.eachTree(internalData.afterTreeList, function (node) {
-          var nodeid = $xeTree.getNodeId(node);
-          checkKeys.push(nodeid);
-          checkNodes.push(node);
-          selectMaps[nodeid] = true;
-        }, {
-          children: transform ? mapChildrenField : childrenField
-        });
-      }
-      internalData.indeterminateNodeMaps = {};
-      internalData.selectCheckboxMaps = selectMaps;
-      reactData.updateCheckboxFlag++;
-      $xeTree.updateCheckboxStatus();
-      return $xeTree.$nextTick().then(function () {
-        return {
-          checkNodeKeys: checkKeys,
-          checkNodes: checkNodes
-        };
-      });
-    },
-    clearExpandNode: function clearExpandNode() {
-      var $xeTree = this;
-      return $xeTree.clearAllExpandNode();
-    },
-    clearAllExpandNode: function clearAllExpandNode() {
-      var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var scrollYLoad = reactData.scrollYLoad;
-      var nodeMaps = internalData.nodeMaps,
-        scrollYStore = internalData.scrollYStore;
-      _xeUtils.default.each(nodeMaps, function (nodeItem) {
-        nodeItem.treeLoaded = false;
-      });
-      internalData.treeExpandedMaps = {};
-      reactData.updateExpandedFlag++;
-      reactData.topSpaceHeight = 0;
-      scrollYStore.startIndex = 0;
-      scrollYStore.endIndex = 1;
-      $xeTree.handleTreeToList();
-      $xeTree.handleData();
-      return $xeTree.recalculate().then(function () {
-        if (scrollYLoad) {
-          $xeTree.loadYData();
-        }
-        return $xeTree.recalculate();
-      });
-    },
-    setExpandByNodeId: function setExpandByNodeId(nodeKeys, expanded) {
-      var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var treeExpandedMaps = internalData.treeExpandedMaps;
-      if (nodeKeys) {
-        if (!_xeUtils.default.isArray(nodeKeys)) {
-          nodeKeys = [nodeKeys];
-        }
-        nodeKeys.forEach(function (nodeKey) {
-          var nodeid = (0, _utils.enModelValue)(nodeKey);
-          handleSetExpand(nodeid, expanded, treeExpandedMaps);
-        });
-        reactData.updateExpandedFlag++;
-      }
-      $xeTree.handleTreeToList();
-      $xeTree.handleData();
-      return $xeTree.recalculate();
-    },
-    getExpandNodeIds: function getExpandNodeIds() {
-      var $xeTree = this;
-      var internalData = $xeTree.internalData;
-      var treeExpandedMaps = internalData.treeExpandedMaps;
-      var nodeKeys = [];
-      _xeUtils.default.each(treeExpandedMaps, function (item, nodeId) {
-        nodeKeys.push((0, _utils.deModelValue)(nodeId));
-      });
-      return nodeKeys;
-    },
-    getExpandNodes: function getExpandNodes() {
-      var $xeTree = this;
-      var internalData = $xeTree.internalData;
-      var nodeMaps = internalData.nodeMaps,
-        treeExpandedMaps = internalData.treeExpandedMaps;
-      var list = [];
-      _xeUtils.default.each(treeExpandedMaps, function (item, nodeid) {
-        var nodeItem = nodeMaps[nodeid];
-        if (nodeItem) {
-          list.push(nodeItem.item);
-        }
-      });
-      return list;
-    },
-    setExpandNode: function setExpandNode(nodes, expanded) {
-      var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var treeExpandedMaps = internalData.treeExpandedMaps;
-      if (nodes) {
-        if (!_xeUtils.default.isArray(nodes)) {
-          nodes = [nodes];
-        }
-        nodes.forEach(function (node) {
-          var nodeid = $xeTree.getNodeId(node);
-          handleSetExpand(nodeid, expanded, treeExpandedMaps);
-        });
-        reactData.updateExpandedFlag++;
-      }
-      $xeTree.handleTreeToList();
-      $xeTree.handleData();
-      return $xeTree.recalculate();
-    },
-    toggleExpandByNodeId: function toggleExpandByNodeId(nodeKeys) {
-      var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var treeExpandedMaps = internalData.treeExpandedMaps;
-      if (nodeKeys) {
-        if (!_xeUtils.default.isArray(nodeKeys)) {
-          nodeKeys = [nodeKeys];
-        }
-        nodeKeys.forEach(function (nodeKey) {
-          var nodeid = (0, _utils.enModelValue)(nodeKey);
-          handleSetExpand(nodeid, !treeExpandedMaps["".concat(nodeid)], treeExpandedMaps);
-        });
-        reactData.updateExpandedFlag++;
-      }
-      $xeTree.handleTreeToList();
-      $xeTree.handleData();
-      return $xeTree.recalculate();
-    },
-    toggleExpandNode: function toggleExpandNode(nodes) {
-      var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var treeExpandedMaps = internalData.treeExpandedMaps;
-      if (nodes) {
-        if (!_xeUtils.default.isArray(nodes)) {
-          nodes = [nodes];
-        }
-        nodes.forEach(function (node) {
-          var nodeid = $xeTree.getNodeId(node);
-          handleSetExpand(nodeid, !treeExpandedMaps[nodeid], treeExpandedMaps);
-        });
-        reactData.updateExpandedFlag++;
-      }
-      $xeTree.handleTreeToList();
-      $xeTree.handleData();
-      return $xeTree.recalculate();
-    },
-    setAllExpandNode: function setAllExpandNode(expanded) {
-      var $xeTree = this;
-      var props = $xeTree;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var transform = props.transform;
-      var scrollYLoad = reactData.scrollYLoad;
-      var scrollYStore = internalData.scrollYStore,
-        treeExpandedMaps = internalData.treeExpandedMaps;
-      var childrenField = $xeTree.computeChildrenField;
-      var mapChildrenField = $xeTree.computeMapChildrenField;
-      if (expanded) {
-        _xeUtils.default.eachTree(internalData.afterTreeList, function (node) {
-          var childList = _xeUtils.default.get(node, childrenField);
-          var hasChild = childList && childList.length;
-          if (hasChild) {
-            var nodeid = $xeTree.getNodeId(node);
-            treeExpandedMaps[nodeid] = true;
-          }
-        }, {
-          children: transform ? mapChildrenField : childrenField
-        });
-      } else {
-        internalData.treeExpandedMaps = {};
-      }
-      reactData.updateExpandedFlag++;
-      reactData.topSpaceHeight = 0;
-      scrollYStore.startIndex = 0;
-      scrollYStore.endIndex = 1;
-      $xeTree.handleTreeToList();
-      $xeTree.handleData();
-      return $xeTree.recalculate().then(function () {
-        if (scrollYLoad) {
-          $xeTree.loadYData();
-        }
-        return $xeTree.recalculate();
-      });
-    },
-    reloadExpandNode: function reloadExpandNode(node) {
-      var $xeTree = this;
-      var props = $xeTree;
-      var lazy = props.lazy;
-      if (lazy) {
-        $xeTree.clearExpandLoaded(node);
-        return $xeTree.handleAsyncTreeExpandChilds(node);
-      }
-      return $xeTree.recalculate();
-    },
-    clearExpandLoaded: function clearExpandLoaded(node) {
-      var $xeTree = this;
-      var props = $xeTree;
-      var internalData = $xeTree.internalData;
-      var lazy = props.lazy;
-      var nodeMaps = internalData.nodeMaps;
-      if (lazy) {
-        var nodeItem = nodeMaps[$xeTree.getNodeId(node)];
-        if (nodeItem) {
-          nodeItem.treeLoaded = false;
-        }
-      }
-      return $xeTree.recalculate();
-    },
-    /**
-     * 用于树结构，给行数据加载子节点
-     */
-    loadChildrenNode: function loadChildrenNode(node, childRecords) {
-      var $xeTree = this;
-      var props = $xeTree;
-      var internalData = $xeTree.internalData;
-      var lazy = props.lazy,
-        transform = props.transform;
-      var nodeMaps = internalData.nodeMaps;
-      if (!lazy) {
-        return Promise.resolve([]);
-      }
-      var childrenField = $xeTree.computeChildrenField;
-      var mapChildrenField = $xeTree.computeMapChildrenField;
-      var parentNodeItem = nodeMaps[$xeTree.getNodeId(node)];
-      var parentLevel = parentNodeItem ? parentNodeItem.level : 0;
-      var parentNodes = parentNodeItem ? parentNodeItem.nodes : [];
-      return $xeTree.createNode(childRecords).then(function (nodeList) {
-        _xeUtils.default.eachTree(nodeList, function (childNode, index, items, path, parent, nodes) {
-          var itemNodeId = $xeTree.getNodeId(childNode);
-          nodeMaps[itemNodeId] = {
-            item: childNode,
-            index: -1,
-            $index: -1,
-            _index: -1,
-            items: items,
-            parent: parent || parentNodeItem.item,
-            nodes: parentNodes.concat(nodes),
-            level: parentLevel + nodes.length,
-            treeIndex: -1,
-            lineCount: 0,
-            treeLoaded: false
-          };
-        }, {
-          children: childrenField
-        });
-        node[childrenField] = nodeList;
-        if (transform) {
-          node[mapChildrenField] = nodeList;
-        }
-        $xeTree.updateAfterDataIndex();
-        return nodeList;
-      });
-    },
-    findNodeIndexOf: function findNodeIndexOf(list, node) {
-      var $xeTree = this;
-      return node ? _xeUtils.default.findIndexOf(list, function (item) {
-        return $xeTree.eqNode(item, node);
-      }) : -1;
-    },
-    eqNode: function eqNode(node1, node2) {
-      var $xeTree = this;
-      if (node1 && node2) {
-        if (node1 === node2) {
-          return true;
-        }
-        return $xeTree.getNodeId(node1) === $xeTree.getNodeId(node2);
-      }
-      return false;
-    },
-    handleCrossTreeNodeDragCancelEvent: function handleCrossTreeNodeDragCancelEvent() {
-      var $xeTree = this;
-      clearNodeDragData($xeTree);
-      clearCrossTreeDragStatus($xeTree);
-    },
-    /**
-       * 处理跨树拖拽完成
-       */
-    handleCrossTreeNodeDragFinishEvent: function handleCrossTreeNodeDragFinishEvent(evnt) {
-      var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var crossTreeDragNodeInfo = (0, _store.getCrossTreeDragNodeInfo)($xeTree);
-      var treeList = reactData.treeList;
-      var nodeMaps = internalData.nodeMaps;
-      var dragOpts = $xeTree.computeDragOpts;
-      var animation = dragOpts.animation,
-        isCrossTreeDrag = dragOpts.isCrossTreeDrag;
-      var mapChildrenField = $xeTree.computeMapChildrenField;
-      var el = $xeTree.$refs.refElem;
-      if (!el) {
-        return;
-      }
-      if (isCrossTreeDrag && crossTreeDragNodeObj && crossTreeDragNodeInfo) {
-        var dragNode = crossTreeDragNodeInfo.node;
-        if (dragNode) {
-          var dragNodeid = $xeTree.getNodeId(dragNode);
-          var dragNodeRest = nodeMaps[dragNodeid];
-          var dragNodeHeight = 0;
-          var rsIndex = -1;
-          if (dragNodeRest) {
-            if (animation) {
-              var oldItemEl = el.querySelector(".vxe-tree--node-wrapper[nodeid=\"".concat(dragNodeid, "\"]"));
-              var targetItemEl = oldItemEl;
-              if (targetItemEl) {
-                dragNodeHeight = targetItemEl.offsetHeight;
-              }
-            }
-            rsIndex = dragNodeRest.$index;
-          }
-          var dragRangeList = rsIndex > -1 && rsIndex < treeList.length - 1 ? treeList.slice(rsIndex + 1) : [];
-          var dragList = _xeUtils.default.toTreeArray([dragNode], {
-            updated: true,
-            children: mapChildrenField
-          });
-          $xeTree.remove(dragList).then(function () {
-            if (animation && dragNodeHeight && dragRangeList.length) {
-              var wrapperEl = el;
-              var dtClss = [];
-              dragRangeList.forEach(function (item) {
-                var nodeid = $xeTree.getNodeId(item);
-                dtClss.push(".vxe-tree--node-wrapper[nodeid=\"".concat(nodeid, "\"]"));
-              });
-              var dtTrList = wrapperEl.querySelectorAll(dtClss.join(','));
-              (0, _anime.moveRowAnimateToTb)(dtTrList, dragNodeHeight);
-            }
-          });
-          $xeTree.dispatchEvent('node-remove-dragend', {
-            node: dragNode
-          }, evnt);
-          handleNodeDragEndClearStatus($xeTree);
-        }
-      }
-    },
-    /**
-     * 处理跨树拖至新的空树
-     */
-    handleCrossTreeNodeDragoverEmptyEvent: function handleCrossTreeNodeDragoverEmptyEvent(evnt) {
-      var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var treeList = reactData.treeList;
-      var dragOpts = $xeTree.computeDragOpts;
-      var isCrossTreeDrag = dragOpts.isCrossTreeDrag;
-      if (isCrossTreeDrag && crossTreeDragNodeObj && !treeList.length) {
-        var _crossTreeDragNodeObj = crossTreeDragNodeObj,
-          $oldTree = _crossTreeDragNodeObj.$oldTree,
-          $newTree = _crossTreeDragNodeObj.$newTree;
-        if ($oldTree) {
-          var oldTreeReactData = $oldTree;
-          if ($oldTree.xID !== $xeTree.xID) {
-            if ($newTree && $newTree.xID !== $xeTree.xID) {
-              $newTree.hideCrossTreeNodeDropClearStatus();
-            }
-            evnt.preventDefault();
-            $oldTree.hideCrossTreeNodeDropClearStatus();
-            crossTreeDragNodeObj.$newTree = $xeTree;
-            internalData.prevDragNode = null;
-            reactData.dragTipText = oldTreeReactData.dragTipText;
-            showDropTip($xeTree, evnt, evnt.currentTarget, true, '');
-          }
-        }
-      }
-    },
-    /**
-     * 处理跨树拖插入
-     */
-    handleCrossTreeNodeDragInsertEvent: function handleCrossTreeNodeDragInsertEvent(evnt) {
-      var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var crossTreeDragNodeInfo = (0, _store.getCrossTreeDragNodeInfo)($xeTree);
-      var prevDragNode = internalData.prevDragNode,
-        prevDragPos = internalData.prevDragPos,
-        prevDragToChild = internalData.prevDragToChild;
-      var dragOpts = $xeTree.computeDragOpts;
-      var animation = dragOpts.animation,
-        isSelfToChildDrag = dragOpts.isSelfToChildDrag,
-        isCrossTreeDrag = dragOpts.isCrossTreeDrag,
-        dragEndMethod = dragOpts.dragEndMethod,
-        dragToChildMethod = dragOpts.dragToChildMethod;
-      var parentField = $xeTree.computeParentField;
-      var mapChildrenField = $xeTree.computeMapChildrenField;
-      var childrenField = $xeTree.computeChildrenField;
-      // 跨表拖拽
-      if (isCrossTreeDrag && crossTreeDragNodeObj && crossTreeDragNodeInfo) {
-        var oldNode = crossTreeDragNodeInfo.node;
-        var _crossTreeDragNodeObj2 = crossTreeDragNodeObj,
-          $oldTree = _crossTreeDragNodeObj2.$oldTree;
-        var el = $xeTree.$refs.refElem;
-        if (!el) {
-          return;
-        }
-        if ($oldTree && oldNode) {
-          var dragNode = oldNode;
-          var dragOffsetIndex = -1;
-          if (prevDragNode) {
-            dragOffsetIndex = prevDragPos === 'bottom' ? 1 : 0;
-          }
-          var dragParams = {
-            oldNode: dragNode,
-            newNode: prevDragNode,
-            dragNode: dragNode,
-            dragPos: prevDragPos,
-            dragToChild: !!prevDragToChild,
-            offsetIndex: dragOffsetIndex
-          };
-          var isDragToChildFlag = isSelfToChildDrag && dragToChildMethod ? dragToChildMethod(dragParams) : prevDragToChild;
-          var errRest = {
-            status: false
-          };
-          Promise.resolve(dragEndMethod ? dragEndMethod(dragParams) : true).then(function (status) {
-            if (!status) {
-              if ($oldTree) {
-                if ($oldTree.xID !== $xeTree.xID) {
-                  $oldTree.handleCrossTreeNodeDragCancelEvent(evnt);
-                }
-              }
-              handleNodeDragEndClearStatus($xeTree);
-              return errRest;
-            }
-            var insertRest = Promise.resolve();
-            var dragList = _xeUtils.default.toTreeArray([dragNode], {
-              updated: true,
-              children: mapChildrenField
-            });
-            $oldTree.handleCrossTreeNodeDragFinishEvent(evnt);
-            if (prevDragNode) {
-              dragNode[parentField] = prevDragNode[parentField];
-            } else {
-              dragNode[parentField] = null;
-            }
-            dragList.forEach(function (item) {
-              item[childrenField] = undefined;
-              item[mapChildrenField] = undefined;
-            });
-            if (prevDragNode) {
-              if (prevDragPos === 'bottom') {
-                insertRest = $xeTree.insertNextAt(dragList, prevDragNode);
-              } else {
-                insertRest = $xeTree.insertAt(dragList, prevDragNode);
-              }
-            } else {
-              insertRest = $xeTree.insert(dragList);
-            }
-            $xeTree.dispatchEvent('node-insert-dragend', {
-              oldNode: oldNode,
-              newNode: prevDragNode,
-              dragNode: dragNode,
-              dragPos: prevDragPos,
-              dragToChild: isDragToChildFlag,
-              offsetIndex: dragOffsetIndex
-            }, evnt);
-            clearNodeDragData($xeTree);
-            insertRest.then(function () {
-              var treeList = reactData.treeList;
-              var nodeMaps = internalData.nodeMaps;
-              var oldNodeid = $xeTree.getNodeId(dragNode);
-              var oldNodeRest = nodeMaps[oldNodeid];
-              var dragNodeHeight = 0;
-              var rsIndex = -1;
-              if (oldNodeRest) {
-                if (animation) {
-                  var oldItemEl = el.querySelector(".vxe-tree--node-wrapper[nodeid=\"".concat(oldNodeid, "\"]"));
-                  var targetItemEl = oldItemEl;
-                  if (targetItemEl) {
-                    dragNodeHeight = targetItemEl.offsetHeight;
-                  }
-                }
-                rsIndex = oldNodeRest.$index;
-              }
-              var dragRangeList = rsIndex > -1 ? treeList.slice(rsIndex) : [];
-              if (animation && dragNodeHeight && dragRangeList.length) {
-                var wrapperEl = el;
-                var dtClss = [];
-                dragRangeList.forEach(function (item) {
-                  var nodeid = $xeTree.getNodeId(item);
-                  dtClss.push(".vxe-tree--node-wrapper[nodeid=\"".concat(nodeid, "\"]"));
-                });
-                var dtTrList = wrapperEl.querySelectorAll(dtClss.join(','));
-                (0, _anime.moveRowAnimateToTb)(dtTrList, -dragNodeHeight);
-              }
-            });
-          });
-        }
-      }
-    },
-    hideCrossTreeNodeDropClearStatus: function hideCrossTreeNodeDropClearStatus() {
-      var $xeTree = this;
-      hideDropTip($xeTree);
-    },
-    getCheckboxIndeterminateNodes: function getCheckboxIndeterminateNodes() {
-      var $xeTree = this;
-      var internalData = $xeTree.internalData;
-      var nodeMaps = internalData.nodeMaps,
-        indeterminateNodeMaps = internalData.indeterminateNodeMaps;
-      var list = [];
-      _xeUtils.default.each(indeterminateNodeMaps, function (item, nodeid) {
-        var nodeItem = nodeMaps[nodeid];
-        if (nodeItem) {
-          list.push(nodeItem.item);
-        }
-      });
-      return list;
-    },
-    handleNodeDragMousedownEvent: function handleNodeDragMousedownEvent(evnt, params) {
-      var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      var crossTreeDragNodeInfo = (0, _store.getCrossTreeDragNodeInfo)($xeTree);
-      evnt.stopPropagation();
-      var node = params.node;
-      var dragConfig = $xeTree.computeDragOpts;
-      var isCrossTreeDrag = dragConfig.isCrossTreeDrag,
-        trigger = dragConfig.trigger,
-        dragStartMethod = dragConfig.dragStartMethod;
-      var dragEl = evnt.currentTarget;
-      var itemEl = trigger === 'node' ? dragEl : dragEl.parentElement.parentElement;
-      clearNodeDropOrigin($xeTree);
-      if (dragStartMethod && !dragStartMethod(params)) {
-        itemEl.draggable = false;
-        reactData.dragNode = null;
-        hideDropTip($xeTree);
-        return;
-      }
-      if (isCrossTreeDrag) {
-        crossTreeDragNodeInfo.node = node;
-        crossTreeDragNodeObj = {
-          $oldTree: $xeTree,
-          $newTree: null
-        };
-      }
-      reactData.dragNode = node;
-      reactData.isCrossDragNode = false;
-      itemEl.draggable = true;
-      updateNodeDropOrigin($xeTree, node);
-      updateNodeDropTipContent($xeTree, itemEl);
-      $xeTree.dispatchEvent('node-dragstart', params, evnt);
-    },
-    handleNodeDragMouseupEvent: function handleNodeDragMouseupEvent() {
-      var $xeTree = this;
-      clearDragStatus($xeTree);
-    },
-    handleNodeDragDragstartEvent: function handleNodeDragDragstartEvent(evnt) {
-      if (evnt.dataTransfer) {
-        evnt.dataTransfer.setDragImage((0, _dom.getTpImg)(), 0, 0);
-      }
-    },
-    handleNodeDragDragendEvent: function handleNodeDragDragendEvent(evnt) {
-      var $xeTree = this;
-      var props = $xeTree;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var lazy = props.lazy;
-      var dragNode = reactData.dragNode;
-      var nodeMaps = internalData.nodeMaps,
-        prevDragNode = internalData.prevDragNode,
-        prevDragPos = internalData.prevDragPos,
-        prevDragToChild = internalData.prevDragToChild;
-      var hasChildField = $xeTree.computeHasChildField;
-      var dragConfig = $xeTree.computeDragOpts;
-      var isCrossDrag = dragConfig.isCrossDrag,
-        isCrossTreeDrag = dragConfig.isCrossTreeDrag;
-      // 跨树拖拽
-      if (isCrossTreeDrag && crossTreeDragNodeObj) {
-        var _crossTreeDragNodeObj3 = crossTreeDragNodeObj,
-          $newTree = _crossTreeDragNodeObj3.$newTree;
-        if ($newTree && $newTree.xID !== $xeTree.xID) {
-          if (isCrossDrag) {
-            $newTree.handleCrossTreeNodeDragInsertEvent(evnt);
-          }
-          return;
-        }
-      }
-      if (lazy && prevDragToChild) {
-        // 懒加载
-        var newNodeid = $xeTree.getNodeId(prevDragNode);
-        var nodeRest = nodeMaps[newNodeid];
-        if (prevDragNode[hasChildField]) {
-          if (nodeRest && nodeRest.treeLoaded) {
-            handleNodeDragSwapEvent($xeTree, evnt, dragNode, prevDragNode, prevDragPos, prevDragToChild);
-          }
-        } else {
-          handleNodeDragSwapEvent($xeTree, evnt, dragNode, prevDragNode, prevDragPos, prevDragToChild);
-        }
-      } else {
-        handleNodeDragSwapEvent($xeTree, evnt, dragNode, prevDragNode, prevDragPos, prevDragToChild);
-      }
-    },
-    handleNodeDragDragoverEvent: function handleNodeDragDragoverEvent(evnt) {
-      var $xeTree = this;
-      var props = $xeTree;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var lazy = props.lazy,
-        transform = props.transform;
-      var dragNode = reactData.dragNode;
-      var nodeMaps = internalData.nodeMaps;
-      var dragConfig = $xeTree.computeDragOpts;
-      var parentField = $xeTree.computeParentField;
-      var hasChildField = $xeTree.computeHasChildField;
-      var isCrossTreeDrag = dragConfig.isCrossTreeDrag,
-        isCrossDrag = dragConfig.isCrossDrag,
-        isPeerDrag = dragConfig.isPeerDrag,
-        isToChildDrag = dragConfig.isToChildDrag;
-      if (!dragNode && !isCrossDrag) {
-        evnt.preventDefault();
-      }
-      var isControlKey = (0, _dom.hasControlKey)(evnt);
-      var itemEl = evnt.currentTarget;
-      var nodeid = itemEl.getAttribute('nodeid') || '';
-      var nodeItem = nodeMaps[nodeid];
-      if (nodeItem) {
-        evnt.preventDefault();
-        var node = nodeItem.item;
-        var offsetY = evnt.clientY - itemEl.getBoundingClientRect().y;
-        var dragPos = offsetY < itemEl.clientHeight / 2 ? 'top' : 'bottom';
-        internalData.prevDragToChild = !!(transform && isCrossDrag && isToChildDrag && isControlKey);
-        internalData.prevDragNode = node;
-        internalData.prevDragPos = dragPos;
-        // 跨树拖拽
-        if (isCrossTreeDrag && isCrossDrag && crossTreeDragNodeObj) {
-          var _crossTreeDragNodeObj4 = crossTreeDragNodeObj,
-            $oldTree = _crossTreeDragNodeObj4.$oldTree,
-            $newTree = _crossTreeDragNodeObj4.$newTree;
-          if ($oldTree) {
-            var oldTreeReactData = $oldTree.reactData;
-            if ($oldTree.xID === $xeTree.xID) {
-              if ($newTree) {
-                $newTree.hideCrossTreeNodeDropClearStatus();
-              }
-              reactData.isCrossDragNode = false;
-              oldTreeReactData.isCrossDragNode = false;
-              crossTreeDragNodeObj.$newTree = null;
-            } else if (isCrossDrag) {
-              if ($newTree && $newTree.xID !== $xeTree.xID) {
-                $newTree.hideCrossTreeNodeDropClearStatus();
-              }
-              $oldTree.hideCrossTreeNodeDropClearStatus();
-              oldTreeReactData.isCrossDragNode = true;
-              reactData.dragTipText = oldTreeReactData.dragTipText;
-              crossTreeDragNodeObj.$newTree = $xeTree;
-              showDropTip($xeTree, evnt, itemEl, true, dragPos);
-              return;
-            }
-          }
-        }
-        if (dragNode && $xeTree.getNodeId(dragNode) === nodeid || isControlKey && lazy && node[hasChildField] && nodeItem && !nodeItem.treeLoaded || !isCrossDrag && transform && (isPeerDrag ? dragNode[parentField] !== node[parentField] : nodeItem.level)) {
-          showDropTip($xeTree, evnt, itemEl, false, dragPos);
-          return;
-        }
-        showDropTip($xeTree, evnt, itemEl, true, dragPos);
-        $xeTree.dispatchEvent('node-dragover', {
-          oldRNode: dragNode,
-          targetNode: node,
-          dragPos: dragPos
-        }, evnt);
-      }
-    },
-    //
-    // Render
-    //
-    renderDragIcon: function renderDragIcon(h, node, nodeid) {
-      var $xeTree = this;
-      var props = $xeTree;
-      var internalData = $xeTree.internalData;
-      var drag = props.drag,
-        transform = props.transform;
-      var nodeMaps = internalData.nodeMaps;
-      var dragOpts = $xeTree.computeDragOpts;
-      var showIcon = dragOpts.showIcon,
-        isPeerDrag = dragOpts.isPeerDrag,
-        isCrossDrag = dragOpts.isCrossDrag,
-        visibleMethod = dragOpts.visibleMethod;
-      var params = {
-        node: node,
-        $tree: $xeTree
-      };
-      if (drag && showIcon && transform && (!visibleMethod || visibleMethod(params))) {
-        var nodeItem = nodeMaps[nodeid];
-        if (nodeItem && (isPeerDrag || isCrossDrag || !nodeItem.level)) {
-          var dragConfig = $xeTree.computeDragOpts;
-          var icon = dragConfig.icon,
-            trigger = dragConfig.trigger,
-            disabledMethod = dragConfig.disabledMethod;
-          var isDisabled = disabledMethod && disabledMethod(params);
-          var ons = {};
-          if (trigger !== 'node') {
-            ons.mousedown = function (evnt) {
-              if (!isDisabled) {
-                $xeTree.handleNodeDragMousedownEvent(evnt, params);
-              }
-            };
-            ons.mouseup = $xeTree.handleNodeDragMouseupEvent;
-          }
-          return h('div', {
-            class: ['vxe-tree--drag-handle', {
-              'is--disabled': isDisabled
-            }],
-            on: ons
-          }, [h('i', {
-            class: icon || getIcon().TREE_DRAG
-          })]);
-        }
-      }
-      return (0, _ui.renderEmptyElement)($xeTree);
-    },
-    renderRadio: function renderRadio(h, node, nodeid, isExistChild, nLevel, isChecked) {
-      var $xeTree = this;
-      var props = $xeTree;
-      var showRadio = props.showRadio;
-      var radioOpts = $xeTree.computeRadioOpts;
-      var showIcon = radioOpts.showIcon,
-        checkMode = radioOpts.checkMode,
-        checkMethod = radioOpts.checkMethod,
-        visibleMode = radioOpts.visibleMode,
-        visibleMethod = radioOpts.visibleMethod;
-      var isVisible = visibleMethod ? visibleMethod({
-        $tree: $xeTree,
-        node: node
-      }) : handleVisibleOrCheckMode(visibleMode, isExistChild, nLevel);
-      if (showRadio && showIcon && isVisible) {
-        var isDisabled = checkMethod ? !checkMethod({
-          $tree: $xeTree,
-          node: node
-        }) : !handleVisibleOrCheckMode(checkMode, isExistChild, nLevel);
-        return h('div', {
-          class: ['vxe-tree--radio-option', {
-            'is--checked': isChecked,
-            'is--disabled': isDisabled
-          }],
-          on: {
-            click: function click(evnt) {
-              if (!isDisabled) {
-                $xeTree.changeRadioEvent(evnt, node);
-              }
-            }
-          }
-        }, [h('span', {
-          class: ['vxe-radio--icon', isChecked ? getIcon().RADIO_CHECKED : getIcon().RADIO_UNCHECKED]
-        })]);
-      }
-      return (0, _ui.renderEmptyElement)($xeTree);
-    },
-    renderCheckbox: function renderCheckbox(h, node, nodeid, isExistChild, nLevel, isChecked, isIndeterminate) {
-      var $xeTree = this;
-      var props = $xeTree;
-      var showCheckbox = props.showCheckbox;
-      var checkboxOpts = $xeTree.computeCheckboxOpts;
-      var showIcon = checkboxOpts.showIcon,
-        checkMode = checkboxOpts.checkMode,
-        checkMethod = checkboxOpts.checkMethod,
-        visibleMode = checkboxOpts.visibleMode,
-        visibleMethod = checkboxOpts.visibleMethod;
-      var isVisible = visibleMethod ? visibleMethod({
-        $tree: $xeTree,
-        node: node
-      }) : handleVisibleOrCheckMode(visibleMode, isExistChild, nLevel);
-      if (showCheckbox && showIcon && isVisible) {
-        var isDisabled = checkMethod ? !checkMethod({
-          $tree: $xeTree,
-          node: node
-        }) : !handleVisibleOrCheckMode(checkMode, isExistChild, nLevel);
-        return h('div', {
-          class: ['vxe-tree--checkbox-option', {
-            'is--checked': isChecked,
-            'is--indeterminate': isIndeterminate,
-            'is--disabled': isDisabled
-          }],
-          on: {
-            click: function click(evnt) {
-              if (!isDisabled) {
-                $xeTree.changeCheckboxEvent(evnt, node);
-              }
-            }
-          }
-        }, [h('span', {
-          class: ['vxe-checkbox--icon', isIndeterminate ? getIcon().CHECKBOX_INDETERMINATE : isChecked ? getIcon().CHECKBOX_CHECKED : getIcon().CHECKBOX_UNCHECKED]
-        })]);
-      }
-      return (0, _ui.renderEmptyElement)($xeTree);
-    },
-    renderNode: function renderNode(h, node, nodeid) {
-      var $xeTree = this;
-      var props = $xeTree;
-      var slots = $xeTree.$scopedSlots;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var lazy = props.lazy,
-        drag = props.drag,
-        transform = props.transform,
-        showRadio = props.showRadio,
-        showCheckbox = props.showCheckbox,
-        showLine = props.showLine,
-        visibleMethod = props.visibleMethod,
-        iconOpen = props.iconOpen,
-        iconClose = props.iconClose,
-        iconLoaded = props.iconLoaded,
-        showIcon = props.showIcon;
-      var currentNode = reactData.currentNode,
-        selectRadioKey = reactData.selectRadioKey,
-        updateExpandedFlag = reactData.updateExpandedFlag;
-      var afterTreeList = internalData.afterTreeList,
-        nodeMaps = internalData.nodeMaps,
-        treeExpandedMaps = internalData.treeExpandedMaps,
-        treeExpandLazyLoadedMaps = internalData.treeExpandLazyLoadedMaps;
-      var tooltipOpts = $xeTree.computeTooltipOpts;
-      var tipMode = tooltipOpts.mode;
-      var childrenField = $xeTree.computeChildrenField;
-      var titleField = $xeTree.computeTitleField;
-      var hasChildField = $xeTree.computeHasChildField;
-      var childList = _xeUtils.default.get(node, childrenField);
-      var isExistChild = childList && childList.length > 0;
-      var iconSlot = slots.icon;
-      var titleSlot = slots.title;
-      var extraSlot = slots.extra;
-      var isExpand = updateExpandedFlag && treeExpandedMaps[nodeid];
-      var nodeItem = nodeMaps[nodeid] || {};
-      var nodeTitle = (0, _utils.getText)(_xeUtils.default.get(node, titleField));
-      var nLevel = nodeItem.level;
-      var isRadioChecked = false;
-      if (showRadio) {
-        isRadioChecked = nodeid === String(selectRadioKey);
-      }
-      var isCheckboxChecked = false;
-      var isIndeterminate = false;
-      if (showCheckbox) {
-        isCheckboxChecked = $xeTree.isCheckedByCheckboxNodeId(nodeid);
-        isIndeterminate = $xeTree.isIndeterminateByCheckboxNodeid(nodeid);
-      }
-      var hasLazyChilds = false;
-      var isLazyLoading = false;
-      var isLazyLoaded = false;
-      if (lazy) {
-        isLazyLoading = !!treeExpandLazyLoadedMaps[nodeid];
-        hasLazyChilds = node[hasChildField];
-        isLazyLoaded = !!nodeItem.treeLoaded;
-      }
-      var prevNode = nodeItem.items[nodeItem.treeIndex - 1];
-      var nParams = {
-        node: node,
-        isExpand: isExpand,
-        $tree: $xeTree
-      };
-      var itemOns = {
-        mousedown: function mousedown(evnt) {
-          $xeTree.handleNodeMousedownEvent(evnt, node);
-        },
-        mouseup: $xeTree.handleNodeDragMouseupEvent,
-        click: function click(evnt) {
-          $xeTree.handleNodeClickEvent(evnt, node);
-        },
-        dblclick: function dblclick(evnt) {
-          $xeTree.handleNodeDblclickEvent(evnt, node);
-        },
-        contextmenu: function contextmenu(evnt) {
-          $xeTree.handleContextmenuEvent(evnt, node);
-        }
-      };
-      if (tipMode === 'tooltip') {
-        itemOns.mouseenter = function (evnt) {
-          $xeTree.handleNodeMouseenterEvent(evnt, node);
-        };
-        itemOns.mouseleave = $xeTree.handleNodeMouseleaveEvent;
-      }
-      // 拖拽行事件
-      if (drag && transform) {
-        itemOns.dragstart = $xeTree.handleNodeDragDragstartEvent;
-        itemOns.dragend = $xeTree.handleNodeDragDragendEvent;
-        itemOns.dragover = $xeTree.handleNodeDragDragoverEvent;
-      }
-      return h('div', {
-        key: nodeid,
-        class: ['vxe-tree--node-wrapper', "node--level-".concat(nLevel)],
-        attrs: {
-          nodeid: nodeid,
-          title: tipMode === 'title' ? nodeTitle : ''
-        },
-        on: itemOns
-      }, [h('div', {
-        class: ['vxe-tree--node-item', {
-          'is--current': currentNode && nodeid === $xeTree.getNodeId(currentNode),
-          'is-radio--checked': isRadioChecked,
-          'is-checkbox--checked': isCheckboxChecked,
-          'is-checkbox--indeterminate': isIndeterminate
-        }]
-      }, [showLine ? h('div', {
-        class: 'vxe-tree--node-line-wrapper'
-      }, [h('div', {
-        class: 'vxe-tree--node-line',
-        style: {
-          height: "".concat($xeTree.getNodeId(afterTreeList[0]) === nodeid ? 1 : (0, _util.calcTreeLine)($xeTree, node, prevNode), "px")
-        }
-      })]) : (0, _ui.renderEmptyElement)($xeTree), h('div', {
-        class: 'vxe-tree--node-item-switcher'
-      }, showIcon && (lazy ? isLazyLoaded ? isExistChild : hasLazyChilds : isExistChild) && (!visibleMethod || visibleMethod(nParams)) ? [h('div', {
-        class: 'vxe-tree--node-item-icon',
-        on: {
-          click: function click(evnt) {
-            $xeTree.toggleExpandEvent(evnt, node);
-          }
-        }
-      }, iconSlot ? (0, _vn.getSlotVNs)(iconSlot(nParams)) : [h('i', {
-        class: isLazyLoading ? iconLoaded || getIcon().TREE_NODE_LOADED : isExpand ? iconOpen || getIcon().TREE_NODE_OPEN : iconClose || getIcon().TREE_NODE_CLOSE
-      })])] : []), $xeTree.renderDragIcon(h, node, nodeid), $xeTree.renderRadio(h, node, nodeid, isExistChild, nLevel, isRadioChecked), $xeTree.renderCheckbox(h, node, nodeid, isExistChild, nLevel, isCheckboxChecked, isIndeterminate), h('div', {
-        class: 'vxe-tree--node-item-inner'
-      }, [h('div', {
-        class: 'vxe-tree--node-item-wrapper'
-      }, [h('span', {
-        class: 'vxe-tree--node-item-title'
-      }, titleSlot ? (0, _vn.getSlotVNs)(titleSlot(nParams)) : nodeTitle)]), extraSlot ? h('div', {
-        class: 'vxe-tree--node-item-extra'
-      }, (0, _vn.getSlotVNs)(extraSlot(nParams))) : (0, _ui.renderEmptyElement)($xeTree)])])]);
-    },
-    renderList: function renderList(h, treeList) {
-      var $xeTree = this;
-      var props = $xeTree;
-      var internalData = $xeTree.internalData;
-      var transform = props.transform;
-      var treeExpandedMaps = internalData.treeExpandedMaps;
-      var childrenField = $xeTree.computeChildrenField;
-      if (!treeList.length) {
-        return [h('div', {
-          class: 'vxe-tree--empty-placeholder'
-        }, getI18n('vxe.tree.searchEmpty'))];
-      }
-      var nodeVNs = [];
-      treeList.forEach(transform ? function (node) {
-        var nodeid = $xeTree.getNodeId(node);
-        nodeVNs.push($xeTree.renderNode(h, node, nodeid));
-      } : function (node) {
-        var nodeid = $xeTree.getNodeId(node);
-        nodeVNs.push($xeTree.renderNode(h, node, nodeid));
-        var childList = _xeUtils.default.get(node, childrenField);
-        var hasChild = childList && childList.length;
-        if (hasChild && treeExpandedMaps[nodeid]) {
-          nodeVNs.push.apply(nodeVNs, _toConsumableArray($xeTree.renderList(h, childList)));
-        }
-      });
-      return nodeVNs;
-    },
-    renderDragTip: function renderDragTip(h) {
-      var $xeTree = this;
-      var props = $xeTree;
-      var reactData = $xeTree.reactData;
-      var drag = props.drag;
-      var dragNode = reactData.dragNode,
-        dragTipText = reactData.dragTipText;
-      var dragOpts = $xeTree.computeDragOpts;
-      var dNode = dragNode;
-      if (drag) {
-        return h('div', {
-          class: 'vxe-tree--drag-wrapper'
-        }, [h('div', {
-          ref: 'refDragNodeLineElem',
-          class: ['vxe-tree--drag-node-line', {
-            'is--guides': dragOpts.showGuidesStatus
-          }]
-        }), dNode && dragOpts.showDragTip ? h('div', {
-          ref: 'refDragTipElem',
-          class: 'vxe-tree--drag-sort-tip'
-        }, [h('div', {
-          class: 'vxe-tree--drag-sort-tip-wrapper'
-        }, [h('div', {
-          class: 'vxe-tree--drag-sort-tip-status'
-        }, [h('span', {
-          class: ['vxe-tree--drag-sort-tip-normal-status', getIcon().TREE_DRAG_STATUS_NODE]
-        }), h('span', {
-          class: ['vxe-tree--drag-sort-tip-sub-status', getIcon().TREE_DRAG_STATUS_SUB_NODE]
-        }), h('span', {
-          class: ['vxe-tree--drag-sort-tip-disabled-status', getIcon().TREE_DRAG_DISABLED]
-        })]), h('div', {
-          class: 'vxe-tree--drag-sort-tip-content'
-        }, dragTipText)])]) : (0, _ui.renderEmptyElement)($xeTree)]);
-      }
-      return (0, _ui.renderEmptyElement)($xeTree);
-    },
-    renderVN: function renderVN(h) {
-      var $xeTree = this;
-      var props = $xeTree;
-      var slots = $xeTree.$scopedSlots;
-      var reactData = $xeTree.reactData;
-      var loading = props.loading,
-        trigger = props.trigger,
-        showLine = props.showLine;
-      var bodyHeight = reactData.bodyHeight,
-        topSpaceHeight = reactData.topSpaceHeight,
-        treeList = reactData.treeList,
-        tooltipStore = reactData.tooltipStore;
-      var vSize = $xeTree.computeSize;
-      var radioOpts = $xeTree.computeRadioOpts;
-      var checkboxOpts = $xeTree.computeCheckboxOpts;
-      var loadingOpts = $xeTree.computeLoadingOpts;
-      var isNodeHover = $xeTree.computeIsNodeHover;
-      var treeStyle = $xeTree.computeTreeStyle;
-      var dragOpts = $xeTree.computeDragOpts;
-      var tooltipOpts = $xeTree.computeTooltipOpts;
-      var loadingSlot = slots.loading;
-      var headerSlot = slots.header;
-      var footerSlot = slots.footer;
-      var tooltipSlot = slots.tooltip;
-      var teOns = {};
-      if (dragOpts.isCrossTreeDrag && !treeList.length) {
-        teOns.dragover = $xeTree.handleCrossTreeNodeDragoverEmptyEvent;
-      }
-      return h('div', {
-        ref: 'refElem',
-        class: ['vxe-tree', _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, "size--".concat(vSize), vSize), 'show--line', showLine), 'checkbox--highlight', checkboxOpts.highlight), 'radio--highlight', radioOpts.highlight), 'node--hover', isNodeHover), 'node--trigger', trigger === 'node'), 'is--loading', loading)],
-        on: teOns
-      }, [headerSlot ? h('div', {
-        ref: 'refHeaderWrapperElem',
-        class: 'vxe-tree--header-wrapper'
-      }, headerSlot({
-        $tree: $xeTree
-      })) : (0, _ui.renderEmptyElement)($xeTree), h('div', {
-        ref: 'refVirtualWrapper',
-        class: 'vxe-tree--node-list-wrapper',
-        style: treeStyle,
-        on: {
-          scroll: $xeTree.scrollEvent
-        }
-      }, [h('div', {
-        class: 'vxe-tree--y-space',
-        style: {
-          height: bodyHeight ? "".concat(bodyHeight, "px") : ''
-        }
-      }), h('div', {
-        ref: 'refVirtualBody',
-        class: 'vxe-tree--node-list-body',
-        style: {
-          transform: "translateY(".concat(topSpaceHeight, "px)")
-        }
-      }, $xeTree.renderList(h, treeList))]), footerSlot ? h('div', {
-        ref: 'refFooterWrapperElem',
-        class: 'vxe-tree--footer-wrapper'
-      }, footerSlot({
-        $tree: $xeTree
-      })) : (0, _ui.renderEmptyElement)($xeTree),
-      /**
-       * 拖拽提示
-       */
-      $xeTree.renderDragTip(h),
-      /**
-        * 工具提示
-        */
-      tooltipOpts.mode === 'tooltip' ? h(_tooltip.default, {
-        ref: 'refTooltip',
-        props: {
-          theme: tooltipOpts.theme,
-          enterable: tooltipOpts.enterable,
-          enterDelay: tooltipOpts.enterDelay,
-          leaveDelay: tooltipOpts.leaveDelay,
-          useHtml: tooltipOpts.useHtml,
-          width: tooltipOpts.width,
-          height: tooltipOpts.height,
-          minWidth: tooltipOpts.minWidth,
-          minHeight: tooltipOpts.minHeight,
-          maxWidth: tooltipOpts.maxWidth,
-          maxHeight: tooltipOpts.maxHeight,
-          placement: tooltipOpts.placement,
-          defaultPlacement: tooltipOpts.defaultPlacement,
-          popupClassName: tooltipOpts.popupClassName
-        },
-        scopedSlots: tooltipSlot ? {
-          content: function content() {
-            var node = tooltipStore.node;
-            return tooltipSlot({
-              node: node,
-              $tree: $xeTree
-            });
-          }
-        } : undefined
-      }) : (0, _ui.renderEmptyElement)($xeTree),
-      /**
-       * 加载中
-       */
-      h(_loading.default, {
-        class: 'vxe-tree--loading',
-        props: {
-          value: loading,
-          icon: loadingOpts.icon,
-          text: loadingOpts.text
-        },
-        scopedSlots: loadingSlot ? {
-          default: function _default() {
-            return loadingSlot({
-              $tree: $xeTree
-            });
-          }
-        } : undefined
-      })]);
-    }
-  },
-  watch: {
-    data: function data() {
-      var $xeTree = this;
-      $xeTree.dataFlag++;
-    },
-    rootParentValue: function rootParentValue() {
-      var $xeTree = this;
-      $xeTree.dataFlag++;
-    },
-    rootValues: function rootValues() {
-      var $xeTree = this;
-      $xeTree.dataFlag++;
-    },
-    dataFlag: function dataFlag() {
-      var $xeTree = this;
-      var props = $xeTree;
-      $xeTree.loadData(props.data || []);
-    },
-    checkNodeKey: function checkNodeKey(nodeKey) {
-      var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      reactData.selectRadioKey = (0, _utils.enModelValue)(nodeKey);
-    },
-    checkNodeKeys: function checkNodeKeys() {
-      var $xeTree = this;
-      var props = $xeTree;
-      $xeTree.updateCheckboxChecked(props.checkNodeKeys || []);
-    },
-    filterValue: function filterValue() {
-      var $xeTree = this;
-      $xeTree.triggerSearchEvent(new Event('filter'));
-    },
-    height: function height() {
-      var $xeTree = this;
-      $xeTree.hFlag++;
-    },
-    minHeight: function minHeight() {
-      var $xeTree = this;
-      $xeTree.hFlag++;
-    },
-    maxHeight: function maxHeight() {
-      var $xeTree = this;
-      $xeTree.hFlag++;
-    },
-    hFlag: function hFlag() {
-      var $xeTree = this;
-      $xeTree.recalculate();
-    }
-  },
-  created: function created() {
-    var $xeTree = this;
-    var props = $xeTree;
-    var reactData = $xeTree.reactData;
-    $xeTree.internalData = createInternalData();
-    reactData.selectRadioKey = (0, _utils.enModelValue)(props.checkNodeKey);
-    $xeTree.loadData(props.data || []);
-  },
-  mounted: function mounted() {
-    var $xeTree = this;
-    var props = $xeTree;
-    var internalData = $xeTree.internalData;
-    var transform = props.transform,
-      drag = props.drag,
-      menuConfig = props.menuConfig,
-      showOverflow = props.showOverflow;
-    var dragOpts = $xeTree.computeDragOpts;
-    if (!showOverflow) {
-      errLog('vxe.error.errProp', ['show-overflow=false', 'show-overflow=true']);
-    }
-    if (drag && !transform) {
-      errLog('vxe.error.notSupportProp', ['drag', 'transform=false', 'transform=true']);
-    }
-    if (dragOpts.isCrossTreeDrag && !dragOpts.isCrossDrag) {
-      errLog('vxe.error.reqSupportProp', ['drag-config.isCrossTreeDrag', 'drag-config.isCrossDrag']);
-    }
-    // if (valueField) {
-    //   errLog('vxe.error.delProp', ['value-field', 'value-field'])
-    // }
-    var VxeUIContextMenu = _ui.VxeUI.getComponent('VxeContextMenu');
-    if (menuConfig && !VxeUIContextMenu) {
-      errLog('vxe.error.reqComp', ['vxe-context-menu']);
-    }
-    if (props.autoResize) {
-      var el = $xeTree.$refs.refElem;
-      var parentEl = $xeTree.getParentElem();
-      var resizeObserver = _ui.globalResize.create(function () {
-        if (props.autoResize) {
-          $xeTree.recalculate();
-        }
-      });
-      if (el) {
-        resizeObserver.observe(el);
-      }
-      if (parentEl) {
-        resizeObserver.observe(parentEl);
-      }
-      internalData.resizeObserver = resizeObserver;
-    }
-    _ui.globalEvents.on($xeTree, 'resize', $xeTree.handleGlobalResizeEvent);
-  },
-  beforeDestroy: function beforeDestroy() {
-    var $xeTree = this;
-    var reactData = $xeTree.reactData;
-    var internalData = $xeTree.internalData;
-    var resizeObserver = internalData.resizeObserver;
-    if (resizeObserver) {
-      resizeObserver.disconnect();
-    }
-    _ui.globalEvents.off($xeTree, 'resize');
-    _xeUtils.default.assign(reactData, createReactData());
-    _xeUtils.default.assign(internalData, createInternalData());
-  },
-  render: function render(h) {
-    return this.renderVN(h);
-  }
-});
-/* define-vxe-component end */