vxe-pc-ui 3.7.4 → 3.7.6

package/lib/tree/src/tree.js

@@ -1,5 +1,6 @@
 "use strict";
 
+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); }
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -7,14 +8,21 @@ 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 _dom = require("../../ui/src/dom");
 var _loading = _interopRequireDefault(require("../../loading/src/loading"));
 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 _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); }
+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; }
 /**
  * 生成节点的唯一主键
  */
@@ -37,7 +45,19 @@ var _default2 = exports.default = /* define-vxe-component start */(0, _comp.defi
   mixins: [_ui.globalMixins.sizeMixin],
   props: {
     data: Array,
+    autoResize: {
+      type: Boolean,
+      default: function _default() {
+        return (0, _ui.getConfig)().tree.autoResize;
+      }
+    },
     height: [String, Number],
+    maxHeight: {
+      type: [String, Number],
+      default: function _default() {
+        return (0, _ui.getConfig)().tree.maxHeight;
+      }
+    },
     minHeight: {
       type: [String, Number],
       default: function _default() {
@@ -165,17 +185,27 @@ var _default2 = exports.default = /* define-vxe-component start */(0, _comp.defi
         return (0, _ui.getConfig)().tree.iconLoaded;
       }
     },
+    filterValue: [String, Number],
+    filterConfig: Object,
     size: {
       type: String,
       default: function _default() {
         return (0, _ui.getConfig)().tree.size || (0, _ui.getConfig)().size;
       }
-    }
+    },
+    virtualYConfig: Object
   },
   data: function data() {
     var xID = _xeUtils.default.uniqueId();
     var reactData = {
+      parentHeight: 0,
+      customHeight: 0,
+      customMinHeight: 0,
+      customMaxHeight: 0,
       currentNode: null,
+      scrollYLoad: false,
+      bodyHeight: 0,
+      topSpaceHeight: 0,
       selectRadioKey: null,
       treeList: [],
       updateExpandedFlag: 1,
@@ -183,11 +213,26 @@ var _default2 = exports.default = /* define-vxe-component start */(0, _comp.defi
     };
     var internalData = {
       // initialized: false,
+      // lastFilterValue: '',
+      treeFullData: [],
+      afterTreeList: [],
+      afterVisibleList: [],
       nodeMaps: {},
       selectCheckboxMaps: {},
       indeterminateRowMaps: {},
       treeExpandedMaps: {},
-      treeExpandLazyLoadedMaps: {}
+      treeExpandLazyLoadedMaps: {},
+      lastScrollLeft: 0,
+      lastScrollTop: 0,
+      scrollYStore: {
+        startIndex: 0,
+        endIndex: 0,
+        visibleSize: 0,
+        offsetSize: 0,
+        rowHeight: 0
+      },
+      lastScrollTime: 0
+      // hpTimeout: undefined
     };
     return {
       xID: xID,
@@ -232,6 +277,11 @@ var _default2 = exports.default = /* define-vxe-component start */(0, _comp.defi
       var props = $xeTree;
       return props.hasChildField || 'hasChild';
     },
+    computeVirtualYOpts: function computeVirtualYOpts() {
+      var $xeTree = this;
+      var props = $xeTree;
+      return Object.assign({}, (0, _ui.getConfig)().tree.virtualYConfig, props.virtualYConfig);
+    },
     computeIsRowCurrent: function computeIsRowCurrent() {
       var $xeTree = this;
       var props = $xeTree;
@@ -278,17 +328,26 @@ var _default2 = exports.default = /* define-vxe-component start */(0, _comp.defi
     },
     computeTreeStyle: function computeTreeStyle() {
       var $xeTree = this;
-      var props = $xeTree;
-      var height = props.height,
-        minHeight = props.minHeight;
+      var reactData = $xeTree.reactData;
+      var customHeight = reactData.customHeight,
+        customMinHeight = reactData.customMinHeight,
+        customMaxHeight = reactData.customMaxHeight;
       var stys = {};
-      if (height) {
-        stys.height = (0, _dom.toCssUnit)(height);
+      if (customHeight) {
+        stys.height = (0, _dom.toCssUnit)(customHeight);
+      }
+      if (customMinHeight) {
+        stys.minHeight = (0, _dom.toCssUnit)(customMinHeight);
       }
-      if (minHeight) {
-        stys.minHeight = (0, _dom.toCssUnit)(minHeight);
+      if (customMaxHeight) {
+        stys.maxHeight = (0, _dom.toCssUnit)(customMaxHeight);
       }
       return stys;
+    },
+    computeFilterOpts: function computeFilterOpts() {
+      var $xeTree = this;
+      var props = $xeTree;
+      return Object.assign({}, (0, _ui.getConfig)().tree.filterConfig, props.filterConfig);
     }
   }),
   methods: {
@@ -301,578 +360,646 @@ var _default2 = exports.default = /* define-vxe-component start */(0, _comp.defi
         $tree: $xeTree
       }, params));
     },
-    clearCurrentNode: function clearCurrentNode() {
-      var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      reactData.currentNode = null;
-      return $xeTree.$nextTick();
-    },
-    getCurrentNodeId: function getCurrentNodeId() {
+    getNodeId: function getNodeId(node) {
       var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      var currentNode = reactData.currentNode;
-      if (currentNode) {
-        return $xeTree.getNodeId(currentNode);
-      }
-      return null;
+      var valueField = $xeTree.computeValueField;
+      var nodeid = _xeUtils.default.get(node, valueField);
+      return _xeUtils.default.eqNull(nodeid) ? '' : encodeURIComponent(nodeid);
     },
-    getCurrentNode: function getCurrentNode() {
+    isExpandByNode: function isExpandByNode(node) {
       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;
+      var updateExpandedFlag = reactData.updateExpandedFlag;
+      var treeExpandedMaps = internalData.treeExpandedMaps;
+      var nodeid = $xeTree.getNodeId(node);
+      return !!(updateExpandedFlag && treeExpandedMaps[nodeid]);
     },
-    setCurrentNodeId: function setCurrentNodeId(nodeKey) {
+    isCheckedByRadioNodeId: function isCheckedByRadioNodeId(nodeid) {
       var $xeTree = this;
       var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var nodeMaps = internalData.nodeMaps;
-      var nodeItem = nodeMaps[nodeKey];
-      reactData.currentNode = nodeItem ? nodeItem.item : null;
-      return $xeTree.$nextTick();
+      var selectRadioKey = reactData.selectRadioKey;
+      return selectRadioKey === nodeid;
     },
-    setCurrentNode: function setCurrentNode(node) {
+    isCheckedByRadioNode: function isCheckedByRadioNode(node) {
       var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      reactData.currentNode = node;
-      return $xeTree.$nextTick();
+      return $xeTree.isCheckedByRadioNodeId($xeTree.getNodeId(node));
     },
-    clearRadioNode: function clearRadioNode() {
+    isCheckedByCheckboxNodeId: function isCheckedByCheckboxNodeId(nodeid) {
       var $xeTree = this;
       var reactData = $xeTree.reactData;
-      reactData.selectRadioKey = null;
-      return $xeTree.$nextTick();
-    },
-    getCheckboxNodeIds: function getCheckboxNodeIds() {
-      var $xeTree = this;
       var internalData = $xeTree.internalData;
+      var updateCheckboxFlag = reactData.updateCheckboxFlag;
       var selectCheckboxMaps = internalData.selectCheckboxMaps;
-      return Object.keys(selectCheckboxMaps);
+      return !!(updateCheckboxFlag && selectCheckboxMaps[nodeid]);
     },
-    getCheckboxNodes: function getCheckboxNodes() {
+    isCheckedByCheckboxNode: function isCheckedByCheckboxNode(node) {
       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;
+      return $xeTree.isCheckedByCheckboxNodeId($xeTree.getNodeId(node));
     },
-    clearCheckboxNode: function clearCheckboxNode() {
+    isIndeterminateByCheckboxNodeid: function isIndeterminateByCheckboxNodeid(nodeid) {
       var $xeTree = this;
       var reactData = $xeTree.reactData;
       var internalData = $xeTree.internalData;
-      internalData.selectCheckboxMaps = {};
-      reactData.updateCheckboxFlag++;
-      return $xeTree.$nextTick();
+      var updateCheckboxFlag = reactData.updateCheckboxFlag;
+      var indeterminateRowMaps = internalData.indeterminateRowMaps;
+      return !!(updateCheckboxFlag && indeterminateRowMaps[nodeid]);
     },
-    setAllCheckboxNode: function setAllCheckboxNode(checked) {
+    isIndeterminateByCheckboxNode: function isIndeterminateByCheckboxNode(node) {
       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;
-      if (checked) {
-        _xeUtils.default.eachTree(reactData.treeList, function (node) {
-          var nodeid = $xeTree.getNodeId(node);
-          selectMaps[nodeid] = true;
-        }, {
-          children: transform ? mapChildrenField : childrenField
-        });
-      }
-      internalData.selectCheckboxMaps = selectMaps;
-      reactData.updateCheckboxFlag++;
-      return $xeTree.$nextTick();
+      return $xeTree.isIndeterminateByCheckboxNodeid($xeTree.getNodeId(node));
     },
-    clearExpandNode: function clearExpandNode() {
+    emitCheckboxMode: function emitCheckboxMode(value) {
       var $xeTree = this;
-      return $xeTree.clearAllExpandNode();
+      $xeTree.$emit('update:checkNodeKeys', value);
     },
-    clearAllExpandNode: function clearAllExpandNode() {
+    emitRadioMode: function emitRadioMode(value) {
       var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var nodeMaps = internalData.nodeMaps;
-      _xeUtils.default.each(nodeMaps, function (nodeItem) {
-        nodeItem.treeLoaded = false;
-      });
-      internalData.treeExpandedMaps = {};
-      reactData.updateExpandedFlag++;
-      return $xeTree.$nextTick();
+      $xeTree.$emit('update:checkNodeKey', value);
     },
-    setExpandByNodeId: function setExpandByNodeId(nodeids, expanded) {
+    setRadioNode: function setRadioNode(node) {
       var $xeTree = this;
       var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var treeExpandedMaps = internalData.treeExpandedMaps;
-      if (nodeids) {
-        if (!_xeUtils.default.isArray(nodeids)) {
-          nodeids = [nodeids];
-        }
-        nodeids.forEach(function (nodeid) {
-          handleSetExpand(nodeid, expanded, treeExpandedMaps);
-        });
-        reactData.updateExpandedFlag++;
+      if (node) {
+        reactData.selectRadioKey = $xeTree.getNodeId(node);
       }
       return $xeTree.$nextTick();
     },
-    getExpandNodeIds: function getExpandNodeIds() {
-      var $xeTree = this;
-      var internalData = $xeTree.internalData;
-      var treeExpandedMaps = internalData.treeExpandedMaps;
-      return _xeUtils.default.keys(treeExpandedMaps);
-    },
-    getExpandNodes: function getExpandNodes() {
+    setCheckboxNode: function setCheckboxNode(nodeList, checked) {
       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);
+      if (nodeList) {
+        if (!_xeUtils.default.isArray(nodeList)) {
+          nodeList = [nodeList];
         }
-      });
-      return list;
+        $xeTree.handleCheckedCheckboxNode(nodeList, checked);
+      }
+      return $xeTree.$nextTick();
     },
-    setExpandNode: function setExpandNode(nodes, expanded) {
+    setCheckboxByNodeId: function setCheckboxByNodeId(nodeIds, checked) {
       var $xeTree = this;
-      var reactData = $xeTree.reactData;
       var internalData = $xeTree.internalData;
-      var treeExpandedMaps = internalData.treeExpandedMaps;
-      if (nodes) {
-        if (!_xeUtils.default.isArray(nodes)) {
-          nodes = [nodes];
+      var nodeMaps = internalData.nodeMaps;
+      if (nodeIds) {
+        if (!_xeUtils.default.isArray(nodeIds)) {
+          nodeIds = [nodeIds];
         }
-        nodes.forEach(function (node) {
-          var nodeid = $xeTree.getNodeId(node);
-          handleSetExpand(nodeid, expanded, treeExpandedMaps);
+        var nodeList = [];
+        nodeIds.forEach(function (nodeid) {
+          var nodeItem = nodeMaps[nodeid];
+          if (nodeItem) {
+            nodeList.push(nodeItem.item);
+          }
         });
-        reactData.updateExpandedFlag++;
+        $xeTree.handleCheckedCheckboxNode(nodeList, checked);
       }
       return $xeTree.$nextTick();
     },
-    toggleExpandByNodeId: function toggleExpandByNodeId(nodeids) {
+    handleCheckedCheckboxNode: function handleCheckedCheckboxNode(nodeList, checked) {
       var $xeTree = this;
+      var props = $xeTree;
       var reactData = $xeTree.reactData;
       var internalData = $xeTree.internalData;
-      var treeExpandedMaps = internalData.treeExpandedMaps;
-      if (nodeids) {
-        if (!_xeUtils.default.isArray(nodeids)) {
-          nodeids = [nodeids];
+      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];
+          }
         }
-        nodeids.forEach(function (nodeid) {
-          handleSetExpand(nodeid, !treeExpandedMaps[nodeid], treeExpandedMaps);
+      };
+      if (checkStrictly) {
+        nodeList.forEach(handleSelect);
+      } else {
+        _xeUtils.default.eachTree(nodeList, handleSelect, {
+          children: transform ? mapChildrenField : childrenField
         });
-        reactData.updateExpandedFlag++;
       }
-      return $xeTree.$nextTick();
+      reactData.updateCheckboxFlag++;
+      $xeTree.updateCheckboxStatus();
     },
-    toggleExpandNode: function toggleExpandNode(nodes) {
+    updateCheckboxChecked: function updateCheckboxChecked(nodeIds) {
       var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var treeExpandedMaps = internalData.treeExpandedMaps;
-      if (nodes) {
-        if (!_xeUtils.default.isArray(nodes)) {
-          nodes = [nodes];
+      $xeTree.setCheckboxByNodeId(nodeIds, true);
+    },
+    handleSetExpand: function handleSetExpand(nodeid, expanded, expandedMaps) {
+      if (expanded) {
+        if (!expandedMaps[nodeid]) {
+          expandedMaps[nodeid] = true;
+        }
+      } else {
+        if (expandedMaps[nodeid]) {
+          delete expandedMaps[nodeid];
         }
-        nodes.forEach(function (node) {
-          var nodeid = $xeTree.getNodeId(node);
-          handleSetExpand(nodeid, !treeExpandedMaps[nodeid], treeExpandedMaps);
-        });
-        reactData.updateExpandedFlag++;
       }
-      return $xeTree.$nextTick();
     },
-    setAllExpandNode: function setAllExpandNode(expanded) {
+    getParentElem: function getParentElem() {
+      var $xeTree = this;
+      var el = $xeTree.$refs.refElem;
+      return el ? el.parentElement : null;
+    },
+    calcTableHeight: function calcTableHeight(key) {
       var $xeTree = this;
       var props = $xeTree;
       var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var transform = props.transform;
-      var treeExpandedMaps = internalData.treeExpandedMaps;
-      var childrenField = $xeTree.computeChildrenField;
-      var mapChildrenField = $xeTree.computeMapChildrenField;
-      if (expanded) {
-        _xeUtils.default.eachTree(reactData.treeList, function (node) {
-          var childList = _xeUtils.default.get(node, childrenField);
-          var hasChild = childList && childList.length;
-          if (hasChild) {
-            var nodeid = $xeTree.getNodeId(node);
-            treeExpandedMaps[nodeid] = true;
+      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);
           }
-        }, {
-          children: transform ? mapChildrenField : childrenField
-        });
-      } else {
-        internalData.treeExpandedMaps = {};
+          num = Math.max(40, num);
+        }
       }
-      reactData.updateExpandedFlag++;
-      return $xeTree.$nextTick();
+      return num;
     },
-    reloadExpandNode: function reloadExpandNode(node) {
+    updateHeight: function updateHeight() {
       var $xeTree = this;
-      var props = $xeTree;
-      var lazy = props.lazy;
-      if (lazy) {
-        $xeTree.clearExpandLoaded(node);
-        return $xeTree.handleAsyncTreeExpandChilds(node);
+      var reactData = $xeTree.reactData;
+      reactData.customHeight = $xeTree.calcTableHeight('height');
+      reactData.customMinHeight = $xeTree.calcTableHeight('minHeight');
+      reactData.customMaxHeight = $xeTree.calcTableHeight('maxHeight');
+      // 如果启用虚拟滚动，默认高度
+      if (reactData.scrollYLoad && !(reactData.customHeight || reactData.customMinHeight)) {
+        reactData.customHeight = 300;
       }
-      return $xeTree.$nextTick();
     },
-    clearExpandLoaded: function clearExpandLoaded(node) {
+    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 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;
+      var treeFullData = internalData.treeFullData;
+      var valueField = $xeTree.computeValueField;
+      var childrenField = $xeTree.computeChildrenField;
+      var keyMaps = {};
+      _xeUtils.default.eachTree(treeFullData, function (item, index, items, path, parent, nodes) {
+        var nodeid = $xeTree.getNodeId(item);
+        if (!nodeid) {
+          nodeid = getNodeUniqueId();
+          _xeUtils.default.set(item, valueField, nodeid);
         }
-      }
-      return $xeTree.$nextTick();
+        keyMaps[nodeid] = {
+          item: item,
+          index: index,
+          items: items,
+          parent: parent,
+          nodes: nodes,
+          level: nodes.length,
+          treeIndex: index,
+          lineCount: 0,
+          treeLoaded: false
+        };
+      }, {
+        children: childrenField
+      });
+      internalData.nodeMaps = keyMaps;
     },
-    /**
-     * 用于树结构，给行数据加载子节点
-     */
-    loadChildrenNode: function loadChildrenNode(node, childRecords) {
+    updateAfterDataIndex: function updateAfterDataIndex() {
       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 transform = props.transform;
+      var afterTreeList = internalData.afterTreeList,
+        nodeMaps = internalData.nodeMaps;
       var childrenField = $xeTree.computeChildrenField;
-      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 (childRow, index, items, path, parent, nodes) {
-          var itemNodeId = $xeTree.getNodeId(childRow);
-          nodeMaps[itemNodeId] = {
-            item: node,
-            itemIndex: -1,
+      var mapChildrenField = $xeTree.computeMapChildrenField;
+      _xeUtils.default.eachTree(afterTreeList, function (item, index, items) {
+        var nodeid = $xeTree.getNodeId(item);
+        var nodeItem = nodeMaps[nodeid];
+        if (nodeItem) {
+          nodeItem.items = items;
+          nodeItem.treeIndex = index;
+        } else {
+          var rest = {
+            item: item,
+            index: index,
             items: items,
-            parent: parent || parentNodeItem.item,
-            nodes: parentNodes.concat(nodes),
-            level: parentLevel + nodes.length,
+            parent: parent,
+            nodes: [],
+            level: 0,
+            treeIndex: index,
             lineCount: 0,
             treeLoaded: false
           };
-        }, {
-          children: childrenField
-        });
-        node[childrenField] = nodeList;
-        if (transform) {
-          node[childrenField] = nodeList;
+          nodeMaps[nodeid] = rest;
         }
-        $xeTree.updateNodeLine(node);
-        return nodeList;
+      }, {
+        children: transform ? mapChildrenField : childrenField
       });
     },
-    getNodeId: function getNodeId(node) {
+    updateAfterFullData: function updateAfterFullData() {
       var $xeTree = this;
-      var valueField = $xeTree.computeValueField;
-      var nodeid = _xeUtils.default.get(node, valueField);
-      return _xeUtils.default.eqNull(nodeid) ? '' : encodeURIComponent(nodeid);
+      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) > -1;
+        };
+        var bafParams = {
+          $tree: $xeTree,
+          filterValue: filterStr
+        };
+        if (beforeFilterMethod) {
+          beforeFilterMethod(bafParams);
+        }
+        if (transform) {
+          treeList = _xeUtils.default.searchTree(treeFullData, handleSearch, {
+            children: childrenField,
+            mapChildren: mapChildrenField,
+            isEvery: true
+          });
+          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;
+          }, {
+            children: childrenField,
+            mapChildren: mapChildrenField,
+            isEvery: true
+          });
+          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();
     },
-    isExpandByNode: function isExpandByNode(node) {
+    /**
+     * 如果为虚拟树、则将树结构拍平
+     */
+    handleTreeToList: function handleTreeToList() {
       var $xeTree = this;
-      var reactData = $xeTree.reactData;
+      var props = $xeTree;
       var internalData = $xeTree.internalData;
-      var updateExpandedFlag = reactData.updateExpandedFlag;
-      var treeExpandedMaps = internalData.treeExpandedMaps;
-      var nodeid = $xeTree.getNodeId(node);
-      return !!(updateExpandedFlag && treeExpandedMaps[nodeid]);
+      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, parentRow) {
+          var nodeid = $xeTree.getNodeId(item);
+          var parentNodeid = $xeTree.getNodeId(parentRow);
+          if (!parentRow || expandMaps[parentNodeid] && treeExpandedMaps[parentNodeid]) {
+            expandMaps[nodeid] = 1;
+            fullData.push(item);
+          }
+        }, {
+          children: mapChildrenField
+        });
+        $xeTree.updateScrollYStatus(fullData);
+        internalData.afterVisibleList = fullData;
+        return fullData;
+      }
+      return internalData.afterVisibleList;
     },
-    isCheckedByRadioNodeId: function isCheckedByRadioNodeId(nodeid) {
+    handleData: function handleData(force) {
       var $xeTree = this;
       var reactData = $xeTree.reactData;
-      var selectRadioKey = reactData.selectRadioKey;
-      return selectRadioKey === nodeid;
-    },
-    isCheckedByRadioNode: function isCheckedByRadioNode(node) {
+      var internalData = $xeTree.internalData;
+      var scrollYLoad = reactData.scrollYLoad;
+      var scrollYStore = internalData.scrollYStore;
+      var fullList = internalData.afterVisibleList;
+      if (force) {
+        // 更新数据，处理筛选和排序
+        $xeTree.updateAfterFullData();
+        // 如果为虚拟树，将树结构拍平
+        fullList = $xeTree.handleTreeToList();
+      }
+      var treeList = scrollYLoad ? fullList.slice(scrollYStore.startIndex, scrollYStore.endIndex) : fullList.slice(0);
+      reactData.treeList = treeList;
+    },
+    triggerSearchEvent: _xeUtils.default.debounce(function () {
+      var $xeSelect = this;
+      $xeSelect.handleData(true);
+    }, 350, {
+      trailing: true
+    }),
+    loadData: function loadData(list) {
       var $xeTree = this;
-      return $xeTree.isCheckedByRadioNodeId($xeTree.getNodeId(node));
+      var props = $xeTree;
+      var internalData = $xeTree.internalData;
+      var expandAll = props.expandAll,
+        transform = props.transform;
+      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
+      }) : list ? list.slice(0) : [];
+      internalData.treeFullData = fullData;
+      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)) {
+          (0, _log.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);
+            }
+            $xeTree.setCheckboxByNodeId(props.checkNodeKeys || [], true);
+          }
+        }
+        $xeTree.updateHeight();
+        $xeTree.refreshScroll();
+      });
     },
-    isCheckedByCheckboxNodeId: function isCheckedByCheckboxNodeId(nodeid) {
+    updateScrollYStatus: function updateScrollYStatus(fullData) {
       var $xeTree = this;
+      var props = $xeTree;
       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));
+      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;
     },
-    isIndeterminateByCheckboxNodeid: function isIndeterminateByCheckboxNodeid(nodeid) {
+    updateYSpace: function updateYSpace() {
       var $xeTree = this;
       var reactData = $xeTree.reactData;
       var internalData = $xeTree.internalData;
-      var updateCheckboxFlag = reactData.updateCheckboxFlag;
-      var indeterminateRowMaps = internalData.indeterminateRowMaps;
-      return !!(updateCheckboxFlag && indeterminateRowMaps[nodeid]);
+      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;
     },
-    isIndeterminateByCheckboxNode: function isIndeterminateByCheckboxNode(node) {
+    updateYData: function updateYData() {
       var $xeTree = this;
-      return $xeTree.isIndeterminateByCheckboxNodeid($xeTree.getNodeId(node));
+      $xeTree.handleData();
+      $xeTree.updateYSpace();
     },
-    getCheckboxIndeterminateNodes: function getCheckboxIndeterminateNodes() {
+    computeScrollLoad: function computeScrollLoad() {
       var $xeTree = this;
+      var reactData = $xeTree.reactData;
       var internalData = $xeTree.internalData;
-      var nodeMaps = internalData.nodeMaps,
-        indeterminateRowMaps = internalData.indeterminateRowMaps;
-      var list = [];
-      _xeUtils.default.each(indeterminateRowMaps, function (item, nodeid) {
-        var nodeItem = nodeMaps[nodeid];
-        if (nodeItem) {
-          list.push(nodeItem.item);
+      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();
         }
       });
-      return list;
     },
-    emitCheckboxMode: function emitCheckboxMode(value) {
-      var $xeTree = this;
-      $xeTree.$emit('update:checkNodeKeys', value);
-    },
-    emitRadioMode: function emitRadioMode(value) {
+    /**
+     * 如果有滚动条，则滚动到对应的位置
+     * @param {Number} scrollLeft 左距离
+     * @param {Number} scrollTop 上距离
+     */
+    scrollTo: function scrollTo(scrollLeft, scrollTop) {
       var $xeTree = this;
-      $xeTree.$emit('update:checkNodeKey', value);
+      var reactData = $xeTree.reactData;
+      var scrollBodyElem = $xeTree.$refs.refVirtualWrapper;
+      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();
     },
-    getRadioNodeId: function getRadioNodeId() {
+    /**
+     * 刷新滚动条
+     */
+    refreshScroll: function refreshScroll() {
       var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      return reactData.selectRadioKey || null;
+      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);
+        }
+      });
     },
-    setRadioNodeId: function setRadioNodeId(nodeKey) {
+    /**
+     * 重新计算列表
+     */
+    recalculate: function recalculate() {
       var $xeTree = this;
       var reactData = $xeTree.reactData;
-      reactData.selectRadioKey = nodeKey;
+      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();
+      }
       return $xeTree.$nextTick();
     },
-    getRadioNode: function getRadioNode() {
+    loadYData: function loadYData(evnt) {
       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;
+      var scrollYStore = internalData.scrollYStore;
+      var startIndex = scrollYStore.startIndex,
+        endIndex = scrollYStore.endIndex,
+        visibleSize = scrollYStore.visibleSize,
+        offsetSize = scrollYStore.offsetSize,
+        rowHeight = scrollYStore.rowHeight;
+      var scrollBodyElem = evnt.target;
+      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();
         }
       }
-      return null;
     },
-    setRadioNode: function setRadioNode(node) {
+    scrollEvent: function scrollEvent(evnt) {
       var $xeTree = this;
       var reactData = $xeTree.reactData;
-      if (node) {
-        reactData.selectRadioKey = $xeTree.getNodeId(node);
+      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(evnt);
+      }
+      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();
     },
-    setCheckboxNode: function setCheckboxNode(nodeList, checked) {
-      var $xeTree = this;
-      if (nodeList) {
-        if (!_xeUtils.default.isArray(nodeList)) {
-          nodeList = [nodeList];
-        }
-        $xeTree.handleCheckedCheckboxNode(nodeList, checked);
-      }
-      return $xeTree.$nextTick();
-    },
-    setCheckboxByNodeId: function setCheckboxByNodeId(nodeIds, checked) {
-      var $xeTree = this;
-      var internalData = $xeTree.internalData;
-      var nodeMaps = internalData.nodeMaps;
-      if (nodeIds) {
-        if (!_xeUtils.default.isArray(nodeIds)) {
-          nodeIds = [nodeIds];
-        }
-        var nodeList = [];
-        nodeIds.forEach(function (nodeid) {
-          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(nodeIds) {
-      var $xeTree = this;
-      $xeTree.setCheckboxByNodeId(nodeIds, true);
-    },
-    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 props = $xeTree;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var transform = props.transform;
-      var treeList = reactData.treeList;
-      var valueField = $xeTree.computeValueField;
-      var childrenField = $xeTree.computeChildrenField;
-      var mapChildrenField = $xeTree.computeMapChildrenField;
-      var keyMaps = {};
-      _xeUtils.default.eachTree(treeList, function (item, itemIndex, items, path, parent, nodes) {
-        var nodeid = $xeTree.getNodeId(item);
-        if (!nodeid) {
-          nodeid = getNodeUniqueId();
-          _xeUtils.default.set(item, valueField, nodeid);
-        }
-        keyMaps[nodeid] = {
-          item: item,
-          itemIndex: itemIndex,
-          items: items,
-          parent: parent,
-          nodes: nodes,
-          level: nodes.length,
-          lineCount: 0,
-          treeLoaded: false
-        };
-      }, {
-        children: transform ? mapChildrenField : childrenField
-      });
-      internalData.nodeMaps = keyMaps;
-    },
-    loadTreeData: function loadTreeData(list) {
-      var $xeTree = this;
-      var props = $xeTree;
-      var reactData = $xeTree.reactData;
-      var internalData = $xeTree.internalData;
-      var expandAll = props.expandAll,
-        transform = props.transform;
-      var initialized = internalData.initialized;
-      var keyField = $xeTree.computeKeyField;
-      var parentField = $xeTree.computeParentField;
-      var mapChildrenField = $xeTree.computeMapChildrenField;
-      if (transform) {
-        reactData.treeList = _xeUtils.default.toArrayTree(list, {
-          key: keyField,
-          parentKey: parentField,
-          mapChildren: mapChildrenField
-        });
-      } else {
-        reactData.treeList = list ? list.slice(0) : [];
-      }
-      $xeTree.cacheNodeMap();
-      if (!initialized) {
-        if (list && list.length) {
-          internalData.initialized = true;
-          if (expandAll) {
-            $xeTree.setAllExpandNode(true);
-          }
-          $xeTree.setCheckboxByNodeId(props.checkNodeKeys || [], true);
-        }
-      }
-    },
-    handleCountLine: function handleCountLine(item, isRoot, nodeItem) {
-      var $xeTree = this;
-      var internalData = $xeTree.internalData;
-      var treeExpandedMaps = internalData.treeExpandedMaps;
-      var childrenField = $xeTree.computeChildrenField;
-      var nodeid = $xeTree.getNodeId(item);
-      nodeItem.lineCount++;
-      if (treeExpandedMaps[nodeid]) {
-        _xeUtils.default.arrayEach(item[childrenField], function (childItem, childIndex, childList) {
-          if (!isRoot || childIndex < childList.length - 1) {
-            $xeTree.handleCountLine(childItem, false, nodeItem);
-          }
-        });
-      }
-    },
-    updateNodeLine: function updateNodeLine(node) {
-      var $xeTree = this;
-      var internalData = $xeTree.internalData;
-      var nodeMaps = internalData.nodeMaps;
-      if (node) {
-        var nodeid = $xeTree.getNodeId(node);
-        var nodeItem = nodeMaps[nodeid];
-        if (nodeItem) {
-          _xeUtils.default.lastArrayEach(nodeItem.nodes, function (childItem) {
-            var nodeid = $xeTree.getNodeId(childItem);
-            var nodeItem = nodeMaps[nodeid];
-            if (nodeItem) {
-              nodeItem.lineCount = 0;
-              $xeTree.handleCountLine(childItem, true, nodeItem);
-            }
-          });
-        }
-      }
-    },
     handleNodeClickEvent: function handleNodeClickEvent(evnt, node) {
       var $xeTree = this;
       var props = $xeTree;
@@ -956,7 +1083,6 @@ var _default2 = exports.default = /* define-vxe-component start */(0, _comp.defi
                 if (!checkStrictly && $xeTree.isCheckedByCheckboxNodeId(nodeid)) {
                   $xeTree.handleCheckedCheckboxNode(childRows, true);
                 }
-                $xeTree.updateNodeLine(node);
                 $xeTree.dispatchEvent('load-success', {
                   node: node,
                   data: childRecords
@@ -964,7 +1090,6 @@ var _default2 = exports.default = /* define-vxe-component start */(0, _comp.defi
                 return $xeTree.$nextTick();
               });
             } else {
-              $xeTree.updateNodeLine(node);
               $xeTree.dispatchEvent('load-success', {
                 node: node,
                 data: childRecords
@@ -976,13 +1101,14 @@ var _default2 = exports.default = /* define-vxe-component start */(0, _comp.defi
             if (treeExpandLazyLoadedMaps[nodeid]) {
               treeExpandLazyLoadedMaps[nodeid] = false;
             }
-            $xeTree.updateNodeLine(node);
             $xeTree.dispatchEvent('load-error', {
               node: node,
               data: e
             }, new Event('load-error'));
           }).finally(function () {
-            return $xeTree.$nextTick();
+            $xeTree.handleTreeToList();
+            $xeTree.handleData();
+            return $xeTree.recalculate();
           });
         } else {
           resolve();
@@ -1058,8 +1184,11 @@ var _default2 = exports.default = /* define-vxe-component start */(0, _comp.defi
         });
       }
       reactData.updateExpandedFlag++;
-      expandNodes.forEach($xeTree.updateNodeLine);
-      return Promise.all(result);
+      $xeTree.handleTreeToList();
+      $xeTree.handleData();
+      return Promise.all(result).then(function () {
+        return $xeTree.recalculate();
+      });
     },
     toggleExpandEvent: function toggleExpandEvent(evnt, node) {
       var $xeTree = this;
@@ -1081,9 +1210,9 @@ var _default2 = exports.default = /* define-vxe-component start */(0, _comp.defi
       var reactData = $xeTree.reactData;
       var internalData = $xeTree.internalData;
       var transform = props.transform;
-      var treeList = reactData.treeList;
       var selectCheckboxMaps = internalData.selectCheckboxMaps,
-        indeterminateRowMaps = internalData.indeterminateRowMaps;
+        indeterminateRowMaps = internalData.indeterminateRowMaps,
+        afterTreeList = internalData.afterTreeList;
       var childrenField = $xeTree.computeChildrenField;
       var mapChildrenField = $xeTree.computeMapChildrenField;
       var checkboxOpts = $xeTree.computeCheckboxOpts;
@@ -1092,7 +1221,7 @@ var _default2 = exports.default = /* define-vxe-component start */(0, _comp.defi
       if (!checkStrictly) {
         var childRowMaps = {};
         var childRowList = [];
-        _xeUtils.default.eachTree(treeList, function (node) {
+        _xeUtils.default.eachTree(afterTreeList, function (node) {
           var nodeid = $xeTree.getNodeId(node);
           var childList = node[childrenField];
           if (childList && childList.length && !childRowMaps[nodeid]) {
@@ -1108,11 +1237,13 @@ var _default2 = exports.default = /* define-vxe-component start */(0, _comp.defi
           var childList = vals[2];
           var sLen = 0; // 已选
           var hLen = 0; // 半选
-          var vLen = 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) {
@@ -1138,8 +1269,25 @@ var _default2 = exports.default = /* define-vxe-component start */(0, _comp.defi
             }
             vLen++;
           });
-          var isSelected = sLen >= vLen;
-          var halfSelect = !isSelected && (sLen >= 1 || hLen >= 1);
+          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 (indeterminateRowMaps[nodeid]) {
@@ -1158,126 +1306,495 @@ var _default2 = exports.default = /* define-vxe-component start */(0, _comp.defi
             }
           }
         });
-        reactData.updateCheckboxFlag++;
+        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;
+      var childrenField = $xeTree.computeChildrenField;
+      var mapChildrenField = $xeTree.computeMapChildrenField;
+      var checkboxOpts = $xeTree.computeCheckboxOpts;
+      var checkStrictly = checkboxOpts.checkStrictly,
+        checkMethod = checkboxOpts.checkMethod;
+      var isDisabled = !!checkMethod;
+      if (checkMethod) {
+        isDisabled = !checkMethod({
+          $tree: $xeTree,
+          node: node
+        });
+      }
+      if (isDisabled) {
+        return;
+      }
+      var nodeid = $xeTree.getNodeId(node);
+      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 value = _xeUtils.default.keys(selectCheckboxMaps);
+      $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;
+      evnt.preventDefault();
+      evnt.stopPropagation();
+      var radioOpts = $xeTree.computeRadioOpts;
+      var checkMethod = radioOpts.checkMethod;
+      var isDisabled = !!checkMethod;
+      if (checkMethod) {
+        isDisabled = !checkMethod({
+          $tree: $xeTree,
+          node: node
+        });
+      }
+      if (isDisabled) {
+        return;
+      }
+      var isChecked = true;
+      var value = $xeTree.getNodeId(node);
+      reactData.selectRadioKey = value;
+      $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 $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[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;
+      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 = nodeKey;
+      return $xeTree.$nextTick();
+    },
+    getCheckboxNodeIds: function getCheckboxNodeIds() {
+      var $xeTree = this;
+      var internalData = $xeTree.internalData;
+      var selectCheckboxMaps = internalData.selectCheckboxMaps;
+      return Object.keys(selectCheckboxMaps);
+    },
+    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.selectCheckboxMaps = {};
+      reactData.updateCheckboxFlag++;
+      return $xeTree.$nextTick().then(function () {
+        return {
+          checkNodeKeys: []
+        };
+      });
+    },
+    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 = [];
+      if (checked) {
+        _xeUtils.default.eachTree(internalData.afterTreeList, function (node) {
+          var nodeid = $xeTree.getNodeId(node);
+          checkKeys.push(nodeid);
+          selectMaps[nodeid] = true;
+        }, {
+          children: transform ? mapChildrenField : childrenField
+        });
+      }
+      internalData.selectCheckboxMaps = selectMaps;
+      reactData.updateCheckboxFlag++;
+      return $xeTree.$nextTick().then(function () {
+        return {
+          checkNodeKeys: checkKeys
+        };
+      });
+    },
+    clearExpandNode: function clearExpandNode() {
+      var $xeTree = this;
+      return $xeTree.clearAllExpandNode();
+    },
+    clearAllExpandNode: function clearAllExpandNode() {
+      var $xeTree = this;
+      var reactData = $xeTree.reactData;
+      var internalData = $xeTree.internalData;
+      var nodeMaps = internalData.nodeMaps;
+      _xeUtils.default.each(nodeMaps, function (nodeItem) {
+        nodeItem.treeLoaded = false;
+      });
+      internalData.treeExpandedMaps = {};
+      reactData.updateExpandedFlag++;
+      $xeTree.handleTreeToList();
+      $xeTree.handleData();
+      return $xeTree.recalculate();
+    },
+    setExpandByNodeId: function setExpandByNodeId(nodeids, expanded) {
+      var $xeTree = this;
+      var reactData = $xeTree.reactData;
+      var internalData = $xeTree.internalData;
+      var treeExpandedMaps = internalData.treeExpandedMaps;
+      if (nodeids) {
+        if (!_xeUtils.default.isArray(nodeids)) {
+          nodeids = [nodeids];
+        }
+        nodeids.forEach(function (nodeid) {
+          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;
+      return _xeUtils.default.keys(treeExpandedMaps);
+    },
+    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(nodeids) {
+      var $xeTree = this;
+      var reactData = $xeTree.reactData;
+      var internalData = $xeTree.internalData;
+      var treeExpandedMaps = internalData.treeExpandedMaps;
+      if (nodeids) {
+        if (!_xeUtils.default.isArray(nodeids)) {
+          nodeids = [nodeids];
+        }
+        nodeids.forEach(function (nodeid) {
+          handleSetExpand(nodeid, !treeExpandedMaps[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();
     },
-    changeCheckboxEvent: function changeCheckboxEvent(evnt, node) {
+    setAllExpandNode: function setAllExpandNode(expanded) {
       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;
+      var treeExpandedMaps = internalData.treeExpandedMaps;
       var childrenField = $xeTree.computeChildrenField;
       var mapChildrenField = $xeTree.computeMapChildrenField;
-      var checkboxOpts = $xeTree.computeCheckboxOpts;
-      var checkStrictly = checkboxOpts.checkStrictly,
-        checkMethod = checkboxOpts.checkMethod;
-      var isDisabled = !!checkMethod;
-      if (checkMethod) {
-        isDisabled = !checkMethod({
-          node: node
-        });
-      }
-      if (isDisabled) {
-        return;
-      }
-      var nodeid = $xeTree.getNodeId(node);
-      var isChecked = false;
-      if (selectCheckboxMaps[nodeid]) {
-        delete selectCheckboxMaps[nodeid];
-      } else {
-        isChecked = true;
-        selectCheckboxMaps[nodeid] = node;
-      }
-      if (!checkStrictly) {
-        _xeUtils.default.eachTree(_xeUtils.default.get(node, childrenField), function (childNode) {
-          var childNodeid = $xeTree.getNodeId(childNode);
-          if (isChecked) {
-            if (!selectCheckboxMaps[childNodeid]) {
-              selectCheckboxMaps[childNodeid] = true;
-            }
-          } else {
-            if (selectCheckboxMaps[childNodeid]) {
-              delete selectCheckboxMaps[childNodeid];
-            }
+      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.updateCheckboxFlag++;
-      $xeTree.updateCheckboxStatus();
-      var value = _xeUtils.default.keys(selectCheckboxMaps);
-      $xeTree.emitCheckboxMode(value);
-      $xeTree.dispatchEvent('checkbox-change', {
-        node: node,
-        value: value,
-        checked: isChecked
-      }, evnt);
+      reactData.updateExpandedFlag++;
+      $xeTree.handleTreeToList();
+      $xeTree.handleData();
+      return $xeTree.recalculate();
     },
-    changeCurrentEvent: function changeCurrentEvent(evnt, node) {
+    reloadExpandNode: function reloadExpandNode(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 props = $xeTree;
+      var lazy = props.lazy;
+      if (lazy) {
+        $xeTree.clearExpandLoaded(node);
+        return $xeTree.handleAsyncTreeExpandChilds(node);
       }
-      var isChecked = true;
-      reactData.currentNode = node;
-      $xeTree.dispatchEvent('current-change', {
-        node: node,
-        checked: isChecked
-      }, evnt);
+      return $xeTree.recalculate();
     },
-    changeRadioEvent: function changeRadioEvent(evnt, node) {
+    clearExpandLoaded: function clearExpandLoaded(node) {
       var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      evnt.preventDefault();
-      evnt.stopPropagation();
-      var radioOpts = $xeTree.computeRadioOpts;
-      var checkMethod = radioOpts.checkMethod;
-      var isDisabled = !!checkMethod;
-      if (checkMethod) {
-        isDisabled = !checkMethod({
-          node: node
-        });
+      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;
+        }
       }
-      if (isDisabled) {
-        return;
+      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 isChecked = true;
-      var value = $xeTree.getNodeId(node);
-      reactData.selectRadioKey = value;
-      $xeTree.emitRadioMode(value);
-      $xeTree.dispatchEvent('radio-change', {
-        node: node,
-        value: value,
-        checked: isChecked
-      }, evnt);
+      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 (childRow, index, items, path, parent, nodes) {
+          var itemNodeId = $xeTree.getNodeId(childRow);
+          nodeMaps[itemNodeId] = {
+            item: node,
+            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;
+      });
+    },
+    getCheckboxIndeterminateNodes: function getCheckboxIndeterminateNodes() {
+      var $xeTree = this;
+      var internalData = $xeTree.internalData;
+      var nodeMaps = internalData.nodeMaps,
+        indeterminateRowMaps = internalData.indeterminateRowMaps;
+      var list = [];
+      _xeUtils.default.each(indeterminateRowMaps, function (item, nodeid) {
+        var nodeItem = nodeMaps[nodeid];
+        if (nodeItem) {
+          list.push(nodeItem.item);
+        }
+      });
+      return list;
     },
     //
     // Render
@@ -1291,12 +1808,14 @@ var _default2 = exports.default = /* define-vxe-component start */(0, _comp.defi
         checkMethod = radioOpts.checkMethod,
         visibleMethod = radioOpts.visibleMethod;
       var isVisible = !visibleMethod || visibleMethod({
+        $tree: $xeTree,
         node: node
       });
       var isDisabled = !!checkMethod;
       if (showRadio && showIcon && isVisible) {
         if (checkMethod) {
           isDisabled = !checkMethod({
+            $tree: $xeTree,
             node: node
           });
         }
@@ -1328,12 +1847,14 @@ var _default2 = exports.default = /* define-vxe-component start */(0, _comp.defi
         visibleMethod = checkboxOpts.visibleMethod;
       var isIndeterminate = $xeTree.isIndeterminateByCheckboxNodeid(nodeid);
       var isVisible = !visibleMethod || visibleMethod({
+        $tree: $xeTree,
         node: node
       });
       var isDisabled = !!checkMethod;
       if (showCheckbox && showIcon && isVisible) {
         if (checkMethod) {
           isDisabled = !checkMethod({
+            $tree: $xeTree,
             node: node
           });
         }
@@ -1356,7 +1877,7 @@ var _default2 = exports.default = /* define-vxe-component start */(0, _comp.defi
       }
       return (0, _ui.renderEmptyElement)($xeTree);
     },
-    renderNode: function renderNode(h, node) {
+    renderNode: function renderNode(h, node, nodeid) {
       var $xeTree = this;
       var props = $xeTree;
       var slots = $xeTree.$scopedSlots;
@@ -1374,7 +1895,8 @@ var _default2 = exports.default = /* define-vxe-component start */(0, _comp.defi
       var currentNode = reactData.currentNode,
         selectRadioKey = reactData.selectRadioKey,
         updateExpandedFlag = reactData.updateExpandedFlag;
-      var nodeMaps = internalData.nodeMaps,
+      var afterTreeList = internalData.afterTreeList,
+        nodeMaps = internalData.nodeMaps,
         treeExpandedMaps = internalData.treeExpandedMaps,
         treeExpandLazyLoadedMaps = internalData.treeExpandLazyLoadedMaps;
       var childrenField = $xeTree.computeChildrenField;
@@ -1385,14 +1907,12 @@ var _default2 = exports.default = /* define-vxe-component start */(0, _comp.defi
       var iconSlot = slots.icon;
       var titleSlot = slots.title;
       var extraSlot = slots.extra;
-      var nodeid = $xeTree.getNodeId(node);
       var isExpand = updateExpandedFlag && treeExpandedMaps[nodeid];
       var nodeItem = nodeMaps[nodeid];
       var nodeValue = _xeUtils.default.get(node, titleField);
       var isRadioChecked = false;
       if (showRadio) {
-        // eslint-disable-next-line eqeqeq
-        isRadioChecked = nodeid == selectRadioKey;
+        isRadioChecked = nodeid === String(selectRadioKey);
       }
       var isCheckboxChecked = false;
       if (showCheckbox) {
@@ -1406,23 +1926,13 @@ var _default2 = exports.default = /* define-vxe-component start */(0, _comp.defi
         hasLazyChilds = node[hasChildField];
         isLazyLoaded = !!nodeItem.treeLoaded;
       }
-      var childVns = [];
-      if (hasChild && treeExpandedMaps[nodeid]) {
-        if (showLine) {
-          childVns.push(h('div', {
-            key: 'line',
-            class: 'vxe-tree--node-child-line',
-            style: {
-              height: "calc(".concat(nodeItem.lineCount, " * var(--vxe-ui-tree-node-height) - var(--vxe-ui-tree-node-height) / 2)"),
-              left: "".concat((nodeItem.level + 1) * (indent || 1), "px")
-            }
-          }));
-        }
-        childList.forEach(function (childItem) {
-          childVns.push($xeTree.renderNode(h, childItem));
-        });
-      }
+      var prevNode = nodeItem.items[nodeItem.treeIndex - 1];
+      var nParams = {
+        node: node,
+        isExpand: isExpand
+      };
       return h('div', {
+        key: nodeid,
         class: ['vxe-tree--node-wrapper', "node--level-".concat(nodeItem.level)],
         attrs: {
           nodeid: nodeid
@@ -1444,7 +1954,14 @@ var _default2 = exports.default = /* define-vxe-component start */(0, _comp.defi
             $xeTree.handleNodeDblclickEvent(evnt, node);
           }
         }
-      }, [showIcon || showLine ? h('div', {
+      }, [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 ? hasChild : hasLazyChilds : hasChild) ? [h('div', {
         class: 'vxe-tree--node-item-icon',
@@ -1453,56 +1970,95 @@ var _default2 = exports.default = /* define-vxe-component start */(0, _comp.defi
             $xeTree.toggleExpandEvent(evnt, node);
           }
         }
-      }, iconSlot ? iconSlot({
-        node: node,
-        isExpand: isExpand
-      }) : [h('i', {
+      }, iconSlot ? (0, _vn.getSlotVNs)(iconSlot(nParams)) : [h('i', {
         class: isLazyLoading ? iconLoaded || (0, _ui.getIcon)().TREE_NODE_LOADED : isExpand ? iconOpen || (0, _ui.getIcon)().TREE_NODE_OPEN : iconClose || (0, _ui.getIcon)().TREE_NODE_CLOSE
-      })])] : []) : (0, _ui.renderEmptyElement)($xeTree), $xeTree.renderRadio(h, node, nodeid, isRadioChecked), $xeTree.renderCheckbox(h, node, nodeid, isCheckboxChecked), h('div', {
+      })])] : []), $xeTree.renderRadio(h, node, nodeid, isRadioChecked), $xeTree.renderCheckbox(h, node, nodeid, isCheckboxChecked), h('div', {
         class: 'vxe-tree--node-item-inner'
       }, [h('div', {
         class: 'vxe-tree--node-item-title'
-      }, titleSlot ? (0, _vn.getSlotVNs)(titleSlot({
-        node: node,
-        isExpand: isExpand
-      })) : "".concat(nodeValue)), extraSlot ? h('div', {
+      }, titleSlot ? (0, _vn.getSlotVNs)(titleSlot(nParams)) : "".concat(nodeValue)), extraSlot ? h('div', {
         class: 'vxe-tree--node-item-extra'
-      }, (0, _vn.getSlotVNs)(extraSlot({
-        node: node,
-        isExpand: isExpand
-      }))) : (0, _ui.renderEmptyElement)($xeTree)])]), hasChild && treeExpandedMaps[nodeid] ? h('div', {
-        class: 'vxe-tree--node-child-wrapper'
-      }, childVns) : (0, _ui.renderEmptyElement)($xeTree)]);
+      }, (0, _vn.getSlotVNs)(extraSlot(nParams))) : (0, _ui.renderEmptyElement)($xeTree)])])]);
     },
-    renderNodeList: function renderNodeList(h) {
+    renderList: function renderList(h, treeList) {
       var $xeTree = this;
-      var reactData = $xeTree.reactData;
-      var treeList = reactData.treeList;
-      return h('div', {
-        class: 'vxe-tree--node-list-wrapper'
-      }, treeList.map(function (node) {
-        return $xeTree.renderNode(h, node);
-      }));
+      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'
+        }, (0, _ui.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;
     },
     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;
       var vSize = $xeTree.computeSize;
       var radioOpts = $xeTree.computeRadioOpts;
       var checkboxOpts = $xeTree.computeCheckboxOpts;
-      var treeStyle = $xeTree.computeTreeStyle;
       var loadingOpts = $xeTree.computeLoadingOpts;
       var isRowHover = $xeTree.computeIsRowHover;
+      var treeStyle = $xeTree.computeTreeStyle;
       var loadingSlot = slots.loading;
+      var headerSlot = slots.header;
+      var footerSlot = slots.footer;
       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', isRowHover), 'node--trigger', trigger === 'node'), 'is--loading', loading)],
-        style: treeStyle
-      }, [$xeTree.renderNodeList(h),
+        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', isRowHover), 'node--trigger', trigger === 'node'), 'is--loading', loading)]
+      }, [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-select--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),
       /**
        * 加载中
        */
@@ -1526,7 +2082,7 @@ var _default2 = exports.default = /* define-vxe-component start */(0, _comp.defi
   watch: {
     data: function data(val) {
       var $xeTree = this;
-      $xeTree.loadTreeData(val || []);
+      $xeTree.loadData(val || []);
     },
     checkNodeKey: function checkNodeKey(val) {
       var $xeTree = this;
@@ -1537,6 +2093,22 @@ var _default2 = exports.default = /* define-vxe-component start */(0, _comp.defi
       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.recalculate();
+    },
+    minHeight: function minHeight() {
+      var $xeTree = this;
+      $xeTree.recalculate();
+    },
+    maxHeight: function maxHeight() {
+      var $xeTree = this;
+      $xeTree.recalculate();
     }
   },
   created: function created() {
@@ -1544,16 +2116,41 @@ var _default2 = exports.default = /* define-vxe-component start */(0, _comp.defi
     var props = $xeTree;
     var reactData = $xeTree.reactData;
     reactData.selectRadioKey = props.checkNodeKey || null;
-    $xeTree.loadTreeData(props.data || []);
+    $xeTree.loadData(props.data || []);
+  },
+  mounted: function mounted() {
+    var $xeTree = this;
+    var props = $xeTree;
+    var internalData = $xeTree.internalData;
+    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;
-    reactData.treeList = [];
+    var resizeObserver = internalData.resizeObserver;
+    if (resizeObserver) {
+      resizeObserver.disconnect();
+    }
     internalData.treeExpandedMaps = {};
     internalData.indeterminateRowMaps = {};
     internalData.nodeMaps = {};
+    _ui.globalEvents.off($xeTree, 'resize');
   },
   render: function render(h) {
     return this.renderVN(h);