vxe-pc-ui 3.15.11 → 3.15.13

package/lib/index.umd.js

@@ -11202,6 +11202,7 @@ __webpack_require__.d(__webpack_exports__, {
   Switch: function() { return /* reexport */ Switch; },
   TabPane: function() { return /* reexport */ TabPane; },
   TableSelect: function() { return /* reexport */ TableSelect; },
+  TableTransfer: function() { return /* reexport */ TableTransfer; },
   Tabs: function() { return /* reexport */ Tabs; },
   Tag: function() { return /* reexport */ Tag; },
   Text: function() { return /* reexport */ Text; },
@@ -11213,6 +11214,7 @@ __webpack_require__.d(__webpack_exports__, {
   Tips: function() { return /* reexport */ Tips; },
   Tooltip: function() { return /* reexport */ Tooltip; },
   Tour: function() { return /* reexport */ Tour; },
+  Transfer: function() { return /* reexport */ Transfer; },
   Tree: function() { return /* reexport */ Tree; },
   TreeSelect: function() { return /* reexport */ TreeSelect; },
   Upload: function() { return /* reexport */ Upload; },
@@ -11291,6 +11293,7 @@ __webpack_require__.d(__webpack_exports__, {
   VxeSwitch: function() { return /* reexport */ VxeSwitch; },
   VxeTabPane: function() { return /* reexport */ VxeTabPane; },
   VxeTableSelect: function() { return /* reexport */ VxeTableSelect; },
+  VxeTableTransfer: function() { return /* reexport */ VxeTableTransfer; },
   VxeTabs: function() { return /* reexport */ VxeTabs; },
   VxeTag: function() { return /* reexport */ VxeTag; },
   VxeText: function() { return /* reexport */ VxeText; },
@@ -11301,6 +11304,7 @@ __webpack_require__.d(__webpack_exports__, {
   VxeTip: function() { return /* reexport */ VxeTip; },
   VxeTooltip: function() { return /* reexport */ VxeTooltip; },
   VxeTour: function() { return /* reexport */ VxeTour; },
+  VxeTransfer: function() { return /* reexport */ VxeTransfer; },
   VxeTree: function() { return /* reexport */ VxeTree; },
   VxeTreeSelect: function() { return /* reexport */ VxeTreeSelect; },
   VxeUI: function() { return /* reexport */ VxeUI; },
@@ -11445,6 +11449,7 @@ __webpack_require__.d(components_namespaceObject, {
   Switch: function() { return Switch; },
   TabPane: function() { return TabPane; },
   TableSelect: function() { return TableSelect; },
+  TableTransfer: function() { return TableTransfer; },
   Tabs: function() { return Tabs; },
   Tag: function() { return Tag; },
   Text: function() { return Text; },
@@ -11456,6 +11461,7 @@ __webpack_require__.d(components_namespaceObject, {
   Tips: function() { return Tips; },
   Tooltip: function() { return Tooltip; },
   Tour: function() { return Tour; },
+  Transfer: function() { return Transfer; },
   Tree: function() { return Tree; },
   TreeSelect: function() { return TreeSelect; },
   Upload: function() { return Upload; },
@@ -11534,6 +11540,7 @@ __webpack_require__.d(components_namespaceObject, {
   VxeSwitch: function() { return VxeSwitch; },
   VxeTabPane: function() { return VxeTabPane; },
   VxeTableSelect: function() { return VxeTableSelect; },
+  VxeTableTransfer: function() { return VxeTableTransfer; },
   VxeTabs: function() { return VxeTabs; },
   VxeTag: function() { return VxeTag; },
   VxeText: function() { return VxeText; },
@@ -11544,6 +11551,7 @@ __webpack_require__.d(components_namespaceObject, {
   VxeTip: function() { return VxeTip; },
   VxeTooltip: function() { return VxeTooltip; },
   VxeTour: function() { return VxeTour; },
+  VxeTransfer: function() { return VxeTransfer; },
   VxeTree: function() { return VxeTree; },
   VxeTreeSelect: function() { return VxeTreeSelect; },
   VxeUI: function() { return VxeUI; },
@@ -13218,7 +13226,7 @@ var es_array_join = __webpack_require__(8598);
 
 
 var log_log = VxeUI.log;
-var uiVersion = "ui v".concat("3.15.11");
+var uiVersion = "ui v".concat("3.15.13");
 function createComponentLog(name) {
   var tableVersion = VxeUI.tableVersion ? "table v".concat(VxeUI.tableVersion) : '';
   var ganttVersion = VxeUI.ganttVersion ? "gantt v".concat(VxeUI.ganttVersion) : '';
@@ -13236,7 +13244,7 @@ var errLog = log_log.create('error', uiVersion);
 
 
 
-var ui_version = "3.15.11";
+var ui_version = "3.15.13";
 VxeUI.uiVersion = ui_version;
 VxeUI.dynamicApp = dynamicApp;
 function config(options) {
@@ -13456,6 +13464,12 @@ setConfig({
   listView: {},
   list: {
     // size: null,
+    dragConfig: {
+      showIcon: true,
+      animation: true,
+      showGuidesStatus: true,
+      showDragTip: true
+    },
     virtualYConfig: {
       enabled: true,
       gt: 60
@@ -13611,6 +13625,7 @@ setConfig({
       }
     }
   },
+  tableTransfer: {},
   tabs: {
     // destroyOnClose: false
   },
@@ -13638,6 +13653,7 @@ setConfig({
     leaveDelay: 300,
     isArrow: true
   },
+  transfer: {},
   tree: {
     // autoResize: false,
     indent: 20,
@@ -13899,7 +13915,11 @@ setIcon({
   // cascader
   CASCADER_NODE_OPEN: iconPrefix + 'arrow-right',
   CASCADER_NODE_CLOSE: iconPrefix + 'arrow-right',
-  CASCADER_NODE_LOADED: iconPrefix + 'spinner roll'
+  CASCADER_NODE_LOADED: iconPrefix + 'spinner roll',
+  // list
+  LIST_DRAG: iconPrefix + 'drag-handle',
+  LIST_DRAG_STATUS_NODE: iconPrefix + 'sort',
+  LIST_DRAG_DISABLED: iconPrefix + 'no-drop'
 });
 
 /* harmony default export */ var ui = ((/* unused pure expression or super */ null && (ui_VxeUI)));
@@ -14019,6 +14039,10 @@ setIcon({
       overSizeErr: '已超出最大可选数量 {0} 个，超出部分将被忽略！',
       searchEmpty: '未匹配到数据！'
     },
+    list: {
+      allChecked: '全选',
+      dragTip: '移动：{0}'
+    },
     tree: {
       searchEmpty: '未匹配到数据！',
       dragTip: '移动：{0}'
@@ -15920,6 +15944,12 @@ function getFuncText(content, args) {
   var translate = getConfig().translate;
   return "".concat(translate ? translate('' + content, args) : content);
 }
+function getText(content) {
+  if (external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eqNull(content)) {
+    return '';
+  }
+  return '' + content;
+}
 /**
  * 判断值为：'' | null | undefined 时都属于空值
  */
@@ -15929,6 +15959,12 @@ function eqEmptyValue(cellValue) {
 function handleBooleanDefaultValue(value) {
   return external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isBoolean(value) ? value : null;
 }
+function enModelValue(nodeid) {
+  return external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eqNull(nodeid) ? '' : encodeURIComponent("".concat(nodeid));
+}
+function deModelValue(nodeid) {
+  return nodeid ? decodeURIComponent("".concat(nodeid)) : nodeid;
+}
 ;// ./node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js
 function _arrayLikeToArray(r, a) {
   (null == a || a > r.length) && (a = r.length);
@@ -21219,6 +21255,79 @@ function enNodeValue(nodeid) {
 function deNodeValue(nodeid) {
   return nodeid ? decodeURIComponent("".concat(nodeid)) : nodeid;
 }
+;// ./packages/list/src/store.ts
+// 跨表拖拽
+var crossListDragRowGlobal = {
+  row: null
+};
+function getCrossListDragRowInfo($xeList) {
+  var crossListDragRowInfo = $xeList.crossListDragRowInfo;
+  return crossListDragRowInfo;
+}
+;// ./packages/ui/src/anime.ts
+/* unused harmony import specifier */ var anime_XEUtils;
+/* unused harmony import specifier */ var anime_addClass;
+/* unused harmony import specifier */ var anime_removeClass;
+
+
+
+
+
+
+
+
+var rowMoveCls = 'row--drag-move';
+var colMoveClass = 'col--drag-move';
+/**
+ * 上下拖拽
+ */
+function moveRowAnimateToTb(elemList, offsetTop) {
+  external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().arrayEach(elemList, function (trEl) {
+    trEl.style.transform = "translateY(".concat(offsetTop, "px)");
+  });
+  requestAnimationFrame(function () {
+    external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().arrayEach(elemList, function (trEl) {
+      addClass(trEl, rowMoveCls);
+      trEl.style.transform = '';
+    });
+  });
+}
+function clearRowAnimate(elem, clss) {
+  setTimeout(function () {
+    if (elem) {
+      external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().arrayEach(elem.querySelectorAll(clss.map(function (cls) {
+        return "".concat(cls, ".").concat(rowMoveCls);
+      }).join(',')), function (elem) {
+        return removeClass(elem, rowMoveCls);
+      });
+    }
+  }, 500);
+}
+/**
+ * 左右拖拽
+ */
+function moveColAnimateToLr(elemList, offsetLeft) {
+  anime_XEUtils.arrayEach(elemList, function (trEl) {
+    trEl.style.transform = "translateX(".concat(offsetLeft, "px)");
+  });
+  requestAnimationFrame(function () {
+    anime_XEUtils.arrayEach(elemList, function (trEl) {
+      anime_addClass(trEl, colMoveClass);
+      trEl.style.transform = '';
+    });
+  });
+}
+function clearColAnimate(elem, clss) {
+  setTimeout(function () {
+    if (elem) {
+      anime_XEUtils.arrayEach(elem.querySelectorAll(clss.map(function (cls) {
+        return "".concat(cls, ".").concat(rowMoveCls);
+      }).join(',')), function (elem) {
+        return anime_removeClass(elem, colMoveClass);
+      });
+    }
+  }, 500);
+}
 ;// ./packages/list/src/list.ts
 
 
@@ -21233,22 +21342,64 @@ function deNodeValue(nodeid) {
 
 
 
-var browseObj = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().browse();
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var list_createComponentLog = createComponentLog('tree'),
+  list_errLog = list_createComponentLog.errLog;
+function eqRowKey(rowKey1, rowKey2) {
+  return '' + rowKey1 === '' + rowKey2;
+}
+function getRowKeyByField(row, keyField) {
+  return row ? '' + (row[keyField] || '') : '';
+}
+function getRowIdByField(row, keyField) {
+  if (!row) {
+    return '';
+  }
+  var rowKey = getRowKeyByField(row, keyField);
+  return enModelValue(rowKey);
+}
 function list_createReactData() {
   return {
     scrollYLoad: false,
     bodyHeight: 0,
+    headHeight: 0,
+    footHeight: 0,
     customHeight: 0,
     customMaxHeight: 0,
     parentHeight: 0,
     topSpaceHeight: 0,
-    items: []
+    rowList: [],
+    selectRadioRow: null,
+    currRowFlag: 1,
+    updateCheckboxFlag: 1,
+    isAllChecked: false,
+    isAllIndeterminate: false,
+    dragRow: null,
+    dragTipText: ''
   };
 }
 function list_createInternalData() {
   return {
     resizeObserver: undefined,
     fullData: [],
+    fullKeyMaps: {},
     lastScrollLeft: 0,
     lastScrollTop: 0,
     scrollYStore: {
@@ -21257,7 +21408,11 @@ function list_createInternalData() {
       visibleSize: 0,
       offsetSize: 0,
       rowHeight: 0
-    }
+    },
+    currentRow: null,
+    selectCheckboxMaps: {}
+    // prevDragRow: null,
+    // prevDragPos: ''
   };
 }
 /* harmony default export */ var list = (/* define-vxe-component start */defineVxeComponent({
@@ -21282,6 +21437,24 @@ function list_createInternalData() {
       }
     },
     syncResize: [Boolean, String, Number],
+    showRadio: {
+      type: Boolean,
+      default: function _default() {
+        return getConfig().list.showRadio;
+      }
+    },
+    checkRowKey: [String, Number],
+    radioConfig: Object,
+    showCheckbox: {
+      type: Boolean,
+      default: function _default() {
+        return getConfig().list.showCheckbox;
+      }
+    },
+    checkRowKeys: Array,
+    checkboxConfig: Object,
+    rowConfig: Object,
+    dragConfig: Object,
     virtualYConfig: Object,
     scrollY: Object
   },
@@ -21290,29 +21463,85 @@ function list_createInternalData() {
     var reactData = list_createReactData();
     return _objectSpread2(_objectSpread2({}, {}), {}, {
       xID: xID,
-      reactData: reactData
+      reactData: reactData,
+      crossListDragRowInfo: crossListDragRowGlobal,
+      reFlag: 0
     });
   },
   computed: _objectSpread2(_objectSpread2({}, {}), {}, {
+    computeRowOpts: function computeRowOpts() {
+      var $xeList = this;
+      var props = $xeList;
+      return Object.assign({}, getConfig().list.rowConfig, props.rowConfig);
+    },
+    computeDragOpts: function computeDragOpts() {
+      var $xeList = this;
+      var props = $xeList;
+      return Object.assign({}, getConfig().list.dragConfig, props.dragConfig);
+    },
     computeSYOpts: function computeSYOpts() {
       var $xeList = this;
       var props = $xeList;
       return Object.assign({}, getConfig().list.virtualYConfig || getConfig().list.scrollY, props.virtualYConfig || props.scrollY);
     },
-    computeStyles: function computeStyles() {
+    computeKeyField: function computeKeyField() {
+      var $xeList = this;
+      var rowOpts = $xeList.computeRowOpts;
+      var keyField = rowOpts.keyField;
+      return keyField || '';
+    },
+    computeIsDrag: function computeIsDrag() {
+      var $xeList = this;
+      var props = $xeList;
+      var dragConfig = props.dragConfig;
+      var dragOpts = $xeList.computeDragOpts;
+      return dragConfig && isEnableConf(dragOpts);
+    },
+    computeRowHeight: function computeRowHeight() {
+      var $xeList = this;
+      var rowOpts = $xeList.computeRowOpts;
+      var height = rowOpts.height;
+      return height;
+    },
+    computeRadioOpts: function computeRadioOpts() {
+      var $xeList = this;
+      var props = $xeList;
+      return Object.assign({
+        showIcon: true
+      }, getConfig().list.radioConfig, props.radioConfig);
+    },
+    computeCheckboxOpts: function computeCheckboxOpts() {
+      var $xeList = this;
+      var props = $xeList;
+      return Object.assign({
+        showIcon: true
+      }, getConfig().list.checkboxConfig, props.checkboxConfig);
+    },
+    computeWrapperStyles: function computeWrapperStyles() {
+      var $xeList = this;
+      var rowHeight = $xeList.computeRowHeight;
+      var style = {};
+      if (rowHeight) {
+        style['--vxe-ui-list-row-height'] = toCssUnit(rowHeight);
+      }
+      return style;
+    },
+    computeVirtualStyles: function computeVirtualStyles() {
       var $xeList = this;
       var props = $xeList;
       var reactData = $xeList.reactData;
       var height = props.height,
         maxHeight = props.maxHeight;
       var customHeight = reactData.customHeight,
-        customMaxHeight = reactData.customMaxHeight;
+        customMaxHeight = reactData.customMaxHeight,
+        headHeight = reactData.headHeight,
+        footHeight = reactData.footHeight;
       var style = {};
       if (height) {
-        style.height = "".concat(customHeight, "px");
+        style.height = toCssUnit(Math.max(20, customHeight - headHeight - footHeight));
       } else if (maxHeight) {
         style.height = 'auto';
-        style.maxHeight = "".concat(customMaxHeight, "px");
+        style.maxHeight = toCssUnit(Math.max(20, customMaxHeight - headHeight - footHeight));
       }
       return style;
     }
@@ -21327,6 +21556,14 @@ function list_createInternalData() {
         $list: $xeList
       }, params));
     },
+    emitCheckboxMode: function emitCheckboxMode(value) {
+      var $xeList = this;
+      $xeList.$emit('update:checkRowKeys', value);
+    },
+    emitRadioMode: function emitRadioMode(value) {
+      var $xeList = this;
+      $xeList.$emit('update:checkRowKey', value);
+    },
     callSlot: function callSlot(slotFunc, params, h) {
       var $xeList = this;
       var slots = $xeList.$scopedSlots;
@@ -21340,6 +21577,66 @@ function list_createInternalData() {
       }
       return [];
     },
+    getRowId: function getRowId(row) {
+      var $xeList = this;
+      var keyField = $xeList.computeKeyField;
+      return getRowIdByField(row, keyField);
+    },
+    updateRadioModeValue: function updateRadioModeValue() {
+      var $xeList = this;
+      var props = $xeList;
+      var reactData = $xeList.reactData;
+      var internalData = $xeList.internalData;
+      var checkRowKey = props.checkRowKey;
+      var fullKeyMaps = internalData.fullKeyMaps;
+      if (checkRowKey) {
+        var row = fullKeyMaps[checkRowKey];
+        reactData.selectRadioRow = row || null;
+      } else {
+        reactData.selectRadioRow = null;
+      }
+    },
+    updateCheckboxModeValue: function updateCheckboxModeValue() {
+      var $xeList = this;
+      var props = $xeList;
+      var internalData = $xeList.internalData;
+      var checkRowKeys = props.checkRowKeys;
+      var fullKeyMaps = internalData.fullKeyMaps;
+      var keyField = $xeList.computeKeyField;
+      var selectMaps = {};
+      if (checkRowKeys && checkRowKeys.length) {
+        var _iterator = _createForOfIteratorHelper(checkRowKeys),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var rowKey = _step.value;
+            var row = fullKeyMaps[rowKey];
+            if (row) {
+              var rowid = getRowIdByField(row, keyField);
+              selectMaps[rowid] = row;
+            }
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+      }
+      internalData.selectCheckboxMaps = selectMaps;
+      $xeList.updateCheckboxStatus();
+    },
+    cacheRowMap: function cacheRowMap() {
+      var $xeList = this;
+      var internalData = $xeList.internalData;
+      var fullData = internalData.fullData;
+      var keyField = $xeList.computeKeyField;
+      var keyMaps = {};
+      fullData.forEach(function (row) {
+        var rowKey = getRowKeyByField(row, keyField);
+        keyMaps[rowKey] = row;
+      });
+      internalData.fullKeyMaps = keyMaps;
+    },
     /**
        * 加载数据
        * @param {Array} datas 数据
@@ -21359,7 +21656,10 @@ function list_createInternalData() {
       internalData.fullData = fullData;
       // 如果gt为0，则总是启用
       reactData.scrollYLoad = !!sYOpts.enabled && sYOpts.gt > -1 && (sYOpts.gt === 0 || sYOpts.gt <= fullData.length);
+      $xeList.cacheRowMap();
       $xeList.handleData();
+      $xeList.updateRadioModeValue();
+      $xeList.updateCheckboxModeValue();
       return $xeList.computeScrollLoad().then(function () {
         $xeList.refreshScroll();
       });
@@ -21373,6 +21673,12 @@ function list_createInternalData() {
       $xeList.clearScroll();
       return $xeList.loadData(datas);
     },
+    getFullData: function getFullData() {
+      var $xeList = this;
+      var internalData = $xeList.internalData;
+      var fullData = internalData.fullData;
+      return fullData;
+    },
     calcTableHeight: function calcTableHeight(key) {
       var $xeList = this;
       var props = $xeList;
@@ -21397,6 +21703,10 @@ function list_createInternalData() {
     updateHeight: function updateHeight() {
       var $xeList = this;
       var reactData = $xeList.reactData;
+      var headEl = $xeList.$refs.refHeaderElem;
+      var footEl = $xeList.$refs.refFooterElem;
+      reactData.headHeight = headEl ? Math.floor(headEl.offsetHeight) : 0;
+      reactData.footHeight = footEl ? Math.floor(footEl.offsetHeight) : 0;
       reactData.customHeight = $xeList.calcTableHeight('height');
       reactData.customMaxHeight = $xeList.calcTableHeight('maxHeight');
     },
@@ -21417,7 +21727,7 @@ function list_createInternalData() {
       var scrollYLoad = reactData.scrollYLoad;
       var fullData = internalData.fullData,
         scrollYStore = internalData.scrollYStore;
-      reactData.items = scrollYLoad ? fullData.slice(scrollYStore.startIndex, scrollYStore.endIndex) : fullData.slice(0);
+      reactData.rowList = scrollYLoad ? fullData.slice(scrollYStore.startIndex, scrollYStore.endIndex) : fullData.slice(0);
       return $xeList.$nextTick();
     },
     updateYData: function updateYData() {
@@ -21429,23 +21739,24 @@ function list_createInternalData() {
       var $xeList = this;
       var reactData = $xeList.reactData;
       var internalData = $xeList.internalData;
+      var browseObj = $xeList.browseObj;
       return $xeList.$nextTick().then(function () {
         var scrollYLoad = reactData.scrollYLoad;
         var scrollYStore = internalData.scrollYStore;
         var virtualBodyElem = $xeList.$refs.refVirtualBody;
         var sYOpts = $xeList.computeSYOpts;
         var rowHeight = 0;
-        var firstItemElem;
+        var firstRowElem;
         if (virtualBodyElem) {
           if (sYOpts.sItem) {
-            firstItemElem = virtualBodyElem.querySelector(sYOpts.sItem);
+            firstRowElem = virtualBodyElem.querySelector(sYOpts.sItem);
           }
-          if (!firstItemElem) {
-            firstItemElem = virtualBodyElem.children[0];
+          if (!firstRowElem) {
+            firstRowElem = virtualBodyElem.children[0];
           }
         }
-        if (firstItemElem) {
-          rowHeight = firstItemElem.offsetHeight;
+        if (firstRowElem) {
+          rowHeight = firstRowElem.offsetHeight;
         }
         rowHeight = Math.max(12, rowHeight);
         scrollYStore.rowHeight = rowHeight;
@@ -21580,31 +21891,1100 @@ function list_createInternalData() {
         isY: isY
       }, evnt);
     },
+    getRowKey: function getRowKey(row) {
+      var $xeList = this;
+      var keyField = $xeList.computeKeyField;
+      return getRowKeyByField(row, keyField);
+    },
+    eqRowKey: eqRowKey,
+    eqRow: function eqRow(row1, row2) {
+      var $xeList = this;
+      if (row1 && row2) {
+        if (row1 === row2) {
+          return true;
+        }
+        return eqRowKey($xeList.getRowId(row1), $xeList.getRowId(row2));
+      }
+      return false;
+    },
+    eqRowByKey: function eqRowByKey(row, rowKey) {
+      var $xeList = this;
+      return row && eqRowKey($xeList.getRowKey(row), rowKey);
+    },
+    findRow: function findRow(list, row) {
+      var $xeList = this;
+      return row ? external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().find(list, function (obj) {
+        return $xeList.eqRow(obj, row);
+      }) : null;
+    },
+    findRowByKey: function findRowByKey(list, rowId) {
+      var $xeList = this;
+      var keyField = $xeList.computeKeyField;
+      return external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().find(list, function (obj) {
+        return eqRowKey(getRowIdByField(obj, keyField), rowId);
+      });
+    },
+    findRowIndexOf: function findRowIndexOf(list, row) {
+      var $xeList = this;
+      return row ? external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().findIndexOf(list, function (obj) {
+        return $xeList.eqRow(obj, row);
+      }) : -1;
+    },
+    findRowIndexOfByKey: function findRowIndexOfByKey(list, rowKey) {
+      var $xeList = this;
+      var keyField = $xeList.computeKeyField;
+      return external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().findIndexOf(list, function (obj) {
+        return eqRowKey(getRowIdByField(obj, keyField), rowKey);
+      });
+    },
+    isCheckedByRadioRowKey: function isCheckedByRadioRowKey(rowKey) {
+      var $xeList = this;
+      var reactData = $xeList.reactData;
+      var selectRadioRow = reactData.selectRadioRow;
+      return $xeList.getRowKey(selectRadioRow) === rowKey;
+    },
+    isCheckedByRadioRow: function isCheckedByRadioRow(row) {
+      var $xeList = this;
+      return $xeList.isCheckedByRadioRowKey($xeList.getRowKey(row));
+    },
+    isCheckedByCheckboxRowKey: function isCheckedByCheckboxRowKey(rowid) {
+      var $xeList = this;
+      var reactData = $xeList.reactData;
+      var internalData = $xeList.internalData;
+      var updateCheckboxFlag = reactData.updateCheckboxFlag;
+      var selectCheckboxMaps = internalData.selectCheckboxMaps;
+      return !!(updateCheckboxFlag && selectCheckboxMaps[rowid]);
+    },
+    isCheckedByCheckboxRow: function isCheckedByCheckboxRow(row) {
+      var $xeList = this;
+      return $xeList.isCheckedByCheckboxRowKey($xeList.getRowKey(row));
+    },
+    setCurrentRow: function setCurrentRow(row) {
+      var $xeList = this;
+      var reactData = $xeList.reactData;
+      var internalData = $xeList.internalData;
+      internalData.currentRow = row;
+      reactData.currRowFlag++;
+      return $xeList.$nextTick();
+    },
+    setCurrentRowByKey: function setCurrentRowByKey(rowKey) {
+      var $xeList = this;
+      var reactData = $xeList.reactData;
+      var internalData = $xeList.internalData;
+      var fullData = internalData.fullData;
+      internalData.currentRow = $xeList.findRowByKey(fullData, rowKey);
+      reactData.currRowFlag++;
+      return $xeList.$nextTick();
+    },
+    getCurrentRow: function getCurrentRow() {
+      var $xeList = this;
+      var internalData = $xeList.internalData;
+      var currentRow = internalData.currentRow;
+      return currentRow;
+    },
+    getCurrentRowKey: function getCurrentRowKey() {
+      var $xeList = this;
+      var internalData = $xeList.internalData;
+      var currentRow = internalData.currentRow;
+      return currentRow ? $xeList.getRowKey(currentRow) : null;
+    },
+    clearCurrentRow: function clearCurrentRow() {
+      var $xeList = this;
+      var reactData = $xeList.reactData;
+      var internalData = $xeList.internalData;
+      internalData.currentRow = null;
+      reactData.currRowFlag++;
+      return $xeList.$nextTick();
+    },
+    setRadioRow: function setRadioRow(row) {
+      var $xeList = this;
+      var reactData = $xeList.reactData;
+      reactData.selectRadioRow = row;
+      var value = $xeList.getRowKey(row);
+      $xeList.emitRadioMode(value);
+      return $xeList.$nextTick();
+    },
+    setRadioRowByKey: function setRadioRowByKey(rowKey) {
+      var $xeList = this;
+      var reactData = $xeList.reactData;
+      var internalData = $xeList.internalData;
+      var fullData = internalData.fullData;
+      reactData.selectRadioRow = $xeList.findRowByKey(fullData, rowKey);
+      var value = rowKey;
+      $xeList.emitRadioMode(value);
+      return $xeList.$nextTick();
+    },
+    getRadioRow: function getRadioRow() {
+      var $xeList = this;
+      var reactData = $xeList.reactData;
+      var selectRadioRow = reactData.selectRadioRow;
+      return selectRadioRow;
+    },
+    getRadioRowKey: function getRadioRowKey() {
+      var $xeList = this;
+      var reactData = $xeList.reactData;
+      var selectRadioRow = reactData.selectRadioRow;
+      return selectRadioRow ? $xeList.getRowKey(selectRadioRow) : null;
+    },
+    clearRadioRow: function clearRadioRow() {
+      var $xeList = this;
+      var reactData = $xeList.reactData;
+      var value = null;
+      reactData.selectRadioRow = value;
+      $xeList.emitRadioMode(value);
+      return $xeList.$nextTick();
+    },
+    setCheckboxRow: function setCheckboxRow(row, checked) {
+      var $xeList = this;
+      var internalData = $xeList.internalData;
+      var selectCheckboxMaps = internalData.selectCheckboxMaps;
+      var keyField = $xeList.computeKeyField;
+      var rowList = row ? external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isArray(row) ? row : [row] : [];
+      rowList.forEach(checked ? function (obj) {
+        var rowid = getRowIdByField(obj, keyField);
+        if (!selectCheckboxMaps[rowid]) {
+          selectCheckboxMaps[rowid] = obj;
+        }
+      } : function (obj) {
+        var rowid = getRowIdByField(obj, keyField);
+        if (selectCheckboxMaps[rowid]) {
+          delete selectCheckboxMaps[rowid];
+        }
+      });
+      var value = $xeList.getCheckboxRowKeys();
+      $xeList.emitCheckboxMode(value);
+      return $xeList.updateCheckboxStatus();
+    },
+    setCheckboxRowByKey: function setCheckboxRowByKey(rowKey, checked) {
+      var $xeList = this;
+      var internalData = $xeList.internalData;
+      var selectCheckboxMaps = internalData.selectCheckboxMaps,
+        fullKeyMaps = internalData.fullKeyMaps;
+      var keyField = $xeList.computeKeyField;
+      var rowKeys = rowKey ? external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isArray(rowKey) ? rowKey : [rowKey] : [];
+      rowKeys.forEach(checked ? function (key) {
+        var row = fullKeyMaps[key || ''];
+        if (row) {
+          var rowid = getRowIdByField(row, keyField);
+          if (row && !selectCheckboxMaps[rowid]) {
+            selectCheckboxMaps[rowid] = row;
+          }
+        }
+      } : function (key) {
+        var row = fullKeyMaps[key || ''];
+        if (row) {
+          var rowid = getRowIdByField(row, keyField);
+          if (selectCheckboxMaps[rowid]) {
+            delete selectCheckboxMaps[rowid];
+          }
+        }
+      });
+      var value = $xeList.getCheckboxRowKeys();
+      $xeList.emitCheckboxMode(value);
+      return $xeList.updateCheckboxStatus();
+    },
+    getCheckboxRows: function getCheckboxRows() {
+      var $xeList = this;
+      var reactData = $xeList.reactData;
+      var internalData = $xeList.internalData;
+      var updateCheckboxFlag = reactData.updateCheckboxFlag;
+      var selectCheckboxMaps = internalData.selectCheckboxMaps;
+      var rowList = [];
+      if (updateCheckboxFlag) {
+        external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().each(selectCheckboxMaps, function (row) {
+          if (row) {
+            rowList.push(row);
+          }
+        });
+      }
+      return rowList;
+    },
+    getCheckboxRowKeys: function getCheckboxRowKeys() {
+      var $xeList = this;
+      var reactData = $xeList.reactData;
+      var internalData = $xeList.internalData;
+      var updateCheckboxFlag = reactData.updateCheckboxFlag;
+      var selectCheckboxMaps = internalData.selectCheckboxMaps;
+      var keyField = $xeList.computeKeyField;
+      var rowKeys = [];
+      if (updateCheckboxFlag) {
+        external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().each(selectCheckboxMaps, function (row) {
+          if (row) {
+            var rowKey = getRowKeyByField(row, keyField);
+            rowKeys.push(rowKey);
+          }
+        });
+      }
+      return rowKeys;
+    },
+    clearCheckboxRow: function clearCheckboxRow() {
+      var $xeList = this;
+      var reactData = $xeList.reactData;
+      var internalData = $xeList.internalData;
+      internalData.selectCheckboxMaps = {};
+      reactData.updateCheckboxFlag++;
+      reactData.isAllChecked = false;
+      reactData.isAllIndeterminate = false;
+      var value = [];
+      $xeList.emitCheckboxMode(value);
+      return $xeList.$nextTick();
+    },
+    setAllCheckboxRow: function setAllCheckboxRow(checked) {
+      var $xeList = this;
+      var internalData = $xeList.internalData;
+      var fullData = internalData.fullData,
+        selectCheckboxMaps = internalData.selectCheckboxMaps;
+      var keyField = $xeList.computeKeyField;
+      if (checked) {
+        var value = [];
+        var _iterator2 = _createForOfIteratorHelper(fullData),
+          _step2;
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var row = _step2.value;
+            var rowKey = getRowKeyByField(row, keyField);
+            var rowid = getRowIdByField(row, keyField);
+            selectCheckboxMaps[rowid] = row;
+            value.push(rowKey);
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+        $xeList.emitCheckboxMode(value);
+        return $xeList.updateCheckboxStatus();
+      }
+      return $xeList.clearCheckboxRow();
+    },
+    updateCheckboxStatus: function updateCheckboxStatus() {
+      var $xeList = this;
+      var reactData = $xeList.reactData;
+      var internalData = $xeList.internalData;
+      var selectCheckboxMaps = internalData.selectCheckboxMaps,
+        fullData = internalData.fullData;
+      var keyField = $xeList.computeKeyField;
+      var checkboxOpts = $xeList.computeCheckboxOpts;
+      var checkMethod = checkboxOpts.checkMethod;
+      var hasChecked = false;
+      var hasUnchecked = false;
+      if (checkMethod) {
+        var _iterator3 = _createForOfIteratorHelper(fullData),
+          _step3;
+        try {
+          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+            var row = _step3.value;
+            if (checkMethod({
+              row: row,
+              $list: $xeList
+            })) {
+              var rowid = getRowIdByField(row, keyField);
+              if (selectCheckboxMaps[rowid]) {
+                hasChecked = true;
+              } else {
+                hasUnchecked = true;
+                if (hasChecked) {
+                  break;
+                }
+              }
+            }
+          }
+        } catch (err) {
+          _iterator3.e(err);
+        } finally {
+          _iterator3.f();
+        }
+      } else {
+        var _iterator4 = _createForOfIteratorHelper(fullData),
+          _step4;
+        try {
+          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+            var _row = _step4.value;
+            var _rowid = getRowIdByField(_row, keyField);
+            if (selectCheckboxMaps[_rowid]) {
+              hasChecked = true;
+            } else {
+              hasUnchecked = true;
+              if (hasChecked) {
+                break;
+              }
+            }
+          }
+        } catch (err) {
+          _iterator4.e(err);
+        } finally {
+          _iterator4.f();
+        }
+      }
+      reactData.isAllChecked = hasChecked && !hasUnchecked;
+      reactData.isAllIndeterminate = hasChecked && hasUnchecked;
+      reactData.updateCheckboxFlag++;
+      return $xeList.$nextTick();
+    },
+    changeCheckboxAllEvent: function changeCheckboxAllEvent(evnt) {
+      var $xeList = this;
+      var reactData = $xeList.reactData;
+      var isAllChecked = reactData.isAllChecked;
+      var isChecked = !isAllChecked;
+      if (isChecked) {
+        $xeList.setAllCheckboxRow(true);
+      } else {
+        $xeList.clearCheckboxRow();
+      }
+      $xeList.dispatchEvent('checkbox-all', {
+        checked: isChecked
+      }, evnt);
+    },
+    changeCheckboxEvent: function changeCheckboxEvent(evnt, row) {
+      var $xeList = this;
+      var reactData = $xeList.reactData;
+      var internalData = $xeList.internalData;
+      evnt.preventDefault();
+      evnt.stopPropagation();
+      var selectCheckboxMaps = internalData.selectCheckboxMaps;
+      var checkboxOpts = $xeList.computeCheckboxOpts;
+      var checkMethod = checkboxOpts.checkMethod;
+      var rowid = $xeList.getRowKey(row);
+      var isDisabled = checkMethod ? !checkMethod({
+        $list: $xeList,
+        row: row
+      }) : false;
+      if (isDisabled) {
+        return;
+      }
+      var isChecked = false;
+      if (selectCheckboxMaps[rowid]) {
+        delete selectCheckboxMaps[rowid];
+      } else {
+        isChecked = true;
+        selectCheckboxMaps[rowid] = row;
+      }
+      reactData.updateCheckboxFlag++;
+      $xeList.updateCheckboxStatus();
+      var rowids = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().keys(selectCheckboxMaps);
+      var value = rowids.map(deModelValue);
+      $xeList.emitCheckboxMode(value);
+      $xeList.dispatchEvent('checkbox-change', {
+        row: row,
+        value: value,
+        checked: isChecked
+      }, evnt);
+    },
+    changeCurrentEvent: function changeCurrentEvent(evnt, row) {
+      var $xeList = this;
+      var reactData = $xeList.reactData;
+      var internalData = $xeList.internalData;
+      evnt.preventDefault();
+      var rowOpts = $xeList.computeRowOpts;
+      var currentMethod = rowOpts.currentMethod;
+      var isDisabled = false;
+      if (currentMethod) {
+        isDisabled = !currentMethod({
+          row: row
+        });
+      }
+      if (isDisabled) {
+        return;
+      }
+      var isChecked = true;
+      internalData.currentRow = row;
+      reactData.currRowFlag++;
+      $xeList.dispatchEvent('current-change', {
+        row: row,
+        checked: isChecked
+      }, evnt);
+    },
+    changeRadioEvent: function changeRadioEvent(evnt, row) {
+      var $xeList = this;
+      var reactData = $xeList.reactData;
+      evnt.preventDefault();
+      evnt.stopPropagation();
+      var selectRadioRow = reactData.selectRadioRow;
+      var radioOpts = $xeList.computeRadioOpts;
+      var strict = radioOpts.strict,
+        checkMethod = radioOpts.checkMethod;
+      var rowKey = $xeList.getRowKey(row);
+      var isDisabled = checkMethod ? !checkMethod({
+        $list: $xeList,
+        row: row
+      }) : false;
+      if (isDisabled) {
+        return;
+      }
+      var value = rowKey;
+      var isChecked = true;
+      if (strict) {
+        if (selectRadioRow && rowKey === $xeList.getRowKey(selectRadioRow)) {
+          isChecked = false;
+          reactData.selectRadioRow = null;
+        } else {
+          reactData.selectRadioRow = row;
+        }
+      } else {
+        reactData.selectRadioRow = row;
+      }
+      $xeList.emitRadioMode(value);
+      $xeList.dispatchEvent('radio-change', {
+        row: row,
+        value: value,
+        checked: isChecked
+      }, evnt);
+    },
+    clearRowDropOrigin: function clearRowDropOrigin() {
+      var $xeList = this;
+      var el = $xeList.$refs.refElem;
+      if (el) {
+        var clss = 'row--drag-origin';
+        external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().arrayEach(el.querySelectorAll(".".concat(clss)), function (elem) {
+          elem.draggable = false;
+          removeClass(elem, clss);
+        });
+      }
+    },
+    updateRowDropOrigin: function updateRowDropOrigin(row) {
+      var $xeList = this;
+      var sYOpts = $xeList.computeSYOpts;
+      var sItem = sYOpts.sItem;
+      var el = $xeList.$refs.refElem;
+      if (el) {
+        var clss = 'row--drag-origin';
+        var rowid = $xeList.getRowId(row);
+        external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().arrayEach(el.querySelectorAll(".vxe-list--row[rowid=\"".concat(rowid, "\"]") + (sItem ? "".concat(sItem, "[rowid=\"").concat(rowid, "\"]") : '')), function (elem) {
+          addClass(elem, clss);
+        });
+      }
+    },
+    updateRowDropTipContent: function updateRowDropTipContent(rowEl) {
+      var $xeList = this;
+      var reactData = $xeList.reactData;
+      var dragRow = reactData.dragRow;
+      var dragOpts = $xeList.computeDragOpts;
+      var tooltipMethod = dragOpts.tooltipMethod;
+      var rTooltipMethod = tooltipMethod;
+      var tipContent = '';
+      if (rTooltipMethod) {
+        var rtParams = {
+          $list: $xeList,
+          row: dragRow
+        };
+        tipContent = "".concat(rTooltipMethod(rtParams) || '');
+      } else {
+        tipContent = getI18n('vxe.list.dragTip', [rowEl.textContent || '']);
+      }
+      reactData.dragTipText = tipContent;
+    },
+    hideDropTip: function hideDropTip() {
+      var $xeList = this;
+      var rdTipEl = $xeList.$refs.refDragTipElem;
+      var rdLineEl = $xeList.$refs.refDragRowLineElem;
+      if (rdTipEl) {
+        rdTipEl.style.display = '';
+      }
+      if (rdLineEl) {
+        rdLineEl.style.display = '';
+      }
+    },
+    clearCrossListDragStatus: function clearCrossListDragStatus() {
+      var $xeList = this;
+      var crossListDragRowInfo = getCrossListDragRowInfo($xeList);
+      // crossListDragRowObj = null
+      crossListDragRowInfo.row = null;
+    },
+    clearDragStatus: function clearDragStatus() {
+      var $xeList = this;
+      var reactData = $xeList.reactData;
+      var dragRow = reactData.dragRow;
+      if (dragRow) {
+        $xeList.hideDropTip();
+        $xeList.clearRowDropOrigin();
+        $xeList.clearCrossListDragStatus();
+        reactData.dragRow = null;
+      }
+    },
+    handleRowDragMousedownEvent: function handleRowDragMousedownEvent(evnt, params) {
+      var $xeList = this;
+      var reactData = $xeList.reactData;
+      evnt.stopPropagation();
+      var row = params.row;
+      var dragConfig = $xeList.computeDragOpts;
+      var trigger = dragConfig.trigger,
+        dragStartMethod = dragConfig.dragStartMethod;
+      var dragEl = evnt.currentTarget;
+      var rowEl = trigger === 'row' ? dragEl : dragEl.parentElement.parentElement;
+      $xeList.clearRowDropOrigin();
+      if (dragStartMethod && !dragStartMethod(params)) {
+        rowEl.draggable = false;
+        reactData.dragRow = null;
+        $xeList.hideDropTip();
+        return;
+      }
+      var dragstartEventParams = {
+        row: row
+      };
+      reactData.dragRow = row;
+      rowEl.draggable = true;
+      $xeList.updateRowDropOrigin(row);
+      $xeList.updateRowDropTipContent(rowEl);
+      $xeList.dispatchEvent('row-dragstart', dragstartEventParams, evnt);
+    },
+    handleRowDragMouseupEvent: function handleRowDragMouseupEvent() {
+      var $xeList = this;
+      $xeList.clearDragStatus();
+    },
+    showDropTip: function showDropTip(evnt, rowEl, showLine, dragPos) {
+      var $xeList = this;
+      var wrapperEl = $xeList.$refs.refElem;
+      if (!wrapperEl) {
+        return;
+      }
+      var wrapperRect = wrapperEl.getBoundingClientRect();
+      var wrapperHeight = wrapperEl.clientHeight;
+      if (rowEl) {
+        var rdLineEl = $xeList.$refs.refDragRowLineElem;
+        if (rdLineEl) {
+          if (showLine) {
+            var trRect = rowEl.getBoundingClientRect();
+            var rowHeight = rowEl.clientHeight;
+            var offsetTop = Math.max(1, trRect.y - wrapperRect.y);
+            if (offsetTop + rowHeight > wrapperHeight) {
+              rowHeight = wrapperHeight - offsetTop;
+            }
+            rdLineEl.style.display = 'block';
+            rdLineEl.style.top = "".concat(offsetTop, "px");
+            rdLineEl.style.height = "".concat(rowHeight, "px");
+            rdLineEl.setAttribute('drag-pos', dragPos);
+          } else {
+            rdLineEl.style.display = '';
+          }
+        }
+      }
+      var rdTipEl = $xeList.$refs.refDragTipElem;
+      if (rdTipEl) {
+        rdTipEl.style.display = 'block';
+        rdTipEl.style.top = "".concat(Math.min(wrapperEl.clientHeight - wrapperEl.scrollTop - rdTipEl.clientHeight, evnt.clientY - wrapperRect.y), "px");
+        rdTipEl.style.left = "".concat(Math.min(wrapperEl.clientWidth - wrapperEl.scrollLeft - rdTipEl.clientWidth - 1, evnt.clientX - wrapperRect.x), "px");
+        rdTipEl.setAttribute('drag-status', showLine ? 'normal' : 'disabled');
+      }
+    },
+    clearRowDragData: function clearRowDragData() {
+      var $xeList = this;
+      var reactData = $xeList.reactData;
+      var wrapperEl = $xeList.$refs.refElem;
+      var dtClss = ['.vxe-list--row'];
+      $xeList.hideDropTip();
+      $xeList.clearRowDropOrigin();
+      clearRowAnimate(wrapperEl, dtClss);
+      reactData.dragRow = null;
+    },
+    handleRowDragSwapEvent: function handleRowDragSwapEvent(evnt, dragRow, prevDragRow, prevDragPos) {
+      var $xeList = this;
+      var reactData = $xeList.reactData;
+      var internalData = $xeList.internalData;
+      var fullData = internalData.fullData;
+      var dragConfig = $xeList.computeDragOpts;
+      var animation = dragConfig.animation,
+        dragEndMethod = dragConfig.dragEndMethod;
+      var dEndMethod = dragEndMethod || (dragConfig ? dragConfig.dragEndMethod : null);
+      var dragOffsetIndex = prevDragPos === 'bottom' ? 1 : 0;
+      var el = $xeList.$refs.refElem;
+      var errRest = {
+        status: false
+      };
+      if (!(el && prevDragRow && dragRow)) {
+        return Promise.resolve(errRest);
+      }
+      // 判断是否有拖动
+      if (prevDragRow !== dragRow) {
+        var dragParams = {
+          oldRow: dragRow,
+          newRow: prevDragRow,
+          dragRow: dragRow,
+          dragPos: prevDragPos,
+          offsetIndex: dragOffsetIndex
+        };
+        var dragRowid = $xeList.getRowId(dragRow);
+        var _dragRowIndex = $xeList.findRowIndexOfByKey(fullData, dragRowid);
+        var newRowid = $xeList.getRowKey(prevDragRow);
+        var dragRowHeight = 0;
+        var dragOffsetTop = -1;
+        if (animation) {
+          var prevRowEl = el.querySelector(".vxe-list--row[rowid=\"".concat(newRowid, "\"]"));
+          var oldRowEl = el.querySelector(".vxe-list--row[rowid=\"".concat(dragRowid, "\"]"));
+          var targetRowEl = prevRowEl || oldRowEl;
+          if (targetRowEl) {
+            dragRowHeight = targetRowEl.offsetHeight;
+          }
+          if (oldRowEl) {
+            dragOffsetTop = oldRowEl.offsetTop;
+          }
+        }
+        var oafIndex = -1;
+        var nafIndex = -1;
+        return Promise.resolve(dEndMethod ? dEndMethod(dragParams) : true).then(function (status) {
+          if (!status) {
+            return errRest;
+          }
+          // 移出
+          oafIndex = $xeList.findRowIndexOf(fullData, dragRow);
+          fullData.splice(oafIndex, 1);
+          // 插入
+          var pafIndex = $xeList.findRowIndexOf(fullData, prevDragRow);
+          nafIndex = pafIndex + dragOffsetIndex;
+          fullData.splice(nafIndex, 0, dragRow);
+          $xeList.handleData();
+          if (reactData.scrollYLoad) {
+            $xeList.updateYSpace();
+          }
+          if (evnt) {
+            var dragendEventParams = {
+              oldRow: dragRow,
+              newRow: prevDragRow,
+              dragRow: dragRow,
+              dragPos: prevDragPos,
+              offsetIndex: dragOffsetIndex,
+              _index: {
+                newIndex: nafIndex,
+                oldIndex: oafIndex
+              }
+            };
+            $xeList.dispatchEvent('row-dragend', dragendEventParams, evnt);
+          }
+          return $xeList.$nextTick().then(function () {
+            if (animation) {
+              var rowList = reactData.rowList;
+              var _fullData = internalData.fullData;
+              var _newRowIndex = $xeList.findRowIndexOfByKey(_fullData, dragRowid);
+              var firstRow = _fullData[0];
+              var _firstRowIndex = $xeList.findRowIndexOf(_fullData, firstRow);
+              var wrapperEl = el;
+              if (_firstRowIndex > -1) {
+                var _lastRowIndex = _firstRowIndex + _fullData.length;
+                var rsIndex = -1;
+                var reIndex = -1;
+                var offsetRate = 1;
+                if (_dragRowIndex < _firstRowIndex) {
+                  // 从上往下虚拟拖拽
+                  rsIndex = 0;
+                  reIndex = _newRowIndex - _firstRowIndex;
+                } else if (_dragRowIndex > _lastRowIndex) {
+                  // 从下往上虚拟拖拽
+                  var $newRowIndex = $xeList.findRowIndexOfByKey(rowList, dragRowid);
+                  rsIndex = $newRowIndex + 1;
+                  reIndex = _fullData.length;
+                  offsetRate = -1;
+                } else {
+                  if (_newRowIndex > _dragRowIndex) {
+                    // 从上往下拖拽
+                    rsIndex = _dragRowIndex - _firstRowIndex;
+                    reIndex = rsIndex + _newRowIndex - _dragRowIndex;
+                  } else {
+                    // 从下往上拖拽
+                    rsIndex = _newRowIndex - _firstRowIndex;
+                    reIndex = rsIndex + _dragRowIndex - _newRowIndex + 1;
+                    offsetRate = -1;
+                  }
+                }
+                var dragRangeList = _fullData.slice(rsIndex, reIndex);
+                if (dragRangeList.length) {
+                  var dtClss = [];
+                  dragRangeList.forEach(function (obj) {
+                    var rowid = $xeList.getRowId(obj);
+                    dtClss.push(".vxe-list--row[rowid=\"".concat(rowid, "\"]"));
+                  });
+                  var dtTrList = wrapperEl.querySelectorAll(dtClss.join(','));
+                  moveRowAnimateToTb(dtTrList, offsetRate * dragRowHeight);
+                }
+              }
+              var drClss = [".vxe-list--row[rowid=\"".concat(dragRowid, "\"]")];
+              var newDtTrList = wrapperEl.querySelectorAll(drClss.join(','));
+              var newTrEl = newDtTrList[0];
+              if (dragOffsetTop > -1 && newTrEl) {
+                moveRowAnimateToTb(newDtTrList, dragOffsetTop - newTrEl.offsetTop);
+              }
+            }
+            $xeList.recalculate();
+          }).then(function () {
+            return {
+              status: true
+            };
+          });
+        }).catch(function () {
+          return errRest;
+        }).then(function (rest) {
+          $xeList.clearRowDragData();
+          $xeList.clearCrossListDragStatus();
+          return rest;
+        });
+      }
+      $xeList.clearRowDragData();
+      $xeList.clearCrossListDragStatus();
+      return Promise.resolve(errRest);
+    },
+    handleRowDragDragstartEvent: function handleRowDragDragstartEvent(evnt) {
+      if (evnt.dataTransfer) {
+        evnt.dataTransfer.setDragImage(getTpImg(), 0, 0);
+      }
+    },
+    handleRowDragDragendEvent: function handleRowDragDragendEvent(evnt) {
+      var $xeList = this;
+      var reactData = $xeList.reactData;
+      var internalData = $xeList.internalData;
+      var dragRow = reactData.dragRow;
+      var prevDragRow = internalData.prevDragRow,
+        prevDragPos = internalData.prevDragPos;
+      $xeList.handleRowDragSwapEvent(evnt, dragRow, prevDragRow, prevDragPos);
+    },
+    handleRowDragDragoverEvent: function handleRowDragDragoverEvent(evnt) {
+      var $xeList = this;
+      var reactData = $xeList.reactData;
+      var internalData = $xeList.internalData;
+      var dragRow = reactData.dragRow;
+      var fullData = internalData.fullData;
+      if (!dragRow) {
+        evnt.preventDefault();
+      }
+      var rowEl = evnt.currentTarget;
+      var rowid = rowEl.getAttribute('rowid') || '';
+      var row = $xeList.findRowByKey(fullData, rowid);
+      if (row) {
+        evnt.preventDefault();
+        var offsetY = evnt.clientY - rowEl.getBoundingClientRect().y;
+        var dragPos = offsetY < rowEl.clientHeight / 2 ? 'top' : 'bottom';
+        internalData.prevDragRow = row;
+        internalData.prevDragPos = dragPos;
+        if (dragRow && $xeList.getRowId(dragRow) === rowid) {
+          $xeList.showDropTip(evnt, rowEl, false, dragPos);
+          return;
+        }
+        var dragOffsetIndex = dragPos === 'bottom' ? 1 : 0;
+        var offsetIndex = dragOffsetIndex;
+        var dragoverEventParams = {
+          oldRow: dragRow,
+          targetRow: row,
+          dragPos: dragPos,
+          dragRow: dragRow,
+          offsetIndex: offsetIndex
+        };
+        $xeList.showDropTip(evnt, rowEl, true, dragPos);
+        $xeList.dispatchEvent('row-dragover', dragoverEventParams, evnt);
+      }
+    },
+    handleRowMousedownEvent: function handleRowMousedownEvent(evnt, row) {
+      var $xeList = this;
+      var dragConfig = $xeList.computeDragOpts;
+      var isDrag = $xeList.computeIsDrag;
+      var trigger = dragConfig.trigger,
+        disabledMethod = dragConfig.disabledMethod;
+      var isRowDrag = false;
+      if (isDrag) {
+        isRowDrag = trigger === 'row';
+      }
+      var params = {
+        row: row,
+        $list: $xeList
+      };
+      if (isRowDrag && !(disabledMethod && disabledMethod(params))) {
+        $xeList.handleRowDragMousedownEvent(evnt, params);
+      }
+    },
+    handleRowClickEvent: function handleRowClickEvent(evnt, row) {
+      var $xeList = this;
+      var reactData = $xeList.reactData;
+      var internalData = $xeList.internalData;
+      var currentRow = internalData.currentRow;
+      var rowOpts = $xeList.computeRowOpts;
+      var isCurrent = rowOpts.isCurrent;
+      var triggerCurrent = false;
+      if (isCurrent) {
+        triggerCurrent = true;
+        $xeList.changeCurrentEvent(evnt, row);
+      } else if (currentRow) {
+        internalData.currentRow = null;
+        reactData.currRowFlag++;
+      }
+      $xeList.dispatchEvent('row-click', {
+        row: row,
+        triggerCurrent: triggerCurrent
+      }, evnt);
+    },
+    handleRowDblclickEvent: function handleRowDblclickEvent(evnt, row) {
+      var $xeList = this;
+      $xeList.dispatchEvent('row-dblclick', {
+        row: row
+      }, evnt);
+    },
     //
     // Render
     //
+    renderDragTip: function renderDragTip(h) {
+      var $xeList = this;
+      var reactData = $xeList.reactData;
+      var dragRow = reactData.dragRow,
+        dragTipText = reactData.dragTipText;
+      var dragOpts = $xeList.computeDragOpts;
+      var isDrag = $xeList.computeIsDrag;
+      var dRow = dragRow;
+      if (isDrag) {
+        return h('div', {
+          class: 'vxe-list--drag-wrapper'
+        }, [h('div', {
+          ref: 'refDragRowLineElem',
+          class: ['vxe-list--drag-row-line', {
+            'is--guides': dragOpts.showGuidesStatus
+          }]
+        }), dRow && dragOpts.showDragTip ? h('div', {
+          ref: 'refDragTipElem',
+          class: 'vxe-list--drag-sort-tip'
+        }, [h('div', {
+          class: 'vxe-list--drag-sort-tip-wrapper'
+        }, [h('div', {
+          class: 'vxe-list--drag-sort-tip-status'
+        }, [h('span', {
+          class: ['vxe-list--drag-sort-tip-normal-status', getIcon().LIST_DRAG_STATUS_NODE]
+        }), h('span', {
+          class: ['vxe-list--drag-sort-tip-disabled-status', getIcon().LIST_DRAG_DISABLED]
+        })]), h('div', {
+          class: 'vxe-list--drag-sort-tip-content'
+        }, dragTipText)])]) : renderEmptyElement($xeList)]);
+      }
+      return renderEmptyElement($xeList);
+    },
+    renderRadio: function renderRadio(h, row, rowid, isChecked) {
+      var $xeList = this;
+      var props = $xeList;
+      var showRadio = props.showRadio;
+      var radioOpts = $xeList.computeRadioOpts;
+      var showIcon = radioOpts.showIcon,
+        checkMethod = radioOpts.checkMethod,
+        visibleMethod = radioOpts.visibleMethod;
+      var isVisible = !visibleMethod || visibleMethod({
+        $list: $xeList,
+        row: row
+      });
+      if (showRadio && showIcon && isVisible) {
+        var isDisabled = checkMethod ? !checkMethod({
+          $list: $xeList,
+          row: row
+        }) : false;
+        return h('div', {
+          key: 'ct2',
+          class: ['vxe-list--radio-option', {
+            'is--checked': isChecked,
+            'is--disabled': isDisabled
+          }],
+          on: {
+            click: function click(evnt) {
+              if (!isDisabled) {
+                $xeList.changeRadioEvent(evnt, row);
+              }
+            }
+          }
+        }, [h('span', {
+          class: ['vxe-radio--icon', isChecked ? getIcon().RADIO_CHECKED : getIcon().RADIO_UNCHECKED]
+        })]);
+      }
+      return renderEmptyElement($xeList);
+    },
+    renderCheckbox: function renderCheckbox(h, row, rowid, isChecked) {
+      var $xeList = this;
+      var props = $xeList;
+      var showCheckbox = props.showCheckbox;
+      var checkboxOpts = $xeList.computeCheckboxOpts;
+      var showIcon = checkboxOpts.showIcon,
+        checkMethod = checkboxOpts.checkMethod,
+        visibleMethod = checkboxOpts.visibleMethod;
+      var isVisible = !visibleMethod || visibleMethod({
+        $list: $xeList,
+        row: row
+      });
+      if (showCheckbox && showIcon && isVisible) {
+        var isDisabled = checkMethod ? !checkMethod({
+          $list: $xeList,
+          row: row
+        }) : false;
+        return h('div', {
+          key: 'ct3',
+          class: ['vxe-list--checkbox-option', {
+            'is--checked': isChecked,
+            'is--disabled': isDisabled
+          }],
+          on: {
+            click: function click(evnt) {
+              if (!isDisabled) {
+                $xeList.changeCheckboxEvent(evnt, row);
+              }
+            }
+          }
+        }, [h('span', {
+          class: ['vxe-checkbox--icon', isChecked ? getIcon().CHECKBOX_CHECKED : getIcon().CHECKBOX_UNCHECKED]
+        })]);
+      }
+      return renderEmptyElement($xeList);
+    },
+    renderRow: function renderRow(h, row, rowIndex) {
+      var $xeList = this;
+      var props = $xeList;
+      var reactData = $xeList.reactData;
+      var internalData = $xeList.internalData;
+      var slots = $xeList.$scopedSlots;
+      var showRadio = props.showRadio,
+        showCheckbox = props.showCheckbox;
+      var selectRadioRow = reactData.selectRadioRow,
+        currRowFlag = reactData.currRowFlag,
+        updateCheckboxFlag = reactData.updateCheckboxFlag;
+      var selectCheckboxMaps = internalData.selectCheckboxMaps,
+        currentRow = internalData.currentRow;
+      var contentSlot = slots.content;
+      var dragOpts = $xeList.computeDragOpts;
+      var trigger = dragOpts.trigger,
+        icon = dragOpts.icon,
+        disabledMethod = dragOpts.disabledMethod,
+        visibleMethod = dragOpts.visibleMethod;
+      var rowOpts = $xeList.computeRowOpts;
+      var useKey = rowOpts.useKey,
+        contentField = rowOpts.contentField,
+        rowClassName = rowOpts.className,
+        isCurrent = rowOpts.isCurrent;
+      var isDrag = $xeList.computeIsDrag;
+      var keyField = $xeList.computeKeyField;
+      var isRowFnCls = rowClassName && external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isFunction(rowClassName);
+      var hasKey = keyField || useKey || isDrag || isCurrent || showRadio || showCheckbox;
+      var rowKey = hasKey && keyField ? getRowIdByField(row, keyField) : '';
+      var rowid = enModelValue(rowKey);
+      var rowParams = {
+        row: row,
+        $list: $xeList
+      };
+      var isRadioChecked = false;
+      if (showRadio) {
+        isRadioChecked = selectRadioRow && (row === selectRadioRow || $xeList.eqRowByKey(selectRadioRow, rowKey));
+      }
+      var isCheckboxChecked = false;
+      if (showCheckbox) {
+        isCheckboxChecked = !!(updateCheckboxFlag && selectCheckboxMaps[rowid]);
+      }
+      var ctVNs = [];
+      var isDragDisabled = false;
+      if (isDrag && keyField && (!visibleMethod || visibleMethod(rowParams))) {
+        var handleOns = {};
+        if (trigger !== 'row') {
+          isDragDisabled = !!(disabledMethod && disabledMethod(rowParams));
+          handleOns.mousedown = function (evnt) {
+            if (!isDragDisabled) {
+              $xeList.handleRowDragMousedownEvent(evnt, rowParams);
+            }
+          };
+          handleOns.mouseup = $xeList.handleRowDragMouseupEvent;
+        }
+        ctVNs.push(h('div', {
+          key: 'ct1',
+          class: 'vxe-list--row-drag'
+        }, [h('span', {
+          class: 'vxe-list--drag-handle',
+          on: handleOns
+        }, [h('i', {
+          class: icon || getIcon().LIST_DRAG
+        })])]));
+      }
+      if (showRadio) {
+        ctVNs.push($xeList.renderRadio(h, row, rowid, isRadioChecked));
+      }
+      if (showCheckbox) {
+        ctVNs.push($xeList.renderCheckbox(h, row, rowid, isCheckboxChecked));
+      }
+      ctVNs.push(h('div', {
+        key: 'ct5',
+        class: 'vxe-list--row-content'
+      }, contentSlot ? contentSlot(rowParams) : contentField ? getText(row[contentField]) : ''));
+      var rowOns = {
+        mousedown: function mousedown(evnt) {
+          $xeList.handleRowMousedownEvent(evnt, row);
+        },
+        mouseup: $xeList.handleRowDragMouseupEvent,
+        click: function click(evnt) {
+          $xeList.handleRowClickEvent(evnt, row);
+        },
+        dblclick: function dblclick(evnt) {
+          $xeList.handleRowDblclickEvent(evnt, row);
+        }
+      };
+      // 拖拽行事件
+      if (isDrag) {
+        rowOns.dragstart = $xeList.handleRowDragDragstartEvent;
+        rowOns.dragend = $xeList.handleRowDragDragendEvent;
+        rowOns.dragover = $xeList.handleRowDragDragoverEvent;
+      }
+      return h('div', {
+        key: hasKey && keyField ? rowid : rowIndex,
+        class: ['vxe-list--row', isRowFnCls ? rowClassName(rowParams) : rowClassName || '', {
+          'is--drag-disabled': isDragDisabled,
+          'is--current': currRowFlag && currentRow && $xeList.eqRowByKey(currentRow, rowKey),
+          'is-radio--checked': isRadioChecked,
+          'is-checkbox--checked': isCheckboxChecked
+        }],
+        attrs: hasKey && keyField ? {
+          rowid: rowid
+        } : undefined,
+        on: rowOns
+      }, ctVNs);
+    },
     renderVN: function renderVN(h) {
       var $xeList = this;
       var props = $xeList;
       var reactData = $xeList.reactData;
       var slots = $xeList.$scopedSlots;
-      var className = props.className,
+      var showCheckbox = props.showCheckbox,
+        className = props.className,
         loading = props.loading;
       var bodyHeight = reactData.bodyHeight,
         topSpaceHeight = reactData.topSpaceHeight,
-        items = reactData.items;
+        rowList = reactData.rowList,
+        isAllChecked = reactData.isAllChecked,
+        isAllIndeterminate = reactData.isAllIndeterminate;
       var defaultSlot = slots.default;
+      var headerSlot = slots.header;
+      var footerSlot = slots.footer;
       var vSize = $xeList.computeSize;
-      var styles = $xeList.computeStyles;
+      var wrapperStyles = $xeList.computeWrapperStyles;
+      var virtualStyles = $xeList.computeVirtualStyles;
+      var radioOpts = $xeList.computeRadioOpts;
+      var checkboxOpts = $xeList.computeCheckboxOpts;
+      var dragOpts = $xeList.computeDragOpts;
+      var trigger = dragOpts.trigger;
+      var rowOpts = $xeList.computeRowOpts;
+      var isHover = rowOpts.isHover,
+        padding = rowOpts.padding;
+      var showDefChekboxHead = showCheckbox && checkboxOpts.showHeader !== false;
       return h('div', {
         ref: 'refElem',
         class: ['vxe-list', className ? external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isFunction(className) ? className({
           $list: $xeList
-        }) : className : '', _defineProperty(_defineProperty({}, "size--".concat(vSize), vSize), 'is--loading', loading)]
+        }) : className : '', _defineProperty(_defineProperty({}, "size--".concat(vSize), vSize), 'is--loading', loading)],
+        style: wrapperStyles
+      }, [headerSlot || showDefChekboxHead ? h('div', {
+        ref: 'refHeaderElem',
+        class: 'vxe-list--header-wrapper'
+      }, [showDefChekboxHead ? h('div', {
+        class: 'vxe-list--header-left'
       }, [h('div', {
+        class: ['vxe-list--checkbox-header', {
+          'is--checked': isAllChecked,
+          'is--indeterminate': isAllIndeterminate
+        }],
+        on: {
+          click: $xeList.changeCheckboxAllEvent
+        }
+      }, [h('span', {
+        class: ['vxe-checkbox--icon', isAllChecked ? getIcon().CHECKBOX_CHECKED : isAllIndeterminate ? getIcon().CHECKBOX_INDETERMINATE : getIcon().CHECKBOX_UNCHECKED]
+      })])]) : renderEmptyElement($xeList), headerSlot ? h('div', {
+        class: 'vxe-list--header-content'
+      }, headerSlot({
+        items: rowList,
+        $list: $xeList
+      })) : renderEmptyElement($xeList)]) : renderEmptyElement($xeList), h('div', {
         ref: 'refVirtualWrapper',
         class: 'vxe-list--virtual-wrapper',
-        style: styles,
+        style: virtualStyles,
         on: {
           scroll: $xeList.scrollEvent
         }
@@ -21615,13 +22995,32 @@ function list_createInternalData() {
         }
       }), h('div', {
         ref: 'refVirtualBody',
-        class: 'vxe-list--body',
+        class: ['vxe-list--body', {
+          'trigger--row': trigger === 'row',
+          'checkbox--highlight': checkboxOpts.highlight,
+          'radio--highlight': radioOpts.highlight,
+          'row--hover': isHover,
+          'is--padding': padding
+        }],
         style: {
           marginTop: topSpaceHeight ? "".concat(topSpaceHeight, "px") : ''
         }
-      }, defaultSlot ? $xeList.callSlot(defaultSlot, {
-        items: items
-      }, h) : [])]),
+      }, defaultSlot ? defaultSlot({
+        items: rowList,
+        $list: $xeList
+      }) : rowList.map(function (row, i) {
+        return $xeList.renderRow(h, row, i);
+      }))]), footerSlot ? h('div', {
+        ref: 'refFooterElem',
+        class: 'vxe-list--footer-wrapper'
+      }, footerSlot({
+        items: rowList,
+        $list: $xeList
+      })) : renderEmptyElement($xeList),
+      /**
+       * 拖拽提示
+       */
+      $xeList.renderDragTip(h),
       /**
        * 加载中
        */
@@ -21641,35 +23040,66 @@ function list_createInternalData() {
     },
     height: function height() {
       var $xeList = this;
-      $xeList.recalculate();
+      $xeList.reFlag++;
     },
     maxHeight: function maxHeight() {
       var $xeList = this;
-      $xeList.recalculate();
+      $xeList.reFlag++;
     },
-    syncResize: function syncResize(val) {
+    syncResize: function syncResize() {
       var $xeList = this;
-      if (val) {
+      $xeList.reFlag++;
+    },
+    computeRowHeight: function computeRowHeight() {
+      var $xeList = this;
+      $xeList.reFlag++;
+    },
+    reFlag: function reFlag() {
+      var $xeList = this;
+      $xeList.$nextTick(function () {
         $xeList.recalculate();
-        $xeList.$nextTick(function () {
-          return setTimeout(function () {
-            return $xeList.recalculate();
-          });
-        });
-      }
+      });
+    },
+    checkRowKey: function checkRowKey() {
+      var $xeList = this;
+      $xeList.updateRadioModeValue();
+    },
+    checkRowKeys: function checkRowKeys() {
+      var $xeList = this;
+      $xeList.updateCheckboxModeValue();
     }
   },
   created: function created() {
     var $xeList = this;
     var props = $xeList;
     $xeList.internalData = list_createInternalData();
+    $xeList.browseObj = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().browse();
     $xeList.loadData(props.data || []);
   },
   mounted: function mounted() {
     var $xeList = this;
     var props = $xeList;
     var internalData = $xeList.internalData;
-    $xeList.recalculate();
+    var showRadio = props.showRadio,
+      showCheckbox = props.showCheckbox;
+    var rowOpts = $xeList.computeRowOpts;
+    var useKey = rowOpts.useKey,
+      keyField = rowOpts.keyField;
+    var isDrag = $xeList.computeIsDrag;
+    if (!keyField) {
+      if (showRadio) {
+        list_errLog('vxe.error.reqSupportProp', ['show-radio', 'row-config.keyField']);
+      }
+      if (showCheckbox) {
+        list_errLog('vxe.error.reqSupportProp', ['show-checkbox', 'row-config.keyField']);
+      }
+      if (isDrag) {
+        list_errLog('vxe.error.reqSupportProp', ['drag-config', 'row-config.keyField']);
+      }
+    }
+    if (useKey && !keyField) {
+      list_errLog('vxe.error.reqSupportProp', ['row-config.useKey', 'row-config.keyField']);
+    }
     if (props.autoResize) {
       var el = $xeList.$refs.refElem;
       var resizeObserver = globalResize.create(function () {
@@ -21681,6 +23111,7 @@ function list_createInternalData() {
       }
       internalData.resizeObserver = resizeObserver;
     }
+    $xeList.recalculate();
     globalEvents.on($xeList, 'resize', $xeList.recalculate);
   },
   activated: function activated() {
@@ -27899,23 +29330,21 @@ var Col = VxeCol;
 
 
 
-
-
-
-
 
 
 function collapse_createReactData() {
   return {
     staticPanes: [],
-    activeNames: [],
-    initNames: [],
-    cachePaneMaps: {}
+    cachePaneMaps: {},
+    activeKeyFlag: 0,
+    openKeyFlag: 0
   };
 }
 function collapse_createInternalData() {
   return {
-    // esTime: null
+    // esTime: null,
+    activeKeyMaps: {},
+    openKeyMaps: {}
   };
 }
 /* harmony default export */ var collapse = (/* define-vxe-component start */defineVxeComponent({
@@ -27996,6 +29425,10 @@ function collapse_createInternalData() {
         $collapse: $xeCollapse
       }, params));
     },
+    emitModel: function emitModel(value) {
+      var $xeCollapse = this;
+      $xeCollapse.$emit('input', value);
+    },
     handleFilterItem: function handleFilterItem(item) {
       var permissionCode = item.permissionCode;
       if (permissionCode) {
@@ -28005,12 +29438,32 @@ function collapse_createInternalData() {
       }
       return true;
     },
-    addInitName: function addInitName(name) {
+    updateModel: function updateModel() {
       var $xeCollapse = this;
+      var props = $xeCollapse;
+      var internalData = $xeCollapse.internalData;
       var reactData = $xeCollapse.reactData;
-      var initNames = reactData.initNames;
-      if (name && !initNames.includes(name)) {
-        initNames.push(name);
+      var modelValue = props.value;
+      var openKeyMaps = internalData.openKeyMaps;
+      var activeMaps = {};
+      if (modelValue) {
+        modelValue.forEach(function (name) {
+          if (!openKeyMaps[name]) {
+            openKeyMaps[name] = true;
+          }
+          activeMaps[name] = true;
+        });
+      }
+      internalData.activeKeyMaps = activeMaps;
+      reactData.activeKeyFlag++;
+      reactData.openKeyFlag++;
+    },
+    handleOpen: function handleOpen(name) {
+      var $xeCollapse = this;
+      var internalData = $xeCollapse.internalData;
+      var openKeyMaps = internalData.openKeyMaps;
+      if (name && !openKeyMaps[name]) {
+        openKeyMaps[name] = true;
         $xeCollapse.dispatchEvent('load', {
           name: name
         }, null);
@@ -28021,7 +29474,8 @@ function collapse_createInternalData() {
     initDefaultName: function initDefaultName(list) {
       var $xeCollapse = this;
       var reactData = $xeCollapse.reactData;
-      var activeNames = reactData.activeNames;
+      var internalData = $xeCollapse.internalData;
+      var activeKeyMaps = internalData.activeKeyMaps;
       var nameMaps = {};
       if (list && list.length) {
         list.forEach(function (item) {
@@ -28029,24 +29483,19 @@ function collapse_createInternalData() {
             name = _ref.name,
             preload = _ref.preload;
           if (name) {
-            var isActive = activeNames.includes(name);
-            nameMaps["".concat(name)] = {
+            var isActive = activeKeyMaps[name];
+            nameMaps[name] = {
               height: 0,
               loading: false
             };
-            if (isActive) {
-              $xeCollapse.addInitName(name);
-            }
-            if (preload) {
-              if (!isActive) {
-                activeNames.push(name);
-              }
+            if (isActive || preload) {
+              $xeCollapse.handleOpen(name);
             }
           }
         });
       }
-      reactData.activeNames = activeNames ? activeNames.slice(0) : [];
       reactData.cachePaneMaps = nameMaps;
+      reactData.openKeyFlag++;
     },
     callSlot: function callSlot(slotFunc, params, h) {
       var $xeCollapse = this;
@@ -28063,20 +29512,28 @@ function collapse_createInternalData() {
     },
     handleClickEvent: function handleClickEvent(evnt, item) {
       var $xeCollapse = this;
-      var reactData = $xeCollapse.reactData;
       var internalData = $xeCollapse.internalData;
-      var activeNames = reactData.activeNames;
+      var reactData = $xeCollapse.reactData;
+      var activeKeyMaps = internalData.activeKeyMaps;
+      var esTime = internalData.esTime;
+      var expandOpts = $xeCollapse.computeExpandOpts;
+      var accordion = expandOpts.accordion;
       var name = item.name;
+      if (esTime) {
+        clearTimeout(esTime);
+      }
       if (name) {
         var headEl = evnt.currentTarget;
         var bodyEl = headEl.nextElementSibling;
-        var aIndex = activeNames.indexOf(name);
         var expanded = false;
-        if (aIndex === -1) {
-          expanded = true;
-          activeNames.push(name);
+        if (activeKeyMaps[name]) {
+          delete activeKeyMaps[name];
         } else {
-          activeNames.splice(aIndex, 1);
+          if (accordion) {
+            activeKeyMaps = {};
+          }
+          expanded = true;
+          activeKeyMaps[name] = true;
         }
         var startAnimation = function startAnimation() {
           var itemEl = bodyEl.firstElementChild;
@@ -28096,6 +29553,11 @@ function collapse_createInternalData() {
             }
           }
         };
+        var value = Object.keys(activeKeyMaps);
+        internalData.activeKeyMaps = activeKeyMaps;
+        $xeCollapse.handleOpen(name);
+        reactData.activeKeyFlag++;
+        reactData.openKeyFlag++;
         if (bodyEl) {
           var itemEl = bodyEl.firstElementChild;
           if (itemEl) {
@@ -28105,13 +29567,13 @@ function collapse_createInternalData() {
             $xeCollapse.$nextTick(startAnimation);
           }
         }
-        $xeCollapse.addInitName(name);
+        $xeCollapse.emitModel(value);
         $xeCollapse.dispatchEvent('change', {
-          value: activeNames,
+          value: value,
           name: name
         }, evnt);
         $xeCollapse.dispatchEvent('toggle-expand', {
-          value: activeNames,
+          value: value,
           name: name,
           expanded: expanded
         }, evnt);
@@ -28123,8 +29585,11 @@ function collapse_createInternalData() {
     renderList: function renderList(h, itemList) {
       var $xeCollapse = this;
       var reactData = $xeCollapse.reactData;
-      var activeNames = reactData.activeNames,
-        initNames = reactData.initNames;
+      var internalData = $xeCollapse.internalData;
+      var activeKeyFlag = reactData.activeKeyFlag,
+        openKeyFlag = reactData.openKeyFlag;
+      var activeKeyMaps = internalData.activeKeyMaps,
+        openKeyMaps = internalData.openKeyMaps;
       var expandOpts = $xeCollapse.computeExpandOpts;
       return itemList.map(function (item) {
         var icon = item.icon,
@@ -28133,7 +29598,7 @@ function collapse_createInternalData() {
           slots = item.slots;
         var titleSlot = slots ? slots.title : null;
         var defaultSlot = slots ? slots.default : null;
-        var isActive = name && activeNames.includes(name);
+        var isActive = name && activeKeyFlag && activeKeyMaps[name];
         return h('div', {
           class: 'vxe-collapse-item'
         }, [h('div', {
@@ -28161,7 +29626,7 @@ function collapse_createInternalData() {
             'is--visible': isActive,
             'is--hidden': !isActive
           }]
-        }, [name && initNames.includes(name) ? h('div', {
+        }, [name && openKeyFlag && openKeyMaps[name] ? h('div', {
           class: 'vxe-collapse--item-inner'
         }, [defaultSlot ? $xeCollapse.callSlot(defaultSlot, {
           name: name,
@@ -28189,10 +29654,9 @@ function collapse_createInternalData() {
     }
   },
   watch: {
-    value: function value(val) {
+    value: function value() {
       var $xeCollapse = this;
-      var reactData = $xeCollapse.reactData;
-      reactData.activeNames = val || [];
+      $xeCollapse.updateModel();
     },
     options: function options() {
       var $xeCollapse = this;
@@ -28210,7 +29674,7 @@ function collapse_createInternalData() {
     var props = $xeCollapse;
     var reactData = $xeCollapse.reactData;
     $xeCollapse.internalData = collapse_createInternalData();
-    reactData.activeNames = props.value || [];
+    $xeCollapse.updateModel();
     $xeCollapse.initDefaultName(reactData.staticPanes.length ? reactData.staticPanes : props.options);
   },
   destroyed: function destroyed() {
@@ -36247,6 +37711,7 @@ function date_picker_createInternalData() {
     }
     globalEvents.off($xeDatePicker, 'mousewheel');
     globalEvents.off($xeDatePicker, 'mousedown');
+    globalEvents.off($xeDatePicker, 'keydown');
     globalEvents.off($xeDatePicker, 'blur');
     globalEvents.off($xeDatePicker, 'resize');
     external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().assign(reactData, date_picker_createReactData());
@@ -43291,24 +44756,8 @@ function image_createReactData() {
       var props = $xeImage;
       var width = props.width,
         height = props.height,
-        minWidth = props.minWidth,
-        minHeight = props.minHeight,
-        maxWidth = props.maxWidth,
-        maxHeight = props.maxHeight,
         circle = props.circle;
       var stys = {};
-      if (minWidth) {
-        stys.minWidth = toCssUnit(minWidth);
-      }
-      if (minHeight) {
-        stys.minHeight = toCssUnit(minHeight);
-      }
-      if (maxWidth) {
-        stys.maxWidth = toCssUnit(maxWidth);
-      }
-      if (maxHeight) {
-        stys.maxHeight = toCssUnit(maxHeight);
-      }
       if (circle) {
         // 圆形只能生效一个
         if (width) {
@@ -43330,7 +44779,11 @@ function image_createReactData() {
       var $xeImage = this;
       var props = $xeImage;
       var width = props.width,
-        height = props.height;
+        height = props.height,
+        minWidth = props.minWidth,
+        minHeight = props.minHeight,
+        maxHeight = props.maxHeight,
+        maxWidth = props.maxWidth;
       var stys = {};
       if (width && height) {
         stys.maxWidth = toCssUnit(width);
@@ -43342,6 +44795,18 @@ function image_createReactData() {
         if (height) {
           stys.height = toCssUnit(height);
         }
+        if (minWidth) {
+          stys.minWidth = toCssUnit(minWidth);
+        }
+        if (minHeight) {
+          stys.minHeight = toCssUnit(minHeight);
+        }
+        if (maxWidth) {
+          stys.maxWidth = toCssUnit(maxWidth);
+        }
+        if (maxHeight) {
+          stys.maxHeight = toCssUnit(maxHeight);
+        }
       }
       return stys;
     },
@@ -50955,7 +52420,6 @@ var web_url_search_params_size = __webpack_require__(8721);
 
 
 
-var util_browseObj = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().browse();
 // 打印
 var printFrame;
 // 默认导出或打印的 HTML 样式
@@ -51062,6 +52526,7 @@ function createHtmlPage(opts, printHtml) {
 }
 function handlePrint(opts) {
   var printHtml = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  var browseObj = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().browse();
   var beforeMethod = opts.beforeMethod,
     styleUrls = opts.styleUrls;
   if (styleUrls && styleUrls.length) {
@@ -51081,7 +52546,7 @@ function handlePrint(opts) {
   printHtml = createHtmlPage(opts, printHtml);
   var blob = getExportBlobByString(printHtml, 'html');
   return new Promise(function (resolve) {
-    if (util_browseObj.msie) {
+    if (browseObj.msie) {
       removeFrame();
       printFrame = createPrintFrame();
       appendPrintFrame();
@@ -51986,6 +53451,7 @@ var Print = VxePrint;
           click: $xePulldown.clickTargetEvent
         }
       }, defaultSlot ? defaultSlot({
+        options: options,
         $pulldown: $xePulldown
       }) : []), h('div', {
         ref: 'refPulldownPanel',
@@ -52003,14 +53469,17 @@ var Print = VxePrint;
       }, initialized && (destroyOnClose ? visiblePanel || isAniVisible : true) ? [headerSlot ? h('div', {
         class: 'vxe-pulldown--panel-header'
       }, headerSlot({
+        options: options,
         $pulldown: $xePulldown
       })) : renderEmptyElement($xePulldown), h('div', {
         class: 'vxe-pulldown--panel-body'
       }, dropdownSlot ? dropdownSlot({
+        options: options,
         $pulldown: $xePulldown
       }) : [$xePulldown.renderDefaultPanel(h, options)]), footerSlot ? h('div', {
         class: 'vxe-pulldown--panel-footer'
       }, footerSlot({
+        options: options,
         $pulldown: $xePulldown
       })) : renderEmptyElement($xePulldown)] : [])] : [])]);
     }
@@ -56550,6 +58019,99 @@ dynamicApp.use(VxeTableSelect);
 VxeUI.component(table_select);
 var TableSelect = VxeTableSelect;
 /* harmony default export */ var packages_table_select = (VxeTableSelect);
+;// ./packages/table-transfer/src/table-transfer.ts
+
+
+
+
+function table_transfer_createReactData() {
+  return {};
+}
+function table_transfer_createInternalData() {
+  return {};
+}
+/* harmony default export */ var table_transfer = (/* define-vxe-component start */defineVxeComponent({
+  name: 'VxeTableTransfer',
+  props: {
+    modelValue: Array,
+    options: Array,
+    size: {
+      type: String,
+      default: function _default() {
+        return getConfig().tableTransfer.size || getConfig().size;
+      }
+    }
+  },
+  data: function data() {
+    var xID = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().uniqueId();
+    var reactData = table_transfer_createReactData();
+    return _objectSpread2(_objectSpread2({}, {}), {}, {
+      xID: xID,
+      reactData: reactData
+    });
+  },
+  methods: {
+    //
+    // Method
+    //
+    dispatchEvent: function dispatchEvent(type, params, evnt) {
+      var $xeTableTransfer = this;
+      $xeTableTransfer.$emit(type, createEvent(evnt, {
+        $tableTransfer: $xeTableTransfer
+      }, params));
+    },
+    emitModel: function emitModel(value) {
+      var $xeTableTransfer = this;
+      var _events = $xeTableTransfer._events;
+      if (_events && _events.modelValue) {
+        $xeTableTransfer.$emit('modelValue', value);
+      } else {
+        $xeTableTransfer.$emit('model-value', value);
+      }
+    },
+    //
+    // Render
+    //
+    renderVN: function renderVN(h) {
+      var $xeTableTransfer = this;
+      var slots = $xeTableTransfer.$scopedSlots;
+      var defaultSlot = slots.default;
+      return h('div', {
+        ref: 'refElem',
+        class: 'vxe-table-transfer'
+      }, defaultSlot ? defaultSlot({}) : []);
+    }
+  },
+  created: function created() {
+    var $xeUpload = this;
+    $xeUpload.internalData = table_transfer_createInternalData();
+  },
+  beforeDestroy: function beforeDestroy() {
+    var $xeUpload = this;
+    var reactData = $xeUpload.reactData;
+    var internalData = $xeUpload.internalData;
+    external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().assign(reactData, table_transfer_createReactData());
+    external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().assign(internalData, table_transfer_createInternalData());
+  },
+  render: function render(h) {
+    return this.renderVN(h);
+  }
+})); /* define-vxe-component end */
+;// ./packages/table-transfer/index.ts
+
+
+
+
+
+var VxeTableTransfer = Object.assign({}, table_transfer, {
+  install: function install(app) {
+    app.component(table_transfer.name, table_transfer);
+  }
+});
+dynamicApp.use(VxeTableTransfer);
+VxeUI.component(table_transfer);
+var TableTransfer = VxeTableTransfer;
+/* harmony default export */ var packages_table_transfer = (VxeTableTransfer);
 ;// ./packages/tabs/src/tabs.ts
 
 
@@ -58897,14 +60459,109 @@ dynamicApp.use(VxeTour);
 VxeUI.component(tour);
 var Tour = VxeTour;
 /* harmony default export */ var packages_tour = (VxeTour);
-;// ./packages/tree/src/util.ts
+;// ./packages/transfer/src/transfer.ts
 
-function util_enNodeValue(nodeid) {
-  return external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eqNull(nodeid) ? '' : encodeURIComponent("".concat(nodeid));
+
+
+
+function transfer_createReactData() {
+  return {};
 }
-function util_deNodeValue(nodeid) {
-  return nodeid ? decodeURIComponent("".concat(nodeid)) : nodeid;
+function transfer_createInternalData() {
+  return {};
 }
+/* harmony default export */ var transfer = (/* define-vxe-component start */defineVxeComponent({
+  name: 'VxeTransfer',
+  props: {
+    modelValue: Array,
+    options: Array,
+    size: {
+      type: String,
+      default: function _default() {
+        return getConfig().transfer.size || getConfig().size;
+      }
+    }
+  },
+  data: function data() {
+    var xID = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().uniqueId();
+    var reactData = transfer_createReactData();
+    return _objectSpread2(_objectSpread2({}, {}), {}, {
+      xID: xID,
+      reactData: reactData
+    });
+  },
+  methods: {
+    //
+    // Method
+    //
+    dispatchEvent: function dispatchEvent(type, params, evnt) {
+      var $xeTransfer = this;
+      $xeTransfer.$emit(type, createEvent(evnt, {
+        $transfer: $xeTransfer
+      }, params));
+    },
+    emitModel: function emitModel(value) {
+      var $xeTransfer = this;
+      var _events = $xeTransfer._events;
+      if (_events && _events.modelValue) {
+        $xeTransfer.$emit('modelValue', value);
+      } else {
+        $xeTransfer.$emit('model-value', value);
+      }
+    },
+    //
+    // Render
+    //
+    renderVN: function renderVN(h) {
+      var $xeTransfer = this;
+      var slots = $xeTransfer.$scopedSlots;
+      var headerSlot = slots.header;
+      var footerSlot = slots.footer;
+      return h('div', {
+        ref: 'refElem',
+        class: 'vxe-transfer'
+      }, [headerSlot ? h('div', {
+        class: 'vxe-transfer--header'
+      }, headerSlot({
+        $transfer: $xeTransfer
+      })) : renderEmptyElement($xeTransfer), h('div'), h('div'), h('div'), footerSlot ? h('div', {
+        class: 'vxe-transfer--footer'
+      }, footerSlot({
+        $transfer: $xeTransfer
+      })) : renderEmptyElement($xeTransfer)]);
+    }
+  },
+  created: function created() {
+    var $xeUpload = this;
+    $xeUpload.internalData = transfer_createInternalData();
+  },
+  beforeDestroy: function beforeDestroy() {
+    var $xeUpload = this;
+    var reactData = $xeUpload.reactData;
+    var internalData = $xeUpload.internalData;
+    external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().assign(reactData, transfer_createReactData());
+    external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().assign(internalData, transfer_createInternalData());
+  },
+  render: function render(h) {
+    return this.renderVN(h);
+  }
+})); /* define-vxe-component end */
+;// ./packages/transfer/index.ts
+
+
+
+
+
+var VxeTransfer = Object.assign({}, transfer, {
+  install: function install(app) {
+    app.component(transfer.name, transfer);
+  }
+});
+dynamicApp.use(VxeTransfer);
+VxeUI.component(transfer);
+var Transfer = VxeTransfer;
+/* harmony default export */ var packages_transfer = (VxeTransfer);
+;// ./packages/tree/src/util.ts
 function countTreeExpand($xeTree, prevNode) {
   var count = 1;
   if (!prevNode) {
@@ -58945,70 +60602,6 @@ function getCrossTreeDragNodeInfo($xeTree) {
   var crossTreeDragNodeInfo = $xeTree.crossTreeDragNodeInfo;
   return crossTreeDragNodeInfo;
 }
-;// ./packages/ui/src/anime.ts
-/* unused harmony import specifier */ var anime_XEUtils;
-/* unused harmony import specifier */ var anime_addClass;
-/* unused harmony import specifier */ var anime_removeClass;
-
-
-
-
-
-
-
-
-var rowMoveCls = 'row--drag-move';
-var colMoveClass = 'col--drag-move';
-/**
- * 上下拖拽
- */
-function moveRowAnimateToTb(elemList, offsetTop) {
-  external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().arrayEach(elemList, function (trEl) {
-    trEl.style.transform = "translateY(".concat(offsetTop, "px)");
-  });
-  requestAnimationFrame(function () {
-    external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().arrayEach(elemList, function (trEl) {
-      addClass(trEl, rowMoveCls);
-      trEl.style.transform = '';
-    });
-  });
-}
-function clearRowAnimate(elem, clss) {
-  setTimeout(function () {
-    if (elem) {
-      external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().arrayEach(elem.querySelectorAll(clss.map(function (cls) {
-        return "".concat(cls, ".").concat(rowMoveCls);
-      }).join(',')), function (elem) {
-        return removeClass(elem, rowMoveCls);
-      });
-    }
-  }, 500);
-}
-/**
- * 左右拖拽
- */
-function moveColAnimateToLr(elemList, offsetLeft) {
-  anime_XEUtils.arrayEach(elemList, function (trEl) {
-    trEl.style.transform = "translateX(".concat(offsetLeft, "px)");
-  });
-  requestAnimationFrame(function () {
-    anime_XEUtils.arrayEach(elemList, function (trEl) {
-      anime_addClass(trEl, colMoveClass);
-      trEl.style.transform = '';
-    });
-  });
-}
-function clearColAnimate(elem, clss) {
-  setTimeout(function () {
-    if (elem) {
-      anime_XEUtils.arrayEach(elem.querySelectorAll(clss.map(function (cls) {
-        return "".concat(cls, ".").concat(rowMoveCls);
-      }).join(',')), function (elem) {
-        return anime_removeClass(elem, colMoveClass);
-      });
-    }
-  }, 500);
-}
 ;// ./packages/tree/src/tree.ts
 
 
@@ -59251,10 +60844,11 @@ function handleNodeDragSwapEvent($xeTree, evnt, dragNode, prevDragNode, prevDrag
     var dragNodeid = $xeTree.getNodeId(dragNode);
     var dragNodeRest = nodeMaps[dragNodeid] || {};
     var _dragNodeIndex = dragNodeRest._index;
+    var newNodeid = $xeTree.getNodeId(prevDragNode);
     var dragNodeHeight = 0;
     var dragOffsetTop = -1;
     if (animation) {
-      var prevItemEl = el.querySelector(".vxe-tree--node-wrapper[nodeid=\"".concat(prevDragNode, "\"]"));
+      var prevItemEl = el.querySelector(".vxe-tree--node-wrapper[nodeid=\"".concat(newNodeid, "\"]"));
       var oldItemEl = el.querySelector(".vxe-tree--node-wrapper[nodeid=\"".concat(dragNodeid, "\"]"));
       var targetItemEl = prevItemEl || oldItemEl;
       if (targetItemEl) {
@@ -59269,7 +60863,6 @@ function handleNodeDragSwapEvent($xeTree, evnt, dragNode, prevDragNode, prevDrag
     var oldAllMaps = {};
     var isSelfToChildStatus = false;
     var oldRest = dragNodeRest;
-    var newNodeid = $xeTree.getNodeId(prevDragNode);
     var newRest = nodeMaps[newNodeid];
     if (transform) {
       if (oldRest && newRest) {
@@ -59645,12 +61238,7 @@ function tree_createReactData() {
         return tree_getConfig().tree.showRadio;
       }
     },
-    checkNodeKey: {
-      type: [String, Number],
-      default: function _default() {
-        return tree_getConfig().tree.checkNodeKey;
-      }
-    },
+    checkNodeKey: [String, Number],
     radioConfig: Object,
     showCheckbox: {
       type: Boolean,
@@ -59658,12 +61246,7 @@ function tree_createReactData() {
         return tree_getConfig().tree.showCheckbox;
       }
     },
-    checkNodeKeys: {
-      type: Array,
-      default: function _default() {
-        return tree_getConfig().tree.checkNodeKeys;
-      }
-    },
+    checkNodeKeys: Array,
     checkboxConfig: Object,
     nodeConfig: Object,
     lazy: Boolean,
@@ -59892,7 +61475,7 @@ function tree_createReactData() {
       }
       var valueField = $xeTree.computeValueField;
       var nodeKey = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().get(node, valueField);
-      return util_enNodeValue(nodeKey);
+      return enModelValue(nodeKey);
     },
     getNodeById: function getNodeById(nodeid) {
       var $xeTree = this;
@@ -59963,7 +61546,7 @@ function tree_createReactData() {
       if (node) {
         var nodeid = $xeTree.getNodeId(node);
         reactData.selectRadioKey = nodeid;
-        $xeTree.emitRadioMode(util_deNodeValue(nodeid));
+        $xeTree.emitRadioMode(deModelValue(nodeid));
       } else {
         $xeTree.emitRadioMode(null);
       }
@@ -59996,7 +61579,7 @@ function tree_createReactData() {
         }
         var nodeList = [];
         nodeKeys.forEach(function (nodeKey) {
-          var nodeid = util_enNodeValue(nodeKey);
+          var nodeid = enModelValue(nodeKey);
           var nodeItem = nodeMaps[nodeid];
           if (nodeItem) {
             nodeList.push(nodeItem.item);
@@ -61060,7 +62643,7 @@ function tree_createReactData() {
       reactData.updateCheckboxFlag++;
       $xeTree.updateCheckboxStatus();
       var nodeids = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().keys(selectCheckboxMaps);
-      var value = nodeids.map(util_deNodeValue);
+      var value = nodeids.map(deModelValue);
       $xeTree.emitCheckboxMode(value);
       $xeTree.dispatchEvent('checkbox-change', {
         node: node,
@@ -61127,7 +62710,7 @@ function tree_createReactData() {
         return;
       }
       var isChecked = true;
-      var value = util_deNodeValue(nodeid);
+      var value = deModelValue(nodeid);
       reactData.selectRadioKey = nodeid;
       $xeTree.emitRadioMode(value);
       $xeTree.dispatchEvent('radio-change', {
@@ -61159,7 +62742,7 @@ function tree_createReactData() {
       var reactData = $xeTree.reactData;
       var currentNode = reactData.currentNode;
       if (currentNode) {
-        return util_deNodeValue($xeTree.getNodeId(currentNode));
+        return deModelValue($xeTree.getNodeId(currentNode));
       }
       return null;
     },
@@ -61182,7 +62765,7 @@ function tree_createReactData() {
       var reactData = $xeTree.reactData;
       var internalData = $xeTree.internalData;
       var nodeMaps = internalData.nodeMaps;
-      var nodeItem = nodeMaps[util_enNodeValue(nodeKey)];
+      var nodeItem = nodeMaps[enModelValue(nodeKey)];
       reactData.currentNode = nodeItem ? nodeItem.item : null;
       return $xeTree.$nextTick();
     },
@@ -61221,7 +62804,7 @@ function tree_createReactData() {
     setRadioNodeId: function setRadioNodeId(nodeKey) {
       var $xeTree = this;
       var reactData = $xeTree.reactData;
-      reactData.selectRadioKey = util_enNodeValue(nodeKey);
+      reactData.selectRadioKey = enModelValue(nodeKey);
       $xeTree.emitRadioMode(nodeKey);
       return $xeTree.$nextTick();
     },
@@ -61231,7 +62814,7 @@ function tree_createReactData() {
       var selectCheckboxMaps = internalData.selectCheckboxMaps;
       var nodeKeys = [];
       external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().each(selectCheckboxMaps, function (item, nodeId) {
-        nodeKeys.push(util_deNodeValue(nodeId));
+        nodeKeys.push(deModelValue(nodeId));
       });
       return nodeKeys;
     },
@@ -61335,7 +62918,7 @@ function tree_createReactData() {
           nodeKeys = [nodeKeys];
         }
         nodeKeys.forEach(function (nodeKey) {
-          var nodeid = util_enNodeValue(nodeKey);
+          var nodeid = enModelValue(nodeKey);
           handleSetExpand(nodeid, expanded, treeExpandedMaps);
         });
         reactData.updateExpandedFlag++;
@@ -61350,7 +62933,7 @@ function tree_createReactData() {
       var treeExpandedMaps = internalData.treeExpandedMaps;
       var nodeKeys = [];
       external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().each(treeExpandedMaps, function (item, nodeId) {
-        nodeKeys.push(util_deNodeValue(nodeId));
+        nodeKeys.push(deModelValue(nodeId));
       });
       return nodeKeys;
     },
@@ -61397,7 +62980,7 @@ function tree_createReactData() {
           nodeKeys = [nodeKeys];
         }
         nodeKeys.forEach(function (nodeKey) {
-          var nodeid = util_enNodeValue(nodeKey);
+          var nodeid = enModelValue(nodeKey);
           handleSetExpand(nodeid, !treeExpandedMaps["".concat(nodeid)], treeExpandedMaps);
         });
         reactData.updateExpandedFlag++;
@@ -62086,7 +63669,7 @@ function tree_createReactData() {
     checkNodeKey: function checkNodeKey(nodeKey) {
       var $xeTree = this;
       var reactData = $xeTree.reactData;
-      reactData.selectRadioKey = util_enNodeValue(nodeKey);
+      reactData.selectRadioKey = enModelValue(nodeKey);
     },
     checkNodeKeys: function checkNodeKeys() {
       var $xeTree = this;
@@ -62119,7 +63702,7 @@ function tree_createReactData() {
     var props = $xeTree;
     var reactData = $xeTree.reactData;
     $xeTree.internalData = tree_createInternalData();
-    reactData.selectRadioKey = util_enNodeValue(props.checkNodeKey);
+    reactData.selectRadioKey = enModelValue(props.checkNodeKey);
     $xeTree.loadData(props.data || []);
   },
   mounted: function mounted() {
@@ -62212,7 +63795,6 @@ var Tree = VxeTree;
 
 
 
-
 
 
 var tree_select_createComponentLog = createComponentLog('tree-select'),
@@ -62320,12 +63902,14 @@ function tree_select_createInternalData() {
         return getConfig().treeSelect.showRadio;
       }
     },
+    radioConfig: Object,
     showCheckbox: {
       type: Boolean,
       default: function _default() {
         return getConfig().treeSelect.showCheckbox;
       }
     },
+    checkboxConfig: Object,
     popupConfig: Object,
     treeConfig: Object,
     menuConfig: Object,
@@ -62499,22 +64083,24 @@ function tree_select_createInternalData() {
     computeTreeCheckboxOpts: function computeTreeCheckboxOpts() {
       var $xeTreeSelect = this;
       var props = $xeTreeSelect;
-      var showCheckbox = props.showCheckbox;
+      var showCheckbox = props.showCheckbox,
+        checkboxConfig = props.checkboxConfig;
       var treeOpts = $xeTreeSelect.computeTreeOpts;
       return Object.assign({
         showIcon: external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isBoolean(showCheckbox) ? showCheckbox : !!treeOpts.showCheckbox
-      }, treeOpts.checkboxConfig, {
+      }, treeOpts.checkboxConfig, checkboxConfig, {
         trigger: 'node'
       });
     },
     computeTreeRadioOpts: function computeTreeRadioOpts() {
       var $xeTreeSelect = this;
       var props = $xeTreeSelect;
-      var showRadio = props.showRadio;
+      var showRadio = props.showRadio,
+        radioConfig = props.radioConfig;
       var treeOpts = $xeTreeSelect.computeTreeOpts;
       return Object.assign({
         showIcon: external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isBoolean(showRadio) ? showRadio : !!treeOpts.showRadio
-      }, treeOpts.radioConfig, {
+      }, treeOpts.radioConfig, radioConfig, {
         trigger: 'node'
       });
     },
@@ -62836,7 +64422,7 @@ function tree_select_createInternalData() {
       var props = $xeTreeSelect;
       var $xeForm = $xeTreeSelect.$xeForm;
       var formItemInfo = $xeTreeSelect.formItemInfo;
-      var value = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isArray(selectValue) ? selectValue.map(util_deNodeValue) : util_deNodeValue(selectValue);
+      var value = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isArray(selectValue) ? selectValue.map(deModelValue) : deModelValue(selectValue);
       $xeTreeSelect.emitModel(value);
       if (value !== props.value) {
         $xeTreeSelect.dispatchEvent('change', {
@@ -66184,6 +67770,8 @@ var Watermark = VxeWatermark;
 
 
 
+
+
 
 
 
@@ -66191,7 +67779,7 @@ var components_setI18n = VxeUI.setI18n,
   components_setLanguage = VxeUI.setLanguage,
   components_setTheme = VxeUI.setTheme,
   components_setConfig = VxeUI.setConfig;
-var components_components = [packages_alert, packages_anchor, packages_anchor_link, packages_avatar, packages_backtop, packages_badge, packages_breadcrumb, packages_breadcrumb_item, packages_button, packages_button_group, packages_calendar, packages_card, packages_carousel, packages_carousel_item, packages_cascader, packages_checkbox, checkbox_button, checkbox_group, packages_col, packages_collapse, packages_collapse_pane, packages_color_picker, packages_context_menu, packages_countdown, packages_date_panel, packages_date_picker, packages_date_range_picker, packages_drawer, packages_empty, packages_form, form_gather, packages_form_group, packages_form_item, packages_icon, packages_icon_picker, packages_image, image_group, image_preview, packages_input, packages_layout_aside, packages_layout_body, packages_layout_container, packages_layout_footer, packages_layout_header, packages_link, packages_list, packages_loading, packages_menu, packages_modal, packages_notice_bar, packages_number_input, packages_optgroup, packages_option, packages_pager, packages_password_input, print_page_break, packages_print, packages_pulldown, packages_radio, radio_button, radio_group, packages_rate, packages_result, packages_row, packages_segmented, packages_select, packages_splitter, packages_splitter_panel, split, split_pane, packages_slider, packages_steps, packages_switch, packages_tab_pane, packages_table_select, packages_tabs, packages_tag, packages_text_ellipsis, packages_text, packages_textarea, packages_timeline, packages_timeline_item, packages_tip, packages_tooltip, packages_tour, packages_tree, packages_tree_select, packages_upload, packages_watermark];
+var components_components = [packages_alert, packages_anchor, packages_anchor_link, packages_avatar, packages_backtop, packages_badge, packages_breadcrumb, packages_breadcrumb_item, packages_button, packages_button_group, packages_calendar, packages_card, packages_carousel, packages_carousel_item, packages_cascader, packages_checkbox, checkbox_button, checkbox_group, packages_col, packages_collapse, packages_collapse_pane, packages_color_picker, packages_context_menu, packages_countdown, packages_date_panel, packages_date_picker, packages_date_range_picker, packages_drawer, packages_empty, packages_form, form_gather, packages_form_group, packages_form_item, packages_icon, packages_icon_picker, packages_image, image_group, image_preview, packages_input, packages_layout_aside, packages_layout_body, packages_layout_container, packages_layout_footer, packages_layout_header, packages_link, packages_list, packages_loading, packages_menu, packages_modal, packages_notice_bar, packages_number_input, packages_optgroup, packages_option, packages_pager, packages_password_input, print_page_break, packages_print, packages_pulldown, packages_radio, radio_button, radio_group, packages_rate, packages_result, packages_row, packages_segmented, packages_select, packages_splitter, packages_splitter_panel, split, split_pane, packages_slider, packages_steps, packages_switch, packages_tab_pane, packages_table_select, packages_table_transfer, packages_tabs, packages_tag, packages_text_ellipsis, packages_text, packages_textarea, packages_timeline, packages_timeline_item, packages_tip, packages_tooltip, packages_tour, packages_transfer, packages_tree, packages_tree_select, packages_upload, packages_watermark];
 function install(app, options) {
   components_setConfig(options);
   components_components.forEach(function (component) {
@@ -66299,6 +67887,8 @@ var readFile = readLocalFile;
 
 
 
+
+