@opencorestack/opengridx 2.0.4 → 2.1.0

package/lib/hooks/features/useAggregation.ts

@@ -9,30 +9,9 @@ import type {
     GridSortItem,
     GridDataSource,
 } from '../../types';
+import { computeAggregations } from '../../utils/aggregation';
 
-export type BuiltInAggFn = 'sum' | 'avg' | 'count' | 'min' | 'max' | 'unique';
-
-const AGGREGATION_FUNCTIONS: Record<BuiltInAggFn, (values: unknown[]) => unknown> = {
-    sum: (values) => {
-        const nums = values.filter((v) => v != null && !isNaN(Number(v)));
-        return nums.reduce((acc: number, v) => acc + Number(v), 0);
-    },
-    avg: (values) => {
-        const nums = values.filter((v) => v != null && !isNaN(Number(v)));
-        if (nums.length === 0) return null;
-        return nums.reduce((acc: number, v) => acc + Number(v), 0) / nums.length;
-    },
-    count: (values) => values.filter((v) => v != null).length,
-    min: (values) => {
-        const nums = values.filter((v) => v != null && !isNaN(Number(v))).map(Number);
-        return nums.length ? Math.min(...nums) : null;
-    },
-    max: (values) => {
-        const nums = values.filter((v) => v != null && !isNaN(Number(v))).map(Number);
-        return nums.length ? Math.max(...nums) : null;
-    },
-    unique: (values) => new Set(values.filter((v) => v != null)).size,
-};
+export type { BuiltInAggFn } from '../../utils/aggregation';
 
 export function formatAggregationValue(value: unknown, fnName: string): string {
     if (value == null) return '—';
@@ -85,21 +64,7 @@ export function useAggregation<R extends GridRowModel>(
     const clientResult = useMemo<GridAggregationResult>(() => {
         if (isServerSide || Object.keys(aggregationModel).length === 0) return {};
 
-        const result: GridAggregationResult = {};
-        for (const [field, fnName] of Object.entries(aggregationModel)) {
-            const colDef = columnsLookup.get(field);
-            if (colDef?.availableAggregationFunctions && !colDef.availableAggregationFunctions.includes(fnName)) {
-                continue;
-            }
-            const fn = AGGREGATION_FUNCTIONS[fnName as BuiltInAggFn];
-            if (!fn) {
-                console.warn(`[useAggregation] Unknown aggregation function: "${fnName}"`);
-                continue;
-            }
-            const values = rows.map((row) => (row as GridRowModel)[field]);
-            result[field] = fn(values);
-        }
-        return result;
+        return computeAggregations(rows, aggregationModel, columnsLookup, 'useAggregation');
     }, [rows, columnsLookup, aggregationModel, isServerSide]);
 
     const [serverResult, setServerResult] = useState<GridAggregationResult>({});

package/lib/hooks/useRowGrouping.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { renderHook } from '@testing-library/react';
+import { renderHook, act } from '@testing-library/react';
 import { useRowGrouping } from './useRowGrouping';
 
 const ROWS = [
@@ -111,6 +111,98 @@ describe('useRowGrouping — rowMetaMap', () => {
     });
 });
 
+describe('useRowGrouping — multi-field rowGroupingModel', () => {
+    const MULTI_ROWS = [
+        { id: 1, dept: 'Engineering', country: 'US', name: 'Alice' },
+        { id: 2, dept: 'Engineering', country: 'US', name: 'Bob' },
+        { id: 3, dept: 'Engineering', country: 'UK', name: 'Carol' },
+        { id: 4, dept: 'HR', country: 'US', name: 'Dave' },
+    ];
+    const MULTI_PARAMS = {
+        rows: MULTI_ROWS,
+        getRowId: GET_ROW_ID,
+        rowGroupingModel: ['dept', 'country'],
+        aggregationModel: AGGREGATION_MODEL,
+    };
+
+    it('nests one group level per field, in rowGroupingModel order', () => {
+        const { result } = renderHook(() => useRowGrouping(MULTI_PARAMS));
+        const map = result.current.rowMetaMap;
+
+        const depts = new Set<unknown>();
+        const countries = new Set<unknown>();
+        map.forEach((meta) => {
+            if (!meta.isGroupRow) return;
+            if (meta.treeDepth === 0) {
+                expect(meta.groupingField).toBe('dept');
+                depts.add(meta.groupingValue);
+            } else if (meta.treeDepth === 1) {
+                expect(meta.groupingField).toBe('country');
+                countries.add(meta.groupingValue);
+            }
+        });
+        // dept groups: Engineering, HR
+        expect(depts).toEqual(new Set(['Engineering', 'HR']));
+        // country groups: US (under Engineering), UK (under Engineering), US (under HR)
+        expect(countries).toEqual(new Set(['US', 'UK']));
+    });
+
+    it('places leaf rows at depth === rowGroupingModel.length', () => {
+        const { result } = renderHook(() => useRowGrouping(MULTI_PARAMS));
+        const map = result.current.rowMetaMap;
+
+        [1, 2, 3, 4].forEach((id) => {
+            const meta = map.get(id);
+            expect(meta?.isGroupRow).toBe(false);
+            expect(meta?.treeDepth).toBe(2);
+        });
+    });
+
+    it('produces one depth-0 group per dept, one depth-1 group per (dept, country) pair', () => {
+        const { result } = renderHook(() => useRowGrouping(MULTI_PARAMS));
+        const map = result.current.rowMetaMap;
+
+        let depth0Count = 0;
+        let depth1Count = 0;
+        map.forEach((meta) => {
+            if (!meta.isGroupRow) return;
+            if (meta.treeDepth === 0) depth0Count++;
+            if (meta.treeDepth === 1) depth1Count++;
+        });
+        // depth 0: Engineering, HR
+        expect(depth0Count).toBe(2);
+        // depth 1: Engineering/US, Engineering/UK, HR/US
+        expect(depth1Count).toBe(3);
+    });
+
+    it('reveals the next level down only after both ancestor groups are expanded', () => {
+        const { result } = renderHook(() => useRowGrouping(MULTI_PARAMS));
+
+        // Fully collapsed: only depth-0 groups are visible.
+        let visible = result.current.getVisibleRows();
+        expect(visible).not.toBeNull();
+        expect(visible!.length).toBe(2);
+
+        const deptGroupId = [...result.current.treeNodes.entries()]
+            .find(([, node]) => node.depth === 0 && node.groupingValue === 'Engineering')![0];
+
+        act(() => { result.current.toggleExpansion(deptGroupId); });
+        visible = result.current.getVisibleRows();
+        // Engineering expanded reveals its 2 country subgroups; HR still collapsed (1 group).
+        expect(visible!.length).toBe(2 + 2);
+
+        // 'US' also exists as a country subgroup under HR — select by parentId to
+        // disambiguate and target Engineering's own US subgroup.
+        const countryGroupId = [...result.current.treeNodes.entries()]
+            .find(([, node]) => node.depth === 1 && node.groupingValue === 'US' && node.parentId === deptGroupId)![0];
+
+        act(() => { result.current.toggleExpansion(countryGroupId); });
+        visible = result.current.getVisibleRows();
+        // Expanding Engineering/US additionally reveals its 2 leaf rows (Alice, Bob).
+        expect(visible!.length).toBe(2 + 2 + 2);
+    });
+});
+
 describe('useRowGrouping — groupable: false', () => {
     it('skips a column with groupable:false — no group rows created for that field', () => {
         const columns = [{ field: 'dept', groupable: false as const }];
@@ -135,3 +227,72 @@ describe('useRowGrouping — groupable: false', () => {
         expect(groupCount).toBe(2);
     });
 });
+
+describe('useRowGrouping — group aggregation matches useAggregation semantics', () => {
+    const NULL_ROWS = [
+        { id: 1, g: 'A', v: 10 as number | null },
+        { id: 2, g: 'A', v: null as number | null },
+        { id: 3, g: 'A', v: 20 as number | null },
+    ];
+    const MODEL = ['g'];
+    const aggFor = (fn: string, columns?: { field: string; availableAggregationFunctions?: string[] }[]) => {
+        const aggregationModel = { v: fn };
+        const { result } = renderHook(() => useRowGrouping({ rows: NULL_ROWS, getRowId: GET_ROW_ID, rowGroupingModel: MODEL, aggregationModel, columns }));
+        return [...result.current.treeNodes.values()].find(n => n.depth === 0)!.aggregatedValues!;
+    };
+
+    it('ignores nulls for min / avg / count instead of treating them as 0', () => {
+        expect(aggFor('min').v).toBe(10);
+        expect(aggFor('avg').v).toBe(15);
+        expect(aggFor('count').v).toBe(2);
+        expect(aggFor('sum').v).toBe(30);
+        expect(aggFor('max').v).toBe(20);
+    });
+
+    it('supports the unique aggregation', () => {
+        expect(aggFor('unique').v).toBe(2);
+    });
+
+    it('honors availableAggregationFunctions', () => {
+        expect(aggFor('avg', [{ field: 'v', availableAggregationFunctions: ['sum'] }])).not.toHaveProperty('v');
+    });
+});
+
+describe('useRowGrouping — expansion state', () => {
+    it('preserves user expansion when rows are replaced with edited copies', () => {
+        const { result, rerender } = renderHook(({ rows }) => useRowGrouping({ ...BASE_PARAMS, rows }), { initialProps: { rows: ROWS } });
+        const eng = [...result.current.treeNodes.values()].find(n => n.groupingValue === 'Engineering')!.id;
+        act(() => { result.current.toggleExpansion(eng); });
+        rerender({ rows: ROWS.map(r => (r.id === 1 ? { ...r, name: 'Alicia' } : r)) });
+        expect(result.current.isGroupExpanded(eng)).toBe(true);
+    });
+
+    it('preserves user expansion when an equal rowGroupingModel is passed as a new array', () => {
+        const { result, rerender } = renderHook(({ model }) => useRowGrouping({ ...BASE_PARAMS, rowGroupingModel: model }), { initialProps: { model: ['dept'] } });
+        const eng = [...result.current.treeNodes.values()].find(n => n.groupingValue === 'Engineering')!.id;
+        act(() => { result.current.toggleExpansion(eng); });
+        rerender({ model: ['dept'] });
+        expect(result.current.isGroupExpanded(eng)).toBe(true);
+    });
+
+    it('discards user overrides when defaultGroupingExpansionDepth changes', () => {
+        const { result, rerender } = renderHook(({ depth }) => useRowGrouping({ ...BASE_PARAMS, defaultGroupingExpansionDepth: depth }), { initialProps: { depth: -1 } });
+        const hr = [...result.current.treeNodes.values()].find(n => n.groupingValue === 'HR')!.id;
+        expect(result.current.isGroupExpanded(hr)).toBe(true);
+        act(() => { result.current.toggleExpansion(hr); });
+        expect(result.current.isGroupExpanded(hr)).toBe(false);
+        // depth 1 also expands depth-0 groups by default; the collapse override must not survive.
+        rerender({ depth: 1 });
+        expect(result.current.isGroupExpanded(hr)).toBe(true);
+    });
+
+    it('does not reorder the memoized tree when getVisibleRows sorts', () => {
+        const { result } = renderHook(() => useRowGrouping({ ...BASE_PARAMS, sortModel: SORT_DESC, defaultGroupingExpansionDepth: -1 }));
+        const eng = [...result.current.treeNodes.values()].find(n => n.groupingValue === 'Engineering')!;
+        const before = [...eng.children!];
+        result.current.getVisibleRows();
+        expect(eng.children).toEqual(before);
+    });
+});
+
+const SORT_DESC = [{ field: 'name', sort: 'desc' as const }];

package/lib/hooks/useRowGrouping.ts

@@ -1,4 +1,4 @@
-import { useState, useMemo, useEffect, useCallback } from 'react';
+import { useState, useMemo, useCallback } from 'react';
 import type {
     GridRowModel,
     GridRowId,
@@ -12,6 +12,7 @@ import type {
 } from '../types';
 import { isRowMatchingFilter } from '../utils/filtering';
 import { compareValues } from '../utils/sorting';
+import { computeAggregations } from '../utils/aggregation';
 
 export interface UseRowGroupingParams<R extends GridRowModel> {
     rows: R[];
@@ -35,6 +36,12 @@ const defaultGetAggregationPosition = (groupNode: GridTreeNode | null): 'inline'
 // infinite re-render loops when callers omit optional params.
 const EMPTY_ROW_GROUPING_MODEL: GridRowGroupingModel = [];
 const EMPTY_AGGREGATION_MODEL: GridAggregationModel = {};
+const EMPTY_OVERRIDES: Map<GridRowId, boolean> = new Map();
+
+interface ExpansionOverrides {
+    configKey: string;
+    overrides: Map<GridRowId, boolean>;
+}
 
 export function useRowGrouping<R extends GridRowModel>(params: UseRowGroupingParams<R>) {
     const {
@@ -55,7 +62,16 @@ export function useRowGrouping<R extends GridRowModel>(params: UseRowGroupingPar
         return map;
     }, [columns]);
 
-    const [expandedGroupIds, setExpandedGroupIds] = useState<Set<GridRowId>>(new Set());
+    // User expand/collapse choices are stored as overrides on top of the depth-based
+    // default, keyed by the grouping config. Rebuilding the tree (row edits, new rows
+    // arrays) keeps them because group ids are deterministic; changing the grouping
+    // config itself discards them.
+    const configKey = `${rowGroupingModel.join('\u001f')}|${defaultGroupingExpansionDepth}`;
+    const [expansionState, setExpansionState] = useState<ExpansionOverrides>(() => ({
+        configKey,
+        overrides: new Map(),
+    }));
+    const overrides = expansionState.configKey === configKey ? expansionState.overrides : EMPTY_OVERRIDES;
 
     const { treeNodes, rootIds, groupingRows } = useMemo(() => {
         const treeNodes = new Map<GridRowId, GridTreeNode>();
@@ -122,24 +138,8 @@ export function useRowGrouping<R extends GridRowModel>(params: UseRowGroupingPar
                 groupIds.push(groupId);
 
                 // Calculate Aggregations for this group
-                const aggregatedValues: Record<string, unknown> = {};
-                if (aggregationModel) {
-                    Object.entries(aggregationModel).forEach(([aggField, aggType]) => {
-                        const values = groupRowsList.map(r => r[aggField]);
-                        if (aggType === 'sum') {
-                            aggregatedValues[aggField] = values.reduce((a: number, b) => a + (Number(b) || 0), 0);
-                        } else if (aggType === 'min') {
-                            aggregatedValues[aggField] = Math.min(...values.map(v => Number(v) || 0));
-                        } else if (aggType === 'max') {
-                            aggregatedValues[aggField] = Math.max(...values.map(v => Number(v) || 0));
-                        } else if (aggType === 'avg') {
-                            const sum = values.reduce((a: number, b) => a + (Number(b) || 0), 0);
-                            aggregatedValues[aggField] = values.length ? sum / values.length : 0;
-                        } else if (aggType === 'count') {
-                            aggregatedValues[aggField] = values.length;
-                        }
-                    });
-                }
+                const aggregatedValues: Record<string, unknown> =
+                    computeAggregations(groupRowsList, aggregationModel, columnsLookup, 'useRowGrouping');
 
                 const groupRow = {
                     [field]: rawValue,
@@ -185,42 +185,29 @@ export function useRowGrouping<R extends GridRowModel>(params: UseRowGroupingPar
 
     }, [rows, rowGroupingModel, aggregationModel, getRowId, getAggregationPosition, columnsLookup]);
 
-    useEffect(() => {
-        if (defaultGroupingExpansionDepth === -1) {
-
-            const allGroupIds = new Set<GridRowId>();
-            treeNodes.forEach((node, id) => {
-                if (node.children && node.children.length > 0) {
-                    allGroupIds.add(id);
-                }
-            });
-            setExpandedGroupIds(allGroupIds);
-        } else if (defaultGroupingExpansionDepth > 0) {
-            const depthIds = new Set<GridRowId>();
-            treeNodes.forEach((node, id) => {
-                if (node.depth < defaultGroupingExpansionDepth && node.children && node.children.length > 0) {
-                    depthIds.add(id);
-                }
-            });
-            setExpandedGroupIds(depthIds);
-        } else {
-
-            setExpandedGroupIds(new Set());
-        }
+    const isDefaultExpanded = useCallback((node: GridTreeNode | undefined) => (
+        Boolean(node?.children && node.children.length > 0) &&
+        (defaultGroupingExpansionDepth === -1 || (node?.depth ?? 0) < defaultGroupingExpansionDepth)
+    ), [defaultGroupingExpansionDepth]);
 
-    }, [rowGroupingModel, defaultGroupingExpansionDepth, treeNodes]);
+    const expandedGroupIds = useMemo<Set<GridRowId>>(() => {
+        const ids = new Set<GridRowId>();
+        treeNodes.forEach((node, id) => {
+            if (!node.children || node.children.length === 0) return;
+            if (overrides.get(id) ?? isDefaultExpanded(node)) ids.add(id);
+        });
+        return ids;
+    }, [treeNodes, overrides, isDefaultExpanded]);
 
     const toggleExpansion = useCallback((id: GridRowId) => {
-        setExpandedGroupIds(prev => {
-            const next = new Set(prev);
-            if (next.has(id)) {
-                next.delete(id);
-            } else {
-                next.add(id);
-            }
-            return next;
+        setExpansionState(prev => {
+            const base = prev.configKey === configKey ? prev.overrides : EMPTY_OVERRIDES;
+            const current = base.get(id) ?? isDefaultExpanded(treeNodes.get(id));
+            const next = new Map(base);
+            next.set(id, !current);
+            return { configKey, overrides: next };
         });
-    }, []);
+    }, [configKey, treeNodes, isDefaultExpanded]);
 
     const isGroupExpanded = useCallback((id: GridRowId) => {
         return expandedGroupIds.has(id);
@@ -255,10 +242,8 @@ export function useRowGrouping<R extends GridRowModel>(params: UseRowGroupingPar
 
         const traverse = (ids: GridRowId[]) => {
 
-            let visibleIds = ids;
-            if (filterModel) {
-                visibleIds = ids.filter(doesNodeMatchFilter);
-            }
+            // Copy before sorting: ids may be node.children / rootIds from the memoized tree.
+            const visibleIds = filterModel ? ids.filter(doesNodeMatchFilter) : [...ids];
 
             if (sortModel && sortModel.length > 0) {
                 visibleIds.sort((aId, bId) => {
@@ -299,15 +284,13 @@ export function useRowGrouping<R extends GridRowModel>(params: UseRowGroupingPar
                     };
                     result.push(enhancedRow);
 
-                    if (isExpandedGroupIds.has(id) && isGroup) {
+                    if (expandedGroupIds.has(id) && isGroup) {
                         traverse(node.children!);
                     }
                 }
             });
         };
 
-        const isExpandedGroupIds = expandedGroupIds; 
-
         traverse(rootIds);
 
         return result;

package/lib/hooks/useTreeData.test.ts

@@ -0,0 +1,83 @@
+import { describe, it, expect, vi } from 'vitest';
+import { renderHook, act } from '@testing-library/react';
+import { useTreeData } from './useTreeData';
+import type { GridRowModel, GridRowId } from '../types';
+
+type Row = GridRowModel & { id: number; path: string[]; name: string };
+
+const ROWS: Row[] = [
+    { id: 1, path: ['CEO'], name: 'Ada' },
+    { id: 2, path: ['CEO', 'CTO'], name: 'Bo' },
+    { id: 3, path: ['CEO', 'CTO', 'Dev'], name: 'Cy' },
+    { id: 4, path: ['CEO', 'CFO'], name: 'Di' },
+];
+
+const getRowId = (r: Row) => r.id;
+const getTreeDataPath = (r: Row) => r.path;
+
+const visibleIds = (rows: GridRowModel[] | null) => (rows ?? []).map(r => r.id as GridRowId);
+
+describe('useTreeData — expansion state', () => {
+    it('expands to defaultGroupingExpansionDepth on the first render (no effect flash)', () => {
+        const { result } = renderHook(() =>
+            useTreeData({ rows: ROWS, getRowId, getTreeDataPath, treeData: true, defaultGroupingExpansionDepth: 1 })
+        );
+        expect(result.current.isGroupExpanded(1)).toBe(true);
+        expect(result.current.isGroupExpanded(2)).toBe(false);
+        expect(visibleIds(result.current.getVisibleRows())).toEqual([1, 2, 4]);
+    });
+
+    it('keeps a user collapse when rows are replaced with edited copies', () => {
+        const { result, rerender } = renderHook(
+            ({ rows }) => useTreeData({ rows, getRowId, getTreeDataPath, treeData: true, defaultGroupingExpansionDepth: -1 }),
+            { initialProps: { rows: ROWS } }
+        );
+        act(() => { result.current.toggleExpansion(2); });
+        expect(result.current.isGroupExpanded(2)).toBe(false);
+
+        rerender({ rows: ROWS.map(r => (r.id === 4 ? { ...r, name: 'Dee' } : r)) });
+        expect(result.current.isGroupExpanded(2)).toBe(false);
+    });
+
+    it('keeps a lazily expanded node open after its children arrive', () => {
+        const lazyRows: Row[] = [
+            { id: 1, path: ['CEO'], name: 'Ada' },
+            { id: 2, path: ['CEO', 'CTO'], name: 'Bo', serverChildrenCount: 1 },
+        ];
+        const { result, rerender } = renderHook(
+            ({ rows }) => useTreeData({ rows, getRowId, getTreeDataPath, treeData: true, defaultGroupingExpansionDepth: 1 }),
+            { initialProps: { rows: lazyRows } }
+        );
+        act(() => { result.current.toggleExpansion(2); });
+        expect(result.current.isGroupExpanded(2)).toBe(true);
+
+        rerender({ rows: [...lazyRows, { id: 3, path: ['CEO', 'CTO', 'Dev'], name: 'Cy' }] });
+        expect(result.current.isGroupExpanded(2)).toBe(true);
+        expect(visibleIds(result.current.getVisibleRows())).toContain(3);
+    });
+
+    it('calls onRowExpansionChange exactly once per expand and never on collapse', () => {
+        const onRowExpansionChange = vi.fn();
+        const { result } = renderHook(() =>
+            useTreeData({ rows: ROWS, getRowId, getTreeDataPath, treeData: true, onRowExpansionChange })
+        );
+        act(() => { result.current.toggleExpansion(1); });
+        expect(onRowExpansionChange).toHaveBeenCalledTimes(1);
+        expect(onRowExpansionChange).toHaveBeenCalledWith(expect.objectContaining({ id: 1 }));
+
+        act(() => { result.current.toggleExpansion(1); });
+        expect(onRowExpansionChange).toHaveBeenCalledTimes(1);
+    });
+
+    it('discards user overrides when defaultGroupingExpansionDepth changes', () => {
+        const { result, rerender } = renderHook(
+            ({ depth }) => useTreeData({ rows: ROWS, getRowId, getTreeDataPath, treeData: true, defaultGroupingExpansionDepth: depth }),
+            { initialProps: { depth: -1 } }
+        );
+        act(() => { result.current.toggleExpansion(1); });
+        expect(result.current.isGroupExpanded(1)).toBe(false);
+
+        rerender({ depth: 1 });
+        expect(result.current.isGroupExpanded(1)).toBe(true);
+    });
+});

package/lib/hooks/useTreeData.ts

@@ -1,9 +1,16 @@
-import { useMemo, useState, useCallback, useEffect } from 'react';
+import { useMemo, useState, useCallback } from 'react';
 import { GridRowModel, GridRowId, GridTreeNode, GridFilterModel, GridSortItem } from '../types';
 import type { GridRowMeta } from '../types';
 import { isRowMatchingFilter } from '../utils/filtering';
 import { compareValues } from '../utils/sorting';
 
+const EMPTY_OVERRIDES: Map<GridRowId, boolean> = new Map();
+
+interface ExpansionOverrides {
+    configKey: string;
+    overrides: Map<GridRowId, boolean>;
+}
+
 interface UseTreeDataProps<R extends GridRowModel> {
     rows: R[];
     getRowId: (row: R) => GridRowId;
@@ -157,49 +164,45 @@ export function useTreeData<R extends GridRowModel>(props: UseTreeDataProps<R>)
 
     }, [rows, getTreeDataPath, treeData, getRowId]);
 
-    const initialExpandedIds = useMemo(() => {
-        if (!treeData) return new Set<GridRowId>();
-
-        const initialExpanded = new Set<GridRowId>();
-        treeNodes.forEach(node => {
-            if (node.children && node.children.length > 0) {
-                 if (defaultGroupingExpansionDepth === -1 || node.depth < defaultGroupingExpansionDepth) {
-                     initialExpanded.add(node.id);
-                 }
-            }
+    // Same model as useRowGrouping: depth-based default plus user overrides keyed by config.
+    // Rebuilding the tree (row edits, lazily loaded children) keeps the user's choices.
+    const configKey = `${treeData}|${defaultGroupingExpansionDepth}`;
+    const [expansionState, setExpansionState] = useState<ExpansionOverrides>(() => ({
+        configKey,
+        overrides: new Map(),
+    }));
+    const overrides = expansionState.configKey === configKey ? expansionState.overrides : EMPTY_OVERRIDES;
+
+    const isDefaultExpanded = useCallback((node: GridTreeNode | undefined) => (
+        Boolean(node?.children && node.children.length > 0) &&
+        (defaultGroupingExpansionDepth === -1 || (node?.depth ?? 0) < defaultGroupingExpansionDepth)
+    ), [defaultGroupingExpansionDepth]);
+
+    const expandedGroupIds = useMemo<Set<GridRowId>>(() => {
+        const ids = new Set<GridRowId>();
+        if (!treeData) return ids;
+        treeNodes.forEach((node, id) => {
+            // A lazily loaded node can be expanded before it has any children, so an
+            // explicit override counts even when children is still empty.
+            if (overrides.get(id) ?? isDefaultExpanded(node)) ids.add(id);
         });
-        return initialExpanded;
-    }, [treeNodes, treeData, defaultGroupingExpansionDepth]);
-
-    const [expandedGroupIds, setExpandedGroupIds] = useState<Set<GridRowId>>(new Set());
-
-    useEffect(() => {
-        if (initialExpandedIds.size > 0) {
-            setExpandedGroupIds(initialExpandedIds);
-        }
-    }, [initialExpandedIds]);
+        return ids;
+    }, [treeData, treeNodes, overrides, isDefaultExpanded]);
 
     const toggleExpansion = useCallback((id: GridRowId) => {
-        setExpandedGroupIds(prev => {
-            const next = new Set(prev);
-            const isExpanding = !next.has(id);
-
-            if (next.has(id)) {
-                next.delete(id);
-            } else {
-                next.add(id);
-            }
-
-            if (isExpanding && onRowExpansionChange) {
-                 const node = treeNodes.get(id);
-                 if (node) {
-                     onRowExpansionChange(node);
-                 }
-            }
-
-            return next;
+        const isExpanding = !expandedGroupIds.has(id);
+        setExpansionState(prev => {
+            const base = prev.configKey === configKey ? prev.overrides : EMPTY_OVERRIDES;
+            const next = new Map(base);
+            next.set(id, isExpanding);
+            return { configKey, overrides: next };
         });
-    }, [treeNodes, onRowExpansionChange]);
+        // Called outside the state updater: updaters may run twice, and this can trigger a server fetch.
+        if (isExpanding && onRowExpansionChange) {
+            const node = treeNodes.get(id);
+            if (node) onRowExpansionChange(node);
+        }
+    }, [expandedGroupIds, configKey, treeNodes, onRowExpansionChange]);
 
     const getVisibleRows = useCallback(() => {
 
@@ -209,9 +212,7 @@ export function useTreeData<R extends GridRowModel>(props: UseTreeDataProps<R>)
         rows.forEach(r => rowLookup.set(getRowId(r), r));
         groupingRows.forEach(r => rowLookup.set(r.id, r));
 
-        const matchesFilter = (row: GridRowModel) => {
-             return isRowMatchingFilter(row, filterModel!);
-        };
+        const matchesFilter = (row: GridRowModel) => (filterModel ? isRowMatchingFilter(row, filterModel) : true);
 
         const filterCache = new Map<GridRowId, boolean>();
 

package/lib/index.ts

@@ -11,6 +11,8 @@ export { FilterPanel } from './components/FilterPanel';
 export { GridToolbar } from './components/Toolbar/GridToolbar';
 export type { GridToolbarProps, ToolbarButtonRenderProps, ToolbarQuickFilterRenderProps } from './components/Toolbar/GridToolbar';
 export { GridTooltip } from './components/Tooltip/Tooltip';
+export { ColumnVisibilityPanel } from './components/ColumnVisibilityPanel/ColumnVisibilityPanel';
+export type { ColumnVisibilityPanelProps } from './components/ColumnVisibilityPanel/ColumnVisibilityPanel';
 
 export { useGridApiRef } from './hooks/core/useGridApiRef';
 export { Button, Input, Checkbox } from './components/ui';

package/lib/types/index.ts

@@ -21,8 +21,9 @@ export interface GridRowModel {
  *
  * @since v1.1 — replaces the `_hasChildren` / `_treeDepth` / `_groupingField` etc.
  * properties that were previously (and incorrectly) typed on `GridRowModel`.
- * Those underscore fields remain on the row object at runtime in v1.1 for
- * backward compatibility; they will be removed from the runtime in v2.0.
+ * Those underscore fields remain on the row object at runtime for backward
+ * compatibility; removal was deferred past v2.0 (still present as of v2.1.0)
+ * to a future major version. Do not rely on them being absent yet.
  */
 export interface GridRowMeta {
     hasChildren?: boolean;
@@ -235,6 +236,11 @@ export interface GridValueFormatterParams<R extends GridRowModel = GridRowModel>
 export interface GridRenderCellParams<R extends GridRowModel = GridRowModel> {
   /** The current cell value. */
   value: unknown;
+  /**
+   * The value after `colDef.valueFormatter` (or `String(value)` when no formatter is set; `''` for null/undefined).
+   * @since v2.1
+   */
+  formattedValue?: string;
   /** The row object. */
   row: R;
   /** The field name and unique ID. */
@@ -704,6 +710,13 @@ export interface DataGridProps<R extends GridRowModel = GridRowModel> {
 
   /** Callback fired when a row is clicked. */
   onRowClick?: (params: GridRowParams<R>) => void;
+  /**
+   * Callback fired when a row is double-clicked. Also fires for group rows; check
+   * `apiRef` / `rowMeta` if you only want leaf rows. Not fired when the double-click
+   * lands on the checkbox, expand icon, drag handle, or an open cell editor.
+   * @since v2.1
+   */
+  onRowDoubleClick?: (params: GridRowParams<R>) => void;
   /** Callback fired when a cell is clicked. */
   onCellClick?: (params: GridCellParams<R>) => void;
 

package/lib/utils/aggregation/aggregation.test.ts

@@ -0,0 +1,16 @@
+import { describe, it, expect } from 'vitest';
+import { AGGREGATION_FUNCTIONS } from './index';
+
+describe('AGGREGATION_FUNCTIONS', () => {
+    it('computes min / max over more values than a spread argument list allows', () => {
+        const values = Array.from({ length: 300_000 }, (_, i) => i);
+        expect(AGGREGATION_FUNCTIONS.min(values)).toBe(0);
+        expect(AGGREGATION_FUNCTIONS.max(values)).toBe(299_999);
+    });
+
+    it('returns null for min / max / avg when there are no numeric values', () => {
+        expect(AGGREGATION_FUNCTIONS.min([null, undefined])).toBeNull();
+        expect(AGGREGATION_FUNCTIONS.max([])).toBeNull();
+        expect(AGGREGATION_FUNCTIONS.avg(['x'])).toBeNull();
+    });
+});