vxe-pc-ui 4.19.5 → 4.19.7

package/dist/all.esm.js

@@ -1,5 +1,5 @@
 import * as core from '@vxe-ui/core';
-import { VxeUI, setConfig as setConfig$1, setIcon, getConfig as getConfig$4, createEvent as createEvent$1, getIcon as getIcon$2, renderEmptyElement as renderEmptyElement$1, useSize, globalEvents, usePermission, permission, renderer, getI18n as getI18n$2, globalResize as globalResize$1, menus as menus$3, GLOBAL_EVENT_KEYS, getSlotVNs as getSlotVNs$1, commands, formats, getComponent, validators } from '@vxe-ui/core';
+import { VxeUI, setConfig as setConfig$1, setIcon, getConfig as getConfig$4, createEvent as createEvent$1, getIcon as getIcon$2, renderEmptyElement as renderEmptyElement$1, useSize, globalEvents as globalEvents$1, usePermission, permission, renderer, getI18n as getI18n$2, globalResize as globalResize$1, menus as menus$3, GLOBAL_EVENT_KEYS, getSlotVNs as getSlotVNs$1, commands, formats, getComponent, validators } from '@vxe-ui/core';
 export * from '@vxe-ui/core';
 import { defineComponent, ref, reactive, h, createCommentVNode, createApp, inject, computed, watch, onMounted, onUnmounted, provide, nextTick, onBeforeUnmount, resolveComponent, Teleport, onActivated, onDeactivated, TransitionGroup } from 'vue';
 import XEUtils from 'xe-utils';
@@ -101,7 +101,7 @@ function checkDynamic() {
 }
 
 const { log } = VxeUI;
-const uiVersion = `ui v${"4.19.5"}`;
+const uiVersion = `ui v${"4.19.7"}`;
 function createComponentLog(name) {
     const tableVersion = VxeUI.tableVersion ? `table v${VxeUI.tableVersion}` : '';
     const ganttVersion = VxeUI.ganttVersion ? `gantt v${VxeUI.ganttVersion}` : '';
@@ -112,18 +112,18 @@ function createComponentLog(name) {
         errLog: log.create('error', versionInfo + '] [' + name)
     };
 }
-const warnLog$i = log.create('warn', uiVersion);
+const warnLog$j = log.create('warn', uiVersion);
 log.create('error', uiVersion);
 
-const version = "4.19.5";
+const version = "4.19.7";
 VxeUI.uiVersion = version;
 VxeUI.dynamicApp = dynamicApp;
 function config(options) {
-    warnLog$i('vxe.error.delFunc', ['config', 'setConfig']);
+    warnLog$j('vxe.error.delFunc', ['config', 'setConfig']);
     return setConfig$1(options);
 }
 function setup(options) {
-    warnLog$i('vxe.error.delFunc', ['setup', 'setConfig']);
+    warnLog$j('vxe.error.delFunc', ['setup', 'setConfig']);
     return setConfig$1(options);
 }
 VxeUI.config = config;
@@ -3192,8 +3192,8 @@ var VxeTooltipComponent = defineVxeComponent({
                     }
                 }
             });
-            globalEvents.on($xeTooltip, 'blur', handleGlobalBlurEvent);
-            globalEvents.on($xeTooltip, 'scroll', handleGlobalScrollEvent);
+            globalEvents$1.on($xeTooltip, 'blur', handleGlobalBlurEvent);
+            globalEvents$1.on($xeTooltip, 'scroll', handleGlobalScrollEvent);
         });
         onBeforeUnmount(() => {
             const { target } = reactData;
@@ -3213,8 +3213,8 @@ var VxeTooltipComponent = defineVxeComponent({
                     parentNode.removeChild(panelElem);
                 }
             }
-            globalEvents.off($xeTooltip, 'blur');
-            globalEvents.off($xeTooltip, 'scroll');
+            globalEvents$1.off($xeTooltip, 'blur');
+            globalEvents$1.off($xeTooltip, 'scroll');
             XEUtils.assign(reactData, createReactData$p());
             XEUtils.assign(internalData, createInternalData$o());
         });
@@ -3290,7 +3290,7 @@ VxeUI.component(VxeTooltipComponent);
 VxeUI.tooltip = TooltipController;
 const Tooltip = VxeTooltip;
 
-const { warnLog: warnLog$h } = createComponentLog('button');
+const { warnLog: warnLog$i } = createComponentLog('button');
 const VxeButtonComponent = defineVxeComponent({
     name: 'VxeButton',
     props: {
@@ -4019,16 +4019,16 @@ const VxeButtonComponent = defineVxeComponent({
         $xeButton.renderVN = renderVN;
         onMounted(() => {
             if (props.type === 'text') {
-                warnLog$h('vxe.error.delProp', ['type=text', 'mode=text']);
+                warnLog$i('vxe.error.delProp', ['type=text', 'mode=text']);
             }
-            globalEvents.on($xeButton, 'mousedown', handleGlobalMousedownEvent);
-            globalEvents.on($xeButton, 'resize', handleGlobalResizeEvent);
-            globalEvents.on($xeButton, 'scroll', handleGlobalScrollEvent);
+            globalEvents$1.on($xeButton, 'mousedown', handleGlobalMousedownEvent);
+            globalEvents$1.on($xeButton, 'resize', handleGlobalResizeEvent);
+            globalEvents$1.on($xeButton, 'scroll', handleGlobalScrollEvent);
         });
         onUnmounted(() => {
-            globalEvents.off($xeButton, 'mousedown');
-            globalEvents.off($xeButton, 'resize');
-            globalEvents.off($xeButton, 'scroll');
+            globalEvents$1.off($xeButton, 'mousedown');
+            globalEvents$1.off($xeButton, 'resize');
+            globalEvents$1.off($xeButton, 'scroll');
         });
         return $xeButton;
     },
@@ -4046,7 +4046,7 @@ dynamicApp.use(VxeButton);
 VxeUI.component(VxeButtonComponent);
 const Button = VxeButton;
 
-const { errLog: errLog$k } = createComponentLog('backtop');
+const { errLog: errLog$l } = createComponentLog('backtop');
 function createInternalData$n() {
     return {
         targetEl: null
@@ -4224,7 +4224,7 @@ var VxeBacktopComponent = defineVxeComponent({
                 const { target } = props;
                 if (!target) {
                     removeScrollEvent();
-                    errLog$k('vxe.error.reqProp', ['target']);
+                    errLog$l('vxe.error.reqProp', ['target']);
                     return;
                 }
                 if (XEUtils.isString(target)) {
@@ -4965,7 +4965,7 @@ const getNextMonth = (date) => {
     return date;
 };
 
-const { errLog: errLog$j } = createComponentLog('calendar');
+const { errLog: errLog$k } = createComponentLog('calendar');
 const { menus: menus$2, getConfig: getConfig$3, getI18n: getI18n$1 } = VxeUI;
 var VxeCalendarComponent = defineVxeComponent({
     name: 'VxeCalendar',
@@ -6231,7 +6231,7 @@ var VxeCalendarComponent = defineVxeComponent({
             const { menuConfig } = props;
             const VxeUIContextMenu = VxeUI.getComponent('VxeContextMenu');
             if (menuConfig && !VxeUIContextMenu) {
-                errLog$j('vxe.error.reqComp', ['vxe-context-menu']);
+                errLog$k('vxe.error.reqComp', ['vxe-context-menu']);
             }
             dateOpenPanel();
         });
@@ -7079,7 +7079,7 @@ function getItemCacheObj$1(item) {
     };
 }
 
-const { warnLog: warnLog$g, errLog: errLog$i } = createComponentLog('tree');
+const { warnLog: warnLog$h, errLog: errLog$j } = createComponentLog('tree');
 function getRowKeyByField(row, keyField) {
     return row ? ('' + (row[keyField] || '')) : '';
 }
@@ -8334,7 +8334,7 @@ var VxeListComponent = defineVxeComponent({
             const { fullData, rowMaps, removeRowMaps, insertRowMaps } = internalData;
             const keyField = computeKeyField.value;
             if (!keyField) {
-                errLog$i('vxe.error.reqSupportProp', ['insert() | insertAt() | insertNextAt()', 'row-config.keyField']);
+                errLog$j('vxe.error.reqSupportProp', ['insert() | insertAt() | insertNextAt()', 'row-config.keyField']);
                 return Promise.resolve({ row: null, rows: [] });
             }
             if (!XEUtils.isArray(records)) {
@@ -8373,7 +8373,7 @@ var VxeListComponent = defineVxeComponent({
                         fullData.splice(targetIndex, 0, ...newRecords);
                     }
                     else {
-                        warnLog$g('vxe.error.unableInsert');
+                        warnLog$h('vxe.error.unableInsert');
                         insertListRow(newRecords, true);
                     }
                 }
@@ -8521,7 +8521,7 @@ var VxeListComponent = defineVxeComponent({
                 const { fullData, insertRowMaps, removeRowMaps } = internalData;
                 const keyField = computeKeyField.value;
                 if (!keyField) {
-                    errLog$i('vxe.error.reqSupportProp', ['insert() | insertAt() | insertNextAt()', 'row-config.keyField']);
+                    errLog$j('vxe.error.reqSupportProp', ['insert() | insertAt() | insertNextAt()', 'row-config.keyField']);
                     return Promise.resolve({ row: null, rows: [] });
                 }
                 let delList = [];
@@ -9131,20 +9131,20 @@ var VxeListComponent = defineVxeComponent({
             const keyField = computeKeyField.value;
             if (!keyField) {
                 if (showSeq) {
-                    errLog$i('vxe.error.reqSupportProp', ['show-seq', 'row-config.keyField']);
+                    errLog$j('vxe.error.reqSupportProp', ['show-seq', 'row-config.keyField']);
                 }
                 if (showRadio) {
-                    errLog$i('vxe.error.reqSupportProp', ['show-radio', 'row-config.keyField']);
+                    errLog$j('vxe.error.reqSupportProp', ['show-radio', 'row-config.keyField']);
                 }
                 if (showCheckbox) {
-                    errLog$i('vxe.error.reqSupportProp', ['show-checkbox', 'row-config.keyField']);
+                    errLog$j('vxe.error.reqSupportProp', ['show-checkbox', 'row-config.keyField']);
                 }
                 if (isDrag) {
-                    errLog$i('vxe.error.reqSupportProp', ['drag-config', 'row-config.keyField']);
+                    errLog$j('vxe.error.reqSupportProp', ['drag-config', 'row-config.keyField']);
                 }
             }
             if (useKey && !keyField) {
-                errLog$i('vxe.error.reqSupportProp', ['row-config.useKey', 'row-config.keyField']);
+                errLog$j('vxe.error.reqSupportProp', ['row-config.useKey', 'row-config.keyField']);
             }
             if (props.autoResize) {
                 const el = refElem.value;
@@ -9156,14 +9156,14 @@ var VxeListComponent = defineVxeComponent({
                 internalData.resizeObserver = resizeObserver;
             }
             recalculate();
-            globalEvents.on($xeList, 'resize', recalculate);
+            globalEvents$1.on($xeList, 'resize', recalculate);
         });
         onBeforeUnmount(() => {
             const { resizeObserver } = internalData;
             if (resizeObserver) {
                 resizeObserver.disconnect();
             }
-            globalEvents.off($xeList, 'resize');
+            globalEvents$1.off($xeList, 'resize');
             XEUtils.assign(reactData, createReactData$n());
             XEUtils.assign(internalData, createInternalData$m());
         });
@@ -9206,7 +9206,7 @@ function toFloatValueFixed(inputValue, type, digitsValue, roundingMode) {
     }
 }
 
-const { warnLog: warnLog$f } = createComponentLog('input');
+const { warnLog: warnLog$g } = createComponentLog('input');
 var VxeInputComponent = defineVxeComponent({
     name: 'VxeInput',
     props: {
@@ -10399,8 +10399,8 @@ var VxeInputComponent = defineVxeComponent({
             dispatchEvent('prev-number', { value: reactData.inputValue }, evnt);
         };
         const numberKeydownEvent = (evnt) => {
-            const isUpArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_UP);
-            const isDwArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_DOWN);
+            const isUpArrow = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_UP);
+            const isDwArrow = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_DOWN);
             if (isUpArrow || isDwArrow) {
                 evnt.preventDefault();
                 if (isUpArrow) {
@@ -10419,11 +10419,11 @@ var VxeInputComponent = defineVxeComponent({
                 const isShiftKey = evnt.shiftKey;
                 const isAltKey = evnt.altKey;
                 const keyCode = evnt.keyCode;
-                const isEsc = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ESCAPE);
-                const isUpArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_UP);
-                const isDwArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_DOWN);
+                const isEsc = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ESCAPE);
+                const isUpArrow = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_UP);
+                const isDwArrow = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_DOWN);
                 if (!isControlKey && !isShiftKey && !isAltKey) {
-                    if (globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.SPACEBAR) || (type === 'integer' && keyCode === 110) || ((!exponential || keyCode !== 69) && (keyCode >= 65 && keyCode <= 90)) || (keyCode >= 186 && keyCode <= 188) || keyCode >= 191) {
+                    if (globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.SPACEBAR) || (type === 'integer' && keyCode === 110) || ((!exponential || keyCode !== 69) && (keyCode >= 65 && keyCode <= 90)) || (keyCode >= 186 && keyCode <= 188) || keyCode >= 191) {
                         evnt.preventDefault();
                     }
                 }
@@ -10783,10 +10783,10 @@ var VxeInputComponent = defineVxeComponent({
             const { isActivated, datePanelValue, datePanelType } = reactData;
             if (isActivated) {
                 evnt.preventDefault();
-                const isLeftArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_LEFT);
-                const isUpArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_UP);
-                const isRightArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_RIGHT);
-                const isDwArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_DOWN);
+                const isLeftArrow = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_LEFT);
+                const isUpArrow = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_UP);
+                const isRightArrow = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_RIGHT);
+                const isDwArrow = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_DOWN);
                 if (datePanelType === 'year') {
                     let offsetYear = XEUtils.getWhatYear(datePanelValue || Date.now(), 0, 'first');
                     if (isLeftArrow) {
@@ -10857,7 +10857,7 @@ var VxeInputComponent = defineVxeComponent({
         const datePgOffsetEvent = (evnt) => {
             const { isActivated } = reactData;
             if (isActivated) {
-                const isPgUp = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.PAGE_UP);
+                const isPgUp = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.PAGE_UP);
                 evnt.preventDefault();
                 if (isPgUp) {
                     datePrevEvent(evnt);
@@ -11043,16 +11043,16 @@ var VxeInputComponent = defineVxeComponent({
             const isDisabled = computeIsDisabled.value;
             const isDatePickerType = computeIsDatePickerType.value;
             if (!isDisabled) {
-                const isTab = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.TAB);
-                const isDel = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.DELETE);
-                const isEsc = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ESCAPE);
-                const isEnter = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ENTER);
-                const isLeftArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_LEFT);
-                const isUpArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_UP);
-                const isRightArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_RIGHT);
-                const isDwArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_DOWN);
-                const isPgUp = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.PAGE_UP);
-                const isPgDn = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.PAGE_DOWN);
+                const isTab = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.TAB);
+                const isDel = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.DELETE);
+                const isEsc = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ESCAPE);
+                const isEnter = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ENTER);
+                const isLeftArrow = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_LEFT);
+                const isUpArrow = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_UP);
+                const isRightArrow = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_RIGHT);
+                const isDwArrow = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_DOWN);
+                const isPgUp = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.PAGE_UP);
+                const isPgDn = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.PAGE_DOWN);
                 const operArrow = isLeftArrow || isUpArrow || isRightArrow || isDwArrow;
                 let isActivated = reactData.isActivated;
                 if (isTab) {
@@ -11911,22 +11911,22 @@ var VxeInputComponent = defineVxeComponent({
         onMounted(() => {
             const { type } = props;
             if (['date', 'time', 'datetime', 'week', 'month', 'quarter', 'year'].includes(type)) {
-                warnLog$f('vxe.error.useNew', [`<vxe-input type="${type}" ... />`, `<vxe-date-picker type="${type}" ... />`]);
+                warnLog$g('vxe.error.useNew', [`<vxe-input type="${type}" ... />`, `<vxe-date-picker type="${type}" ... />`]);
             }
             else if (['number', 'integer', 'float'].includes(type)) {
-                warnLog$f('vxe.error.useNew', [`<vxe-input type="${type}" ... />`, `<vxe-number-input type="${type}" ... />`]);
+                warnLog$g('vxe.error.useNew', [`<vxe-input type="${type}" ... />`, `<vxe-number-input type="${type}" ... />`]);
             }
             else if (['password'].includes(type)) {
-                warnLog$f('vxe.error.useNew', [`<vxe-input type="${type}" ... />`, '<vxe-password-input ... />']);
+                warnLog$g('vxe.error.useNew', [`<vxe-input type="${type}" ... />`, '<vxe-password-input ... />']);
             }
             const inputElem = refInputTarget.value;
             if (inputElem) {
                 inputElem.addEventListener('wheel', wheelEvent, { passive: false });
             }
-            globalEvents.on($xeInput, 'mousewheel', handleGlobalMousewheelEvent);
-            globalEvents.on($xeInput, 'mousedown', handleGlobalMousedownEvent);
-            globalEvents.on($xeInput, 'keydown', handleGlobalKeydownEvent);
-            globalEvents.on($xeInput, 'blur', handleGlobalBlurEvent);
+            globalEvents$1.on($xeInput, 'mousewheel', handleGlobalMousewheelEvent);
+            globalEvents$1.on($xeInput, 'mousedown', handleGlobalMousedownEvent);
+            globalEvents$1.on($xeInput, 'keydown', handleGlobalKeydownEvent);
+            globalEvents$1.on($xeInput, 'blur', handleGlobalBlurEvent);
             updateDomValue();
         });
         onBeforeUnmount(() => {
@@ -11936,10 +11936,10 @@ var VxeInputComponent = defineVxeComponent({
             if (inputElem) {
                 inputElem.removeEventListener('wheel', wheelEvent);
             }
-            globalEvents.off($xeInput, 'mousewheel');
-            globalEvents.off($xeInput, 'mousedown');
-            globalEvents.off($xeInput, 'keydown');
-            globalEvents.off($xeInput, 'blur');
+            globalEvents$1.off($xeInput, 'mousewheel');
+            globalEvents$1.off($xeInput, 'mousedown');
+            globalEvents$1.off($xeInput, 'keydown');
+            globalEvents$1.off($xeInput, 'blur');
         });
         initValue();
         $xeInput.renderVN = renderVN;
@@ -13708,16 +13708,16 @@ var VxeCascaderComponent = defineVxeComponent({
         });
         loadData(props.options || []);
         onMounted(() => {
-            globalEvents.on($xeCascader, 'mousedown', handleGlobalMousedownEvent);
-            globalEvents.on($xeCascader, 'blur', handleGlobalBlurEvent);
-            globalEvents.on($xeCascader, 'resize', handleGlobalResizeEvent);
-            globalEvents.on($xeCascader, 'scroll', handleGlobalScrollEvent);
+            globalEvents$1.on($xeCascader, 'mousedown', handleGlobalMousedownEvent);
+            globalEvents$1.on($xeCascader, 'blur', handleGlobalBlurEvent);
+            globalEvents$1.on($xeCascader, 'resize', handleGlobalResizeEvent);
+            globalEvents$1.on($xeCascader, 'scroll', handleGlobalScrollEvent);
         });
         onUnmounted(() => {
-            globalEvents.off($xeCascader, 'mousedown');
-            globalEvents.off($xeCascader, 'blur');
-            globalEvents.off($xeCascader, 'resize');
-            globalEvents.off($xeCascader, 'scroll');
+            globalEvents$1.off($xeCascader, 'mousedown');
+            globalEvents$1.off($xeCascader, 'blur');
+            globalEvents$1.off($xeCascader, 'resize');
+            globalEvents$1.off($xeCascader, 'scroll');
             XEUtils.assign(reactData, createReactData$m());
             XEUtils.assign(internalData, createInternalData$l());
         });
@@ -13739,7 +13739,7 @@ dynamicApp.use(VxeCascader);
 VxeUI.component(VxeCascaderComponent);
 const Cascader = VxeCascader;
 
-const { warnLog: warnLog$e } = createComponentLog('checkbox');
+const { warnLog: warnLog$f } = createComponentLog('checkbox');
 var VxeCheckboxComponent = defineVxeComponent({
     name: 'VxeCheckbox',
     props: {
@@ -13900,7 +13900,7 @@ var VxeCheckboxComponent = defineVxeComponent({
         };
         onMounted(() => {
             if (props.label !== null) {
-                warnLog$e('vxe.error.delProp', ['label', 'checked-value']);
+                warnLog$f('vxe.error.delProp', ['label', 'checked-value']);
             }
         });
         $xeCheckbox.renderVN = renderVN;
@@ -13920,7 +13920,7 @@ dynamicApp.use(VxeCheckbox);
 VxeUI.component(VxeCheckboxComponent);
 const Checkbox = VxeCheckbox;
 
-const { warnLog: warnLog$d } = createComponentLog('checkbox-button');
+const { warnLog: warnLog$e } = createComponentLog('checkbox-button');
 var VxeCheckboxButtonComponent = defineVxeComponent({
     name: 'VxeCheckboxButton',
     props: {
@@ -14106,7 +14106,7 @@ var VxeCheckboxButtonComponent = defineVxeComponent({
         };
         onMounted(() => {
             if (props.label !== null) {
-                warnLog$d('vxe.error.delProp', ['label', 'checked-value']);
+                warnLog$e('vxe.error.delProp', ['label', 'checked-value']);
             }
         });
         $xeCheckboxButton.renderVN = renderVN;
@@ -14362,6 +14362,7 @@ dynamicApp.use(VxeCheckboxGroup);
 VxeUI.component(VxeCheckboxGroupComponent);
 const CheckboxGroup = VxeCheckboxGroup;
 
+const { errLog: errLog$i } = createComponentLog('col');
 var VxeColComponent = defineVxeComponent({
     name: 'VxeCol',
     props: {
@@ -14402,27 +14403,33 @@ var VxeColComponent = defineVxeComponent({
             const { width } = props;
             const rowGutter = computeRowGutter.value;
             const rowVertical = computeRowVertical.value;
+            let gridLayout = false;
+            if ($xeRow) {
+                gridLayout = !!$xeRow.props.gridLayout;
+            }
             const style = {};
-            if (rowGutter) {
-                let [lrGutter, tbGutter] = XEUtils.isArray(rowGutter) ? rowGutter : [rowGutter];
-                if (rowVertical) {
-                    tbGutter = lrGutter;
-                    lrGutter = '';
-                }
-                if (lrGutter) {
-                    const padding = XEUtils.isNumber(lrGutter) ? toCssUnit(lrGutter / 2) : `calc(${toCssUnit(lrGutter)} / 2)`;
-                    style.paddingLeft = padding;
-                    style.paddingRight = padding;
+            if (!gridLayout) {
+                if (rowGutter) {
+                    let [lrGutter, tbGutter] = XEUtils.isArray(rowGutter) ? rowGutter : [rowGutter];
+                    if (rowVertical) {
+                        tbGutter = lrGutter;
+                        lrGutter = '';
+                    }
+                    if (lrGutter) {
+                        const padding = XEUtils.isNumber(lrGutter) ? toCssUnit(lrGutter / 2) : `calc(${toCssUnit(lrGutter)} / 2)`;
+                        style.paddingLeft = padding;
+                        style.paddingRight = padding;
+                    }
+                    if (tbGutter) {
+                        const padding = XEUtils.isNumber(tbGutter) ? toCssUnit(tbGutter / 2) : `calc(${toCssUnit(tbGutter)} / 2)`;
+                        style.paddingTop = padding;
+                        style.paddingBottom = padding;
+                    }
                 }
-                if (tbGutter) {
-                    const padding = XEUtils.isNumber(tbGutter) ? toCssUnit(tbGutter / 2) : `calc(${toCssUnit(tbGutter)} / 2)`;
-                    style.paddingTop = padding;
-                    style.paddingBottom = padding;
+                if (width) {
+                    style.width = toCssUnit(width);
                 }
             }
-            if (width) {
-                style.width = toCssUnit(width);
-            }
             return style;
         });
         const computeMaps = {};
@@ -14461,6 +14468,19 @@ var VxeColComponent = defineVxeComponent({
                 }, defaultSlot ? defaultSlot({}) : [])
             ]);
         };
+        onMounted(() => {
+            const { width, fill } = props;
+            if ($xeRow) {
+                if ($xeRow.props.gridLayout) {
+                    if (width) {
+                        errLog$i('vxe.error.notSupportProp', ['grid-layout', `width=${width}`, 'width=null']);
+                    }
+                    if (fill) {
+                        errLog$i('vxe.error.notSupportProp', ['grid-layout', `fill=${fill}`, 'fill=false']);
+                    }
+                }
+            }
+        });
         $xeCol.renderVN = renderVN;
         return $xeCol;
     },
@@ -15959,8 +15979,8 @@ var VxeNumberInputComponent = defineVxeComponent({
             dispatchEvent('prev-number', { value: reactData.inputValue }, evnt);
         };
         const numberKeydownEvent = (evnt) => {
-            const isUpArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_UP);
-            const isDwArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_DOWN);
+            const isUpArrow = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_UP);
+            const isDwArrow = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_DOWN);
             if (isUpArrow || isDwArrow) {
                 evnt.preventDefault();
                 if (isUpArrow) {
@@ -16018,11 +16038,11 @@ var VxeNumberInputComponent = defineVxeComponent({
             const isAltKey = evnt.altKey;
             const key = evnt.key;
             const keyCode = evnt.keyCode;
-            const isEsc = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ESCAPE);
-            const isUpArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_UP);
-            const isDwArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_DOWN);
+            const isEsc = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ESCAPE);
+            const isUpArrow = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_UP);
+            const isDwArrow = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_DOWN);
             if (!isControlKey && !isShiftKey && !isAltKey) {
-                if (globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.SPACEBAR) ||
+                if (globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.SPACEBAR) ||
                     (!negative && key === '-') ||
                     (type === 'integer' && key === '.') ||
                     ((!exponential || keyCode !== 69) && (keyCode >= 65 && keyCode <= 90)) ||
@@ -16166,8 +16186,8 @@ var VxeNumberInputComponent = defineVxeComponent({
             const isDisabled = computeIsDisabled.value;
             const inputReadonly = computeInputReadonly.value;
             if (!isDisabled && !inputReadonly) {
-                const isTab = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.TAB);
-                const isDel = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.DELETE);
+                const isTab = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.TAB);
+                const isDel = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.DELETE);
                 let isActivated = reactData.isActivated;
                 if (isTab) {
                     if (isActivated) {
@@ -16469,9 +16489,9 @@ var VxeNumberInputComponent = defineVxeComponent({
             if (targetElem) {
                 targetElem.addEventListener('wheel', wheelEvent, { passive: false });
             }
-            globalEvents.on($xeNumberInput, 'mousedown', handleGlobalMousedownEvent);
-            globalEvents.on($xeNumberInput, 'keydown', handleGlobalKeydownEvent);
-            globalEvents.on($xeNumberInput, 'blur', handleGlobalBlurEvent);
+            globalEvents$1.on($xeNumberInput, 'mousedown', handleGlobalMousedownEvent);
+            globalEvents$1.on($xeNumberInput, 'keydown', handleGlobalKeydownEvent);
+            globalEvents$1.on($xeNumberInput, 'blur', handleGlobalBlurEvent);
         });
         onBeforeUnmount(() => {
             reactData.isFocus = false;
@@ -16481,9 +16501,9 @@ var VxeNumberInputComponent = defineVxeComponent({
             if (targetElem) {
                 targetElem.removeEventListener('wheel', wheelEvent);
             }
-            globalEvents.off($xeNumberInput, 'mousedown');
-            globalEvents.off($xeNumberInput, 'keydown');
-            globalEvents.off($xeNumberInput, 'blur');
+            globalEvents$1.off($xeNumberInput, 'mousedown');
+            globalEvents$1.off($xeNumberInput, 'keydown');
+            globalEvents$1.off($xeNumberInput, 'blur');
         });
         initValue();
         return $xeNumberInput;
@@ -17543,16 +17563,16 @@ var VxeColorPickerComponent = defineVxeComponent({
             updateType();
         });
         onMounted(() => {
-            globalEvents.on($xeColorPicker, 'mousedown', handleGlobalMousedownEvent);
-            globalEvents.on($xeColorPicker, 'blur', handleGlobalBlurEvent);
-            globalEvents.on($xeColorPicker, 'resize', handleGlobalResizeEvent);
-            globalEvents.on($xeColorPicker, 'scroll', handleGlobalScrollEvent);
+            globalEvents$1.on($xeColorPicker, 'mousedown', handleGlobalMousedownEvent);
+            globalEvents$1.on($xeColorPicker, 'blur', handleGlobalBlurEvent);
+            globalEvents$1.on($xeColorPicker, 'resize', handleGlobalResizeEvent);
+            globalEvents$1.on($xeColorPicker, 'scroll', handleGlobalScrollEvent);
         });
         onUnmounted(() => {
-            globalEvents.off($xeColorPicker, 'mousedown');
-            globalEvents.off($xeColorPicker, 'blur');
-            globalEvents.off($xeColorPicker, 'resize');
-            globalEvents.off($xeColorPicker, 'scroll');
+            globalEvents$1.off($xeColorPicker, 'mousedown');
+            globalEvents$1.off($xeColorPicker, 'blur');
+            globalEvents$1.off($xeColorPicker, 'resize');
+            globalEvents$1.off($xeColorPicker, 'scroll');
         });
         updateType();
         provide('$xeColorPicker', $xeColorPicker);
@@ -17950,12 +17970,12 @@ var VxeContextMenuComponent = defineVxeComponent({
             const { visible, activeOption, activeChildOption } = reactData;
             const allFirstMenuList = computeAllFirstMenuList.value;
             if (visible) {
-                const isUpArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_UP);
-                const isDwArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_DOWN);
-                const isLeftArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_LEFT);
-                const isRightArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_RIGHT);
-                const isEnter = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ENTER);
-                const isEsc = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ESCAPE);
+                const isUpArrow = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_UP);
+                const isDwArrow = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_DOWN);
+                const isLeftArrow = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_LEFT);
+                const isRightArrow = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_RIGHT);
+                const isEnter = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ENTER);
+                const isEsc = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ESCAPE);
                 if (isEsc) {
                     closeMenu();
                     return;
@@ -18188,20 +18208,20 @@ var VxeContextMenuComponent = defineVxeComponent({
         });
         handleVisible();
         onMounted(() => {
-            globalEvents.on($xeContextMenu, 'mousewheel', handleGlobalMousewheelEvent);
-            globalEvents.on($xeContextMenu, 'keydown', handleGlobalKeydownEvent);
-            globalEvents.on($xeContextMenu, 'mousedown', handleGlobalMousedownEvent);
-            globalEvents.on($xeContextMenu, 'blur', handleGlobalBlurEvent);
+            globalEvents$1.on($xeContextMenu, 'mousewheel', handleGlobalMousewheelEvent);
+            globalEvents$1.on($xeContextMenu, 'keydown', handleGlobalKeydownEvent);
+            globalEvents$1.on($xeContextMenu, 'mousedown', handleGlobalMousedownEvent);
+            globalEvents$1.on($xeContextMenu, 'blur', handleGlobalBlurEvent);
         });
         onBeforeUnmount(() => {
             const { leaveTime } = internalData;
             if (leaveTime) {
                 clearTimeout(leaveTime);
             }
-            globalEvents.off($xeContextMenu, 'mousewheel');
-            globalEvents.off($xeContextMenu, 'keydown');
-            globalEvents.off($xeContextMenu, 'mousedown');
-            globalEvents.off($xeContextMenu, 'blur');
+            globalEvents$1.off($xeContextMenu, 'mousewheel');
+            globalEvents$1.off($xeContextMenu, 'keydown');
+            globalEvents$1.off($xeContextMenu, 'mousedown');
+            globalEvents$1.off($xeContextMenu, 'blur');
             XEUtils.assign(reactData, createReactData$j());
             XEUtils.assign(internalData, createInternalData$i());
         });
@@ -20525,7 +20545,7 @@ dynamicApp.use(VxeDatePanel);
 VxeUI.component(VxeDatePanelComponent);
 const DatePanel = VxeDatePanel;
 
-const { warnLog: warnLog$c, errLog: errLog$f } = createComponentLog('date-picker');
+const { warnLog: warnLog$d, errLog: errLog$f } = createComponentLog('date-picker');
 const defaultMaskPlaceholder = '_';
 const maskedTypes = ['year', 'month', 'date', 'datetime', 'time'];
 const inputMaskedKeys = ['y', 'M', 'd', 'H', 'm', 'n', 's'];
@@ -21266,8 +21286,8 @@ var VxeDatePickerComponent = defineVxeComponent({
             }
             evnt.preventDefault();
             const eKey = evnt.key;
-            const isDeleleKey = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.DELETE);
-            const isBackspaceKey = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.BACKSPACE);
+            const isDeleleKey = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.DELETE);
+            const isBackspaceKey = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.BACKSPACE);
             const isNumKey = eKey >= '0' && eKey <= '9';
             const numKey = isNumKey ? evnt.key : '';
             if (!(isDeleleKey || isBackspaceKey || isNumKey)) {
@@ -21536,11 +21556,11 @@ var VxeDatePickerComponent = defineVxeComponent({
             const { type, editable, maskedConfig } = props;
             const { visiblePanel } = reactData;
             const maskedOpts = computeMaskedOpts.value;
-            const isUpArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_UP);
-            const isDwArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_DOWN);
-            const isLtArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_LEFT);
-            const isRtArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_RIGHT);
-            const isEnter = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ENTER);
+            const isUpArrow = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_UP);
+            const isDwArrow = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_DOWN);
+            const isLtArrow = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_LEFT);
+            const isRtArrow = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_RIGHT);
+            const isEnter = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ENTER);
             if (editable) {
                 if (isEnter) {
                     const { inputLabel } = internalData;
@@ -21613,8 +21633,8 @@ var VxeDatePickerComponent = defineVxeComponent({
             const { isActivated, visiblePanel } = reactData;
             const isDisabled = computeIsDisabled.value;
             if (!isDisabled) {
-                const isTab = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.TAB);
-                const isEsc = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ESCAPE);
+                const isTab = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.TAB);
+                const isEsc = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ESCAPE);
                 if (isTab) {
                     if (isActivated) {
                         reactData.isActivated = false;
@@ -22130,11 +22150,11 @@ var VxeDatePickerComponent = defineVxeComponent({
         });
         updateModelValue();
         nextTick(() => {
-            globalEvents.on($xeDatePicker, 'mousedown', handleGlobalMousedownEvent);
-            globalEvents.on($xeDatePicker, 'keydown', handleGlobalKeydownEvent);
-            globalEvents.on($xeDatePicker, 'blur', handleGlobalBlurEvent);
-            globalEvents.on($xeDatePicker, 'resize', handleGlobalResizeEvent);
-            globalEvents.on($xeDatePicker, 'scroll', handleGlobalScrollEvent);
+            globalEvents$1.on($xeDatePicker, 'mousedown', handleGlobalMousedownEvent);
+            globalEvents$1.on($xeDatePicker, 'keydown', handleGlobalKeydownEvent);
+            globalEvents$1.on($xeDatePicker, 'blur', handleGlobalBlurEvent);
+            globalEvents$1.on($xeDatePicker, 'resize', handleGlobalResizeEvent);
+            globalEvents$1.on($xeDatePicker, 'scroll', handleGlobalScrollEvent);
         });
         onMounted(() => {
             const { type, multiple, maskedConfig } = props;
@@ -22143,16 +22163,16 @@ var VxeDatePickerComponent = defineVxeComponent({
                     errLog$f('vxe.error.notSupportProp', ['multiple', 'masked-config.enabled=true', 'masked-config.enabled=false']);
                 }
                 if (!maskedTypes.includes(type)) {
-                    warnLog$c('vxe.error.notSupportProp', ['masked-config.enabled=true', `type=${type}`, `type=${maskedTypes.join('|')}`]);
+                    warnLog$d('vxe.error.notSupportProp', ['masked-config.enabled=true', `type=${type}`, `type=${maskedTypes.join('|')}`]);
                 }
             }
         });
         onUnmounted(() => {
-            globalEvents.off($xeDatePicker, 'mousedown');
-            globalEvents.off($xeDatePicker, 'keydown');
-            globalEvents.off($xeDatePicker, 'blur');
-            globalEvents.off($xeDatePicker, 'resize');
-            globalEvents.off($xeDatePicker, 'scroll');
+            globalEvents$1.off($xeDatePicker, 'mousedown');
+            globalEvents$1.off($xeDatePicker, 'keydown');
+            globalEvents$1.off($xeDatePicker, 'blur');
+            globalEvents$1.off($xeDatePicker, 'resize');
+            globalEvents$1.off($xeDatePicker, 'scroll');
             XEUtils.assign(reactData, createReactData$i());
             XEUtils.assign(internalData, createInternalData$h());
         });
@@ -23084,8 +23104,8 @@ var VxeDateRangePickerComponent = defineVxeComponent({
             const { visiblePanel } = reactData;
             const isDisabled = computeIsDisabled.value;
             if (!isDisabled) {
-                const isTab = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.TAB);
-                const isEsc = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ESCAPE);
+                const isTab = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.TAB);
+                const isEsc = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ESCAPE);
                 if (isTab) {
                     reactData.isActivated = false;
                 }
@@ -23654,11 +23674,11 @@ var VxeDateRangePickerComponent = defineVxeComponent({
         });
         updateModelValue(true);
         nextTick(() => {
-            globalEvents.on($xeDateRangePicker, 'mousedown', handleGlobalMousedownEvent);
-            globalEvents.on($xeDateRangePicker, 'keydown', handleGlobalKeydownEvent);
-            globalEvents.on($xeDateRangePicker, 'blur', handleGlobalBlurEvent);
-            globalEvents.on($xeDateRangePicker, 'resize', handleGlobalResizeEvent);
-            globalEvents.on($xeDateRangePicker, 'scroll', handleGlobalScrollEvent);
+            globalEvents$1.on($xeDateRangePicker, 'mousedown', handleGlobalMousedownEvent);
+            globalEvents$1.on($xeDateRangePicker, 'keydown', handleGlobalKeydownEvent);
+            globalEvents$1.on($xeDateRangePicker, 'blur', handleGlobalBlurEvent);
+            globalEvents$1.on($xeDateRangePicker, 'resize', handleGlobalResizeEvent);
+            globalEvents$1.on($xeDateRangePicker, 'scroll', handleGlobalScrollEvent);
         });
         onDeactivated(() => {
             checkValue();
@@ -23667,11 +23687,11 @@ var VxeDateRangePickerComponent = defineVxeComponent({
             checkValue();
         });
         onUnmounted(() => {
-            globalEvents.off($xeDateRangePicker, 'mousedown');
-            globalEvents.off($xeDateRangePicker, 'keydown');
-            globalEvents.off($xeDateRangePicker, 'blur');
-            globalEvents.off($xeDateRangePicker, 'resize');
-            globalEvents.off($xeDateRangePicker, 'scroll');
+            globalEvents$1.off($xeDateRangePicker, 'mousedown');
+            globalEvents$1.off($xeDateRangePicker, 'keydown');
+            globalEvents$1.off($xeDateRangePicker, 'blur');
+            globalEvents$1.off($xeDateRangePicker, 'resize');
+            globalEvents$1.off($xeDateRangePicker, 'scroll');
             XEUtils.assign(reactData, createReactData$h());
             XEUtils.assign(internalData, createInternalData$g());
         });
@@ -24119,7 +24139,7 @@ var VxeDrawerComponent = defineVxeComponent({
             }
         };
         const handleGlobalKeydownEvent = (evnt) => {
-            const isEsc = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ESCAPE);
+            const isEsc = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ESCAPE);
             if (isEsc) {
                 const lastDrawer = XEUtils.max(allActiveDrawers, (item) => item.reactData.drawerZIndex);
                 // 多个时，只关掉最上层的窗口
@@ -24441,11 +24461,11 @@ var VxeDrawerComponent = defineVxeComponent({
                 recalculate();
             });
             if (props.escClosable) {
-                globalEvents.on($xeDrawer, 'keydown', handleGlobalKeydownEvent);
+                globalEvents$1.on($xeDrawer, 'keydown', handleGlobalKeydownEvent);
             }
         });
         onUnmounted(() => {
-            globalEvents.off($xeDrawer, 'keydown');
+            globalEvents$1.off($xeDrawer, 'keydown');
             removeActiveQueue();
         });
         provide('$xeDrawer', $xeDrawer);
@@ -25876,7 +25896,7 @@ renderer.mixin({
     // 以上已废弃
 });
 
-const { warnLog: warnLog$b, errLog: errLog$b } = createComponentLog('form');
+const { warnLog: warnLog$c, errLog: errLog$b } = createComponentLog('form');
 class Rule {
     constructor(rule) {
         Object.assign(this, {
@@ -26437,7 +26457,7 @@ var VxeFormComponent = defineVxeComponent({
                                                 customValid = validatorMethod(validParams);
                                             }
                                             else {
-                                                warnLog$b('vxe.error.notValidators', [validator]);
+                                                warnLog$c('vxe.error.notValidators', [validator]);
                                             }
                                         }
                                         else {
@@ -26836,10 +26856,10 @@ var VxeFormComponent = defineVxeComponent({
                     errLog$b('vxe.error.errConflicts', ['custom-layout', 'items']);
                 }
             });
-            globalEvents.on($xeForm, 'resize', handleGlobalResizeEvent);
+            globalEvents$1.on($xeForm, 'resize', handleGlobalResizeEvent);
         });
         onUnmounted(() => {
-            globalEvents.off($xeForm, 'resize');
+            globalEvents$1.off($xeForm, 'resize');
             XEUtils.assign(reactData, createReactData$g());
             XEUtils.assign(internalData, createInternalData$f());
         });
@@ -27312,13 +27332,13 @@ var VxeIconPickerComponent = defineVxeComponent({
             const { visiblePanel } = reactData;
             const isDisabled = computeIsDisabled.value;
             if (!isDisabled) {
-                const isTab = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.TAB);
-                const isEnter = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ENTER);
-                const isEsc = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ESCAPE);
-                const isUpArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_UP);
-                const isDwArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_DOWN);
-                const isDel = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.DELETE);
-                const isSpacebar = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.SPACEBAR);
+                const isTab = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.TAB);
+                const isEnter = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ENTER);
+                const isEsc = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ESCAPE);
+                const isUpArrow = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_UP);
+                const isDwArrow = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_DOWN);
+                const isDel = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.DELETE);
+                const isSpacebar = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.SPACEBAR);
                 if (isTab) {
                     reactData.isActivated = false;
                 }
@@ -27643,19 +27663,19 @@ var VxeIconPickerComponent = defineVxeComponent({
             handleData();
         });
         onMounted(() => {
-            globalEvents.on($xeIconPicker, 'mousedown', handleGlobalMousedownEvent);
-            globalEvents.on($xeIconPicker, 'keydown', handleGlobalKeydownEvent);
-            globalEvents.on($xeIconPicker, 'blur', handleGlobalBlurEvent);
-            globalEvents.on($xeIconPicker, 'resize', handleGlobalResizeEvent);
-            globalEvents.on($xeIconPicker, 'scroll', handleGlobalScrollEvent);
+            globalEvents$1.on($xeIconPicker, 'mousedown', handleGlobalMousedownEvent);
+            globalEvents$1.on($xeIconPicker, 'keydown', handleGlobalKeydownEvent);
+            globalEvents$1.on($xeIconPicker, 'blur', handleGlobalBlurEvent);
+            globalEvents$1.on($xeIconPicker, 'resize', handleGlobalResizeEvent);
+            globalEvents$1.on($xeIconPicker, 'scroll', handleGlobalScrollEvent);
         });
         onBeforeUnmount(() => {
-            globalEvents.off($xeIconPicker, 'mousewheel');
-            globalEvents.off($xeIconPicker, 'mousedown');
-            globalEvents.off($xeIconPicker, 'keydown');
-            globalEvents.off($xeIconPicker, 'blur');
-            globalEvents.off($xeIconPicker, 'resize');
-            globalEvents.off($xeIconPicker, 'scroll');
+            globalEvents$1.off($xeIconPicker, 'mousewheel');
+            globalEvents$1.off($xeIconPicker, 'mousedown');
+            globalEvents$1.off($xeIconPicker, 'keydown');
+            globalEvents$1.off($xeIconPicker, 'blur');
+            globalEvents$1.off($xeIconPicker, 'resize');
+            globalEvents$1.off($xeIconPicker, 'scroll');
             XEUtils.assign(reactData, createReactData$f());
             XEUtils.assign(internalData, createInternalData$e());
         });
@@ -28077,12 +28097,12 @@ var VxeImagePreviewComponent = defineVxeComponent({
         const handleGlobalKeydownEvent = (evnt) => {
             const isControlKey = hasControlKey(evnt);
             const hasShiftKey = evnt.shiftKey;
-            const isUpArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_UP);
-            const isDownArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_DOWN);
-            const isLeftArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_LEFT);
-            const isRightArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_RIGHT);
-            const isR = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.R);
-            const isP = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.P);
+            const isUpArrow = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_UP);
+            const isDownArrow = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_DOWN);
+            const isLeftArrow = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_LEFT);
+            const isRightArrow = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_RIGHT);
+            const isR = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.R);
+            const isP = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.P);
             if (isUpArrow) {
                 evnt.preventDefault();
                 if (hasShiftKey) {
@@ -28289,7 +28309,7 @@ var VxeImagePreviewComponent = defineVxeComponent({
             if (elem) {
                 elem.addEventListener('wheel', wheelEvent, { passive: false });
             }
-            globalEvents.on($xeImagePreview, 'keydown', handleGlobalKeydownEvent);
+            globalEvents$1.on($xeImagePreview, 'keydown', handleGlobalKeydownEvent);
         });
         onBeforeUnmount(() => {
             const elem = refElem.value;
@@ -28299,7 +28319,7 @@ var VxeImagePreviewComponent = defineVxeComponent({
             }
         });
         onUnmounted(() => {
-            globalEvents.off($xeImagePreview, 'keydown');
+            globalEvents$1.off($xeImagePreview, 'keydown');
         });
         provide('$xeImagePreview', $xeImagePreview);
         $xeImagePreview.renderVN = renderVN;
@@ -28836,7 +28856,7 @@ function getScrollFromDrag(pointerPosition, dragOffset, viewportSize, contentSiz
     return (thumbOffset / maxThumbOffset) * maxScroll;
 }
 
-const { getConfig: getConfig$2, createEvent, domUtils, globalResize, renderEmptyElement } = VxeUI;
+const { getConfig: getConfig$2, createEvent, domUtils, globalResize, globalEvents, renderEmptyElement } = VxeUI;
 function createReactData$d() {
     return {
         yThumbHeight: 0,
@@ -29383,9 +29403,7 @@ var VxeScrollbarComponent = defineVxeComponent({
             reFlag.value++;
         });
         watch(reFlag, () => {
-            $xeScrollbar.recalculate().then(() => {
-                $xeScrollbar.recalculate();
-            });
+            $xeScrollbar.recalculate();
         });
         onMounted(() => {
             const { autoResize } = props;
@@ -29406,12 +29424,16 @@ var VxeScrollbarComponent = defineVxeComponent({
                 internalData.resizeObserver = resizeObserver;
             }
             reFlag.value++;
+            globalEvents.on($xeScrollbar, 'resize', () => {
+                reFlag.value++;
+            });
         });
         onBeforeUnmount(() => {
             const { resizeObserver } = internalData;
             if (resizeObserver) {
                 resizeObserver.disconnect();
             }
+            globalEvents.off($xeScrollbar, 'resize');
         });
         $xeScrollbar.renderVN = renderVN;
         return $xeScrollbar;
@@ -30746,14 +30768,14 @@ var VxeMenuComponent = defineVxeComponent({
             if (menuConfig && !VxeUIContextMenu) {
                 errLog$a('vxe.error.reqComp', ['vxe-context-menu']);
             }
-            globalEvents.on($xeMenu, 'resize', updateCollapseStyle);
+            globalEvents$1.on($xeMenu, 'resize', updateCollapseStyle);
             updateCollapseStyle();
             nextTick(() => {
                 $xeMenu.scrollToActiveMenu();
             });
         });
         onBeforeUnmount(() => {
-            globalEvents.off($xeMenu, 'resize');
+            globalEvents$1.off($xeMenu, 'resize');
             XEUtils.assign(reactData, createReactData$b());
             XEUtils.assign(internalData, createInternalData$a());
         });
@@ -30780,7 +30802,7 @@ const Menu = VxeMenu;
 
 const allActiveModals = [];
 
-const { warnLog: warnLog$a, errLog: errLog$9 } = createComponentLog('modal');
+const { warnLog: warnLog$b, errLog: errLog$9 } = createComponentLog('modal');
 function createInternalData$9() {
     return {
         // msgTimeout: undefined,
@@ -31607,7 +31629,7 @@ var VxeModalComponent = defineVxeComponent({
             }
         };
         const handleGlobalKeydownEvent = (evnt) => {
-            const isEsc = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ESCAPE);
+            const isEsc = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ESCAPE);
             if (isEsc) {
                 const lastModal = XEUtils.max(allActiveModals.filter(item => item.reactData.zoomStatus !== 'minimize'), (item) => item.reactData.modalZindex);
                 // 多个时，只关掉最上层的窗口
@@ -32265,7 +32287,7 @@ var VxeModalComponent = defineVxeComponent({
         });
         onMounted(() => {
             if (props.type === 'modal' && props.showFooter && !(props.showConfirmButton || props.showCancelButton || slots.footer)) {
-                warnLog$a('vxe.modal.footPropErr');
+                warnLog$b('vxe.modal.footPropErr');
             }
             reactData.initialized = !!props.preload;
             nextTick(() => {
@@ -32278,13 +32300,13 @@ var VxeModalComponent = defineVxeComponent({
                 recalculate();
             });
             if (props.escClosable) {
-                globalEvents.on($xeModal, 'keydown', handleGlobalKeydownEvent);
+                globalEvents$1.on($xeModal, 'keydown', handleGlobalKeydownEvent);
             }
-            globalEvents.on($xeModal, 'resize', handleGlobalResizeEvent);
+            globalEvents$1.on($xeModal, 'resize', handleGlobalResizeEvent);
         });
         onUnmounted(() => {
-            globalEvents.off($xeModal, 'keydown');
-            globalEvents.off($xeModal, 'resize');
+            globalEvents$1.off($xeModal, 'keydown');
+            globalEvents$1.off($xeModal, 'resize');
             removeMsgQueue();
             removeActiveQueue();
             removeBodyLockScroll();
@@ -32553,11 +32575,11 @@ var VxeNoticeBarComponent = defineVxeComponent({
             updateAnimationStyle();
         });
         onMounted(() => {
-            globalEvents.on($xeNoticeBar, 'resize', updateAnimationStyle);
+            globalEvents$1.on($xeNoticeBar, 'resize', updateAnimationStyle);
             updateAnimationStyle();
         });
         onBeforeUnmount(() => {
-            globalEvents.off($xeNoticeBar, 'resize');
+            globalEvents$1.off($xeNoticeBar, 'resize');
         });
         $xeNoticeBar.renderVN = renderVN;
         return $xeNoticeBar;
@@ -33560,12 +33582,12 @@ var VxeSelectComponent = defineVxeComponent({
             const popupOpts = computePopupOpts.value;
             const { trigger } = popupOpts;
             if (!isDisabled) {
-                const isTab = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.TAB);
-                const isEnter = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ENTER);
-                const isEsc = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ESCAPE);
-                const isUpArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_UP);
-                const isDwArrow = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_DOWN);
-                const isDel = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.DELETE);
+                const isTab = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.TAB);
+                const isEnter = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ENTER);
+                const isEsc = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ESCAPE);
+                const isUpArrow = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_UP);
+                const isDwArrow = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_DOWN);
+                const isDel = globalEvents$1.hasKey(evnt, GLOBAL_EVENT_KEYS.DELETE);
                 if (isTab) {
                     reactData.isActivated = false;
                 }
@@ -34443,18 +34465,18 @@ var VxeSelectComponent = defineVxeComponent({
                     loadData(options);
                 }
             });
-            globalEvents.on($xeSelect, 'mousedown', handleGlobalMousedownEvent);
-            globalEvents.on($xeSelect, 'keydown', handleGlobalKeydownEvent);
-            globalEvents.on($xeSelect, 'blur', handleGlobalBlurEvent);
-            globalEvents.on($xeSelect, 'resize', handleGlobalResizeEvent);
-            globalEvents.on($xeSelect, 'scroll', handleGlobalScrollEvent);
+            globalEvents$1.on($xeSelect, 'mousedown', handleGlobalMousedownEvent);
+            globalEvents$1.on($xeSelect, 'keydown', handleGlobalKeydownEvent);
+            globalEvents$1.on($xeSelect, 'blur', handleGlobalBlurEvent);
+            globalEvents$1.on($xeSelect, 'resize', handleGlobalResizeEvent);
+            globalEvents$1.on($xeSelect, 'scroll', handleGlobalScrollEvent);
         });
         onUnmounted(() => {
-            globalEvents.off($xeSelect, 'mousedown');
-            globalEvents.off($xeSelect, 'keydown');
-            globalEvents.off($xeSelect, 'blur');
-            globalEvents.off($xeSelect, 'resize');
-            globalEvents.off($xeSelect, 'scroll');
+            globalEvents$1.off($xeSelect, 'mousedown');
+            globalEvents$1.off($xeSelect, 'keydown');
+            globalEvents$1.off($xeSelect, 'blur');
+            globalEvents$1.off($xeSelect, 'resize');
+            globalEvents$1.off($xeSelect, 'scroll');
             XEUtils.assign(reactData, createReactData$9());
             XEUtils.assign(internalData, createInternalData$8());
         });
@@ -34476,7 +34498,7 @@ dynamicApp.use(VxeSelect);
 VxeUI.component(VxeSelectComponent);
 const Select = VxeSelect;
 
-const { warnLog: warnLog$9, errLog: errLog$7 } = createComponentLog('pager');
+const { warnLog: warnLog$a, errLog: errLog$7 } = createComponentLog('pager');
 var VxePagerComponent = defineVxeComponent({
     name: 'VxePager',
     props: {
@@ -34687,14 +34709,14 @@ var VxePagerComponent = defineVxeComponent({
         };
         const jumpKeydownEvent = (params) => {
             const { $event } = params;
-            if (globalEvents.hasKey($event, GLOBAL_EVENT_KEYS.ENTER)) {
+            if (globalEvents$1.hasKey($event, GLOBAL_EVENT_KEYS.ENTER)) {
                 triggerJumpEvent(params);
             }
-            else if (globalEvents.hasKey($event, GLOBAL_EVENT_KEYS.ARROW_UP)) {
+            else if (globalEvents$1.hasKey($event, GLOBAL_EVENT_KEYS.ARROW_UP)) {
                 $event.preventDefault();
                 handleNextPage($event);
             }
-            else if (globalEvents.hasKey($event, GLOBAL_EVENT_KEYS.ARROW_DOWN)) {
+            else if (globalEvents$1.hasKey($event, GLOBAL_EVENT_KEYS.ARROW_DOWN)) {
                 $event.preventDefault();
                 handlePrevPage($event);
             }
@@ -35080,7 +35102,7 @@ var VxePagerComponent = defineVxeComponent({
              * @deprecated
              */
             jumpPage(currentPage) {
-                warnLog$9('vxe.error.delFunc', ['jumpPage', 'setCurrentPage']);
+                warnLog$a('vxe.error.delFunc', ['jumpPage', 'setCurrentPage']);
                 return $xePager.setCurrentPage(currentPage);
             }
         };
@@ -35635,7 +35657,7 @@ dynamicApp.use(VxePasswordInput);
 VxeUI.component(VxePasswordInputComponent);
 const PasswordInput = VxePasswordInput;
 
-const { warnLog: warnLog$8, errLog: errLog$6 } = createComponentLog('print');
+const { warnLog: warnLog$9, errLog: errLog$6 } = createComponentLog('print');
 // 打印
 let printFrame;
 // 默认导出或打印的 HTML 样式
@@ -35775,7 +35797,7 @@ function handlePrint(opts, printHtml = '') {
     if (styleUrls && styleUrls.length) {
         styleUrls.forEach(url => {
             if (!/.css$/.test(url)) {
-                warnLog$8('vxe.error.errProp', [url, `${url}.css`]);
+                warnLog$9('vxe.error.errProp', [url, `${url}.css`]);
             }
         });
     }
@@ -35789,7 +35811,7 @@ function handlePrint(opts, printHtml = '') {
             }
         }
         else {
-            warnLog$8('vxe.error.returnErr', ['beforePrintMethod', 'boolean', bpRest]);
+            warnLog$9('vxe.error.returnErr', ['beforePrintMethod', 'boolean', bpRest]);
             errLog$6('vxe.error.notSupportReturn', [bpRest, 'beforePrintMethod', 'printMethod']);
             printHtml = bpRest || '';
         }
@@ -36634,16 +36656,16 @@ var VxePulldownComponent = defineVxeComponent({
             if (props.modelValue) {
                 showPanel();
             }
-            globalEvents.on($xePulldown, 'mousedown', handleGlobalMousedownEvent);
-            globalEvents.on($xePulldown, 'blur', handleGlobalBlurEvent);
-            globalEvents.on($xePulldown, 'resize', handleGlobalResizeEvent);
-            globalEvents.on($xePulldown, 'scroll', handleGlobalScrollEvent);
+            globalEvents$1.on($xePulldown, 'mousedown', handleGlobalMousedownEvent);
+            globalEvents$1.on($xePulldown, 'blur', handleGlobalBlurEvent);
+            globalEvents$1.on($xePulldown, 'resize', handleGlobalResizeEvent);
+            globalEvents$1.on($xePulldown, 'scroll', handleGlobalScrollEvent);
         });
         onUnmounted(() => {
-            globalEvents.off($xePulldown, 'mousedown');
-            globalEvents.off($xePulldown, 'blur');
-            globalEvents.off($xePulldown, 'resize');
-            globalEvents.off($xePulldown, 'scroll');
+            globalEvents$1.off($xePulldown, 'mousedown');
+            globalEvents$1.off($xePulldown, 'blur');
+            globalEvents$1.off($xePulldown, 'resize');
+            globalEvents$1.off($xePulldown, 'scroll');
         });
         $xePulldown.renderVN = renderVN;
         return $xePulldown;
@@ -36662,7 +36684,7 @@ dynamicApp.use(VxePulldown);
 VxeUI.component(VxePulldownComponent);
 const Pulldown = VxePulldown;
 
-const { warnLog: warnLog$7 } = createComponentLog('radio');
+const { warnLog: warnLog$8 } = createComponentLog('radio');
 var VxeRadioComponent = defineVxeComponent({
     name: 'VxeRadio',
     props: {
@@ -36836,7 +36858,7 @@ var VxeRadioComponent = defineVxeComponent({
         };
         onMounted(() => {
             if (props.label !== null) {
-                warnLog$7('vxe.error.delProp', ['label', 'checked-value']);
+                warnLog$8('vxe.error.delProp', ['label', 'checked-value']);
             }
         });
         $xeRadio.renderVN = renderVN;
@@ -36856,7 +36878,7 @@ dynamicApp.use(VxeRadio);
 VxeUI.component(VxeRadioComponent);
 const Radio = VxeRadio;
 
-const { warnLog: warnLog$6 } = createComponentLog('radio-button');
+const { warnLog: warnLog$7 } = createComponentLog('radio-button');
 var VxeRadioButtonComponent = defineVxeComponent({
     name: 'VxeRadioButton',
     props: {
@@ -37058,7 +37080,7 @@ var VxeRadioButtonComponent = defineVxeComponent({
         };
         onMounted(() => {
             if (props.label !== null) {
-                warnLog$6('vxe.error.delProp', ['label', 'checked-value']);
+                warnLog$7('vxe.error.delProp', ['label', 'checked-value']);
             }
         });
         $xeRadioButton.renderVN = renderVN;
@@ -37559,9 +37581,14 @@ dynamicApp.use(VxeResult);
 VxeUI.component(VxeResultComponent);
 const Result = VxeResult;
 
+const { warnLog: warnLog$6 } = createComponentLog('row');
 var VxeRowComponent = defineVxeComponent({
     name: 'VxeRow',
     props: {
+        gridLayout: {
+            type: Boolean,
+            default: () => getConfig$4().row.gridLayout
+        },
         gutter: [Number, String, Array],
         wrap: {
             type: Boolean,
@@ -37586,23 +37613,29 @@ var VxeRowComponent = defineVxeComponent({
             refElem
         };
         const computeRowStyle = computed(() => {
-            const { gutter, vertical } = props;
+            const { gridLayout, gutter, vertical } = props;
             const style = {};
             if (gutter) {
                 let [lrGutter, tbGutter] = XEUtils.isArray(gutter) ? gutter : [gutter];
-                if (vertical) {
-                    tbGutter = lrGutter;
-                    lrGutter = '';
-                }
-                if (lrGutter) {
-                    const offsetSize = XEUtils.isNumber(lrGutter) ? toCssUnit(-(lrGutter / 2)) : `calc(${toCssUnit(lrGutter)} / 2 * -1)`;
-                    style.marginLeft = offsetSize;
-                    style.marginRight = offsetSize;
+                if (gridLayout) {
+                    style.columnGap = toCssUnit(lrGutter);
+                    style.rowGap = toCssUnit(tbGutter || lrGutter);
                 }
-                if (tbGutter) {
-                    const offsetSize = XEUtils.isNumber(tbGutter) ? toCssUnit(-(tbGutter / 2)) : `calc(${toCssUnit(tbGutter)} / 2 * -1)`;
-                    style.marginTop = offsetSize;
-                    style.marginBottom = offsetSize;
+                else {
+                    if (vertical) {
+                        tbGutter = lrGutter;
+                        lrGutter = '';
+                    }
+                    if (lrGutter) {
+                        const offsetSize = XEUtils.isNumber(lrGutter) ? toCssUnit(-(lrGutter / 2)) : `calc(${toCssUnit(lrGutter)} / 2 * -1)`;
+                        style.marginLeft = offsetSize;
+                        style.marginRight = offsetSize;
+                    }
+                    if (tbGutter) {
+                        const offsetSize = XEUtils.isNumber(tbGutter) ? toCssUnit(-(tbGutter / 2)) : `calc(${toCssUnit(tbGutter)} / 2 * -1)`;
+                        style.marginTop = offsetSize;
+                        style.marginBottom = offsetSize;
+                    }
                 }
             }
             return style;
@@ -37628,12 +37661,12 @@ var VxeRowComponent = defineVxeComponent({
         const rowPrivateMethods = {};
         Object.assign($xeRow, rowMethods, rowPrivateMethods);
         const renderVN = () => {
-            const { vertical, wrap } = props;
+            const { gridLayout, vertical, wrap } = props;
             const rowStyle = computeRowStyle.value;
             const defaultSlot = slots.default;
             return h('div', {
                 ref: refElem,
-                class: ['vxe-row', {
+                class: ['vxe-row', gridLayout ? 'grid--layout' : 'def--layout', {
                         'is--vertical': vertical,
                         'is--wrap': wrap
                     }],
@@ -37641,6 +37674,12 @@ var VxeRowComponent = defineVxeComponent({
                 onClick: clickEvent
             }, defaultSlot ? defaultSlot({}) : []);
         };
+        onMounted(() => {
+            const { gridLayout, wrap } = props;
+            if (gridLayout && !wrap) {
+                warnLog$6('vxe.error.notSupportProp', ['grid-layout', 'wrap=false', 'wrap=true']);
+            }
+        });
         provide('$xeRow', $xeRow);
         $xeRow.renderVN = renderVN;
         return $xeRow;
@@ -38831,13 +38870,13 @@ var VxeSplitComponent = defineVxeComponent({
             if (actionOpts.direction) {
                 errLog$5('vxe.error.delProp', ['action-config.direction', 'action-config.showPrevButton | action-config.showNextButton']);
             }
-            globalEvents.on($xeSplitter, 'resize', handleGlobalResizeEvent);
+            globalEvents$1.on($xeSplitter, 'resize', handleGlobalResizeEvent);
         });
         onUnmounted(() => {
             if (resizeObserver) {
                 resizeObserver.disconnect();
             }
-            globalEvents.off($xeSplitter, 'resize');
+            globalEvents$1.off($xeSplitter, 'resize');
         });
         onActivated(() => {
             recalculate();
@@ -40757,16 +40796,16 @@ var VxeTableSelectComponent = defineVxeComponent({
                     reactData.initialized = true;
                 }
             }
-            globalEvents.on($xeTableSelect, 'mousedown', handleGlobalMousedownEvent);
-            globalEvents.on($xeTableSelect, 'blur', handleGlobalBlurEvent);
-            globalEvents.on($xeTableSelect, 'resize', handleGlobalResizeEvent);
-            globalEvents.on($xeTableSelect, 'scroll', handleGlobalScrollEvent);
+            globalEvents$1.on($xeTableSelect, 'mousedown', handleGlobalMousedownEvent);
+            globalEvents$1.on($xeTableSelect, 'blur', handleGlobalBlurEvent);
+            globalEvents$1.on($xeTableSelect, 'resize', handleGlobalResizeEvent);
+            globalEvents$1.on($xeTableSelect, 'scroll', handleGlobalScrollEvent);
         });
         onUnmounted(() => {
-            globalEvents.off($xeTableSelect, 'mousedown');
-            globalEvents.off($xeTableSelect, 'blur');
-            globalEvents.off($xeTableSelect, 'resize');
-            globalEvents.off($xeTableSelect, 'scroll');
+            globalEvents$1.off($xeTableSelect, 'mousedown');
+            globalEvents$1.off($xeTableSelect, 'blur');
+            globalEvents$1.off($xeTableSelect, 'resize');
+            globalEvents$1.off($xeTableSelect, 'scroll');
             XEUtils.assign(reactData, createReactData$5());
             XEUtils.assign(internalData, createInternalData$5());
         });
@@ -41717,10 +41756,10 @@ var VxeTabsComponent = defineVxeComponent({
         });
         onMounted(() => {
             updateTabStyle();
-            globalEvents.on($xeTabs, 'resize', updateTabStyle);
+            globalEvents$1.on($xeTabs, 'resize', updateTabStyle);
         });
         onUnmounted(() => {
-            globalEvents.off($xeTabs, 'resize');
+            globalEvents$1.off($xeTabs, 'resize');
         });
         provide('$xeTabs', $xeTabs);
         addInitName(props.modelValue, null);
@@ -46440,14 +46479,14 @@ var VxeTreeComponent = defineVxeComponent({
                 internalData.resizeObserver = resizeObserver;
             }
             recalculate();
-            globalEvents.on($xeTree, 'resize', handleGlobalResizeEvent);
+            globalEvents$1.on($xeTree, 'resize', handleGlobalResizeEvent);
         });
         onBeforeUnmount(() => {
             const { resizeObserver } = internalData;
             if (resizeObserver) {
                 resizeObserver.disconnect();
             }
-            globalEvents.off($xeTree, 'resize');
+            globalEvents$1.off($xeTree, 'resize');
             XEUtils.assign(reactData, createReactData$2());
             XEUtils.assign(internalData, createInternalData$2());
         });
@@ -47439,16 +47478,16 @@ var VxeTreeSelectComponent = defineVxeComponent({
             if (XEUtils.isBoolean(props.autoClose)) {
                 warnLog$1('vxe.error.delProp', ['auto-close', 'checked-closable | clear-closable']);
             }
-            globalEvents.on($xeTreeSelect, 'mousedown', handleGlobalMousedownEvent);
-            globalEvents.on($xeTreeSelect, 'blur', handleGlobalBlurEvent);
-            globalEvents.on($xeTreeSelect, 'resize', handleGlobalResizeEvent);
-            globalEvents.on($xeTreeSelect, 'scroll', handleGlobalScrollEvent);
+            globalEvents$1.on($xeTreeSelect, 'mousedown', handleGlobalMousedownEvent);
+            globalEvents$1.on($xeTreeSelect, 'blur', handleGlobalBlurEvent);
+            globalEvents$1.on($xeTreeSelect, 'resize', handleGlobalResizeEvent);
+            globalEvents$1.on($xeTreeSelect, 'scroll', handleGlobalScrollEvent);
         });
         onBeforeUnmount(() => {
-            globalEvents.off($xeTreeSelect, 'mousedown');
-            globalEvents.off($xeTreeSelect, 'blur');
-            globalEvents.off($xeTreeSelect, 'resize');
-            globalEvents.off($xeTreeSelect, 'scroll');
+            globalEvents$1.off($xeTreeSelect, 'mousedown');
+            globalEvents$1.off($xeTreeSelect, 'blur');
+            globalEvents$1.off($xeTreeSelect, 'resize');
+            globalEvents$1.off($xeTreeSelect, 'scroll');
             XEUtils.assign(reactData, createReactData$1());
             XEUtils.assign(internalData, createInternalData$1());
         });
@@ -49406,15 +49445,15 @@ var VxeUploadComponent = defineVxeComponent({
             if (props.dragSort) {
                 initTpImg();
             }
-            globalEvents.on($xeUpload, 'paste', handleGlobalPasteEvent);
-            globalEvents.on($xeUpload, 'click', handleGlobalClickEvent);
-            globalEvents.on($xeUpload, 'blur', handleGlobalBlurEvent);
+            globalEvents$1.on($xeUpload, 'paste', handleGlobalPasteEvent);
+            globalEvents$1.on($xeUpload, 'click', handleGlobalClickEvent);
+            globalEvents$1.on($xeUpload, 'blur', handleGlobalBlurEvent);
         });
         onBeforeUnmount(() => {
             reactData.isDragUploadStatus = false;
-            globalEvents.off($xeUpload, 'paste');
-            globalEvents.off($xeUpload, 'click');
-            globalEvents.off($xeUpload, 'blur');
+            globalEvents$1.off($xeUpload, 'paste');
+            globalEvents$1.off($xeUpload, 'click');
+            globalEvents$1.off($xeUpload, 'blur');
             XEUtils.assign(reactData, createReactData());
             XEUtils.assign(internalData, createInternalData());
         });
@@ -49702,12 +49741,12 @@ var VxeWatermarkComponent = defineVxeComponent({
         });
         onMounted(() => {
             updateMarkStyle();
-            globalEvents.on($xeWatermark, 'resize', XEUtils.throttle(() => {
+            globalEvents$1.on($xeWatermark, 'resize', XEUtils.throttle(() => {
                 updateMarkStyle();
             }, 300, { trailing: true, leading: true }));
         });
         onUnmounted(() => {
-            globalEvents.off($xeWatermark, 'resize');
+            globalEvents$1.off($xeWatermark, 'resize');
         });
         $xeWatermark.renderVN = renderVN;
         return $xeWatermark;