vxe-table 4.13.34 → 4.13.36

package/es/table/src/table.js

@@ -528,8 +528,11 @@ export default defineComponent({
         const computeRowOpts = computed(() => {
             return Object.assign({}, getConfig().table.rowConfig, props.rowConfig);
         });
+        const computeAggregateOpts = computed(() => {
+            return Object.assign({}, getConfig().table.aggregateConfig || getConfig().table.rowGroupConfig, props.aggregateConfig || props.rowGroupConfig);
+        });
         const computeRowGroupOpts = computed(() => {
-            return Object.assign({}, getConfig().table.rowGroupConfig, props.rowGroupConfig);
+            return computeAggregateOpts.value;
         });
         const computeCurrentRowOpts = computed(() => {
             return Object.assign({}, getConfig().table.currentRowConfig, props.currentRowConfig);
@@ -811,6 +814,7 @@ export default defineComponent({
             computeHeaderCellOpts,
             computeFooterCellOpts,
             computeRowOpts,
+            computeAggregateOpts,
             computeRowGroupOpts,
             computeCurrentRowOpts,
             computeRowDragOpts,
@@ -1847,7 +1851,7 @@ export default defineComponent({
             const { treeConfig } = props;
             const { isRowGroupStatus } = reactData;
             const { fullAllDataRowIdData, treeExpandedMaps, rowGroupExpandedMaps } = internalData;
-            const rowGroupOpts = computeRowGroupOpts.value;
+            const aggregateOpts = computeAggregateOpts.value;
             const treeOpts = computeTreeOpts.value;
             const { handleGetRowId } = createHandleGetRowId($xeTable);
             const fullData = [];
@@ -1871,7 +1875,7 @@ export default defineComponent({
                 return fullData;
             }
             else if (isRowGroupStatus) {
-                const { childrenField } = rowGroupOpts;
+                const { childrenField } = aggregateOpts;
                 XEUtils.eachTree(internalData.afterGroupFullData, (row, index, items, path, parentRow) => {
                     const rowid = handleGetRowId(row);
                     const parentRowid = handleGetRowId(parentRow);
@@ -1900,7 +1904,7 @@ export default defineComponent({
             const { tableFullColumn, tableFullData, tableFullTreeData, tableFullGroupData } = internalData;
             const filterOpts = computeFilterOpts.value;
             const sortOpts = computeSortOpts.value;
-            const rowGroupOpts = computeRowGroupOpts.value;
+            const aggregateOpts = computeAggregateOpts.value;
             const treeOpts = computeTreeOpts.value;
             const childrenField = treeOpts.children || treeOpts.childrenField;
             const { transform, rowField, parentField, mapChildrenField } = treeOpts;
@@ -1964,8 +1968,8 @@ export default defineComponent({
                         tableTree = XEUtils.searchTree(tableFullGroupData, handleFilter, {
                             original: true,
                             isEvery: true,
-                            children: rowGroupOpts.mapChildrenField,
-                            mapChildren: rowGroupOpts.childrenField
+                            children: aggregateOpts.mapChildrenField,
+                            mapChildren: aggregateOpts.childrenField
                         });
                         tableData = tableTree;
                     }
@@ -1990,8 +1994,8 @@ export default defineComponent({
                         tableTree = XEUtils.searchTree(tableFullGroupData, () => true, {
                             original: true,
                             isEvery: true,
-                            children: rowGroupOpts.mapChildrenField,
-                            mapChildren: rowGroupOpts.childrenField
+                            children: aggregateOpts.mapChildrenField,
+                            mapChildren: aggregateOpts.childrenField
                         });
                         tableData = tableTree;
                     }
@@ -2021,15 +2025,15 @@ export default defineComponent({
                         }
                         else {
                             const treeList = XEUtils.toTreeArray(tableTree, {
-                                key: rowGroupOpts.rowField,
-                                parentKey: rowGroupOpts.parentField,
-                                children: rowGroupOpts.mapChildrenField
+                                key: aggregateOpts.rowField,
+                                parentKey: aggregateOpts.parentField,
+                                children: aggregateOpts.mapChildrenField
                             });
                             tableTree = XEUtils.toArrayTree(XEUtils.orderBy(treeList, orderColumns.map(({ column, order }) => [getOrderField(column), order])), {
-                                key: rowGroupOpts.rowField,
-                                parentKey: rowGroupOpts.parentField,
-                                children: rowGroupOpts.childrenField,
-                                mapChildren: rowGroupOpts.mapChildrenField
+                                key: aggregateOpts.rowField,
+                                parentKey: aggregateOpts.parentField,
+                                children: aggregateOpts.childrenField,
+                                mapChildren: aggregateOpts.mapChildrenField
                             });
                         }
                         tableData = tableTree;
@@ -2072,8 +2076,8 @@ export default defineComponent({
                     tableTree = XEUtils.searchTree(tableFullGroupData, () => true, {
                         original: true,
                         isEvery: true,
-                        children: rowGroupOpts.mapChildrenField,
-                        mapChildren: rowGroupOpts.childrenField
+                        children: aggregateOpts.mapChildrenField,
+                        mapChildren: aggregateOpts.childrenField
                     });
                     tableData = tableTree;
                 }
@@ -2517,7 +2521,7 @@ export default defineComponent({
             const { isRowGroupStatus } = reactData;
             const { afterFullData, afterTreeFullData, afterGroupFullData, checkboxReserveRowMap, selectCheckboxMaps } = internalData;
             const treeOpts = computeTreeOpts.value;
-            const rowGroupOpts = computeRowGroupOpts.value;
+            const aggregateOpts = computeAggregateOpts.value;
             const childrenField = treeOpts.children || treeOpts.childrenField;
             const checkboxOpts = computeCheckboxOpts.value;
             const { checkField, reserve, checkMethod } = checkboxOpts;
@@ -2566,7 +2570,7 @@ export default defineComponent({
                                 const rowid = handleGetRowId(row);
                                 selectRowMaps[rowid] = row;
                             }
-                        }, { children: rowGroupOpts.mapChildrenField });
+                        }, { children: aggregateOpts.mapChildrenField });
                     }
                     else {
                         /**
@@ -2579,7 +2583,7 @@ export default defineComponent({
                                 if (checkMethod({ $table: $xeTable, row }) ? false : selectCheckboxMaps[rowid]) {
                                     selectRowMaps[rowid] = row;
                                 }
-                            }, { children: rowGroupOpts.mapChildrenField });
+                            }, { children: aggregateOpts.mapChildrenField });
                         }
                     }
                 }
@@ -2996,12 +3000,49 @@ export default defineComponent({
                 })
                 : [];
         };
+        const handleeGroupSummary = (aggList) => {
+            const aggregateOpts = computeAggregateOpts.value;
+            const { mapChildrenField } = aggregateOpts;
+            if (mapChildrenField) {
+                XEUtils.lastEach(aggList, aggRow => {
+                    let count = 0;
+                    XEUtils.each(aggRow[mapChildrenField], (row) => {
+                        if (row.isAggregate) {
+                            count += row.childCount || 0;
+                        }
+                        else {
+                            count++;
+                        }
+                    });
+                    aggRow.childCount = count;
+                });
+                if ($xeTable.handlePivotTableAggregateData) {
+                    $xeTable.handlePivotTableAggregateData(aggList);
+                }
+            }
+        };
+        const updateGroupData = () => {
+            const { aggregateConfig, rowGroupConfig } = props;
+            const { isRowGroupStatus } = reactData;
+            const { tableFullGroupData } = internalData;
+            const aggregateOpts = computeAggregateOpts.value;
+            const { mapChildrenField } = aggregateOpts;
+            if ((aggregateConfig || rowGroupConfig) && isRowGroupStatus) {
+                const aggList = [];
+                XEUtils.eachTree(tableFullGroupData, row => {
+                    if (row.isAggregate) {
+                        aggList.push(row);
+                    }
+                }, { children: mapChildrenField });
+                handleeGroupSummary(aggList);
+            }
+        };
         const handleGroupData = (list, rowGroups) => {
             let fullData = list;
             let treeData = list;
             if (rowGroups) {
-                const rowGroupOpts = computeRowGroupOpts.value;
-                const { rowField, parentField, childrenField, mapChildrenField } = rowGroupOpts;
+                const aggregateOpts = computeAggregateOpts.value;
+                const { rowField, parentField, childrenField, mapChildrenField } = aggregateOpts;
                 const checkboxOpts = computeCheckboxOpts.value;
                 const { checkField } = checkboxOpts;
                 const indeterminateField = checkboxOpts.indeterminateField || checkboxOpts.halfField;
@@ -3012,7 +3053,7 @@ export default defineComponent({
                     const groupField = rgItem.field;
                     const groupColumn = $xeTable.getColumnByField(groupField);
                     const groupMaps = {};
-                    const groupList = [];
+                    const aggList = [];
                     const rowkey = getRowkey($xeTable);
                     list.forEach((row) => {
                         const cellValue = groupColumn ? $xeTable.getCellLabel(row, groupColumn) : XEUtils.get(row, groupField);
@@ -3029,12 +3070,12 @@ export default defineComponent({
                     });
                     XEUtils.objectEach(groupMaps, (childList, groupValue) => {
                         const { fullData: childFullData, treeData: childTreeData } = handleGroupData(childList, rowGroups.slice(1));
-                        const childCount = 0;
-                        const groupRow = {
+                        const aggRow = {
                             isAggregate: true,
-                            childCount,
+                            aggData: {},
                             groupContent: groupValue,
                             groupField,
+                            childCount: 0,
                             [rowField]: getRowUniqueId(),
                             [parentField]: null,
                             [rowkey]: getRowUniqueId(),
@@ -3042,30 +3083,19 @@ export default defineComponent({
                             [mapChildrenField]: childTreeData
                         };
                         if (checkField) {
-                            groupRow[checkField] = false;
+                            aggRow[checkField] = false;
                         }
                         if (indeterminateField) {
-                            groupRow[indeterminateField] = false;
+                            aggRow[indeterminateField] = false;
                         }
-                        groupList.push(groupRow);
-                        treeData.push(groupRow);
-                        fullData.push(groupRow);
+                        aggList.push(aggRow);
+                        treeData.push(aggRow);
+                        fullData.push(aggRow);
                         if (childFullData.length) {
                             fullData.push(...childFullData);
                         }
                     });
-                    XEUtils.lastEach(groupList, groupItem => {
-                        let count = 0;
-                        XEUtils.each(groupItem[childrenField], row => {
-                            if (row.isAggregate) {
-                                count += row[childrenField] ? row[childrenField].length : 0;
-                            }
-                            else {
-                                count++;
-                            }
-                        });
-                        groupItem.childCount = count;
-                    });
+                    handleeGroupSummary(aggList);
                 }
             }
             return {
@@ -3078,7 +3108,7 @@ export default defineComponent({
          * @param {Array} datas 数据
          */
         const loadTableData = (datas, isReset) => {
-            const { keepSource, treeConfig, rowGroupConfig } = props;
+            const { keepSource, treeConfig, rowGroupConfig, aggregateConfig } = props;
             const { rowGroupList, scrollYLoad: oldScrollYLoad } = reactData;
             const { scrollYStore, scrollXStore, lastScrollLeft, lastScrollTop } = internalData;
             const rowOpts = computeRowOpts.value;
@@ -3092,11 +3122,11 @@ export default defineComponent({
                 errLog('vxe.error.errMaxRow', [supportMaxRow]);
             }
             if (treeConfig && rowGroupList.length) {
-                errLog('vxe.error.noTree', ['row-group-config']);
+                errLog('vxe.error.noTree', ['aggregate-config']);
                 return nextTick();
             }
             if (rowOpts.drag && rowGroupList.length) {
-                errLog('vxe.error.errConflicts', ['row-config.drag', 'row-group-config']);
+                errLog('vxe.error.errConflicts', ['row-config.drag', 'aggregate-config']);
                 return nextTick();
             }
             let isRGroup = false;
@@ -3135,7 +3165,7 @@ export default defineComponent({
                     treeData = fullData.slice(0);
                 }
             }
-            else if (rowGroupConfig && rowGroupList.length) {
+            else if ((aggregateConfig || rowGroupConfig) && rowGroupList.length) {
                 const groupRest = handleGroupData(fullData, rowGroupList);
                 treeData = groupRest.treeData;
                 fullData = groupRest.fullData;
@@ -3244,6 +3274,8 @@ export default defineComponent({
                         if (oldScrollYLoad === sYLoad) {
                             restoreScrollLocation($xeTable, targetScrollLeft, targetScrollTop)
                                 .then(() => {
+                                calcCellHeight();
+                                updateRowOffsetTop();
                                 resolve();
                             });
                         }
@@ -3251,6 +3283,8 @@ export default defineComponent({
                             setTimeout(() => {
                                 restoreScrollLocation($xeTable, targetScrollLeft, targetScrollTop)
                                     .then(() => {
+                                    calcCellHeight();
+                                    updateRowOffsetTop();
                                     resolve();
                                 });
                             });
@@ -3487,6 +3521,7 @@ export default defineComponent({
                 $xeTable.clearMergeCells();
                 $xeTable.clearMergeFooterItems();
                 $xeTable.handleTableData(true);
+                $xeTable.handleAggregateSummaryData();
                 if ((scrollXLoad || scrollYLoad) && (expandColumn && expandOpts.mode !== 'fixed')) {
                     warnLog('vxe.error.scrollErrProp', ['column.type=expand']);
                 }
@@ -3612,8 +3647,8 @@ export default defineComponent({
          */
         const handleRowGroupBaseExpand = (rows, expanded) => {
             const { fullAllDataRowIdData, tableFullGroupData, rowGroupExpandedMaps } = internalData;
-            const rowGroupOpts = computeRowGroupOpts.value;
-            const { mapChildrenField, accordion } = rowGroupOpts;
+            const aggregateOpts = computeAggregateOpts.value;
+            const { mapChildrenField, accordion } = aggregateOpts;
             const { handleGetRowId } = createHandleGetRowId($xeTable);
             let validRows = rows;
             if (mapChildrenField) {
@@ -4095,10 +4130,12 @@ export default defineComponent({
             reloadRow(row, record, field) {
                 const { keepSource } = props;
                 const { tableData } = reactData;
-                const { tableSourceData } = internalData;
+                const { sourceDataRowIdData } = internalData;
                 if (keepSource) {
-                    const rowIndex = tableMethods.getRowIndex(row);
-                    const oRow = tableSourceData[rowIndex];
+                    if ($xeTable.isAggregateRecord(row)) {
+                        return nextTick();
+                    }
+                    const oRow = sourceDataRowIdData[getRowid($xeTable, row)];
                     if (oRow && row) {
                         if (field) {
                             const newValue = XEUtils.clone(XEUtils.get(record || row, field), true);
@@ -6005,9 +6042,9 @@ export default defineComponent({
                 return rest;
             },
             setRowGroups(fieldOrColumns) {
-                const { rowGroupConfig } = props;
-                if (!rowGroupConfig) {
-                    errLog('vxe.error.reqProp', ['row-group-config']);
+                const { aggregateConfig, rowGroupConfig } = props;
+                if (!(aggregateConfig || rowGroupConfig)) {
+                    errLog('vxe.error.reqProp', ['aggregate-config']);
                     return nextTick();
                 }
                 if (fieldOrColumns) {
@@ -6019,19 +6056,27 @@ export default defineComponent({
                 return nextTick();
             },
             clearRowGroups() {
-                const { rowGroupConfig } = props;
-                if (!rowGroupConfig) {
-                    errLog('vxe.error.reqProp', ['row-group-config']);
+                const { aggregateConfig, rowGroupConfig } = props;
+                if (!(aggregateConfig || rowGroupConfig)) {
+                    errLog('vxe.error.reqProp', ['aggregate-config']);
                     return nextTick();
                 }
                 handleUpdateRowGroup([]);
                 return loadTableData(internalData.tableSynchData, true);
             },
             isRowGroupRecord(row) {
+                warnLog('vxe.error.delFunc', ['isRowGroupRecord', 'isAggregateRecord']);
+                return $xeTable.isAggregateRecord(row);
+            },
+            isRowGroupExpandByRow(row) {
+                warnLog('vxe.error.delFunc', ['isRowGroupExpandByRow', 'isAggregateExpandByRow']);
+                return $xeTable.isAggregateExpandByRow(row);
+            },
+            isAggregateRecord(row) {
                 const { isRowGroupStatus } = reactData;
                 return isRowGroupStatus && row.isAggregate;
             },
-            isRowGroupExpandByRow(row) {
+            isAggregateExpandByRow(row) {
                 const { rowGroupExpandedFlag } = reactData;
                 const { rowGroupExpandedMaps } = internalData;
                 return !!rowGroupExpandedFlag && !!rowGroupExpandedMaps[getRowid($xeTable, row)];
@@ -6047,8 +6092,8 @@ export default defineComponent({
             },
             setAllRowGroupExpand(expanded) {
                 const { tableFullGroupData } = internalData;
-                const rowGroupOpts = computeRowGroupOpts.value;
-                const { mapChildrenField } = rowGroupOpts;
+                const aggregateOpts = computeAggregateOpts.value;
+                const { mapChildrenField } = aggregateOpts;
                 const rgExpandedMaps = {};
                 if (expanded && mapChildrenField) {
                     XEUtils.eachTree(tableFullGroupData, (row) => {
@@ -7590,8 +7635,8 @@ export default defineComponent({
                     }, { children: childrenField });
                 }
                 else if (isRowGroupStatus) {
-                    const rowGroupOpts = computeRowGroupOpts.value;
-                    const { mapChildrenField } = rowGroupOpts;
+                    const aggregateOpts = computeAggregateOpts.value;
+                    const { mapChildrenField } = aggregateOpts;
                     XEUtils.eachTree(tableFullGroupData, (row, index, items, path, parentRow, nodes) => {
                         const rowid = handleUpdateRowId(row);
                         handleRowCache(row, index, items, parentRow ? -1 : index, parentRow, rowid, nodes.length - 1, toTreePathSeq(path));
@@ -8104,7 +8149,7 @@ export default defineComponent({
                 const { treeConfig } = props;
                 const { isRowGroupStatus } = reactData;
                 const { afterTreeFullData, afterGroupFullData, selectCheckboxMaps, treeIndeterminateRowMaps } = internalData;
-                const rowGroupOpts = computeRowGroupOpts.value;
+                const aggregateOpts = computeAggregateOpts.value;
                 const treeOpts = computeTreeOpts.value;
                 const childrenField = treeOpts.children || treeOpts.childrenField;
                 const checkboxOpts = computeCheckboxOpts.value;
@@ -8118,7 +8163,7 @@ export default defineComponent({
                     const childRowList = [];
                     if (isRowGroupStatus) {
                         // 行分组
-                        const mapChildrenField = rowGroupOpts.mapChildrenField;
+                        const mapChildrenField = aggregateOpts.mapChildrenField;
                         if (mapChildrenField) {
                             XEUtils.eachTree(afterGroupFullData, (row) => {
                                 const rowid = handleGetRowId(row);
@@ -8279,7 +8324,7 @@ export default defineComponent({
                 const { treeConfig } = props;
                 const { isRowGroupStatus } = reactData;
                 const { selectCheckboxMaps } = internalData;
-                const rowGroupOpts = computeRowGroupOpts.value;
+                const aggregateOpts = computeAggregateOpts.value;
                 const treeOpts = computeTreeOpts.value;
                 const { transform, mapChildrenField } = treeOpts;
                 const childrenField = treeOpts.children || treeOpts.childrenField;
@@ -8331,7 +8376,7 @@ export default defineComponent({
                                 }
                                 handleCheckboxReserveRow(row, checked);
                             }
-                        }, { children: rowGroupOpts.mapChildrenField });
+                        }, { children: aggregateOpts.mapChildrenField });
                         reactData.updateCheckboxFlag++;
                         return;
                     }
@@ -8394,6 +8439,9 @@ export default defineComponent({
                 internalData.mergeFooterCellMaps = buildMergeData(mergeFooterList);
                 reactData.mergeFootFlag++;
             },
+            handleAggregateSummaryData() {
+                return updateGroupData();
+            },
             triggerHeaderTitleEvent(evnt, iconParams, params) {
                 const tipContent = iconParams.content || iconParams.message;
                 if (tipContent) {
@@ -8554,7 +8602,7 @@ export default defineComponent({
                 const radioOpts = computeRadioOpts.value;
                 const checkboxOpts = computeCheckboxOpts.value;
                 const keyboardOpts = computeKeyboardOpts.value;
-                const rowGroupOpts = computeRowGroupOpts.value;
+                const aggregateOpts = computeAggregateOpts.value;
                 const rowOpts = computeRowOpts.value;
                 const columnOpts = computeColumnOpts.value;
                 const currentColumnOpts = computeCurrentColumnOpts.value;
@@ -8581,7 +8629,7 @@ export default defineComponent({
                         $xeTable.triggerTreeExpandEvent(evnt, params);
                     }
                     // 如果是行分组
-                    if ((rowGroupOpts.trigger === 'row' || (rowGroupNode && rowGroupOpts.trigger === 'cell'))) {
+                    if ((aggregateOpts.trigger === 'row' || (rowGroupNode && aggregateOpts.trigger === 'cell'))) {
                         $xeTable.triggerRowGroupExpandEvent(evnt, params);
                     }
                 }
@@ -8869,9 +8917,9 @@ export default defineComponent({
              */
             triggerRowGroupExpandEvent(evnt, params) {
                 const { rowGroupExpandedMaps } = internalData;
-                const rowGroupOpts = computeRowGroupOpts.value;
+                const aggregateOpts = computeAggregateOpts.value;
                 const { row, column } = params;
-                const { trigger } = rowGroupOpts;
+                const { trigger } = aggregateOpts;
                 if (trigger === 'manual') {
                     return;
                 }
@@ -10115,10 +10163,10 @@ export default defineComponent({
                 const { tableFullData } = internalData;
                 const rests = [];
                 if (treeConfig || isRowGroupStatus) {
-                    const rowGroupOpts = computeRowGroupOpts.value;
+                    const aggregateOpts = computeAggregateOpts.value;
                     const treeOpts = computeTreeOpts.value;
                     const childrenField = treeOpts.children || treeOpts.childrenField;
-                    const matchObj = XEUtils.findTree(tableFullData, item => $xeTable.eqRow(item, row), { children: isRowGroupStatus ? rowGroupOpts.mapChildrenField : childrenField });
+                    const matchObj = XEUtils.findTree(tableFullData, item => $xeTable.eqRow(item, row), { children: isRowGroupStatus ? aggregateOpts.mapChildrenField : childrenField });
                     if (matchObj) {
                         const nodes = matchObj.nodes;
                         nodes.forEach((row, index) => {
@@ -11231,9 +11279,9 @@ export default defineComponent({
             const columnOpts = computeColumnOpts.value;
             const rowOpts = computeRowOpts.value;
             const customOpts = computeCustomOpts.value;
-            const rowGroupOpts = computeRowGroupOpts.value;
+            const aggregateOpts = computeAggregateOpts.value;
             const virtualYOpts = computeVirtualYOpts.value;
-            const { groupFields } = rowGroupOpts;
+            const { groupFields } = aggregateOpts;
             if (columnOpts.drag || rowOpts.drag || customOpts.allowSort) {
                 initTpImg();
             }
@@ -11254,6 +11302,7 @@ export default defineComponent({
                 const currentRowOpts = computeCurrentRowOpts.value;
                 const currentColumnOpts = computeCurrentColumnOpts.value;
                 const keyboardOpts = computeKeyboardOpts.value;
+                const aggregateOpts = computeAggregateOpts.value;
                 if (props.rowId) {
                     warnLog('vxe.error.delProp', ['row-id', 'row-config.keyField']);
                 }
@@ -11341,6 +11390,15 @@ export default defineComponent({
                 if (props.dragConfig) {
                     warnLog('vxe.error.delProp', ['drag-config', 'row-drag-config']);
                 }
+                if (props.rowGroupConfig) {
+                    warnLog('vxe.error.delProp', ['row-group-config', 'aggregate-config']);
+                }
+                if (aggregateOpts.countFields) {
+                    warnLog('vxe.error.delProp', ['row-group-config.countFields', 'column.agg-func']);
+                }
+                if (aggregateOpts.countMethod) {
+                    warnLog('vxe.error.delProp', ['row-group-config.countMethod', 'aggregate-config.aggregateMethod']);
+                }
                 if (props.treeConfig && treeOpts.children) {
                     warnLog('vxe.error.delProp', ['tree-config.children', 'tree-config.childrenField']);
                 }

package/es/table/src/util.js

@@ -145,19 +145,22 @@ export function updateFastRowKey(row, rowKey) {
     }
     return rowid;
 }
-export const handleFieldOrColumn = ($xeTable, fieldOrColumn) => {
+export function handleFieldOrColumn($xeTable, fieldOrColumn) {
     if (fieldOrColumn) {
         return XEUtils.isString(fieldOrColumn) || XEUtils.isNumber(fieldOrColumn) ? $xeTable.getColumnByField(`${fieldOrColumn}`) : fieldOrColumn;
     }
     return null;
-};
-export const handleRowidOrRow = ($xeTable, rowidOrRow) => {
+}
+export function handleRowidOrRow($xeTable, rowidOrRow) {
     if (rowidOrRow) {
         const rowid = XEUtils.isString(rowidOrRow) || XEUtils.isNumber(rowidOrRow) ? rowidOrRow : getRowid($xeTable, rowidOrRow);
         return $xeTable.getRowById(rowid);
     }
     return null;
-};
+}
+export function getCellRestHeight(rowRest, cellOpts, rowOpts, defaultRowHeight) {
+    return rowRest.resizeHeight || cellOpts.height || rowOpts.height || rowRest.height || defaultRowHeight;
+}
 function getPaddingLeftRightSize(elem) {
     if (elem) {
         const computedStyle = getComputedStyle(elem);

package/es/ui/index.js

@@ -1,6 +1,6 @@
 import { VxeUI } from '@vxe-ui/core';
 import { getFuncText } from './src/utils';
-export const version = "4.13.34";
+export const version = "4.13.36";
 VxeUI.version = version;
 VxeUI.tableVersion = version;
 VxeUI.setConfig({
@@ -126,7 +126,7 @@ VxeUI.setConfig({
             // isEvery: false,
             showIcon: true
         },
-        rowGroupConfig: {
+        aggregateConfig: {
             padding: true,
             rowField: 'id',
             parentField: '_X_ROW_PARENT_KEY',
@@ -200,13 +200,13 @@ VxeUI.setConfig({
             isReplace: true
         },
         virtualXConfig: {
-            enabled: true,
+            // enabled: false,
             gt: 24,
             preSize: 1,
             oSize: 0
         },
         virtualYConfig: {
-            enabled: true,
+            // enabled: false,
             gt: 100,
             preSize: 1,
             oSize: 0

package/es/ui/src/log.js

@@ -1,5 +1,5 @@
 import { VxeUI } from '@vxe-ui/core';
 const { log } = VxeUI;
-const version = `table v${"4.13.34"}`;
+const version = `table v${"4.13.36"}`;
 export const warnLog = log.create('warn', version);
 export const errLog = log.create('error', version);