vxe-pc-ui 3.16.0 → 3.16.1

package/lib/tree/src/tree.js

@@ -0,0 +1,3952 @@
+"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 */