vxe-pc-ui 4.6.9 → 4.6.10

package/lib/index.umd.js

@@ -4213,26 +4213,22 @@ function checkDynamic() {
 }
 ;// CONCATENATED MODULE: ./packages/ui/src/log.ts
 
-const log_version = `ui v${"4.6.9"}`;
+const log_version = `ui v${"4.6.10"}`;
 const warnLog = log.create('warn', log_version);
 const errLog = log.create('error', log_version);
 ;// CONCATENATED MODULE: ./packages/ui/index.ts
 
 
 
-const ui_version = "4.6.9";
+const ui_version = "4.6.10";
 index_esm_VxeUI.uiVersion = ui_version;
 index_esm_VxeUI.dynamicApp = dynamicApp;
 function config(options) {
-  if (true) {
-    warnLog('vxe.error.delFunc', ['config', 'setConfig']);
-  }
+  warnLog('vxe.error.delFunc', ['config', 'setConfig']);
   return setConfig(options);
 }
 function setup(options) {
-  if (true) {
-    warnLog('vxe.error.delFunc', ['setup', 'setConfig']);
-  }
+  warnLog('vxe.error.delFunc', ['setup', 'setConfig']);
   return setConfig(options);
 }
 index_esm_VxeUI.config = config;
@@ -7168,10 +7164,8 @@ const VxeButtonComponent = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.defi
     };
     $xeButton.renderVN = renderVN;
     (0,external_commonjs_vue_commonjs2_vue_root_Vue_.onMounted)(() => {
-      if (true) {
-        if (props.type === 'text') {
-          warnLog('vxe.error.delProp', ['type=text', 'mode=text']);
-        }
+      if (props.type === 'text') {
+        warnLog('vxe.error.delProp', ['type=text', 'mode=text']);
       }
       globalEvents.on($xeButton, 'mousewheel', handleGlobalMousewheelEvent);
       globalEvents.on($xeButton, 'mousedown', handleGlobalMousedownEvent);
@@ -19966,33 +19960,108 @@ class Rule {
     return this.content;
   }
 }
-const validErrorRuleValue = (rule, val) => {
+// 如果存在 pattern，判断正则
+function validREValue(pattern, val) {
+  if (pattern && !(external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isRegExp(pattern) ? pattern : new RegExp(pattern)).test(val)) {
+    return false;
+  }
+  return true;
+}
+// 如果存在 max，判断最大值
+function validMaxValue(max, num) {
+  if (!external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eqNull(max) && num > external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toNumber(max)) {
+    return false;
+  }
+  return true;
+}
+// 如果存在 min，判断最小值
+function validMinValue(min, num) {
+  if (!external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eqNull(min) && num < external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toNumber(min)) {
+    return false;
+  }
+  return true;
+}
+function validRuleValue(rule, val, required) {
   const {
     type,
     min,
     max,
     pattern
   } = rule;
+  const isArrType = type === 'array';
   const isNumType = type === 'number';
-  const numVal = isNumType ? external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toNumber(val) : external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().getSize(val);
-  // 判断数值
-  if (isNumType && isNaN(val)) {
-    return true;
+  const isStrType = type === 'string';
+  const strVal = `${val}`;
+  if (!validREValue(pattern, strVal)) {
+    return false;
   }
-  // 如果存在 min，判断最小值
-  if (!external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eqNull(min) && numVal < external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toNumber(min)) {
-    return true;
-  }
-  // 如果存在 max，判断最大值
-  if (!external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eqNull(max) && numVal > external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toNumber(max)) {
-    return true;
+  if (isArrType) {
+    if (!external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isArray(val)) {
+      return false;
+    }
+    if (required) {
+      if (!val.length) {
+        return false;
+      }
+    }
+    if (!validMinValue(min, val.length)) {
+      return false;
+    }
+    if (!validMaxValue(max, val.length)) {
+      return false;
+    }
+  } else if (isNumType) {
+    const numVal = Number(val);
+    if (isNaN(numVal)) {
+      return false;
+    }
+    if (!validMinValue(min, numVal)) {
+      return false;
+    }
+    if (!validMaxValue(max, numVal)) {
+      return false;
+    }
+  } else {
+    if (isStrType) {
+      if (!external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isString(val)) {
+        return false;
+      }
+    }
+    if (required) {
+      if (!strVal) {
+        return false;
+      }
+    }
+    if (!validMinValue(min, strVal.length)) {
+      return false;
+    }
+    if (!validMaxValue(max, strVal.length)) {
+      return false;
+    }
   }
-  // 如果存在 pattern，正则校验
-  if (pattern && !(external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isRegExp(pattern) ? pattern : new RegExp(pattern)).test(val)) {
-    return true;
+  return true;
+}
+function checkRuleStatus(rule, val) {
+  const {
+    required
+  } = rule;
+  const isEmptyVal = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eqNull(val);
+  if (required) {
+    if (isEmptyVal) {
+      return false;
+    }
+    if (!validRuleValue(rule, val, required)) {
+      return false;
+    }
+  } else {
+    if (!isEmptyVal) {
+      if (!validRuleValue(rule, val, required)) {
+        return false;
+      }
+    }
   }
-  return false;
-};
+  return true;
+}
 /* harmony default export */ var src_form = ((0,external_commonjs_vue_commonjs2_vue_root_Vue_.defineComponent)({
   name: 'VxeForm',
   props: {
@@ -20370,9 +20439,7 @@ const validErrorRuleValue = (rule, val) => {
             const itemValue = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isUndefined(val) ? external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().get(data, property) : val;
             rules.forEach(rule => {
               const {
-                type,
                 trigger,
-                required,
                 validator
               } = rule;
               if (validType === 'all' || !trigger || validType === trigger) {
@@ -20394,14 +20461,10 @@ const validErrorRuleValue = (rule, val) => {
                       if (validatorMethod) {
                         customValid = validatorMethod(validParams);
                       } else {
-                        if (true) {
-                          warnLog('vxe.error.notValidators', [validator]);
-                        }
+                        warnLog('vxe.error.notValidators', [validator]);
                       }
                     } else {
-                      if (true) {
-                        errLog('vxe.error.notValidators', [validator]);
-                      }
+                      errLog('vxe.error.notValidators', [validator]);
                     }
                   } else {
                     customValid = validator(validParams);
@@ -20427,17 +20490,7 @@ const validErrorRuleValue = (rule, val) => {
                     }
                   }
                 } else {
-                  const isArrType = type === 'array';
-                  const isArrVal = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isArray(itemValue);
-                  let hasEmpty = true;
-                  if (isArrType || isArrVal) {
-                    hasEmpty = !isArrVal || !itemValue.length;
-                  } else if (external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isString(itemValue)) {
-                    hasEmpty = eqEmptyValue(itemValue.trim());
-                  } else {
-                    hasEmpty = eqEmptyValue(itemValue);
-                  }
-                  if (required ? hasEmpty || validErrorRuleValue(rule, itemValue) : !hasEmpty && validErrorRuleValue(rule, itemValue)) {
+                  if (!checkRuleStatus(rule, itemValue)) {
                     errorRules.push(new Rule(rule));
                   }
                 }
@@ -20902,10 +20955,8 @@ function getComponentOns(renderOpts, params, eFns, eventOns) {
   const ons = {};
   external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().objectEach(events, (func, key) => {
     ons[getOnName(key)] = function (...args) {
-      if (true) {
-        if (!external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isFunction(func)) {
-          errLog('vxe.error.errFunc', [func]);
-        }
+      if (!external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isFunction(func)) {
+        errLog('vxe.error.errFunc', [func]);
       }
       func(params, ...args);
     };
@@ -22608,15 +22659,11 @@ const ViewItemComponent = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.defin
         return handlePrevNext(true);
       },
       prevTab() {
-        if (true) {
-          warnLog('vxe.error.delFunc', ['prevTab', 'prev']);
-        }
+        warnLog('vxe.error.delFunc', ['prevTab', 'prev']);
         return tabsMethods.prev();
       },
       nextTab() {
-        if (true) {
-          warnLog('vxe.error.delFunc', ['nextTab', 'next']);
-        }
+        warnLog('vxe.error.delFunc', ['nextTab', 'next']);
         return tabsMethods.next();
       }
     };
@@ -24983,10 +25030,8 @@ const lockScrollCssWidthKey = '--vxe-ui-modal-lock-scroll-view-width';
       }
     });
     (0,external_commonjs_vue_commonjs2_vue_root_Vue_.onMounted)(() => {
-      if (true) {
-        if (props.type === 'modal' && props.showFooter && !(props.showConfirmButton || props.showCancelButton || slots.footer)) {
-          warnLog('vxe.modal.footPropErr');
-        }
+      if (props.type === 'modal' && props.showFooter && !(props.showConfirmButton || props.showCancelButton || slots.footer)) {
+        warnLog('vxe.modal.footPropErr');
       }
       (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)(() => {
         if (props.storage && !props.id) {
@@ -25419,9 +25464,7 @@ const createDefaultFormViewMobileFormConfig = params => {
        * @deprecated
        */
       updateItemStatus(widget, value) {
-        if (true) {
-          warnLog('vxe.error.delFunc', ['updateItemStatus', 'updateWidgetStatus']);
-        }
+        warnLog('vxe.error.delFunc', ['updateItemStatus', 'updateWidgetStatus']);
         return updateWidgetStatus(widget, value);
       }
     };
@@ -33517,10 +33560,10 @@ function getNodeUniqueId() {
       type: String,
       default: () => getConfig().tree.hasChildField
     },
-    // mapChildrenField: {
-    //   type: String as PropType<VxeTreePropTypes.MapChildrenField>,
-    //   default: () => getConfig().tree.mapChildrenField
-    // },
+    mapChildrenField: {
+      type: String,
+      default: () => getConfig().tree.mapChildrenField
+    },
     transform: Boolean,
     // 已废弃
     isCurrent: Boolean,
@@ -33592,16 +33635,18 @@ function getNodeUniqueId() {
     const refElem = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.ref)();
     const reactData = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.reactive)({
       currentNode: null,
-      nodeMaps: {},
       selectRadioKey: props.checkNodeKey,
       treeList: [],
-      treeExpandedMaps: {},
-      treeExpandLazyLoadedMaps: {},
-      selectCheckboxMaps: {},
-      indeterminateCheckboxMaps: {}
+      updateExpandedFlag: 1,
+      updateCheckboxFlag: 1
     });
     const internalData = {
-      // initialized: false
+      // initialized: false,
+      nodeMaps: {},
+      selectCheckboxMaps: {},
+      indeterminateRowMaps: {},
+      treeExpandedMaps: {},
+      treeExpandLazyLoadedMaps: {}
     };
     const refMaps = {
       refElem
@@ -33622,6 +33667,9 @@ function getNodeUniqueId() {
     const computeChildrenField = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
       return props.childrenField || 'children';
     });
+    const computeMapChildrenField = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
+      return props.mapChildrenField || 'mapChildren';
+    });
     const computeHasChildField = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
       return props.hasChildField || 'hasChild';
     });
@@ -33696,10 +33744,13 @@ function getNodeUniqueId() {
     };
     const isExpandByNode = node => {
       const {
-        treeExpandedMaps
+        updateExpandedFlag
       } = reactData;
+      const {
+        treeExpandedMaps
+      } = internalData;
       const nodeid = getNodeId(node);
-      return !!treeExpandedMaps[nodeid];
+      return !!(updateExpandedFlag && treeExpandedMaps[nodeid]);
     };
     const isCheckedByRadioNodeId = nodeid => {
       const {
@@ -33712,18 +33763,24 @@ function getNodeUniqueId() {
     };
     const isCheckedByCheckboxNodeId = nodeid => {
       const {
-        selectCheckboxMaps
+        updateCheckboxFlag
       } = reactData;
-      return !!selectCheckboxMaps[nodeid];
+      const {
+        selectCheckboxMaps
+      } = internalData;
+      return !!(updateCheckboxFlag && selectCheckboxMaps[nodeid]);
     };
     const isCheckedByCheckboxNode = node => {
       return isCheckedByCheckboxNodeId(getNodeId(node));
     };
     const isIndeterminateByCheckboxNodeid = nodeid => {
       const {
-        indeterminateCheckboxMaps
+        updateCheckboxFlag
       } = reactData;
-      return !!indeterminateCheckboxMaps[nodeid];
+      const {
+        indeterminateRowMaps
+      } = internalData;
+      return !!(updateCheckboxFlag && indeterminateRowMaps[nodeid]);
     };
     const isIndeterminateByCheckboxNode = node => {
       return isIndeterminateByCheckboxNodeid(getNodeId(node));
@@ -33745,38 +33802,66 @@ function getNodeUniqueId() {
         if (!external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isArray(nodeList)) {
           nodeList = [nodeList];
         }
-        handleCheckedCheckboxNode(nodeList.map(item => getNodeId(item)), checked);
+        handleCheckedCheckboxNode(nodeList, checked);
       }
       return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
     };
     const setCheckboxByNodeId = (nodeIds, checked) => {
+      const {
+        nodeMaps
+      } = internalData;
       if (nodeIds) {
         if (!external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isArray(nodeIds)) {
           nodeIds = [nodeIds];
         }
-        handleCheckedCheckboxNode(nodeIds, checked);
+        const nodeList = [];
+        nodeIds.forEach(nodeid => {
+          const nodeItem = nodeMaps[nodeid];
+          if (nodeItem) {
+            nodeList.push(nodeItem.item);
+          }
+        });
+        handleCheckedCheckboxNode(nodeList, checked);
       }
       return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
     };
-    const handleCheckedCheckboxNode = (nodeIds, checked) => {
-      const selectKeyMaps = Object.assign({}, reactData.selectCheckboxMaps);
-      nodeIds.forEach(key => {
+    const handleCheckedCheckboxNode = (nodeList, checked) => {
+      const {
+        transform
+      } = props;
+      const {
+        selectCheckboxMaps
+      } = internalData;
+      const mapChildrenField = computeMapChildrenField.value;
+      const childrenField = computeChildrenField.value;
+      const checkboxOpts = computeCheckboxOpts.value;
+      const {
+        checkStrictly
+      } = checkboxOpts;
+      const handleSelect = node => {
+        const nodeid = getNodeId(node);
         if (checked) {
-          selectKeyMaps[key] = true;
-        } else if (selectKeyMaps[key]) {
-          delete selectKeyMaps[key];
+          if (!selectCheckboxMaps[nodeid]) {
+            selectCheckboxMaps[nodeid] = node;
+          }
+        } else {
+          if (selectCheckboxMaps[nodeid]) {
+            delete selectCheckboxMaps[nodeid];
+          }
         }
-      });
-      reactData.selectCheckboxMaps = selectKeyMaps;
-    };
-    const updateCheckboxChecked = nodeIds => {
-      const selectKeyMaps = {};
-      if (nodeIds) {
-        nodeIds.forEach(key => {
-          selectKeyMaps[key] = true;
+      };
+      if (checkStrictly) {
+        nodeList.forEach(handleSelect);
+      } else {
+        external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eachTree(nodeList, handleSelect, {
+          children: transform ? mapChildrenField : childrenField
         });
       }
-      reactData.selectCheckboxMaps = selectKeyMaps;
+      reactData.updateCheckboxFlag++;
+      updateCheckboxStatus();
+    };
+    const updateCheckboxChecked = nodeIds => {
+      setCheckboxByNodeId(nodeIds, true);
     };
     const handleSetExpand = (nodeid, expanded, expandedMaps) => {
       if (expanded) {
@@ -33825,9 +33910,11 @@ function getNodeUniqueId() {
       },
       getCurrentNode() {
         const {
-          currentNode,
-          nodeMaps
+          currentNode
         } = reactData;
+        const {
+          nodeMaps
+        } = internalData;
         if (currentNode) {
           const nodeItem = nodeMaps[getNodeId(currentNode)];
           if (nodeItem) {
@@ -33839,7 +33926,7 @@ function getNodeUniqueId() {
       setCurrentNodeId(nodeKey) {
         const {
           nodeMaps
-        } = reactData;
+        } = internalData;
         const nodeItem = nodeMaps[nodeKey];
         reactData.currentNode = nodeItem ? nodeItem.item : null;
         return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
@@ -33857,9 +33944,11 @@ function getNodeUniqueId() {
       },
       getRadioNode() {
         const {
-          selectRadioKey,
-          nodeMaps
+          selectRadioKey
         } = reactData;
+        const {
+          nodeMaps
+        } = internalData;
         if (selectRadioKey) {
           const nodeItem = nodeMaps[selectRadioKey];
           if (nodeItem) {
@@ -33878,14 +33967,14 @@ function getNodeUniqueId() {
       getCheckboxNodeIds() {
         const {
           selectCheckboxMaps
-        } = reactData;
+        } = internalData;
         return Object.keys(selectCheckboxMaps);
       },
       getCheckboxNodes() {
         const {
           nodeMaps,
           selectCheckboxMaps
-        } = reactData;
+        } = internalData;
         const list = [];
         external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().each(selectCheckboxMaps, (item, nodeid) => {
           const nodeItem = nodeMaps[nodeid];
@@ -33896,57 +33985,69 @@ function getNodeUniqueId() {
         return list;
       },
       clearCheckboxNode() {
-        reactData.selectCheckboxMaps = {};
+        internalData.selectCheckboxMaps = {};
+        reactData.updateCheckboxFlag++;
         return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
       },
       setAllCheckboxNode(checked) {
+        const {
+          transform
+        } = props;
         const selectMaps = {};
         const childrenField = computeChildrenField.value;
+        const mapChildrenField = computeMapChildrenField.value;
         if (checked) {
           external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eachTree(reactData.treeList, node => {
             const nodeid = getNodeId(node);
             selectMaps[nodeid] = true;
           }, {
-            children: childrenField
+            children: transform ? mapChildrenField : childrenField
           });
         }
-        reactData.selectCheckboxMaps = selectMaps;
+        internalData.selectCheckboxMaps = selectMaps;
+        reactData.updateCheckboxFlag++;
         return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
       },
       clearExpandNode() {
         return treeMethods.clearAllExpandNode();
       },
       clearAllExpandNode() {
-        external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().each(reactData.nodeMaps, nodeItem => {
+        const {
+          nodeMaps
+        } = internalData;
+        external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().each(nodeMaps, nodeItem => {
           nodeItem.treeLoaded = false;
         });
-        reactData.treeExpandedMaps = {};
+        internalData.treeExpandedMaps = {};
+        reactData.updateExpandedFlag++;
         return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
       },
       setExpandByNodeId(nodeids, expanded) {
-        const expandedMaps = Object.assign({}, reactData.treeExpandedMaps);
+        const {
+          treeExpandedMaps
+        } = internalData;
         if (nodeids) {
           if (!external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isArray(nodeids)) {
             nodeids = [nodeids];
           }
           nodeids.forEach(nodeid => {
-            handleSetExpand(nodeid, expanded, expandedMaps);
+            handleSetExpand(nodeid, expanded, treeExpandedMaps);
           });
-          reactData.treeExpandedMaps = expandedMaps;
+          reactData.updateExpandedFlag++;
         }
         return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
       },
       getExpandNodeIds() {
         const {
           treeExpandedMaps
-        } = reactData;
-        return Object.keys(treeExpandedMaps);
+        } = internalData;
+        return external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().keys(treeExpandedMaps);
       },
       getExpandNodes() {
         const {
           nodeMaps,
           treeExpandedMaps
-        } = reactData;
+        } = internalData;
         const list = [];
         external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().each(treeExpandedMaps, (item, nodeid) => {
           const nodeItem = nodeMaps[nodeid];
@@ -33957,62 +34058,74 @@ function getNodeUniqueId() {
         return list;
       },
       setExpandNode(nodes, expanded) {
-        const expandedMaps = Object.assign({}, reactData.treeExpandedMaps);
+        const {
+          treeExpandedMaps
+        } = internalData;
         if (nodes) {
           if (!external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isArray(nodes)) {
             nodes = [nodes];
           }
           nodes.forEach(node => {
             const nodeid = getNodeId(node);
-            handleSetExpand(nodeid, expanded, expandedMaps);
+            handleSetExpand(nodeid, expanded, treeExpandedMaps);
           });
-          reactData.treeExpandedMaps = expandedMaps;
+          reactData.updateExpandedFlag++;
         }
         return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
       },
       toggleExpandByNodeId(nodeids) {
-        const expandedMaps = Object.assign({}, reactData.treeExpandedMaps);
+        const {
+          treeExpandedMaps
+        } = internalData;
         if (nodeids) {
           if (!external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isArray(nodeids)) {
             nodeids = [nodeids];
           }
           nodeids.forEach(nodeid => {
-            handleSetExpand(nodeid, !expandedMaps[nodeid], expandedMaps);
+            handleSetExpand(nodeid, !treeExpandedMaps[nodeid], treeExpandedMaps);
           });
-          reactData.treeExpandedMaps = expandedMaps;
+          reactData.updateExpandedFlag++;
         }
         return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
       },
       toggleExpandNode(nodes) {
-        const expandedMaps = Object.assign({}, reactData.treeExpandedMaps);
+        const {
+          treeExpandedMaps
+        } = internalData;
         if (nodes) {
           if (!external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isArray(nodes)) {
             nodes = [nodes];
           }
           nodes.forEach(node => {
             const nodeid = getNodeId(node);
-            handleSetExpand(nodeid, !expandedMaps[nodeid], expandedMaps);
+            handleSetExpand(nodeid, !treeExpandedMaps[nodeid], treeExpandedMaps);
           });
-          reactData.treeExpandedMaps = expandedMaps;
+          reactData.updateExpandedFlag++;
         }
         return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
       },
       setAllExpandNode(expanded) {
-        const expandedMaps = {};
+        const {
+          transform
+        } = props;
+        const {
+          treeExpandedMaps
+        } = internalData;
         const childrenField = computeChildrenField.value;
+        const mapChildrenField = computeMapChildrenField.value;
         if (expanded) {
           external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eachTree(reactData.treeList, node => {
             const childList = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().get(node, childrenField);
             const hasChild = childList && childList.length;
             if (hasChild) {
               const nodeid = getNodeId(node);
-              expandedMaps[nodeid] = true;
+              treeExpandedMaps[nodeid] = true;
             }
           }, {
-            children: childrenField
+            children: transform ? mapChildrenField : childrenField
           });
         }
-        reactData.treeExpandedMaps = expandedMaps;
+        reactData.updateExpandedFlag++;
         return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
       },
       reloadExpandNode(node) {
@@ -34031,7 +34144,7 @@ function getNodeUniqueId() {
         } = props;
         const {
           nodeMaps
-        } = reactData;
+        } = internalData;
         if (lazy) {
           const nodeItem = nodeMaps[getNodeId(node)];
           if (nodeItem) {
@@ -34050,7 +34163,7 @@ function getNodeUniqueId() {
         } = props;
         const {
           nodeMaps
-        } = reactData;
+        } = internalData;
         if (!lazy) {
           return Promise.resolve([]);
         }
@@ -34090,24 +34203,29 @@ function getNodeUniqueId() {
       isCheckedByCheckboxNode,
       getCheckboxIndeterminateNodes() {
         const {
-          treeList,
-          indeterminateCheckboxMaps
-        } = reactData;
-        const indeterminateNodes = [];
-        external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eachTree(treeList, node => {
-          if (indeterminateCheckboxMaps[getNodeId(node)]) {
-            indeterminateNodes.push(node);
+          nodeMaps,
+          indeterminateRowMaps
+        } = internalData;
+        const list = [];
+        external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().each(indeterminateRowMaps, (item, nodeid) => {
+          const nodeItem = nodeMaps[nodeid];
+          if (nodeItem) {
+            list.push(nodeItem.item);
           }
         });
-        return indeterminateNodes;
+        return list;
       }
     };
     const cacheNodeMap = () => {
+      const {
+        transform
+      } = props;
       const {
         treeList
       } = reactData;
       const valueField = computeValueField.value;
       const childrenField = computeChildrenField.value;
+      const mapChildrenField = computeMapChildrenField.value;
       const keyMaps = {};
       external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eachTree(treeList, (item, itemIndex, items, path, parent, nodes) => {
         let nodeid = getNodeId(item);
@@ -34126,11 +34244,11 @@ function getNodeUniqueId() {
           treeLoaded: false
         };
       }, {
-        children: childrenField
+        children: transform ? mapChildrenField : childrenField
       });
-      reactData.nodeMaps = keyMaps;
+      internalData.nodeMaps = keyMaps;
     };
-    const updateData = list => {
+    const loadTreeData = list => {
       const {
         expandAll,
         transform
@@ -34140,28 +34258,31 @@ function getNodeUniqueId() {
       } = internalData;
       const keyField = computeKeyField.value;
       const parentField = computeParentField.value;
-      const childrenField = computeChildrenField.value;
+      const mapChildrenField = computeMapChildrenField.value;
       if (transform) {
         reactData.treeList = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toArrayTree(list, {
           key: keyField,
           parentKey: parentField,
-          mapChildren: childrenField
+          mapChildren: mapChildrenField
         });
       } else {
         reactData.treeList = list ? list.slice(0) : [];
       }
       cacheNodeMap();
-      if (expandAll && !initialized) {
+      if (!initialized) {
         if (list && list.length) {
           internalData.initialized = true;
-          $xeTree.setAllExpandNode(true);
+          if (expandAll) {
+            $xeTree.setAllExpandNode(true);
+          }
+          $xeTree.setCheckboxByNodeId(props.checkNodeKeys || [], true);
         }
       }
     };
     const handleCountLine = (item, isRoot, nodeItem) => {
       const {
         treeExpandedMaps
-      } = reactData;
+      } = internalData;
       const childrenField = computeChildrenField.value;
       const nodeid = getNodeId(item);
       nodeItem.lineCount++;
@@ -34176,7 +34297,7 @@ function getNodeUniqueId() {
     const updateNodeLine = node => {
       const {
         nodeMaps
-      } = reactData;
+      } = internalData;
       if (node) {
         const nodeid = getNodeId(node);
         const nodeItem = nodeMaps[nodeid];
@@ -34246,21 +34367,19 @@ function getNodeUniqueId() {
       } = checkboxOpts;
       return new Promise(resolve => {
         if (loadMethod) {
-          const tempExpandLazyLoadedMaps = Object.assign({}, reactData.treeExpandLazyLoadedMaps);
           const {
             nodeMaps
-          } = reactData;
+          } = internalData;
           const nodeid = getNodeId(node);
           const nodeItem = nodeMaps[nodeid];
-          tempExpandLazyLoadedMaps[nodeid] = true;
-          reactData.treeExpandLazyLoadedMaps = tempExpandLazyLoadedMaps;
+          internalData.treeExpandLazyLoadedMaps[nodeid] = true;
           Promise.resolve(loadMethod({
             $tree: $xeTree,
             node
           })).then(childRecords => {
             const {
               treeExpandLazyLoadedMaps
-            } = reactData;
+            } = internalData;
             nodeItem.treeLoaded = true;
             if (treeExpandLazyLoadedMaps[nodeid]) {
               treeExpandLazyLoadedMaps[nodeid] = false;
@@ -34269,15 +34388,17 @@ function getNodeUniqueId() {
               childRecords = [];
             }
             if (childRecords) {
-              return treeMethods.loadChildrenNode(node, childRecords).then(childRows => {
-                const tempExpandedMaps = Object.assign({}, reactData.treeExpandedMaps);
-                if (childRows.length && !tempExpandedMaps[nodeid]) {
-                  tempExpandedMaps[nodeid] = true;
+              return $xeTree.loadChildrenNode(node, childRecords).then(childRows => {
+                const {
+                  treeExpandedMaps
+                } = internalData;
+                if (childRows.length && !treeExpandedMaps[nodeid]) {
+                  treeExpandedMaps[nodeid] = true;
                 }
-                reactData.treeExpandedMaps = tempExpandedMaps;
+                reactData.updateExpandedFlag++;
                 // 如果当前节点已选中，则展开后子节点也被选中
-                if (!checkStrictly && treeMethods.isCheckedByCheckboxNodeId(nodeid)) {
-                  handleCheckedCheckboxNode(childRows.map(item => getNodeId(item)), true);
+                if (!checkStrictly && $xeTree.isCheckedByCheckboxNodeId(nodeid)) {
+                  handleCheckedCheckboxNode(childRows, true);
                 }
                 updateNodeLine(node);
                 dispatchEvent('load-success', {
@@ -34296,7 +34417,7 @@ function getNodeUniqueId() {
           }).catch(e => {
             const {
               treeExpandLazyLoadedMaps
-            } = reactData;
+            } = internalData;
             nodeItem.treeLoaded = false;
             if (treeExpandLazyLoadedMaps[nodeid]) {
               treeExpandLazyLoadedMaps[nodeid] = false;
@@ -34327,10 +34448,12 @@ function getNodeUniqueId() {
         toggleMethod
       } = props;
       const {
-        nodeMaps,
-        treeExpandLazyLoadedMaps
-      } = reactData;
-      const tempExpandedMaps = Object.assign({}, reactData.treeExpandedMaps);
+        treeExpandLazyLoadedMaps,
+        treeExpandedMaps
+      } = internalData;
+      const {
+        nodeMaps
+      } = internalData;
       const childrenField = computeChildrenField.value;
       const hasChildField = computeHasChildField.value;
       const result = [];
@@ -34347,8 +34470,8 @@ function getNodeUniqueId() {
         if (nodeItem) {
           nodeItem.items.forEach(item => {
             const itemNodeId = getNodeId(item);
-            if (tempExpandedMaps[itemNodeId]) {
-              delete tempExpandedMaps[itemNodeId];
+            if (treeExpandedMaps[itemNodeId]) {
+              delete treeExpandedMaps[itemNodeId];
             }
           });
         }
@@ -34357,7 +34480,7 @@ function getNodeUniqueId() {
       if (expanded) {
         validNodes.forEach(item => {
           const itemNodeId = getNodeId(item);
-          if (!tempExpandedMaps[itemNodeId]) {
+          if (!treeExpandedMaps[itemNodeId]) {
             const nodeItem = nodeMaps[itemNodeId];
             const isLoad = lazy && item[hasChildField] && !nodeItem.treeLoaded && !treeExpandLazyLoadedMaps[itemNodeId];
             // 是否使用懒加载
@@ -34365,7 +34488,7 @@ function getNodeUniqueId() {
               result.push(handleAsyncTreeExpandChilds(item));
             } else {
               if (item[childrenField] && item[childrenField].length) {
-                tempExpandedMaps[itemNodeId] = true;
+                treeExpandedMaps[itemNodeId] = true;
                 expandNodes.push(item);
               }
             }
@@ -34374,13 +34497,13 @@ function getNodeUniqueId() {
       } else {
         validNodes.forEach(item => {
           const itemNodeId = getNodeId(item);
-          if (tempExpandedMaps[itemNodeId]) {
-            delete tempExpandedMaps[itemNodeId];
+          if (treeExpandedMaps[itemNodeId]) {
+            delete treeExpandedMaps[itemNodeId];
             expandNodes.push(item);
           }
         });
       }
-      reactData.treeExpandedMaps = tempExpandedMaps;
+      reactData.updateExpandedFlag++;
       expandNodes.forEach(updateNodeLine);
       return Promise.all(result);
     };
@@ -34391,7 +34514,7 @@ function getNodeUniqueId() {
       const {
         treeExpandedMaps,
         treeExpandLazyLoadedMaps
-      } = reactData;
+      } = internalData;
       const nodeid = getNodeId(node);
       const expanded = !treeExpandedMaps[nodeid];
       evnt.stopPropagation();
@@ -34399,74 +34522,107 @@ function getNodeUniqueId() {
         handleBaseTreeExpand([node], expanded);
       }
     };
-    const handleNodeCheckboxStatus = (node, selectKeyMaps, indeterminateMaps) => {
-      const childrenField = computeChildrenField.value;
-      const childList = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().get(node, childrenField);
-      const nodeid = getNodeId(node);
-      if (childList && childList.length) {
-        let checkSome = false;
-        let checkSize = 0;
-        childList.forEach(childNode => {
-          const childNodeid = getNodeId(childNode);
-          const isChecked = selectKeyMaps[childNodeid];
-          if (isChecked || indeterminateMaps[childNodeid]) {
-            if (isChecked) {
-              checkSize++;
-            }
-            checkSome = true;
-          }
-        });
-        const checkAll = checkSize === childList.length;
-        if (checkAll) {
-          if (!selectKeyMaps[nodeid]) {
-            selectKeyMaps[nodeid] = true;
-          }
-          if (indeterminateMaps[nodeid]) {
-            delete indeterminateMaps[nodeid];
-          }
-        } else {
-          if (selectKeyMaps[nodeid]) {
-            delete selectKeyMaps[nodeid];
-          }
-          indeterminateMaps[nodeid] = checkSome;
-        }
-      } else {
-        if (indeterminateMaps[nodeid]) {
-          delete indeterminateMaps[nodeid];
-        }
-      }
-    };
     const updateCheckboxStatus = () => {
+      const {
+        transform
+      } = props;
       const {
         treeList
       } = reactData;
+      const {
+        selectCheckboxMaps,
+        indeterminateRowMaps
+      } = internalData;
       const childrenField = computeChildrenField.value;
+      const mapChildrenField = computeMapChildrenField.value;
       const checkboxOpts = computeCheckboxOpts.value;
       const {
-        checkStrictly
+        checkStrictly,
+        checkMethod
       } = checkboxOpts;
       if (!checkStrictly) {
-        const selectKeyMaps = Object.assign({}, reactData.selectCheckboxMaps);
-        const indeterminateMaps = {};
-        external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eachTree(treeList, (node, index, items, path, parent, nodes) => {
-          const childList = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().get(node, childrenField);
-          if (!childList || !childList.length) {
-            handleNodeCheckboxStatus(node, selectKeyMaps, indeterminateMaps);
+        const childRowMaps = {};
+        const childRowList = [];
+        external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eachTree(treeList, node => {
+          const nodeid = getNodeId(node);
+          const childList = node[childrenField];
+          if (childList && childList.length && !childRowMaps[nodeid]) {
+            childRowMaps[nodeid] = 1;
+            childRowList.unshift([node, nodeid, childList]);
           }
-          if (index === items.length - 1) {
-            for (let len = nodes.length - 2; len >= 0; len--) {
-              const parentItem = nodes[len];
-              handleNodeCheckboxStatus(parentItem, selectKeyMaps, indeterminateMaps);
+        }, {
+          children: transform ? mapChildrenField : childrenField
+        });
+        childRowList.forEach(vals => {
+          const node = vals[0];
+          const nodeid = vals[1];
+          const childList = vals[2];
+          let sLen = 0; // 已选
+          let hLen = 0; // 半选
+          let vLen = 0; // 有效行
+          childList.forEach(checkMethod ? item => {
+            const childNodeid = getNodeId(item);
+            const isSelect = selectCheckboxMaps[childNodeid];
+            if (checkMethod({
+              node: item
+            })) {
+              if (isSelect) {
+                sLen++;
+              } else if (indeterminateRowMaps[childNodeid]) {
+                hLen++;
+              }
+              vLen++;
+            } else {
+              if (isSelect) {
+                sLen++;
+              } else if (indeterminateRowMaps[childNodeid]) {
+                hLen++;
+              }
+            }
+          } : item => {
+            const childNodeid = getNodeId(item);
+            const isSelect = selectCheckboxMaps[childNodeid];
+            if (isSelect) {
+              sLen++;
+            } else if (indeterminateRowMaps[childNodeid]) {
+              hLen++;
+            }
+            vLen++;
+          });
+          const isSelected = sLen >= vLen;
+          const halfSelect = !isSelected && (sLen >= 1 || hLen >= 1);
+          if (isSelected) {
+            selectCheckboxMaps[nodeid] = node;
+            if (indeterminateRowMaps[nodeid]) {
+              delete indeterminateRowMaps[nodeid];
+            }
+          } else {
+            if (selectCheckboxMaps[nodeid]) {
+              delete selectCheckboxMaps[nodeid];
+            }
+            if (halfSelect) {
+              indeterminateRowMaps[nodeid] = node;
+            } else {
+              if (indeterminateRowMaps[nodeid]) {
+                delete indeterminateRowMaps[nodeid];
+              }
             }
           }
         });
-        reactData.selectCheckboxMaps = selectKeyMaps;
-        reactData.indeterminateCheckboxMaps = indeterminateMaps;
+        reactData.updateCheckboxFlag++;
       }
     };
     const changeCheckboxEvent = (evnt, node) => {
       evnt.preventDefault();
       evnt.stopPropagation();
+      const {
+        transform
+      } = props;
+      const {
+        selectCheckboxMaps
+      } = internalData;
+      const childrenField = computeChildrenField.value;
+      const mapChildrenField = computeMapChildrenField.value;
       const checkboxOpts = computeCheckboxOpts.value;
       const {
         checkStrictly,
@@ -34481,35 +34637,33 @@ function getNodeUniqueId() {
       if (isDisabled) {
         return;
       }
-      const selectKeyMaps = Object.assign({}, reactData.selectCheckboxMaps);
-      const childrenField = computeChildrenField.value;
       const nodeid = getNodeId(node);
       let isChecked = false;
-      if (selectKeyMaps[nodeid]) {
-        delete selectKeyMaps[nodeid];
+      if (selectCheckboxMaps[nodeid]) {
+        delete selectCheckboxMaps[nodeid];
       } else {
         isChecked = true;
-        selectKeyMaps[nodeid] = isChecked;
+        selectCheckboxMaps[nodeid] = node;
       }
       if (!checkStrictly) {
         external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().eachTree(external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().get(node, childrenField), childNode => {
           const childNodeid = getNodeId(childNode);
           if (isChecked) {
-            if (!selectKeyMaps[childNodeid]) {
-              selectKeyMaps[childNodeid] = true;
+            if (!selectCheckboxMaps[childNodeid]) {
+              selectCheckboxMaps[childNodeid] = true;
             }
           } else {
-            if (selectKeyMaps[childNodeid]) {
-              delete selectKeyMaps[childNodeid];
+            if (selectCheckboxMaps[childNodeid]) {
+              delete selectCheckboxMaps[childNodeid];
             }
           }
         }, {
-          children: childrenField
+          children: transform ? mapChildrenField : childrenField
         });
       }
-      reactData.selectCheckboxMaps = selectKeyMaps;
+      reactData.updateCheckboxFlag++;
       updateCheckboxStatus();
-      const value = Object.keys(reactData.selectCheckboxMaps);
+      const value = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().keys(selectCheckboxMaps);
       emitCheckboxMode(value);
       dispatchEvent('checkbox-change', {
         node,
@@ -34667,12 +34821,15 @@ function getNodeUniqueId() {
         showIcon
       } = props;
       const {
-        nodeMaps,
-        treeExpandedMaps,
         currentNode,
         selectRadioKey,
-        treeExpandLazyLoadedMaps
+        updateExpandedFlag
       } = reactData;
+      const {
+        nodeMaps,
+        treeExpandedMaps,
+        treeExpandLazyLoadedMaps
+      } = internalData;
       const childrenField = computeChildrenField.value;
       const titleField = computeTitleField.value;
       const hasChildField = computeHasChildField.value;
@@ -34682,7 +34839,7 @@ function getNodeUniqueId() {
       const titleSlot = slots.title;
       const extraSlot = slots.extra;
       const nodeid = getNodeId(node);
-      const isExpand = treeExpandedMaps[nodeid];
+      const isExpand = updateExpandedFlag && treeExpandedMaps[nodeid];
       const nodeItem = nodeMaps[nodeid];
       const nodeValue = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().get(node, titleField);
       const childVns = [];
@@ -34820,7 +34977,7 @@ function getNodeUniqueId() {
       dataFlag.value++;
     });
     (0,external_commonjs_vue_commonjs2_vue_root_Vue_.watch)(dataFlag, () => {
-      updateData(props.data || []);
+      loadTreeData(props.data || []);
     });
     (0,external_commonjs_vue_commonjs2_vue_root_Vue_.watch)(() => props.checkNodeKey, val => {
       reactData.selectRadioKey = val;
@@ -34837,11 +34994,11 @@ function getNodeUniqueId() {
     });
     (0,external_commonjs_vue_commonjs2_vue_root_Vue_.onUnmounted)(() => {
       reactData.treeList = [];
-      reactData.treeExpandedMaps = {};
-      reactData.nodeMaps = {};
+      internalData.treeExpandedMaps = {};
+      internalData.indeterminateRowMaps = {};
+      internalData.nodeMaps = {};
     });
-    updateData(props.data || []);
-    updateCheckboxChecked(props.checkNodeKeys || []);
+    loadTreeData(props.data || []);
     $xeTree.renderVN = renderVN;
     return $xeTree;
   },
@@ -37761,13 +37918,11 @@ const saveLocalFile = options => {
       updateFileList();
     });
     (0,external_commonjs_vue_commonjs2_vue_root_Vue_.onMounted)(() => {
-      if (true) {
-        if (props.multiple && props.singleMode) {
-          errLog('vxe.error.errConflicts', ['multiple', 'single-mode']);
-        }
-        if (props.imageStyle) {
-          warnLog('vxe.error.delProp', ['image-style', 'image-config']);
-        }
+      if (props.multiple && props.singleMode) {
+        errLog('vxe.error.errConflicts', ['multiple', 'single-mode']);
+      }
+      if (props.imageStyle) {
+        warnLog('vxe.error.delProp', ['image-style', 'image-config']);
       }
       if (props.dragSort) {
         initTpImg();
@@ -41580,13 +41735,11 @@ const default_setting_data_getDefaultSettingFormData = () => {
     (0,external_commonjs_vue_commonjs2_vue_root_Vue_.onMounted)(() => {
       updateTableData();
     });
-    if (true) {
-      (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)(() => {
-        if (!VxeTableGridComponent) {
-          errLog('vxe.error.reqComp', ['vxe-grid']);
-        }
-      });
-    }
+    (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)(() => {
+      if (!VxeTableGridComponent) {
+        errLog('vxe.error.reqComp', ['vxe-grid']);
+      }
+    });
     return () => {
       const {
         searchFormData,
@@ -43301,13 +43454,11 @@ const ListDesign = VxeListDesign;
       loadConfig(props.config);
     }
     (0,external_commonjs_vue_commonjs2_vue_root_Vue_.provide)('$xeListView', $xeListView);
-    if (true) {
-      (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)(() => {
-        if (!VxeTableGridComponent) {
-          errLog('vxe.error.reqComp', ['vxe-grid']);
-        }
-      });
-    }
+    (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)(() => {
+      if (!VxeTableGridComponent) {
+        errLog('vxe.error.reqComp', ['vxe-grid']);
+      }
+    });
     $xeListView.renderVN = renderVN;
     return $xeListView;
   },
@@ -45477,9 +45628,7 @@ const Option = VxeOption;
         if (renderFn) {
           childNodes.push(renderFn());
         } else {
-          if (true) {
-            errLog('vxe.error.notProp', [`layouts -> ${name}`]);
-          }
+          errLog('vxe.error.notProp', [`layouts -> ${name}`]);
         }
       });
       if (slots.right) {
@@ -48593,13 +48742,11 @@ function getRowUniqueId() {
       globalEvents.off($xeTableSelect, 'mousedown');
       globalEvents.off($xeTableSelect, 'blur');
     });
-    if (true) {
-      (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)(() => {
-        if (!VxeTableGridComponent) {
-          errLog('vxe.error.reqComp', ['vxe-grid']);
-        }
-      });
-    }
+    (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)(() => {
+      if (!VxeTableGridComponent) {
+        errLog('vxe.error.reqComp', ['vxe-grid']);
+      }
+    });
     (0,external_commonjs_vue_commonjs2_vue_root_Vue_.provide)('$xeTableSelect', $xeTableSelect);
     $xeTableSelect.renderVN = renderVN;
     return $xeTableSelect;