vxe-table 4.19.1 → 4.19.3

package/es/table/src/table.js

@@ -260,6 +260,10 @@ export default defineVxeComponent({
         const computeRowGroupOpts = computed(() => {
             return computeAggregateOpts.value;
         });
+        const computeAggregateMode = computed(() => {
+            const aggregateOpts = computeAggregateOpts.value;
+            return aggregateOpts.mode;
+        });
         const computeAggregateAccuracyOpts = computed(() => {
             return Object.assign({}, getConfig().table.aggregateAccuracyConfig, props.aggregateAccuracyConfig);
         });
@@ -3453,12 +3457,12 @@ export default defineVxeComponent({
                 handleeGroupSummary(aggList);
             }
         };
-        const handleGroupData = (list, rowGroups) => {
+        const handleGroupData = (list, rowGroups, isCombinedField) => {
             let fullData = list;
             let treeData = list;
             if (rowGroups) {
                 const aggregateOpts = computeAggregateOpts.value;
-                const { rowField, parentField, childrenField, mapChildrenField } = aggregateOpts;
+                const { rowField, parentField, separator, childrenField, mapChildrenField } = aggregateOpts;
                 const rowOpts = computeRowOpts.value;
                 const checkboxOpts = computeCheckboxOpts.value;
                 const { checkField } = checkboxOpts;
@@ -3470,11 +3474,26 @@ export default defineVxeComponent({
                     const groupField = rgItem.field;
                     const groupColumn = $xeTable.getColumnByField(groupField);
                     const groupMaps = {};
+                    const groupCombinedMaps = {};
                     const aggList = [];
                     const rowkey = getRowkey($xeTable);
                     list.forEach((row) => {
                         const cellValue = groupColumn ? $xeTable.getCellLabel(row, groupColumn) : XEUtils.get(row, groupField);
-                        const groupValue = XEUtils.eqNull(cellValue) ? '' : cellValue;
+                        let groupValue = XEUtils.eqNull(cellValue) ? '' : cellValue;
+                        if (isCombinedField) {
+                            const groupVals = [groupValue];
+                            rowGroups.slice(1).forEach(ogItem => {
+                                const ogField = ogItem.field;
+                                const ogColumn = $xeTable.getColumnByField(ogField);
+                                const ocValue = ogColumn ? $xeTable.getCellLabel(row, ogColumn) : XEUtils.get(row, ogField);
+                                const ogValue = XEUtils.eqNull(ocValue) ? '' : ocValue;
+                                groupValue += (separator || ' / ') + ogValue;
+                                groupVals.push(ogValue);
+                            });
+                            if (!groupCombinedMaps[groupValue]) {
+                                groupCombinedMaps[groupValue] = groupVals;
+                            }
+                        }
                         let childList = groupMaps[groupValue];
                         if (!childList) {
                             childList = [];
@@ -3485,33 +3504,62 @@ export default defineVxeComponent({
                         }
                         childList.push(row);
                     });
-                    XEUtils.objectEach(groupMaps, (childList, groupValue) => {
-                        const { fullData: childFullData, treeData: childTreeData } = handleGroupData(childList, rowGroups.slice(1));
-                        const aggRow = {
-                            isAggregate: true,
-                            aggData: {},
-                            groupContent: groupValue,
-                            groupField,
-                            childCount: 0,
-                            [rowField]: getRowUniqueId(),
-                            [parentField]: null,
-                            [childrenField]: childTreeData,
-                            [mapChildrenField]: childTreeData
-                        };
-                        aggRow[rowkey] = createRowId(rowOpts, aggRow, rowkey);
-                        if (checkField) {
-                            aggRow[checkField] = false;
-                        }
-                        if (indeterminateField) {
-                            aggRow[indeterminateField] = false;
-                        }
-                        aggList.push(aggRow);
-                        treeData.push(aggRow);
-                        fullData.push(aggRow);
-                        if (childFullData.length) {
-                            fullData.push(...childFullData);
-                        }
-                    });
+                    if (isCombinedField) {
+                        XEUtils.objectEach(groupMaps, (childList, groupValue) => {
+                            const aggRow = {
+                                isAggregate: true,
+                                aggData: {},
+                                groupContent: groupValue,
+                                groupCombineds: groupCombinedMaps[groupValue],
+                                groupField,
+                                childCount: 0,
+                                [rowField]: getRowUniqueId(),
+                                [parentField]: null,
+                                [childrenField]: childList,
+                                [mapChildrenField]: childList
+                            };
+                            aggRow[rowkey] = createRowId(rowOpts, aggRow, rowkey);
+                            if (checkField) {
+                                aggRow[checkField] = false;
+                            }
+                            if (indeterminateField) {
+                                aggRow[indeterminateField] = false;
+                            }
+                            aggList.push(aggRow);
+                            treeData.push(aggRow);
+                            fullData.push(aggRow);
+                        });
+                    }
+                    else {
+                        XEUtils.objectEach(groupMaps, (childList, groupValue) => {
+                            const { fullData: childFullData, treeData: childTreeData } = handleGroupData(childList, rowGroups.slice(1));
+                            const aggRow = {
+                                isAggregate: true,
+                                aggData: {},
+                                groupContent: groupValue,
+                                groupCombineds: [],
+                                groupField,
+                                childCount: 0,
+                                [rowField]: getRowUniqueId(),
+                                [parentField]: null,
+                                [childrenField]: childTreeData,
+                                [mapChildrenField]: childTreeData
+                            };
+                            aggRow[rowkey] = createRowId(rowOpts, aggRow, rowkey);
+                            if (checkField) {
+                                aggRow[checkField] = false;
+                            }
+                            if (indeterminateField) {
+                                aggRow[indeterminateField] = false;
+                            }
+                            aggList.push(aggRow);
+                            treeData.push(aggRow);
+                            fullData.push(aggRow);
+                            if (childFullData.length) {
+                                fullData.push(...childFullData);
+                            }
+                        });
+                    }
                     handleeGroupSummary(aggList);
                 }
             }
@@ -3520,6 +3568,13 @@ export default defineVxeComponent({
                 fullData
             };
         };
+        const initGroupData = (list, rowGroups) => {
+            const aggregateOpts = computeAggregateOpts.value;
+            const { mode } = aggregateOpts;
+            const isCombinedField = mode === 'combined';
+            const groupRest = handleGroupData(list, rowGroups, isCombinedField);
+            return groupRest;
+        };
         const initData = () => {
             const { data } = props;
             loadTableData(data || [], true, true).then(() => {
@@ -3602,7 +3657,7 @@ export default defineVxeComponent({
                 }
             }
             else if ((aggregateConfig || rowGroupConfig) && rowGroupList.length) {
-                const groupRest = handleGroupData(fullData, rowGroupList);
+                const groupRest = initGroupData(fullData, rowGroupList);
                 treeData = groupRest.treeData;
                 fullData = groupRest.fullData;
                 isRGroup = true;
@@ -13665,6 +13720,11 @@ export default defineVxeComponent({
             });
             internalData.keepUpdateFieldMaps = kpfMaps;
         });
+        watch(computeAggregateMode, () => {
+            if (reactData.isRowGroupStatus) {
+                loadTableData(internalData.tableSynchData, false, true);
+            }
+        });
         if ($xeTabs) {
             watch(() => $xeTabs ? $xeTabs.reactData.resizeFlag : null, () => {
                 handleGlobalResizeEvent();
@@ -13816,6 +13876,9 @@ export default defineVxeComponent({
             if (exportConfig && exportOpts.types && !exportOpts.exportMethod && !XEUtils.includeArrays(XEUtils.keys(exportOpts._typeMaps), exportOpts.types)) {
                 warnLog('vxe.error.errProp', [`export-config.types=${exportOpts.types.join(',')}`, exportOpts.types.filter((type) => XEUtils.includes(XEUtils.keys(exportOpts._typeMaps), type)).join(',') || XEUtils.keys(exportOpts._typeMaps).join(',')]);
             }
+            if (exportConfig && XEUtils.isBoolean(exportOpts.isAllExpand)) {
+                warnLog('vxe.error.delProp', ['isAllExpand', 'isTreeAllExpanded']);
+            }
             if (!props.id) {
                 if ((props.customConfig ? isEnableConf(customOpts) : customOpts.enabled) && customOpts.storage) {
                     errLog('vxe.error.reqProp', ['id']);

package/es/table/src/util.js

@@ -323,6 +323,7 @@ export function createReactData() {
             hasFooter: false,
             hasMerge: false,
             hasTree: false,
+            hasRowGroup: false,
             hasColgroup: false,
             visible: false
         },
@@ -333,7 +334,8 @@ export function createReactData() {
             type: '',
             isColgroup: false,
             isMerge: false,
-            isAllExpand: false,
+            isTreeAllExpanded: false,
+            isRowGroupAllExpanded: false,
             useStyle: false,
             original: false,
             message: true,

package/es/table/style.css

@@ -1364,7 +1364,7 @@
   width: 80%;
 }
 .vxe-table-export--panel .vxe-table-export--panel-table tr td > .vxe-table-export--panel-option-row {
-  padding: 0.25em 0;
+  padding: 0.5em 0;
 }
 .vxe-table-export--panel .vxe-table-export--panel-column {
   width: 80%;