cloud-ide-element 1.1.90 → 1.1.91

package/fesm2022/cloud-ide-element.mjs

@@ -11763,6 +11763,24 @@ class CideEleDataGridComponent {
         const newExpanded = new Set(expanded);
         const shouldAutoExpand = this.shouldAutoExpandGroups();
         groups.forEach((group, groupKey) => {
+            // Calculate actual row count (excluding nested group headers)
+            const countActualRows = (rows) => {
+                let count = 0;
+                rows.forEach(row => {
+                    // Check if this row has children (tree structure)
+                    const children = treeConfig?.enabled ? this.getNestedValue(row, childrenKey) : undefined;
+                    if (children && Array.isArray(children) && children.length > 0) {
+                        // Count this row plus its children (recursively)
+                        count += 1 + countActualRows(children);
+                    }
+                    else {
+                        // Regular row
+                        count += 1;
+                    }
+                });
+                return count;
+            };
+            const actualRowCount = countActualRows(group.rows);
             // Add group header row
             const groupHeader = {
                 ...group.rows[0],
@@ -11771,7 +11789,7 @@ class CideEleDataGridComponent {
                 _groupValue: group.value,
                 _groupColumnKey: groupColumnKey,
                 _groupLevel: level,
-                _groupRowCount: group.rows.length,
+                _groupRowCount: actualRowCount,
                 _groupPath: level > 0 ? this.buildGroupPath(group.rows[0], groupColumns, level) : []
             };
             result.push(groupHeader);
@@ -11790,18 +11808,32 @@ class CideEleDataGridComponent {
                     // Check if this row has children (tree structure)
                     const children = treeConfig?.enabled ? this.getNestedValue(row, childrenKey) : undefined;
                     if (children && Array.isArray(children) && children.length > 0) {
+                        // This row has children - check if children belong to the same group
+                        const parentGroupValue = this.getGroupValueForRow(row, groupColumnKey, displayValueGetter, groupKeyGetter);
+                        // Check if all children belong to the same group as parent
+                        const childrenInSameGroup = children.every(child => {
+                            const childGroupValue = this.getGroupValueForRow(child, groupColumnKey, displayValueGetter, groupKeyGetter);
+                            return this.getFilterValueKey(childGroupValue) === this.getFilterValueKey(parentGroupValue);
+                        });
                         // This row has children - preserve tree structure
                         const processedRow = { ...row };
-                        // Recursively process children if there are more grouping levels
-                        if (level + 1 < groupColumns.length) {
-                            // Apply grouping to children
-                            const groupedChildren = this.groupDataRecursive(children, groupColumns, level + 1);
-                            // Update the row with grouped children
-                            this.setNestedValue(processedRow, childrenKey, groupedChildren);
+                        if (childrenInSameGroup) {
+                            // All children are in the same group as parent - don't create group headers for them
+                            // Just preserve children structure without grouping
+                            this.setNestedValue(processedRow, childrenKey, children);
                         }
                         else {
-                            // No more grouping levels, but preserve children structure
-                            this.setNestedValue(processedRow, childrenKey, children);
+                            // Children are in different groups - apply grouping to show group headers
+                            if (level + 1 < groupColumns.length) {
+                                // Apply grouping to children to create group headers
+                                const groupedChildren = this.groupDataRecursive(children, groupColumns, level + 1);
+                                // Update the row with grouped children
+                                this.setNestedValue(processedRow, childrenKey, groupedChildren);
+                            }
+                            else {
+                                // No more grouping levels, but preserve children structure
+                                this.setNestedValue(processedRow, childrenKey, children);
+                            }
                         }
                         processedRows.push(processedRow);
                     }
@@ -11829,6 +11861,19 @@ class CideEleDataGridComponent {
         }
         return result;
     }
+    /**
+     * Get the group value for a row (helper for checking if parent and children are in same group)
+     */
+    getGroupValueForRow(row, columnKey, displayValueGetter, groupKeyGetter) {
+        let rawValue;
+        if (groupKeyGetter.includes('.') || groupKeyGetter !== columnKey) {
+            rawValue = this.getNestedValue(row, groupKeyGetter);
+        }
+        else {
+            rawValue = row[columnKey];
+        }
+        return rawValue;
+    }
     /**
      * Get the group path for nested grouping display (internal method)
      */