vxe-pc-ui 4.7.5 → 4.7.7

package/lib/index.umd.js

@@ -3573,8 +3573,26 @@ setTheme();
       operError: '发生错误，操作失败！'
     },
     select: {
+      clear: '清除',
+      allChecked: '全选',
+      total: '{0} / {1}',
       search: '搜索',
       loadingText: '加载中',
+      emptyText: '暂无数据',
+      maxSize: '最大可选择的数量不能超过 {0} 个',
+      overSizeErr: '已超出最大可选数量 {0} 个，超出部分将被忽略！',
+      searchEmpty: '未匹配到数据！'
+    },
+    tree: {
+      searchEmpty: '未匹配到数据！'
+    },
+    treeSelect: {
+      clearChecked: '清除',
+      allChecked: '全选',
+      allExpand: '全部展开',
+      clearExpand: '全部收起',
+      total: '已选 {0}',
+      search: '搜索',
       emptyText: '暂无数据'
     },
     pager: {
@@ -4260,14 +4278,14 @@ function checkDynamic() {
 }
 ;// CONCATENATED MODULE: ./packages/ui/src/log.ts
 
-const log_version = `ui v${"4.7.5"}`;
+const log_version = `ui v${"4.7.7"}`;
 const warnLog = log.create('warn', log_version);
 const errLog = log.create('error', log_version);
 ;// CONCATENATED MODULE: ./packages/ui/index.ts
 
 
 
-const ui_version = "4.7.5";
+const ui_version = "4.7.7";
 index_esm_VxeUI.uiVersion = ui_version;
 index_esm_VxeUI.dynamicApp = dynamicApp;
 function config(options) {
@@ -4557,7 +4575,7 @@ setConfig({
     },
     virtualYConfig: {
       enabled: true,
-      gt: 100,
+      gt: 50,
       oSize: 2
     }
   },
@@ -4614,16 +4632,32 @@ setConfig({
     isArrow: true
   },
   tree: {
+    // autoResize: false,
     indent: 20,
     minHeight: 60,
     radioConfig: {
       strict: true
+    },
+    virtualYConfig: {
+      enabled: true,
+      gt: 50,
+      oSize: 2
     }
   },
   treeSelect: {
+    autoClose: true,
+    virtualYConfig: {
+      enabled: true,
+      gt: 0,
+      oSize: 2
+    },
     treeConfig: {
+      maxHeight: 300,
       radioConfig: {},
-      checkboxConfig: {}
+      checkboxConfig: {},
+      filterConfig: {
+        autoExpandAll: true
+      }
     }
   },
   upload: {
@@ -5106,6 +5140,15 @@ function getAbsolutePos(elem) {
     visibleWidth
   };
 }
+function getPaddingTopBottomSize(elem) {
+  if (elem) {
+    const computedStyle = getComputedStyle(elem);
+    const paddingTop = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toNumber(computedStyle.paddingTop);
+    const paddingBottom = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toNumber(computedStyle.paddingBottom);
+    return paddingTop + paddingBottom;
+  }
+  return 0;
+}
 const scrollIntoViewIfNeeded = 'scrollIntoViewIfNeeded';
 const scrollIntoView = 'scrollIntoView';
 function scrollToView(elem) {
@@ -24998,7 +25041,7 @@ const Link = VxeLink;
         ref: refVirtualBody,
         class: 'vxe-list--body',
         style: {
-          marginTop: topSpaceHeight ? `${topSpaceHeight}px` : ''
+          transform: `translateY(${topSpaceHeight}px)`
         }
       }, defaultSlot ? defaultSlot({
         items,
@@ -28541,6 +28584,7 @@ const Option = VxeOption;
 
 
 
+
 function isOptionVisible(option) {
   return option.visible !== false;
 }
@@ -28592,25 +28636,46 @@ function getOptUniqueId() {
     filterable: Boolean,
     filterMethod: Function,
     remote: Boolean,
-    // 已废弃，被 remote-config.queryMethod 替换
-    remoteMethod: Function,
     remoteConfig: Object,
     emptyText: String,
+    showTotalButoon: {
+      type: Boolean,
+      default: () => getConfig().select.showTotalButoon
+    },
+    showCheckedButoon: {
+      type: Boolean,
+      default: () => getConfig().select.showCheckedButoon
+    },
+    showClearButton: {
+      type: Boolean,
+      default: () => getConfig().select.showClearButton
+    },
     transfer: {
       type: Boolean,
       default: null
     },
     virtualYConfig: Object,
     scrollY: Object,
-    // 已废弃，被 option-config.keyField 替换
+    /**
+     * 已废弃，被 remote-config.queryMethod 替换
+     * @deprecated
+     */
+    remoteMethod: Function,
+    /**
+     * 已废弃，被 option-config.keyField 替换
+     * @deprecated
+     */
     optionId: {
       type: String,
       default: () => getConfig().select.optionId
     },
-    // 已废弃，被 option-config.useKey 替换
+    /**
+     * 已废弃，被 option-config.useKey 替换
+     * @deprecated
+     */
     optionKey: Boolean
   },
-  emits: ['update:modelValue', 'change', 'clear', 'blur', 'focus', 'click', 'scroll', 'visible-change'],
+  emits: ['update:modelValue', 'change', 'all-change', 'clear', 'blur', 'focus', 'click', 'scroll', 'visible-change'],
   setup(props, context) {
     const {
       slots,
@@ -28637,7 +28702,6 @@ function getOptUniqueId() {
       bodyHeight: 0,
       topSpaceHeight: 0,
       optList: [],
-      afterVisibleList: [],
       staticOptions: [],
       reactFlag: 0,
       currentOption: null,
@@ -28654,6 +28718,7 @@ function getOptUniqueId() {
     const internalData = {
       synchData: [],
       fullData: [],
+      afterVisibleList: [],
       optAddMaps: {},
       optGroupKeyMaps: {},
       optFullValMaps: {},
@@ -28760,16 +28825,11 @@ function getOptUniqueId() {
     });
     const computeIsMaximize = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
       const {
-        modelValue,
-        multiple,
-        max
+        modelValue
       } = props;
-      if (multiple && max) {
-        return (external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isArray(modelValue) ? modelValue.length : external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eqNull(modelValue) ? 0 : 1) >= external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toNumber(max);
-      }
-      return false;
+      return checkMaxLimit(modelValue);
     });
-    const computeSYOpts = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
+    const computeVirtualYOpts = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
       return Object.assign({}, getConfig().select.virtualYConfig || getConfig().select.scrollY, props.virtualYConfig || props.scrollY);
     });
     const computeRemoteOpts = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
@@ -28833,6 +28893,16 @@ function getOptUniqueId() {
       const optid = option[getOptKey()];
       return optid ? encodeURIComponent(optid) : '';
     };
+    const checkMaxLimit = selectVals => {
+      const {
+        multiple,
+        max
+      } = props;
+      if (multiple && max) {
+        return (external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isArray(selectVals) ? selectVals.length : external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eqNull(selectVals) ? 0 : 1) >= external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toNumber(max);
+      }
+      return false;
+    };
     const getRemoteSelectLabel = value => {
       const {
         remoteValMaps,
@@ -28923,7 +28993,7 @@ function getOptUniqueId() {
           cacheItem._index = index;
         }
       });
-      reactData.afterVisibleList = avList;
+      internalData.afterVisibleList = avList;
       return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
     };
     const setCurrentOption = option => {
@@ -28984,7 +29054,7 @@ function getOptUniqueId() {
         reactData.isAniVisible = true;
         if (filterable) {
           if (remote && remoteOpts.enabled && remoteOpts.autoLoad && !fullData.length) {
-            triggerSearchEvent();
+            handleSearchEvent();
           } else {
             handleOption();
             updateYData();
@@ -29042,6 +29112,52 @@ function getOptUniqueId() {
       clearValueEvent($event, null);
       hideOptionPanel();
     };
+    const allCheckedPanelEvent = params => {
+      const {
+        $event
+      } = params;
+      const {
+        modelValue,
+        multiple,
+        max
+      } = props;
+      const {
+        optList
+      } = reactData;
+      const valueField = computeValueField.value;
+      if (multiple) {
+        const multipleValue = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eqNull(modelValue) ? [] : external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isArray(modelValue) ? modelValue : [modelValue];
+        for (let i = 0; i < optList.length; i++) {
+          const option = optList[i];
+          const selectValue = option[valueField];
+          // 检测是否超过最大可选数量
+          if (checkMaxLimit(multipleValue)) {
+            if (index_esm_VxeUI) {
+              index_esm_VxeUI.modal.message({
+                content: getI18n('vxe.select.overSizeErr', [max]),
+                status: 'warning'
+              });
+            }
+            break;
+          }
+          if (!multipleValue.some(val => val === selectValue)) {
+            multipleValue.push(selectValue);
+          }
+        }
+        changeEvent($event, multipleValue);
+        dispatchEvent('all-change', {
+          value: multipleValue
+        }, $event);
+        hideOptionPanel();
+      }
+    };
+    const clearCheckedPanelEvent = params => {
+      const {
+        $event
+      } = params;
+      clearValueEvent($event, null);
+      hideOptionPanel();
+    };
     const changeOptionEvent = (evnt, option) => {
       const {
         modelValue,
@@ -29124,12 +29240,12 @@ function getOptUniqueId() {
         allowCreate
       } = props;
       const {
-        afterVisibleList,
         optList
       } = reactData;
       const {
         optFullValMaps,
-        optAddMaps
+        optAddMaps,
+        afterVisibleList
       } = internalData;
       const valueField = computeValueField.value;
       let fullList = afterVisibleList;
@@ -29342,13 +29458,10 @@ function getOptUniqueId() {
         }
       }
     };
-    const checkOptionDisabled = (isSelected, option, group) => {
+    const checkOptionDisabled = (isSelected, option) => {
       if (option.disabled) {
         return true;
       }
-      if (group && group.disabled) {
-        return true;
-      }
       const isMaximize = computeIsMaximize.value;
       if (isMaximize && !isSelected) {
         return true;
@@ -29357,11 +29470,11 @@ function getOptUniqueId() {
     };
     const updateYSpace = () => {
       const {
-        scrollYLoad,
-        afterVisibleList
+        scrollYLoad
       } = reactData;
       const {
-        scrollYStore
+        scrollYStore,
+        afterVisibleList
       } = internalData;
       reactData.bodyHeight = scrollYLoad ? afterVisibleList.length * scrollYStore.rowHeight : 0;
       reactData.topSpaceHeight = scrollYLoad ? Math.max(scrollYStore.startIndex * scrollYStore.rowHeight, 0) : 0;
@@ -29373,12 +29486,12 @@ function getOptUniqueId() {
       } = props;
       const {
         scrollYLoad,
-        afterVisibleList,
         searchValue
       } = reactData;
       const {
         optAddMaps,
-        scrollYStore
+        scrollYStore,
+        afterVisibleList
       } = internalData;
       const labelField = computeLabelField.value;
       const valueField = computeValueField.value;
@@ -29410,13 +29523,10 @@ function getOptUniqueId() {
           scrollYStore
         } = internalData;
         const virtualBodyElem = refVirtualBody.value;
-        const sYOpts = computeSYOpts.value;
+        const virtualYOpts = computeVirtualYOpts.value;
         let rowHeight = 0;
         let firstItemElem;
         if (virtualBodyElem) {
-          if (sYOpts.sItem) {
-            firstItemElem = virtualBodyElem.querySelector(sYOpts.sItem);
-          }
           if (!firstItemElem) {
             firstItemElem = virtualBodyElem.children[0];
           }
@@ -29430,7 +29540,7 @@ function getOptUniqueId() {
         if (scrollYLoad) {
           const scrollBodyElem = refVirtualWrapper.value;
           const visibleYSize = Math.max(8, scrollBodyElem ? Math.ceil(scrollBodyElem.clientHeight / rowHeight) : 0);
-          const offsetYSize = Math.max(0, Math.min(2, external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toNumber(sYOpts.oSize)));
+          const offsetYSize = Math.max(0, Math.min(2, external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toNumber(virtualYOpts.oSize)));
           scrollYStore.offsetSize = offsetYSize;
           scrollYStore.visibleSize = visibleYSize;
           scrollYStore.endIndex = Math.max(scrollYStore.startIndex, visibleYSize + offsetYSize, scrollYStore.endIndex);
@@ -29456,6 +29566,9 @@ function getOptUniqueId() {
         if (avIndex > -1) {
           const optWrapperElem = refVirtualWrapper.value;
           const panelElem = refOptionPanel.value;
+          if (!panelElem) {
+            return;
+          }
           const optElem = panelElem.querySelector(`[optid='${optid}']`);
           if (optWrapperElem) {
             if (optElem) {
@@ -29600,7 +29713,7 @@ function getOptUniqueId() {
         scrollYStore
       } = internalData;
       const defaultOpts = computeDefaultOpts.value;
-      const sYOpts = computeSYOpts.value;
+      const virtualYOpts = computeVirtualYOpts.value;
       const valueField = computeValueField.value;
       Object.assign(scrollYStore, {
         startIndex: 0,
@@ -29609,7 +29722,7 @@ function getOptUniqueId() {
       });
       internalData.synchData = datas || [];
       // 如果gt为0，则总是启用
-      reactData.scrollYLoad = !!sYOpts.enabled && sYOpts.gt > -1 && (sYOpts.gt === 0 || sYOpts.gt <= fullData.length);
+      reactData.scrollYLoad = !!virtualYOpts.enabled && virtualYOpts.gt > -1 && (virtualYOpts.gt === 0 || virtualYOpts.gt <= fullData.length);
       handleData();
       if (!isLoaded) {
         const {
@@ -29687,13 +29800,17 @@ function getOptUniqueId() {
       },
       focus() {
         const $input = refInput.value;
+        if ($input) {
+          $input.blur();
+        }
         reactData.isActivated = true;
-        $input.blur();
         return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
       },
       blur() {
         const $input = refInput.value;
-        $input.blur();
+        if ($input) {
+          $input.blur();
+        }
         reactData.isActivated = false;
         return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
       },
@@ -29701,7 +29818,7 @@ function getOptUniqueId() {
       clearScroll
     };
     Object.assign($xeSelect, selectMethods);
-    const renderOption = (list, group) => {
+    const renderOption = list => {
       const {
         allowCreate,
         optionKey,
@@ -29732,11 +29849,11 @@ function getOptUniqueId() {
         const isAdd = !!(allowCreate && optAddMaps[optid]);
         const isSelected = !isAdd && (external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isArray(modelValue) ? modelValue.indexOf(optionValue) > -1 : modelValue === optionValue);
         const isVisible = isAdd || !isOptGroup || isOptionVisible(option);
-        const isDisabled = !isAdd && checkOptionDisabled(isSelected, option, group);
+        const isDisabled = !isAdd && checkOptionDisabled(isSelected, option);
         const defaultSlot = slots ? slots.default : null;
         const optParams = {
           option,
-          group: null,
+          group: isOptGroup ? option : null,
           $select: $xeSelect
         };
         let optLabel = '';
@@ -29810,15 +29927,21 @@ function getOptUniqueId() {
     };
     const renderVN = () => {
       const {
+        modelValue,
         className,
         popupClassName,
+        multiple,
         loading,
-        filterable
+        filterable,
+        showTotalButoon,
+        showCheckedButoon,
+        showClearButton
       } = props;
       const {
         initialized,
         isActivated,
         isAniVisible,
+        optList,
         visiblePanel,
         bodyHeight,
         topSpaceHeight
@@ -29844,6 +29967,7 @@ function getOptUniqueId() {
           class: 'vxe-select-label'
         }, selectLabel)]);
       }
+      const selectVals = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eqNull(modelValue) ? [] : external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isArray(modelValue) ? modelValue : [modelValue];
       return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
         ref: refElem,
         class: ['vxe-select', className ? external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isFunction(className) ? className({
@@ -29910,9 +30034,23 @@ function getOptUniqueId() {
         onFocus: focusSearchEvent,
         onChange: triggerSearchEvent,
         onSearch: triggerSearchEvent
-      })]) : renderEmptyElement($xeSelect), headerSlot ? (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
+      })]) : renderEmptyElement($xeSelect), showTotalButoon || showCheckedButoon && multiple || showClearButton || headerSlot ? (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
         class: 'vxe-select--panel-header'
-      }, headerSlot({})) : renderEmptyElement($xeSelect), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
+      }, headerSlot ? callSlot(headerSlot, {}) : [(0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
+        class: 'vxe-select--header-button'
+      }, [showTotalButoon ? (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
+        class: 'vxe-select--header-total'
+      }, getI18n('vxe.select.total', [selectVals.length, optList.length])) : renderEmptyElement($xeSelect), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
+        class: 'vxe-select--header-btns'
+      }, [showCheckedButoon && multiple ? (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)(src_button, {
+        content: getI18n('vxe.select.allChecked'),
+        mode: 'text',
+        onClick: allCheckedPanelEvent
+      }) : renderEmptyElement($xeSelect), showClearButton ? (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)(src_button, {
+        content: getI18n('vxe.select.clear'),
+        mode: 'text',
+        onClick: clearCheckedPanelEvent
+      }) : renderEmptyElement($xeSelect)])])]) : renderEmptyElement($xeSelect), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
         class: 'vxe-select--panel-body'
       }, [(0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
         ref: refVirtualWrapper,
@@ -29927,11 +30065,11 @@ function getOptUniqueId() {
         ref: refVirtualBody,
         class: 'vxe-select--body',
         style: {
-          marginTop: topSpaceHeight ? `${topSpaceHeight}px` : ''
+          transform: `translateY(${topSpaceHeight}px)`
         }
       }, renderOpts())])]), footerSlot ? (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
         class: 'vxe-select--panel-footer'
-      }, footerSlot({})) : renderEmptyElement($xeSelect)])] : [])])]);
+      }, callSlot(footerSlot, {})) : renderEmptyElement($xeSelect)])] : [])])]);
     };
     (0,external_commonjs_vue_commonjs2_vue_root_Vue_.watch)(() => reactData.staticOptions, val => {
       loadData(val);
@@ -37175,6 +37313,52 @@ dynamicApp.use(VxeTooltip);
 index_esm_VxeUI.component(tooltip);
 const Tooltip = VxeTooltip;
 /* harmony default export */ var packages_tooltip = (VxeTooltip);
+;// CONCATENATED MODULE: ./packages/tree/src/util.ts
+function countTreeExpand($xeTree, prevNode) {
+  let count = 1;
+  if (!prevNode) {
+    return count;
+  }
+  const props = $xeTree.props;
+  const {
+    transform
+  } = props;
+  const reactData = $xeTree.reactData;
+  const {
+    updateExpandedFlag
+  } = reactData;
+  const internalData = $xeTree.internalData;
+  const {
+    treeExpandedMaps
+  } = internalData;
+  const {
+    computeChildrenField,
+    computeMapChildrenField
+  } = $xeTree.getComputeMaps();
+  const childrenField = computeChildrenField.value;
+  const mapChildrenField = computeMapChildrenField.value;
+  const nodeChildren = prevNode[transform ? mapChildrenField : childrenField];
+  if (nodeChildren && updateExpandedFlag && treeExpandedMaps[$xeTree.getNodeId(prevNode)]) {
+    for (let index = 0; index < nodeChildren.length; index++) {
+      count += countTreeExpand($xeTree, nodeChildren[index]);
+    }
+  }
+  return count;
+}
+function calcTreeLine($xeTree, node, prevNode) {
+  const internalData = $xeTree.internalData;
+  const {
+    scrollYStore
+  } = internalData;
+  const {
+    rowHeight
+  } = scrollYStore;
+  let expandSize = 1;
+  if (prevNode) {
+    expandSize = countTreeExpand($xeTree, prevNode);
+  }
+  return (rowHeight || 28) * expandSize - (prevNode ? 1 : 12);
+}
 ;// CONCATENATED MODULE: ./packages/tree/src/tree.ts
 
 
@@ -37184,6 +37368,8 @@ const Tooltip = VxeTooltip;
 
 
 
+
+
 /**
  * 生成节点的唯一主键
  */
@@ -37194,7 +37380,15 @@ function getNodeUniqueId() {
   name: 'VxeTree',
   props: {
     data: Array,
+    autoResize: {
+      type: Boolean,
+      default: () => getConfig().tree.autoResize
+    },
     height: [String, Number],
+    maxHeight: {
+      type: [String, Number],
+      default: () => getConfig().tree.maxHeight
+    },
     minHeight: {
       type: [String, Number],
       default: () => getConfig().tree.minHeight
@@ -37286,12 +37480,15 @@ function getNodeUniqueId() {
       type: String,
       default: () => getConfig().tree.iconLoaded
     },
+    filterValue: [String, Number],
+    filterConfig: Object,
     size: {
       type: String,
       default: () => getConfig().tree.size || getConfig().size
-    }
+    },
+    virtualYConfig: Object
   },
-  emits: ['update:modelValue', 'update:checkNodeKey', 'update:checkNodeKeys', 'node-click', 'node-dblclick', 'current-change', 'radio-change', 'checkbox-change', 'load-success', 'load-error'],
+  emits: ['update:modelValue', 'update:checkNodeKey', 'update:checkNodeKeys', 'node-click', 'node-dblclick', 'current-change', 'radio-change', 'checkbox-change', 'load-success', 'load-error', 'scroll'],
   setup(props, context) {
     const {
       emit,
@@ -37302,8 +37499,19 @@ function getNodeUniqueId() {
       computeSize
     } = useSize(props);
     const refElem = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.ref)();
+    const refHeaderWrapperElem = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.ref)();
+    const refFooterWrapperElem = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.ref)();
+    const refVirtualWrapper = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.ref)();
+    const refVirtualBody = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.ref)();
     const reactData = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.reactive)({
+      parentHeight: 0,
+      customHeight: 0,
+      customMinHeight: 0,
+      customMaxHeight: 0,
       currentNode: null,
+      scrollYLoad: false,
+      bodyHeight: 0,
+      topSpaceHeight: 0,
       selectRadioKey: props.checkNodeKey,
       treeList: [],
       updateExpandedFlag: 1,
@@ -37311,11 +37519,26 @@ function getNodeUniqueId() {
     });
     const 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
     };
     const refMaps = {
       refElem
@@ -37342,6 +37565,9 @@ function getNodeUniqueId() {
     const computeHasChildField = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
       return props.hasChildField || 'hasChild';
     });
+    const computeVirtualYOpts = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
+      return Object.assign({}, getConfig().tree.virtualYConfig, props.virtualYConfig);
+    });
     const computeIsRowCurrent = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
       const nodeOpts = computeNodeOpts.value;
       const {
@@ -37380,19 +37606,28 @@ function getNodeUniqueId() {
     });
     const computeTreeStyle = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
       const {
-        height,
-        minHeight
-      } = props;
+        customHeight,
+        customMinHeight,
+        customMaxHeight
+      } = reactData;
       const stys = {};
-      if (height) {
-        stys.height = toCssUnit(height);
+      if (customHeight) {
+        stys.height = toCssUnit(customHeight);
       }
-      if (minHeight) {
-        stys.minHeight = toCssUnit(minHeight);
+      if (customMinHeight) {
+        stys.minHeight = toCssUnit(customMinHeight);
+      }
+      if (customMaxHeight) {
+        stys.maxHeight = toCssUnit(customMaxHeight);
       }
       return stys;
     });
+    const computeFilterOpts = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
+      return Object.assign({}, getConfig().tree.filterConfig, props.filterConfig);
+    });
     const computeMaps = {
+      computeChildrenField,
+      computeMapChildrenField,
       computeRadioOpts,
       computeCheckboxOpts,
       computeNodeOpts
@@ -37548,6 +37783,39 @@ function getNodeUniqueId() {
         $tree: $xeTree
       }, params));
     };
+    const getParentElem = () => {
+      const el = refElem.value;
+      return el ? el.parentElement : null;
+    };
+    const calcTableHeight = key => {
+      const {
+        parentHeight
+      } = reactData;
+      const val = props[key];
+      let num = 0;
+      if (val) {
+        if (val === '100%' || val === 'auto') {
+          num = parentHeight;
+        } else {
+          if (isScale(val)) {
+            num = Math.floor((external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toInteger(val) || 1) / 100 * parentHeight);
+          } else {
+            num = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toNumber(val);
+          }
+          num = Math.max(40, num);
+        }
+      }
+      return num;
+    };
+    const updateHeight = () => {
+      reactData.customHeight = calcTableHeight('height');
+      reactData.customMinHeight = calcTableHeight('minHeight');
+      reactData.customMaxHeight = calcTableHeight('maxHeight');
+      // 如果启用虚拟滚动，默认高度
+      if (reactData.scrollYLoad && !(reactData.customHeight || reactData.customMinHeight)) {
+        reactData.customHeight = 300;
+      }
+    };
     const createNode = records => {
       const valueField = computeValueField.value;
       return Promise.resolve(records.map(obj => {
@@ -37562,428 +37830,454 @@ function getNodeUniqueId() {
         return item;
       }));
     };
-    const treeMethods = {
-      dispatchEvent,
-      clearCurrentNode() {
-        reactData.currentNode = null;
-        return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
-      },
-      getCurrentNodeId() {
-        const {
-          currentNode
-        } = reactData;
-        if (currentNode) {
-          return getNodeId(currentNode);
+    const cacheNodeMap = () => {
+      const {
+        treeFullData
+      } = internalData;
+      const valueField = computeValueField.value;
+      const childrenField = computeChildrenField.value;
+      const keyMaps = {};
+      external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eachTree(treeFullData, (item, index, items, path, parent, nodes) => {
+        let nodeid = getNodeId(item);
+        if (!nodeid) {
+          nodeid = getNodeUniqueId();
+          external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().set(item, valueField, nodeid);
         }
-        return null;
-      },
-      getCurrentNode() {
-        const {
-          currentNode
-        } = reactData;
-        const {
-          nodeMaps
-        } = internalData;
-        if (currentNode) {
-          const nodeItem = nodeMaps[getNodeId(currentNode)];
-          if (nodeItem) {
-            return nodeItem.item;
-          }
+        keyMaps[nodeid] = {
+          item,
+          index,
+          items,
+          parent,
+          nodes,
+          level: nodes.length,
+          treeIndex: index,
+          lineCount: 0,
+          treeLoaded: false
+        };
+      }, {
+        children: childrenField
+      });
+      internalData.nodeMaps = keyMaps;
+    };
+    const updateAfterDataIndex = () => {
+      const {
+        transform
+      } = props;
+      const {
+        afterTreeList,
+        nodeMaps
+      } = internalData;
+      const childrenField = computeChildrenField.value;
+      const mapChildrenField = computeMapChildrenField.value;
+      external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eachTree(afterTreeList, (item, index, items) => {
+        const nodeid = getNodeId(item);
+        const nodeItem = nodeMaps[nodeid];
+        if (nodeItem) {
+          nodeItem.items = items;
+          nodeItem.treeIndex = index;
+        } else {
+          const rest = {
+            item,
+            index,
+            items,
+            parent,
+            nodes: [],
+            level: 0,
+            treeIndex: index,
+            lineCount: 0,
+            treeLoaded: false
+          };
+          nodeMaps[nodeid] = rest;
         }
-        return null;
-      },
-      setCurrentNodeId(nodeKey) {
-        const {
-          nodeMaps
-        } = internalData;
-        const nodeItem = nodeMaps[nodeKey];
-        reactData.currentNode = nodeItem ? nodeItem.item : null;
-        return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
-      },
-      setCurrentNode(node) {
-        reactData.currentNode = node;
-        return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
-      },
-      clearRadioNode() {
-        reactData.selectRadioKey = null;
-        return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
-      },
-      getRadioNodeId() {
-        return reactData.selectRadioKey || null;
-      },
-      getRadioNode() {
-        const {
-          selectRadioKey
-        } = reactData;
-        const {
-          nodeMaps
-        } = internalData;
-        if (selectRadioKey) {
-          const nodeItem = nodeMaps[selectRadioKey];
-          if (nodeItem) {
-            return nodeItem.item;
-          }
+      }, {
+        children: transform ? mapChildrenField : childrenField
+      });
+    };
+    const updateAfterFullData = () => {
+      const {
+        transform,
+        filterValue
+      } = props;
+      const {
+        treeFullData,
+        lastFilterValue
+      } = internalData;
+      const titleField = computeTitleField.value;
+      const childrenField = computeChildrenField.value;
+      const mapChildrenField = computeMapChildrenField.value;
+      const filterOpts = computeFilterOpts.value;
+      const {
+        autoExpandAll,
+        beforeFilterMethod,
+        filterMethod,
+        afterFilterMethod
+      } = filterOpts;
+      let fullList = treeFullData;
+      let treeList = fullList;
+      let filterStr = '';
+      if (filterValue || filterValue === 0) {
+        filterStr = `${filterValue}`;
+        const handleSearch = filterMethod ? item => {
+          return filterMethod({
+            $tree: $xeTree,
+            node: item,
+            filterValue: filterStr
+          });
+        } : item => {
+          return String(item[titleField]).toLowerCase().indexOf(filterStr) > -1;
+        };
+        const bafParams = {
+          $tree: $xeTree,
+          filterValue: filterStr
+        };
+        if (beforeFilterMethod) {
+          beforeFilterMethod(bafParams);
+        }
+        if (transform) {
+          treeList = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().searchTree(treeFullData, handleSearch, {
+            children: childrenField,
+            mapChildren: mapChildrenField,
+            isEvery: true
+          });
+          fullList = treeList;
+        } else {
+          fullList = treeFullData.filter(handleSearch);
         }
-        return null;
-      },
-      setRadioNodeId(nodeKey) {
-        reactData.selectRadioKey = nodeKey;
-        return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
-      },
-      setRadioNode,
-      setCheckboxNode,
-      setCheckboxByNodeId,
-      getCheckboxNodeIds() {
-        const {
-          selectCheckboxMaps
-        } = internalData;
-        return Object.keys(selectCheckboxMaps);
-      },
-      getCheckboxNodes() {
-        const {
-          nodeMaps,
-          selectCheckboxMaps
-        } = internalData;
-        const list = [];
-        external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().each(selectCheckboxMaps, (item, nodeid) => {
-          const nodeItem = nodeMaps[nodeid];
-          if (nodeItem) {
-            list.push(nodeItem.item);
+        internalData.lastFilterValue = filterStr;
+        (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)(() => {
+          // 筛选时自动展开
+          if (autoExpandAll) {
+            $xeTree.setAllExpandNode(true).then(() => {
+              if (afterFilterMethod) {
+                afterFilterMethod(bafParams);
+              }
+            });
+          } else {
+            if (afterFilterMethod) {
+              afterFilterMethod(bafParams);
+            }
           }
         });
-        return list;
-      },
-      clearCheckboxNode() {
-        internalData.selectCheckboxMaps = {};
-        reactData.updateCheckboxFlag++;
-        return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
-      },
-      setAllCheckboxNode(checked) {
-        const {
-          transform
-        } = props;
-        const selectMaps = {};
-        const childrenField = computeChildrenField.value;
-        const mapChildrenField = computeMapChildrenField.value;
-        if (checked) {
-          external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eachTree(reactData.treeList, node => {
-            const nodeid = getNodeId(node);
-            selectMaps[nodeid] = true;
-          }, {
-            children: transform ? mapChildrenField : childrenField
+      } else {
+        if (transform) {
+          treeList = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().searchTree(treeFullData, () => true, {
+            children: childrenField,
+            mapChildren: mapChildrenField,
+            isEvery: true
           });
+          fullList = treeList;
+          if (lastFilterValue) {
+            const bafParams = {
+              $tree: $xeTree,
+              filterValue: filterStr
+            };
+            if (beforeFilterMethod) {
+              beforeFilterMethod(bafParams);
+            }
+            // 取消筛选时自动收起
+            (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)(() => {
+              if (autoExpandAll) {
+                $xeTree.clearAllExpandNode().then(() => {
+                  if (afterFilterMethod) {
+                    afterFilterMethod(bafParams);
+                  }
+                });
+              } else {
+                if (afterFilterMethod) {
+                  afterFilterMethod(bafParams);
+                }
+              }
+            });
+          }
         }
-        internalData.selectCheckboxMaps = selectMaps;
-        reactData.updateCheckboxFlag++;
-        return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
-      },
-      clearExpandNode() {
-        return treeMethods.clearAllExpandNode();
-      },
-      clearAllExpandNode() {
-        const {
-          nodeMaps
-        } = internalData;
-        external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().each(nodeMaps, nodeItem => {
-          nodeItem.treeLoaded = false;
+        internalData.lastFilterValue = '';
+      }
+      internalData.afterVisibleList = fullList;
+      internalData.afterTreeList = treeList;
+      updateAfterDataIndex();
+    };
+    /**
+     * 如果为虚拟树、则将树结构拍平
+     */
+    const handleTreeToList = () => {
+      const {
+        transform
+      } = props;
+      const {
+        afterTreeList,
+        treeExpandedMaps
+      } = internalData;
+      const mapChildrenField = computeMapChildrenField.value;
+      const expandMaps = {};
+      if (transform) {
+        const fullData = [];
+        external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eachTree(afterTreeList, (item, index, items, path, parentRow) => {
+          const nodeid = getNodeId(item);
+          const parentNodeid = getNodeId(parentRow);
+          if (!parentRow || expandMaps[parentNodeid] && treeExpandedMaps[parentNodeid]) {
+            expandMaps[nodeid] = 1;
+            fullData.push(item);
+          }
+        }, {
+          children: mapChildrenField
         });
-        internalData.treeExpandedMaps = {};
-        reactData.updateExpandedFlag++;
-        return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
-      },
-      setExpandByNodeId(nodeids, expanded) {
-        const {
-          treeExpandedMaps
-        } = internalData;
-        if (nodeids) {
-          if (!external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isArray(nodeids)) {
-            nodeids = [nodeids];
+        updateScrollYStatus(fullData);
+        internalData.afterVisibleList = fullData;
+        return fullData;
+      }
+      return internalData.afterVisibleList;
+    };
+    const handleData = force => {
+      const {
+        scrollYLoad
+      } = reactData;
+      const {
+        scrollYStore
+      } = internalData;
+      let fullList = internalData.afterVisibleList;
+      if (force) {
+        // 更新数据，处理筛选和排序
+        updateAfterFullData();
+        // 如果为虚拟树，将树结构拍平
+        fullList = handleTreeToList();
+      }
+      const treeList = scrollYLoad ? fullList.slice(scrollYStore.startIndex, scrollYStore.endIndex) : fullList.slice(0);
+      reactData.treeList = treeList;
+    };
+    const triggerSearchEvent = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().debounce(() => handleData(true), 350, {
+      trailing: true
+    });
+    const loadData = list => {
+      const {
+        expandAll,
+        transform
+      } = props;
+      const {
+        initialized,
+        scrollYStore
+      } = internalData;
+      const keyField = computeKeyField.value;
+      const parentField = computeParentField.value;
+      const childrenField = computeChildrenField.value;
+      const fullData = transform ? external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_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
+      });
+      const sYLoad = updateScrollYStatus(fullData);
+      cacheNodeMap();
+      handleData(true);
+      if (sYLoad) {
+        if (!(props.height || props.maxHeight)) {
+          errLog('vxe.error.reqProp', ['height | max-height | virtual-y-config.enabled=false']);
+        }
+      }
+      return computeScrollLoad().then(() => {
+        if (!initialized) {
+          if (list && list.length) {
+            internalData.initialized = true;
+            if (expandAll) {
+              $xeTree.setAllExpandNode(true);
+            }
+            $xeTree.setCheckboxByNodeId(props.checkNodeKeys || [], true);
           }
-          nodeids.forEach(nodeid => {
-            handleSetExpand(nodeid, expanded, treeExpandedMaps);
-          });
-          reactData.updateExpandedFlag++;
         }
-        return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
-      },
-      getExpandNodeIds() {
-        const {
-          treeExpandedMaps
-        } = internalData;
-        return external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().keys(treeExpandedMaps);
-      },
-      getExpandNodes() {
+        updateHeight();
+        refreshScroll();
+      });
+    };
+    const updateScrollYStatus = fullData => {
+      const {
+        transform
+      } = props;
+      const virtualYOpts = computeVirtualYOpts.value;
+      const allList = fullData || internalData.treeFullData;
+      // 如果gt为0，则总是启用
+      const scrollYLoad = !!transform && !!virtualYOpts.enabled && virtualYOpts.gt > -1 && (virtualYOpts.gt === 0 || virtualYOpts.gt < allList.length);
+      reactData.scrollYLoad = scrollYLoad;
+      return scrollYLoad;
+    };
+    const updateYSpace = () => {
+      const {
+        scrollYLoad
+      } = reactData;
+      const {
+        scrollYStore,
+        afterVisibleList
+      } = internalData;
+      reactData.bodyHeight = scrollYLoad ? afterVisibleList.length * scrollYStore.rowHeight : 0;
+      reactData.topSpaceHeight = scrollYLoad ? Math.max(scrollYStore.startIndex * scrollYStore.rowHeight, 0) : 0;
+    };
+    const updateYData = () => {
+      handleData();
+      updateYSpace();
+    };
+    const computeScrollLoad = () => {
+      return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)().then(() => {
         const {
-          nodeMaps,
-          treeExpandedMaps
-        } = internalData;
-        const list = [];
-        external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().each(treeExpandedMaps, (item, nodeid) => {
-          const nodeItem = nodeMaps[nodeid];
-          if (nodeItem) {
-            list.push(nodeItem.item);
-          }
-        });
-        return list;
-      },
-      setExpandNode(nodes, expanded) {
+          scrollYLoad
+        } = reactData;
         const {
-          treeExpandedMaps
+          scrollYStore
         } = internalData;
-        if (nodes) {
-          if (!external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isArray(nodes)) {
-            nodes = [nodes];
+        const virtualBodyElem = refVirtualBody.value;
+        const virtualYOpts = computeVirtualYOpts.value;
+        let rowHeight = 0;
+        let firstItemElem;
+        if (virtualBodyElem) {
+          if (!firstItemElem) {
+            firstItemElem = virtualBodyElem.children[0];
           }
-          nodes.forEach(node => {
-            const nodeid = getNodeId(node);
-            handleSetExpand(nodeid, expanded, treeExpandedMaps);
-          });
-          reactData.updateExpandedFlag++;
-        }
-        return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
-      },
-      toggleExpandByNodeId(nodeids) {
-        const {
-          treeExpandedMaps
-        } = internalData;
-        if (nodeids) {
-          if (!external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isArray(nodeids)) {
-            nodeids = [nodeids];
-          }
-          nodeids.forEach(nodeid => {
-            handleSetExpand(nodeid, !treeExpandedMaps[nodeid], treeExpandedMaps);
-          });
-          reactData.updateExpandedFlag++;
         }
-        return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
-      },
-      toggleExpandNode(nodes) {
-        const {
-          treeExpandedMaps
-        } = internalData;
-        if (nodes) {
-          if (!external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isArray(nodes)) {
-            nodes = [nodes];
-          }
-          nodes.forEach(node => {
-            const nodeid = getNodeId(node);
-            handleSetExpand(nodeid, !treeExpandedMaps[nodeid], treeExpandedMaps);
-          });
-          reactData.updateExpandedFlag++;
+        if (firstItemElem) {
+          rowHeight = firstItemElem.offsetHeight;
         }
-        return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
-      },
-      setAllExpandNode(expanded) {
-        const {
-          transform
-        } = props;
-        const {
-          treeExpandedMaps
-        } = internalData;
-        const childrenField = computeChildrenField.value;
-        const mapChildrenField = computeMapChildrenField.value;
-        if (expanded) {
-          external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eachTree(reactData.treeList, node => {
-            const childList = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().get(node, childrenField);
-            const hasChild = childList && childList.length;
-            if (hasChild) {
-              const nodeid = getNodeId(node);
-              treeExpandedMaps[nodeid] = true;
-            }
-          }, {
-            children: transform ? mapChildrenField : childrenField
-          });
+        rowHeight = Math.max(20, rowHeight);
+        scrollYStore.rowHeight = rowHeight;
+        // 计算 Y 逻辑
+        if (scrollYLoad) {
+          const scrollBodyElem = refVirtualWrapper.value;
+          const visibleYSize = Math.max(8, scrollBodyElem ? Math.ceil(scrollBodyElem.clientHeight / rowHeight) : 0);
+          const offsetYSize = Math.max(0, Math.min(2, external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toNumber(virtualYOpts.oSize)));
+          scrollYStore.offsetSize = offsetYSize;
+          scrollYStore.visibleSize = visibleYSize;
+          scrollYStore.endIndex = Math.max(scrollYStore.startIndex, visibleYSize + offsetYSize, scrollYStore.endIndex);
+          updateYData();
         } else {
-          internalData.treeExpandedMaps = {};
-        }
-        reactData.updateExpandedFlag++;
-        return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
-      },
-      reloadExpandNode(node) {
-        const {
-          lazy
-        } = props;
-        if (lazy) {
-          treeMethods.clearExpandLoaded(node);
-          return handleAsyncTreeExpandChilds(node);
+          updateYSpace();
         }
-        return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
-      },
-      clearExpandLoaded(node) {
-        const {
-          lazy
-        } = props;
-        const {
-          nodeMaps
-        } = internalData;
-        if (lazy) {
-          const nodeItem = nodeMaps[getNodeId(node)];
-          if (nodeItem) {
-            nodeItem.treeLoaded = false;
-          }
+      });
+    };
+    /**
+     * 如果有滚动条，则滚动到对应的位置
+     * @param {Number} scrollLeft 左距离
+     * @param {Number} scrollTop 上距离
+     */
+    const scrollTo = (scrollLeft, scrollTop) => {
+      const scrollBodyElem = refVirtualWrapper.value;
+      if (scrollBodyElem) {
+        if (external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isNumber(scrollLeft)) {
+          scrollBodyElem.scrollLeft = scrollLeft;
         }
-        return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
-      },
-      /**
-       * 用于树结构，给行数据加载子节点
-       */
-      loadChildrenNode(node, childRecords) {
-        const {
-          lazy,
-          transform
-        } = props;
-        const {
-          nodeMaps
-        } = internalData;
-        if (!lazy) {
-          return Promise.resolve([]);
+        if (external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isNumber(scrollTop)) {
+          scrollBodyElem.scrollTop = scrollTop;
         }
-        const childrenField = computeChildrenField.value;
-        const parentNodeItem = nodeMaps[getNodeId(node)];
-        const parentLevel = parentNodeItem ? parentNodeItem.level : 0;
-        const parentNodes = parentNodeItem ? parentNodeItem.nodes : [];
-        return createNode(childRecords).then(nodeList => {
-          external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eachTree(nodeList, (childRow, index, items, path, parent, nodes) => {
-            const itemNodeId = getNodeId(childRow);
-            nodeMaps[itemNodeId] = {
-              item: node,
-              itemIndex: -1,
-              items,
-              parent: parent || parentNodeItem.item,
-              nodes: parentNodes.concat(nodes),
-              level: parentLevel + nodes.length,
-              lineCount: 0,
-              treeLoaded: false
-            };
-          }, {
-            children: childrenField
-          });
-          node[childrenField] = nodeList;
-          if (transform) {
-            node[childrenField] = nodeList;
-          }
-          updateNodeLine(node);
-          return nodeList;
-        });
-      },
-      isExpandByNode,
-      isCheckedByRadioNodeId,
-      isCheckedByRadioNode,
-      isCheckedByCheckboxNodeId,
-      isIndeterminateByCheckboxNode,
-      isCheckedByCheckboxNode,
-      getCheckboxIndeterminateNodes() {
-        const {
-          nodeMaps,
-          indeterminateRowMaps
-        } = internalData;
-        const list = [];
-        external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().each(indeterminateRowMaps, (item, nodeid) => {
-          const nodeItem = nodeMaps[nodeid];
-          if (nodeItem) {
-            list.push(nodeItem.item);
-          }
+      }
+      if (reactData.scrollYLoad) {
+        return new Promise(resolve => {
+          setTimeout(() => {
+            (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)(() => {
+              resolve();
+            });
+          }, 50);
         });
-        return list;
       }
+      return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
     };
-    const cacheNodeMap = () => {
-      const {
-        transform
-      } = props;
+    /**
+     * 刷新滚动条
+     */
+    const refreshScroll = () => {
       const {
-        treeList
-      } = reactData;
-      const valueField = computeValueField.value;
-      const childrenField = computeChildrenField.value;
-      const mapChildrenField = computeMapChildrenField.value;
-      const keyMaps = {};
-      external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eachTree(treeList, (item, itemIndex, items, path, parent, nodes) => {
-        let nodeid = getNodeId(item);
-        if (!nodeid) {
-          nodeid = getNodeUniqueId();
-          external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().set(item, valueField, nodeid);
+        lastScrollLeft,
+        lastScrollTop
+      } = internalData;
+      return clearScroll().then(() => {
+        if (lastScrollLeft || lastScrollTop) {
+          internalData.lastScrollLeft = 0;
+          internalData.lastScrollTop = 0;
+          return scrollTo(lastScrollLeft, lastScrollTop);
         }
-        keyMaps[nodeid] = {
-          item,
-          itemIndex,
-          items,
-          parent,
-          nodes,
-          level: nodes.length,
-          lineCount: 0,
-          treeLoaded: false
-        };
-      }, {
-        children: transform ? mapChildrenField : childrenField
       });
-      internalData.nodeMaps = keyMaps;
     };
-    const loadTreeData = list => {
-      const {
-        expandAll,
-        transform
-      } = props;
+    /**
+     * 重新计算列表
+     */
+    const recalculate = () => {
       const {
-        initialized
+        scrollYStore
       } = internalData;
-      const keyField = computeKeyField.value;
-      const parentField = computeParentField.value;
-      const mapChildrenField = computeMapChildrenField.value;
-      if (transform) {
-        reactData.treeList = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toArrayTree(list, {
-          key: keyField,
-          parentKey: parentField,
-          mapChildren: mapChildrenField
-        });
-      } else {
-        reactData.treeList = list ? list.slice(0) : [];
-      }
-      cacheNodeMap();
-      if (!initialized) {
-        if (list && list.length) {
-          internalData.initialized = true;
-          if (expandAll) {
-            $xeTree.setAllExpandNode(true);
-          }
-          $xeTree.setCheckboxByNodeId(props.checkNodeKeys || [], true);
-        }
-      }
-    };
-    const handleCountLine = (item, isRoot, nodeItem) => {
       const {
-        treeExpandedMaps
-      } = internalData;
-      const childrenField = computeChildrenField.value;
-      const nodeid = getNodeId(item);
-      nodeItem.lineCount++;
-      if (treeExpandedMaps[nodeid]) {
-        external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().arrayEach(item[childrenField], (childItem, childIndex, childList) => {
-          if (!isRoot || childIndex < childList.length - 1) {
-            handleCountLine(childItem, false, nodeItem);
-          }
+        rowHeight
+      } = scrollYStore;
+      const el = refElem.value;
+      if (el && el.clientWidth && el.clientHeight) {
+        const parentEl = getParentElem();
+        const headerWrapperEl = refHeaderWrapperElem.value;
+        const footerWrapperEl = refFooterWrapperElem.value;
+        const headHeight = headerWrapperEl ? headerWrapperEl.clientHeight : 0;
+        const footHeight = footerWrapperEl ? footerWrapperEl.clientHeight : 0;
+        if (parentEl) {
+          const parentPaddingSize = getPaddingTopBottomSize(parentEl);
+          reactData.parentHeight = Math.max(headHeight + footHeight + rowHeight, parentEl.clientHeight - parentPaddingSize - headHeight - footHeight);
+        }
+        updateHeight();
+        return computeScrollLoad().then(() => {
+          updateHeight();
+          updateYSpace();
         });
       }
+      return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
     };
-    const updateNodeLine = node => {
+    const loadYData = evnt => {
       const {
-        nodeMaps
+        scrollYStore
       } = internalData;
-      if (node) {
-        const nodeid = getNodeId(node);
-        const nodeItem = nodeMaps[nodeid];
-        if (nodeItem) {
-          external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().lastArrayEach(nodeItem.nodes, childItem => {
-            const nodeid = getNodeId(childItem);
-            const nodeItem = nodeMaps[nodeid];
-            if (nodeItem) {
-              nodeItem.lineCount = 0;
-              handleCountLine(childItem, true, nodeItem);
-            }
-          });
+      const {
+        startIndex,
+        endIndex,
+        visibleSize,
+        offsetSize,
+        rowHeight
+      } = scrollYStore;
+      const scrollBodyElem = evnt.target;
+      const scrollTop = scrollBodyElem.scrollTop;
+      const toVisibleIndex = Math.floor(scrollTop / rowHeight);
+      const offsetStartIndex = Math.max(0, toVisibleIndex - 1 - offsetSize);
+      const offsetEndIndex = toVisibleIndex + visibleSize + offsetSize;
+      if (toVisibleIndex <= startIndex || toVisibleIndex >= endIndex - visibleSize - 1) {
+        if (startIndex !== offsetStartIndex || endIndex !== offsetEndIndex) {
+          scrollYStore.startIndex = offsetStartIndex;
+          scrollYStore.endIndex = offsetEndIndex;
+          updateYData();
         }
       }
     };
+    const scrollEvent = evnt => {
+      const scrollBodyElem = evnt.target;
+      const scrollTop = scrollBodyElem.scrollTop;
+      const scrollLeft = scrollBodyElem.scrollLeft;
+      const isX = scrollLeft !== internalData.lastScrollLeft;
+      const isY = scrollTop !== internalData.lastScrollTop;
+      internalData.lastScrollTop = scrollTop;
+      internalData.lastScrollLeft = scrollLeft;
+      if (reactData.scrollYLoad) {
+        loadYData(evnt);
+      }
+      internalData.lastScrollTime = Date.now();
+      dispatchEvent('scroll', {
+        scrollLeft,
+        scrollTop,
+        isX,
+        isY
+      }, evnt);
+    };
+    const clearScroll = () => {
+      const scrollBodyElem = refVirtualWrapper.value;
+      if (scrollBodyElem) {
+        scrollBodyElem.scrollTop = 0;
+        scrollBodyElem.scrollLeft = 0;
+      }
+      internalData.lastScrollTop = 0;
+      internalData.lastScrollLeft = 0;
+      return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
+    };
     const handleNodeClickEvent = (evnt, node) => {
       const {
         showRadio,
@@ -38071,7 +38365,6 @@ function getNodeUniqueId() {
                 if (!checkStrictly && $xeTree.isCheckedByCheckboxNodeId(nodeid)) {
                   handleCheckedCheckboxNode(childRows, true);
                 }
-                updateNodeLine(node);
                 dispatchEvent('load-success', {
                   node,
                   data: childRecords
@@ -38079,7 +38372,6 @@ function getNodeUniqueId() {
                 return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
               });
             } else {
-              updateNodeLine(node);
               dispatchEvent('load-success', {
                 node,
                 data: childRecords
@@ -38093,13 +38385,14 @@ function getNodeUniqueId() {
             if (treeExpandLazyLoadedMaps[nodeid]) {
               treeExpandLazyLoadedMaps[nodeid] = false;
             }
-            updateNodeLine(node);
             dispatchEvent('load-error', {
               node,
               data: e
             }, new Event('load-error'));
           }).finally(() => {
-            return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
+            handleTreeToList();
+            handleData();
+            return recalculate();
           });
         } else {
           resolve();
@@ -38175,8 +38468,9 @@ function getNodeUniqueId() {
         });
       }
       reactData.updateExpandedFlag++;
-      expandNodes.forEach(updateNodeLine);
-      return Promise.all(result);
+      handleTreeToList();
+      handleData();
+      return Promise.all(result).then(() => recalculate());
     };
     const toggleExpandEvent = (evnt, node) => {
       const {
@@ -38197,12 +38491,10 @@ function getNodeUniqueId() {
       const {
         transform
       } = props;
-      const {
-        treeList
-      } = reactData;
       const {
         selectCheckboxMaps,
-        indeterminateRowMaps
+        indeterminateRowMaps,
+        afterTreeList
       } = internalData;
       const childrenField = computeChildrenField.value;
       const mapChildrenField = computeMapChildrenField.value;
@@ -38214,7 +38506,7 @@ function getNodeUniqueId() {
       if (!checkStrictly) {
         const childRowMaps = {};
         const childRowList = [];
-        external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eachTree(treeList, node => {
+        external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eachTree(afterTreeList, node => {
           const nodeid = getNodeId(node);
           const childList = node[childrenField];
           if (childList && childList.length && !childRowMaps[nodeid]) {
@@ -38230,11 +38522,13 @@ function getNodeUniqueId() {
           const childList = vals[2];
           let sLen = 0; // 已选
           let hLen = 0; // 半选
-          let vLen = 0; // 有效行
+          let vLen = 0; // 有效子行
+          const cLen = childList.length; // 子行
           childList.forEach(checkMethod ? item => {
             const childNodeid = getNodeId(item);
             const isSelect = selectCheckboxMaps[childNodeid];
             if (checkMethod({
+              $tree: $xeTree,
               node: item
             })) {
               if (isSelect) {
@@ -38260,8 +38554,25 @@ function getNodeUniqueId() {
             }
             vLen++;
           });
-          const isSelected = sLen >= vLen;
-          const halfSelect = !isSelected && (sLen >= 1 || hLen >= 1);
+          let 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];
+          }
+          const halfSelect = !isSelected && (sLen > 0 || hLen > 0);
           if (isSelected) {
             selectCheckboxMaps[nodeid] = node;
             if (indeterminateRowMaps[nodeid]) {
@@ -38302,6 +38613,7 @@ function getNodeUniqueId() {
       let isDisabled = !!checkMethod;
       if (checkMethod) {
         isDisabled = !checkMethod({
+          $tree: $xeTree,
           node
         });
       }
@@ -38317,7 +38629,7 @@ function getNodeUniqueId() {
         selectCheckboxMaps[nodeid] = node;
       }
       if (!checkStrictly) {
-        external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eachTree(external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().get(node, childrenField), childNode => {
+        external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eachTree(external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().get(node, transform ? mapChildrenField : childrenField), childNode => {
           const childNodeid = getNodeId(childNode);
           if (isChecked) {
             if (!selectCheckboxMaps[childNodeid]) {
@@ -38387,6 +38699,7 @@ function getNodeUniqueId() {
       let isDisabled = !!checkMethod;
       if (checkMethod) {
         isDisabled = !checkMethod({
+          $tree: $xeTree,
           node
         });
       }
@@ -38403,6 +38716,376 @@ function getNodeUniqueId() {
         checked: isChecked
       }, evnt);
     };
+    const handleGlobalResizeEvent = () => {
+      const el = refElem.value;
+      if (!el || !el.clientWidth) {
+        return;
+      }
+      recalculate();
+    };
+    const treeMethods = {
+      dispatchEvent,
+      getNodeId,
+      loadData(data) {
+        return loadData(data || []);
+      },
+      reloadData(data) {
+        return loadData(data || []);
+      },
+      clearCurrentNode() {
+        reactData.currentNode = null;
+        return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
+      },
+      getCurrentNodeId() {
+        const {
+          currentNode
+        } = reactData;
+        if (currentNode) {
+          return getNodeId(currentNode);
+        }
+        return null;
+      },
+      getCurrentNode() {
+        const {
+          currentNode
+        } = reactData;
+        const {
+          nodeMaps
+        } = internalData;
+        if (currentNode) {
+          const nodeItem = nodeMaps[getNodeId(currentNode)];
+          if (nodeItem) {
+            return nodeItem.item;
+          }
+        }
+        return null;
+      },
+      setCurrentNodeId(nodeKey) {
+        const {
+          nodeMaps
+        } = internalData;
+        const nodeItem = nodeMaps[nodeKey];
+        reactData.currentNode = nodeItem ? nodeItem.item : null;
+        return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
+      },
+      setCurrentNode(node) {
+        reactData.currentNode = node;
+        return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
+      },
+      clearRadioNode() {
+        reactData.selectRadioKey = null;
+        return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
+      },
+      getRadioNodeId() {
+        return reactData.selectRadioKey || null;
+      },
+      getRadioNode() {
+        const {
+          selectRadioKey
+        } = reactData;
+        const {
+          nodeMaps
+        } = internalData;
+        if (selectRadioKey) {
+          const nodeItem = nodeMaps[selectRadioKey];
+          if (nodeItem) {
+            return nodeItem.item;
+          }
+        }
+        return null;
+      },
+      setRadioNodeId(nodeKey) {
+        reactData.selectRadioKey = nodeKey;
+        return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
+      },
+      setRadioNode,
+      setCheckboxNode,
+      setCheckboxByNodeId,
+      getCheckboxNodeIds() {
+        const {
+          selectCheckboxMaps
+        } = internalData;
+        return Object.keys(selectCheckboxMaps);
+      },
+      getCheckboxNodes() {
+        const {
+          nodeMaps,
+          selectCheckboxMaps
+        } = internalData;
+        const list = [];
+        external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().each(selectCheckboxMaps, (item, nodeid) => {
+          const nodeItem = nodeMaps[nodeid];
+          if (nodeItem) {
+            list.push(nodeItem.item);
+          }
+        });
+        return list;
+      },
+      clearCheckboxNode() {
+        internalData.selectCheckboxMaps = {};
+        reactData.updateCheckboxFlag++;
+        return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)().then(() => {
+          return {
+            checkNodeKeys: []
+          };
+        });
+      },
+      setAllCheckboxNode(checked) {
+        const {
+          transform
+        } = props;
+        const selectMaps = {};
+        const childrenField = computeChildrenField.value;
+        const mapChildrenField = computeMapChildrenField.value;
+        const checkKeys = [];
+        if (checked) {
+          external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eachTree(internalData.afterTreeList, node => {
+            const nodeid = getNodeId(node);
+            checkKeys.push(nodeid);
+            selectMaps[nodeid] = true;
+          }, {
+            children: transform ? mapChildrenField : childrenField
+          });
+        }
+        internalData.selectCheckboxMaps = selectMaps;
+        reactData.updateCheckboxFlag++;
+        return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)().then(() => {
+          return {
+            checkNodeKeys: checkKeys
+          };
+        });
+      },
+      clearExpandNode() {
+        return treeMethods.clearAllExpandNode();
+      },
+      clearAllExpandNode() {
+        const {
+          nodeMaps,
+          scrollYStore
+        } = internalData;
+        external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().each(nodeMaps, nodeItem => {
+          nodeItem.treeLoaded = false;
+        });
+        internalData.treeExpandedMaps = {};
+        reactData.updateExpandedFlag++;
+        reactData.topSpaceHeight = 0;
+        scrollYStore.startIndex = 0;
+        scrollYStore.endIndex = 1;
+        handleTreeToList();
+        handleData();
+        return recalculate();
+      },
+      setExpandByNodeId(nodeids, expanded) {
+        const {
+          treeExpandedMaps
+        } = internalData;
+        if (nodeids) {
+          if (!external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isArray(nodeids)) {
+            nodeids = [nodeids];
+          }
+          nodeids.forEach(nodeid => {
+            handleSetExpand(nodeid, expanded, treeExpandedMaps);
+          });
+          reactData.updateExpandedFlag++;
+        }
+        handleTreeToList();
+        handleData();
+        return recalculate();
+      },
+      getExpandNodeIds() {
+        const {
+          treeExpandedMaps
+        } = internalData;
+        return external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().keys(treeExpandedMaps);
+      },
+      getExpandNodes() {
+        const {
+          nodeMaps,
+          treeExpandedMaps
+        } = internalData;
+        const list = [];
+        external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().each(treeExpandedMaps, (item, nodeid) => {
+          const nodeItem = nodeMaps[nodeid];
+          if (nodeItem) {
+            list.push(nodeItem.item);
+          }
+        });
+        return list;
+      },
+      setExpandNode(nodes, expanded) {
+        const {
+          treeExpandedMaps
+        } = internalData;
+        if (nodes) {
+          if (!external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isArray(nodes)) {
+            nodes = [nodes];
+          }
+          nodes.forEach(node => {
+            const nodeid = getNodeId(node);
+            handleSetExpand(nodeid, expanded, treeExpandedMaps);
+          });
+          reactData.updateExpandedFlag++;
+        }
+        handleTreeToList();
+        handleData();
+        return recalculate();
+      },
+      toggleExpandByNodeId(nodeids) {
+        const {
+          treeExpandedMaps
+        } = internalData;
+        if (nodeids) {
+          if (!external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isArray(nodeids)) {
+            nodeids = [nodeids];
+          }
+          nodeids.forEach(nodeid => {
+            handleSetExpand(nodeid, !treeExpandedMaps[nodeid], treeExpandedMaps);
+          });
+          reactData.updateExpandedFlag++;
+        }
+        handleTreeToList();
+        handleData();
+        return recalculate();
+      },
+      toggleExpandNode(nodes) {
+        const {
+          treeExpandedMaps
+        } = internalData;
+        if (nodes) {
+          if (!external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isArray(nodes)) {
+            nodes = [nodes];
+          }
+          nodes.forEach(node => {
+            const nodeid = getNodeId(node);
+            handleSetExpand(nodeid, !treeExpandedMaps[nodeid], treeExpandedMaps);
+          });
+          reactData.updateExpandedFlag++;
+        }
+        handleTreeToList();
+        handleData();
+        return recalculate();
+      },
+      setAllExpandNode(expanded) {
+        const {
+          transform
+        } = props;
+        const {
+          treeExpandedMaps
+        } = internalData;
+        const childrenField = computeChildrenField.value;
+        const mapChildrenField = computeMapChildrenField.value;
+        if (expanded) {
+          external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eachTree(internalData.afterTreeList, node => {
+            const childList = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().get(node, childrenField);
+            const hasChild = childList && childList.length;
+            if (hasChild) {
+              const nodeid = getNodeId(node);
+              treeExpandedMaps[nodeid] = true;
+            }
+          }, {
+            children: transform ? mapChildrenField : childrenField
+          });
+        } else {
+          internalData.treeExpandedMaps = {};
+        }
+        reactData.updateExpandedFlag++;
+        handleTreeToList();
+        handleData();
+        return recalculate();
+      },
+      reloadExpandNode(node) {
+        const {
+          lazy
+        } = props;
+        if (lazy) {
+          treeMethods.clearExpandLoaded(node);
+          return handleAsyncTreeExpandChilds(node);
+        }
+        return recalculate();
+      },
+      clearExpandLoaded(node) {
+        const {
+          lazy
+        } = props;
+        const {
+          nodeMaps
+        } = internalData;
+        if (lazy) {
+          const nodeItem = nodeMaps[getNodeId(node)];
+          if (nodeItem) {
+            nodeItem.treeLoaded = false;
+          }
+        }
+        return recalculate();
+      },
+      /**
+       * 用于树结构，给行数据加载子节点
+       */
+      loadChildrenNode(node, childRecords) {
+        const {
+          lazy,
+          transform
+        } = props;
+        const {
+          nodeMaps
+        } = internalData;
+        if (!lazy) {
+          return Promise.resolve([]);
+        }
+        const childrenField = computeChildrenField.value;
+        const mapChildrenField = computeMapChildrenField.value;
+        const parentNodeItem = nodeMaps[getNodeId(node)];
+        const parentLevel = parentNodeItem ? parentNodeItem.level : 0;
+        const parentNodes = parentNodeItem ? parentNodeItem.nodes : [];
+        return createNode(childRecords).then(nodeList => {
+          external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eachTree(nodeList, (childRow, index, items, path, parent, nodes) => {
+            const itemNodeId = getNodeId(childRow);
+            nodeMaps[itemNodeId] = {
+              item: node,
+              index: -1,
+              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;
+          }
+          updateAfterDataIndex();
+          return nodeList;
+        });
+      },
+      isExpandByNode,
+      isCheckedByRadioNodeId,
+      isCheckedByRadioNode,
+      isCheckedByCheckboxNodeId,
+      isIndeterminateByCheckboxNode,
+      isCheckedByCheckboxNode,
+      getCheckboxIndeterminateNodes() {
+        const {
+          nodeMaps,
+          indeterminateRowMaps
+        } = internalData;
+        const list = [];
+        external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().each(indeterminateRowMaps, (item, nodeid) => {
+          const nodeItem = nodeMaps[nodeid];
+          if (nodeItem) {
+            list.push(nodeItem.item);
+          }
+        });
+        return list;
+      },
+      recalculate,
+      scrollTo,
+      clearScroll
+    };
     const treePrivateMethods = {};
     Object.assign($xeTree, treeMethods, treePrivateMethods);
     const renderRadio = (node, nodeid, isChecked) => {
@@ -38416,12 +39099,14 @@ function getNodeUniqueId() {
         visibleMethod
       } = radioOpts;
       const isVisible = !visibleMethod || visibleMethod({
+        $tree: $xeTree,
         node
       });
       let isDisabled = !!checkMethod;
       if (showRadio && showIcon && isVisible) {
         if (checkMethod) {
           isDisabled = !checkMethod({
+            $tree: $xeTree,
             node
           });
         }
@@ -38453,12 +39138,14 @@ function getNodeUniqueId() {
       } = checkboxOpts;
       const isIndeterminate = isIndeterminateByCheckboxNodeid(nodeid);
       const isVisible = !visibleMethod || visibleMethod({
+        $tree: $xeTree,
         node
       });
       let isDisabled = !!checkMethod;
       if (showCheckbox && showIcon && isVisible) {
         if (checkMethod) {
           isDisabled = !checkMethod({
+            $tree: $xeTree,
             node
           });
         }
@@ -38479,7 +39166,7 @@ function getNodeUniqueId() {
       }
       return renderEmptyElement($xeTree);
     };
-    const renderNode = node => {
+    const renderNode = (node, nodeid) => {
       const {
         lazy,
         showRadio,
@@ -38497,6 +39184,7 @@ function getNodeUniqueId() {
         updateExpandedFlag
       } = reactData;
       const {
+        afterTreeList,
         nodeMaps,
         treeExpandedMaps,
         treeExpandLazyLoadedMaps
@@ -38509,30 +39197,13 @@ function getNodeUniqueId() {
       const iconSlot = slots.icon;
       const titleSlot = slots.title;
       const extraSlot = slots.extra;
-      const nodeid = getNodeId(node);
       const isExpand = updateExpandedFlag && treeExpandedMaps[nodeid];
       const nodeItem = nodeMaps[nodeid];
       const nodeValue = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().get(node, titleField);
-      const childVns = [];
-      if (hasChild && treeExpandedMaps[nodeid]) {
-        if (showLine) {
-          childVns.push((0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
-            key: 'line',
-            class: 'vxe-tree--node-child-line',
-            style: {
-              height: `calc(${nodeItem.lineCount} * var(--vxe-ui-tree-node-height) - var(--vxe-ui-tree-node-height) / 2)`,
-              left: `${(nodeItem.level + 1) * (indent || 1)}px`
-            }
-          }));
-        }
-        childList.forEach(childItem => {
-          childVns.push(renderNode(childItem));
-        });
-      }
+      const nLevel = nodeItem.level;
       let isRadioChecked = false;
       if (showRadio) {
-        // eslint-disable-next-line eqeqeq
-        isRadioChecked = nodeid == selectRadioKey;
+        isRadioChecked = nodeid === String(selectRadioKey);
       }
       let isCheckboxChecked = false;
       if (showCheckbox) {
@@ -38546,8 +39217,14 @@ function getNodeUniqueId() {
         hasLazyChilds = node[hasChildField];
         isLazyLoaded = !!nodeItem.treeLoaded;
       }
+      const prevNode = nodeItem.items[nodeItem.treeIndex - 1];
+      const nParams = {
+        node,
+        isExpand
+      };
       return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
-        class: ['vxe-tree--node-wrapper', `node--level-${nodeItem.level}`],
+        key: nodeid,
+        class: ['vxe-tree--node-wrapper', `node--level-${nLevel}`],
         nodeid
       }, [(0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
         class: ['vxe-tree--node-item', {
@@ -38556,7 +39233,7 @@ function getNodeUniqueId() {
           'is-checkbox--checked': isCheckboxChecked
         }],
         style: {
-          paddingLeft: `${(nodeItem.level - 1) * (indent || 1)}px`
+          paddingLeft: `${(nLevel - 1) * (indent || 1)}px`
         },
         onClick(evnt) {
           handleNodeClickEvent(evnt, node);
@@ -38564,41 +39241,57 @@ function getNodeUniqueId() {
         onDblclick(evnt) {
           handleNodeDblclickEvent(evnt, node);
         }
-      }, [showIcon || showLine ? (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
+      }, [showLine ? (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
+        class: 'vxe-tree--node-line-wrapper'
+      }, [(0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
+        class: 'vxe-tree--node-line',
+        style: {
+          height: `${getNodeId(afterTreeList[0]) === nodeid ? 1 : calcTreeLine($xeTree, node, prevNode)}px`
+        }
+      })]) : renderEmptyElement($xeTree), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
         class: 'vxe-tree--node-item-switcher'
       }, showIcon && (lazy ? isLazyLoaded ? hasChild : hasLazyChilds : hasChild) ? [(0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
         class: 'vxe-tree--node-item-icon',
         onClick(evnt) {
           toggleExpandEvent(evnt, node);
         }
-      }, iconSlot ? iconSlot({
-        node,
-        isExpand
-      }) : [(0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('i', {
+      }, iconSlot ? getSlotVNs(iconSlot(nParams)) : [(0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('i', {
         class: isLazyLoading ? iconLoaded || getIcon().TREE_NODE_LOADED : isExpand ? iconOpen || getIcon().TREE_NODE_OPEN : iconClose || getIcon().TREE_NODE_CLOSE
-      })])] : []) : renderEmptyElement($xeTree), renderRadio(node, nodeid, isRadioChecked), renderCheckbox(node, nodeid, isCheckboxChecked), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
+      })])] : []), renderRadio(node, nodeid, isRadioChecked), renderCheckbox(node, nodeid, isCheckboxChecked), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
         class: 'vxe-tree--node-item-inner'
       }, [(0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
         class: 'vxe-tree--node-item-title'
-      }, titleSlot ? getSlotVNs(titleSlot({
-        node,
-        isExpand
-      })) : `${nodeValue}`), extraSlot ? (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
+      }, titleSlot ? getSlotVNs(titleSlot(nParams)) : `${nodeValue}`), extraSlot ? (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
         class: 'vxe-tree--node-item-extra'
-      }, getSlotVNs(extraSlot({
-        node,
-        isExpand
-      }))) : renderEmptyElement($xeTree)])]), hasChild && treeExpandedMaps[nodeid] ? (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
-        class: 'vxe-tree--node-child-wrapper'
-      }, childVns) : renderEmptyElement($xeTree)]);
+      }, getSlotVNs(extraSlot(nParams))) : renderEmptyElement($xeTree)])])]);
     };
-    const renderNodeList = () => {
+    const renderList = treeList => {
       const {
-        treeList
-      } = reactData;
-      return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
-        class: 'vxe-tree--node-list-wrapper'
-      }, treeList.map(node => renderNode(node)));
+        transform
+      } = props;
+      const {
+        treeExpandedMaps
+      } = internalData;
+      const childrenField = computeChildrenField.value;
+      if (!treeList.length) {
+        return [(0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
+          class: 'vxe-tree--empty-placeholder'
+        }, getI18n('vxe.tree.searchEmpty'))];
+      }
+      const nodeVNs = [];
+      treeList.forEach(transform ? node => {
+        const nodeid = getNodeId(node);
+        nodeVNs.push(renderNode(node, nodeid));
+      } : node => {
+        const nodeid = getNodeId(node);
+        nodeVNs.push(renderNode(node, nodeid));
+        const childList = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().get(node, childrenField);
+        const hasChild = childList && childList.length;
+        if (hasChild && treeExpandedMaps[nodeid]) {
+          nodeVNs.push(...renderList(childList));
+        }
+      });
+      return nodeVNs;
     };
     const renderVN = () => {
       const {
@@ -38606,13 +39299,20 @@ function getNodeUniqueId() {
         trigger,
         showLine
       } = props;
+      const {
+        bodyHeight,
+        topSpaceHeight,
+        treeList
+      } = reactData;
       const vSize = computeSize.value;
       const radioOpts = computeRadioOpts.value;
       const checkboxOpts = computeCheckboxOpts.value;
-      const treeStyle = computeTreeStyle.value;
       const loadingOpts = computeLoadingOpts.value;
       const isRowHover = computeIsRowHover.value;
+      const treeStyle = computeTreeStyle.value;
       const loadingSlot = slots.loading;
+      const headerSlot = slots.header;
+      const footerSlot = slots.footer;
       return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
         ref: refElem,
         class: ['vxe-tree', {
@@ -38623,9 +39323,34 @@ function getNodeUniqueId() {
           'node--hover': isRowHover,
           'node--trigger': trigger === 'node',
           'is--loading': loading
-        }],
-        style: treeStyle
-      }, [renderNodeList(),
+        }]
+      }, [headerSlot ? (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
+        ref: refHeaderWrapperElem,
+        class: 'vxe-tree--header-wrapper'
+      }, headerSlot({
+        $tree: $xeTree
+      })) : renderEmptyElement($xeTree), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
+        ref: refVirtualWrapper,
+        class: 'vxe-tree--node-list-wrapper',
+        style: treeStyle,
+        onScroll: scrollEvent
+      }, [(0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
+        class: 'vxe-tree--y-space',
+        style: {
+          height: bodyHeight ? `${bodyHeight}px` : ''
+        }
+      }), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
+        ref: refVirtualBody,
+        class: 'vxe-tree--node-list-body',
+        style: {
+          transform: `translateY(${topSpaceHeight}px)`
+        }
+      }, renderList(treeList))]), footerSlot ? (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
+        ref: refFooterWrapperElem,
+        class: 'vxe-tree--footer-wrapper'
+      }, footerSlot({
+        $tree: $xeTree
+      })) : renderEmptyElement($xeTree),
       /**
        * 加载中
        */
@@ -38648,7 +39373,7 @@ function getNodeUniqueId() {
       dataFlag.value++;
     });
     (0,external_commonjs_vue_commonjs2_vue_root_Vue_.watch)(dataFlag, () => {
-      loadTreeData(props.data || []);
+      loadData(props.data || []);
     });
     (0,external_commonjs_vue_commonjs2_vue_root_Vue_.watch)(() => props.checkNodeKey, val => {
       reactData.selectRadioKey = val;
@@ -38663,13 +39388,54 @@ function getNodeUniqueId() {
     (0,external_commonjs_vue_commonjs2_vue_root_Vue_.watch)(checkboxFlag, () => {
       updateCheckboxChecked(props.checkNodeKeys || []);
     });
+    (0,external_commonjs_vue_commonjs2_vue_root_Vue_.watch)(() => props.filterValue, () => {
+      triggerSearchEvent(new Event('filter'));
+    });
+    const hFlag = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.ref)(0);
+    (0,external_commonjs_vue_commonjs2_vue_root_Vue_.watch)(() => props.height, () => {
+      hFlag.value++;
+    });
+    (0,external_commonjs_vue_commonjs2_vue_root_Vue_.watch)(() => props.minHeight, () => {
+      hFlag.value++;
+    });
+    (0,external_commonjs_vue_commonjs2_vue_root_Vue_.watch)(() => props.maxHeight, () => {
+      hFlag.value++;
+    });
+    (0,external_commonjs_vue_commonjs2_vue_root_Vue_.watch)(hFlag, () => {
+      recalculate();
+    });
+    (0,external_commonjs_vue_commonjs2_vue_root_Vue_.onMounted)(() => {
+      if (props.autoResize) {
+        const el = refElem.value;
+        const parentEl = getParentElem();
+        const resizeObserver = globalResize.create(() => {
+          if (props.autoResize) {
+            recalculate();
+          }
+        });
+        if (el) {
+          resizeObserver.observe(el);
+        }
+        if (parentEl) {
+          resizeObserver.observe(parentEl);
+        }
+        internalData.resizeObserver = resizeObserver;
+      }
+      globalEvents.on($xeTree, 'resize', handleGlobalResizeEvent);
+    });
     (0,external_commonjs_vue_commonjs2_vue_root_Vue_.onUnmounted)(() => {
-      reactData.treeList = [];
+      const {
+        resizeObserver
+      } = internalData;
+      if (resizeObserver) {
+        resizeObserver.disconnect();
+      }
       internalData.treeExpandedMaps = {};
       internalData.indeterminateRowMaps = {};
       internalData.nodeMaps = {};
+      globalEvents.off($xeTree, 'resize');
     });
-    loadTreeData(props.data || []);
+    loadData(props.data || []);
     $xeTree.renderVN = renderVN;
     return $xeTree;
   },
@@ -38700,6 +39466,7 @@ const Tree = VxeTree;
 
 
 
+
 function tree_select_getOptUniqueId() {
   return external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().uniqueId('node_');
 }
@@ -38721,6 +39488,8 @@ function tree_select_getOptUniqueId() {
       type: Boolean,
       default: null
     },
+    filterable: Boolean,
+    filterConfig: Object,
     multiple: Boolean,
     className: [String, Function],
     popupClassName: [String, Function],
@@ -38730,18 +39499,44 @@ function tree_select_getOptUniqueId() {
     optionProps: Object,
     size: {
       type: String,
-      default: () => getConfig().select.size || getConfig().size
+      default: () => getConfig().treeSelect.size || getConfig().size
     },
     remote: Boolean,
-    remoteMethod: Function,
+    remoteConfig: Function,
     popupConfig: Object,
     treeConfig: Object,
+    virtualYConfig: Object,
+    autoClose: {
+      type: Boolean,
+      default: () => getConfig().treeSelect.autoClose
+    },
+    showTotalButoon: {
+      type: Boolean,
+      default: () => getConfig().treeSelect.showTotalButoon
+    },
+    showCheckedButoon: {
+      type: Boolean,
+      default: () => getConfig().treeSelect.showCheckedButoon
+    },
+    showClearButton: {
+      type: Boolean,
+      default: () => getConfig().treeSelect.showClearButton
+    },
+    showExpandButton: {
+      type: Boolean,
+      default: () => getConfig().treeSelect.showExpandButton
+    },
     transfer: {
       type: Boolean,
       default: null
-    }
+    },
+    /**
+     * 已废弃，被 remote-config.queryMethod 替换
+     * @deprecated
+     */
+    remoteMethod: Function
   },
-  emits: ['update:modelValue', 'change', 'clear', 'blur', 'focus', 'click', 'node-click'],
+  emits: ['update:modelValue', 'change', 'all-change', 'clear', 'blur', 'focus', 'click', 'node-click'],
   setup(props, context) {
     const {
       emit,
@@ -38758,12 +39553,14 @@ function tree_select_getOptUniqueId() {
     } = useSize(props);
     const refElem = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.ref)();
     const refInput = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.ref)();
+    const refInpSearch = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.ref)();
     const refTreeWrapper = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.ref)();
     const refOptionPanel = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.ref)();
+    const refTree = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.ref)();
     const reactData = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.reactive)({
       initialized: false,
-      fullOptionList: [],
-      fullNodeMaps: {},
+      searchValue: '',
+      searchLoading: false,
       panelIndex: 0,
       panelStyle: {},
       panelPlacement: null,
@@ -38773,7 +39570,9 @@ function tree_select_getOptUniqueId() {
       isActivated: false
     });
     const internalData = {
-      hpTimeout: undefined
+      // hpTimeout: undefined,
+      fullOptionList: [],
+      fullNodeMaps: {}
     };
     const refMaps = {
       refElem
@@ -38874,15 +39673,26 @@ function tree_select_getOptUniqueId() {
       const propsOpts = computePropsOpts.value;
       return propsOpts.hasChild || 'hasChild';
     });
+    const computeVirtualYOpts = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
+      return Object.assign({}, getConfig().treeSelect.virtualYConfig, props.virtualYConfig);
+    });
+    const computeRemoteOpts = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
+      return Object.assign({}, getConfig().treeSelect.remoteConfig, props.remoteConfig);
+    });
+    const computeFilterOpts = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
+      const treeOpts = computeTreeOpts.value;
+      return Object.assign({}, treeOpts.filterConfig, props.filterConfig);
+    });
     const computeSelectLabel = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
       const {
         modelValue
       } = props;
       const {
         fullNodeMaps
-      } = reactData;
+      } = internalData;
       const labelField = computeLabelField.value;
-      return (external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isArray(modelValue) ? modelValue : [modelValue]).map(val => {
+      const selectVals = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eqNull(modelValue) ? [] : external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isArray(modelValue) ? modelValue : [modelValue];
+      return selectVals.map(val => {
         const cacheItem = fullNodeMaps[val];
         return cacheItem ? cacheItem.item[labelField] : val;
       }).join(', ');
@@ -38933,12 +39743,16 @@ function tree_select_getOptUniqueId() {
       const {
         options
       } = props;
+      const treeOpts = computeTreeOpts.value;
       const nodeKeyField = computeNodeKeyField.value;
       const childrenField = computeChildrenField.value;
       const valueField = computeValueField.value;
+      const {
+        transform
+      } = treeOpts;
       const nodeMaps = {};
       const keyMaps = {};
-      external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eachTree(options, (item, index, items, path, parent, nodes) => {
+      const handleOptNode = (item, index, items, path, parent, nodes) => {
         let nodeid = getNodeid(item);
         if (!nodeid) {
           nodeid = tree_select_getOptUniqueId();
@@ -38958,11 +39772,20 @@ function tree_select_getOptUniqueId() {
           parent,
           nodes
         };
-      }, {
-        children: childrenField
-      });
-      reactData.fullOptionList = options || [];
-      reactData.fullNodeMaps = nodeMaps;
+      };
+      if (options) {
+        if (transform) {
+          options.forEach((item, index, items) => {
+            handleOptNode(item, index, items, [], null, []);
+          });
+        } else {
+          external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eachTree(options, handleOptNode, {
+            children: childrenField
+          });
+        }
+      }
+      internalData.fullOptionList = options || [];
+      internalData.fullNodeMaps = nodeMaps;
     };
     const updateZindex = () => {
       if (reactData.panelIndex < getLastZIndex()) {
@@ -38995,9 +39818,15 @@ function tree_select_getOptUniqueId() {
     };
     const showOptionPanel = () => {
       const {
-        loading
+        loading,
+        remote,
+        filterable
       } = props;
+      const {
+        fullOptionList
+      } = internalData;
       const isDisabled = computeIsDisabled.value;
+      const remoteOpts = computeRemoteOpts.value;
       if (!loading && !isDisabled) {
         clearTimeout(internalData.hpTimeout);
         if (!reactData.initialized) {
@@ -39005,8 +39834,14 @@ function tree_select_getOptUniqueId() {
         }
         reactData.isActivated = true;
         reactData.isAniVisible = true;
+        if (filterable) {
+          if (remote && remoteOpts.enabled && remoteOpts.autoLoad && !fullOptionList.length) {
+            handleSearchEvent();
+          }
+        }
         setTimeout(() => {
           reactData.visiblePanel = true;
+          handleFocusSearch();
         }, 10);
         updateZindex();
         updatePlacement();
@@ -39021,7 +39856,7 @@ function tree_select_getOptUniqueId() {
     const changeEvent = (evnt, selectValue) => {
       const {
         fullNodeMaps
-      } = reactData;
+      } = internalData;
       emitModel(selectValue);
       if (selectValue !== props.modelValue) {
         const cacheItem = fullNodeMaps[selectValue];
@@ -39045,6 +39880,65 @@ function tree_select_getOptUniqueId() {
       clearValueEvent(evnt, null);
       hideOptionPanel();
     };
+    const allCheckedPanelEvent = params => {
+      const {
+        $event
+      } = params;
+      const {
+        multiple,
+        autoClose
+      } = props;
+      const $tree = refTree.value;
+      if (multiple) {
+        if ($tree) {
+          $tree.setAllCheckboxNode(true).then(({
+            checkNodeKeys
+          }) => {
+            changeEvent($event, checkNodeKeys);
+            dispatchEvent('all-change', {
+              value: checkNodeKeys
+            }, $event);
+            if (autoClose) {
+              hideOptionPanel();
+            }
+          });
+        }
+      }
+    };
+    const clearCheckedPanelEvent = params => {
+      const {
+        $event
+      } = params;
+      const {
+        multiple,
+        autoClose
+      } = props;
+      const $tree = refTree.value;
+      if ($tree) {
+        const value = multiple ? [] : null;
+        $tree.clearCheckboxNode().then(() => {
+          if (autoClose) {
+            hideOptionPanel();
+          }
+        });
+        changeEvent($event, value);
+        dispatchEvent('clear', {
+          value
+        }, $event);
+      }
+    };
+    const allExpandPanelEvent = () => {
+      const $tree = refTree.value;
+      if ($tree) {
+        $tree.setAllExpandNode(true);
+      }
+    };
+    const clearExpandPanelEvent = () => {
+      const $tree = refTree.value;
+      if ($tree) {
+        $tree.clearAllExpandNode();
+      }
+    };
     const handleGlobalMousewheelEvent = evnt => {
       const {
         visiblePanel
@@ -39086,6 +39980,16 @@ function tree_select_getOptUniqueId() {
         updatePlacement();
       }
     };
+    const handleFocusSearch = () => {
+      if (props.filterable) {
+        (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)(() => {
+          const inpSearch = refInpSearch.value;
+          if (inpSearch) {
+            inpSearch.focus();
+          }
+        });
+      }
+    };
     const focusEvent = evnt => {
       const isDisabled = computeIsDisabled.value;
       if (!isDisabled) {
@@ -39107,6 +40011,31 @@ function tree_select_getOptUniqueId() {
       reactData.isActivated = false;
       dispatchEvent('blur', {}, evnt);
     };
+    const modelSearchEvent = value => {
+      reactData.searchValue = value;
+    };
+    const handleSearchEvent = () => {
+      const {
+        modelValue,
+        remote,
+        remoteMethod
+      } = props;
+      const {
+        searchValue
+      } = reactData;
+      const remoteOpts = computeRemoteOpts.value;
+      const queryMethod = remoteOpts.queryMethod || remoteMethod;
+      if (remote && queryMethod && remoteOpts.enabled) {
+        reactData.searchLoading = true;
+        Promise.resolve(queryMethod({
+          $treeSelect: $xeTreeSelect,
+          searchValue,
+          value: modelValue
+        })).then(() => (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)()).catch(() => (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)()).finally(() => {
+          reactData.searchLoading = false;
+        });
+      }
+    };
     const togglePanelEvent = params => {
       const {
         $event
@@ -39154,13 +40083,19 @@ function tree_select_getOptUniqueId() {
         modelValue,
         multiple,
         options,
-        loading
+        loading,
+        filterable,
+        showTotalButoon,
+        showCheckedButoon,
+        showClearButton,
+        showExpandButton
       } = props;
       const {
         initialized,
         isActivated,
         isAniVisible,
-        visiblePanel
+        visiblePanel,
+        searchValue
       } = reactData;
       const vSize = computeSize.value;
       const isDisabled = computeIsDisabled.value;
@@ -39183,6 +40118,8 @@ function tree_select_getOptUniqueId() {
       const childrenField = computeChildrenField.value;
       const parentField = computeParentField.value;
       const hasChildField = computeHasChildField.value;
+      const virtualYOpts = computeVirtualYOpts.value;
+      const filterOpts = computeFilterOpts.value;
       if (formReadonly) {
         return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
           ref: refElem,
@@ -39191,12 +40128,14 @@ function tree_select_getOptUniqueId() {
           class: 'vxe-tree-select-label'
         }, selectLabel)]);
       }
+      const selectVals = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eqNull(modelValue) ? [] : external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isArray(modelValue) ? modelValue : [modelValue];
       return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
         ref: refElem,
         class: ['vxe-tree-select', className ? external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isFunction(className) ? className({
           $treeSelect: $xeTreeSelect
         }) : className : '', {
           [`size--${vSize}`]: vSize,
+          'is--filterable': filterable,
           'is--visible': visiblePanel,
           'is--disabled': isDisabled,
           'is--loading': loading,
@@ -39212,6 +40151,7 @@ function tree_select_getOptUniqueId() {
         prefixIcon: props.prefixIcon,
         suffixIcon: loading ? getIcon().TREE_SELECT_LOADED : visiblePanel ? getIcon().TREE_SELECT_OPEN : getIcon().TREE_SELECT_CLOSE,
         modelValue: loading ? '' : selectLabel,
+        title: selectLabel,
         onClear: clearEvent,
         onClick: clickEvent,
         onFocus: focusEvent,
@@ -39236,16 +40176,55 @@ function tree_select_getOptUniqueId() {
         style: reactData.panelStyle
       }, initialized ? [(0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
         class: 'vxe-tree-select--panel-wrapper'
-      }, [headerSlot ? (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
+      }, [filterable ? (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
+        class: 'vxe-tree-select--panel-search'
+      }, [(0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)(input, {
+        ref: refInpSearch,
+        class: 'vxe-tree-select-search--input',
+        modelValue: searchValue,
+        clearable: true,
+        disabled: false,
+        readonly: false,
+        placeholder: getI18n('vxe.treeSelect.search'),
+        prefixIcon: getIcon().INPUT_SEARCH,
+        'onUpdate:modelValue': modelSearchEvent
+      })]) : renderEmptyElement($xeTreeSelect), showTotalButoon || showCheckedButoon && multiple || showClearButton || showExpandButton || headerSlot ? (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
         class: 'vxe-tree-select--panel-header'
-      }, headerSlot({})) : renderEmptyElement($xeTreeSelect), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
+      }, headerSlot ? headerSlot({}) : [(0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
+        class: 'vxe-tree-select--header-button'
+      }, [showTotalButoon ? (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
+        class: 'vxe-tree-select--header-total'
+      }, getI18n('vxe.treeSelect.total', [selectVals.length])) : renderEmptyElement($xeTreeSelect), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
+        class: 'vxe-tree-select--header-btns'
+      }, [showCheckedButoon && multiple ? (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)(src_button, {
+        content: getI18n('vxe.treeSelect.allChecked'),
+        mode: 'text',
+        onClick: allCheckedPanelEvent
+      }) : renderEmptyElement($xeTreeSelect), showClearButton ? (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)(src_button, {
+        content: getI18n('vxe.treeSelect.clearChecked'),
+        mode: 'text',
+        onClick: clearCheckedPanelEvent
+      }) : renderEmptyElement($xeTreeSelect), showExpandButton ? (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)(src_button, {
+        content: getI18n('vxe.treeSelect.allExpand'),
+        mode: 'text',
+        onClick: allExpandPanelEvent
+      }) : renderEmptyElement($xeTreeSelect), showExpandButton ? (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)(src_button, {
+        content: getI18n('vxe.treeSelect.clearExpand'),
+        mode: 'text',
+        onClick: clearExpandPanelEvent
+      }) : renderEmptyElement($xeTreeSelect)])])]) : renderEmptyElement($xeTreeSelect), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
         class: 'vxe-tree-select--panel-body'
       }, [(0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
         ref: refTreeWrapper,
         class: 'vxe-tree-select-tree--wrapper',
         style: popupWrapperStyle
       }, [(0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)(tree, {
+        ref: refTree,
         class: 'vxe-tree-select--tree',
+        height: popupOpts.height ? '100%' : treeOpts.height,
+        minHeight: treeOpts.minHeight,
+        maxHeight: popupOpts.height ? '' : treeOpts.maxHeight,
+        autoResize: true,
         data: options,
         indent: treeOpts.indent,
         showRadio: !multiple,
@@ -39273,6 +40252,9 @@ function tree_select_getOptUniqueId() {
         iconOpen: treeOpts.iconOpen,
         iconLoaded: treeOpts.iconLoaded,
         iconClose: treeOpts.iconClose,
+        filterValue: searchValue,
+        filterConfig: filterOpts,
+        virtualYConfig: virtualYOpts,
         onNodeClick: nodeClickEvent,
         onRadioChange: radioChangeEvent,
         onCheckboxChange: checkboxChangeEvent,