@opencorestack/opengridx 2.0.4 → 3.0.0

package/lib/hooks/core/useGridRowPipeline.test.ts

@@ -1,117 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { renderHook } from '@testing-library/react';
-import { useGridRowPipeline } from './useGridRowPipeline';
-
-const DEFAULT_PAGINATION = { page: 0, pageSize: 3 };
-
-const ROWS = [
-    { id: 1, name: 'Alice', age: 30 },
-    { id: 2, name: 'Bob', age: 25 },
-    { id: 3, name: 'Carol', age: 35 },
-    { id: 4, name: 'Dan', age: 28 },
-    { id: 5, name: 'Eve', age: 22 },
-];
-
-const BASE_PARAMS = {
-    effectiveRows: ROWS,
-    activeHierarchyHandlers: null,
-    filterMode: 'client',
-    filterModel: { items: [] },
-    sortModel: [],
-    sortingMode: 'client',
-    pagination: false,
-    paginationMode: 'client',
-    effectivePaginationModel: DEFAULT_PAGINATION,
-    isLoading: false,
-    pageSize: 3,
-};
-
-describe('useGridRowPipeline — filtering', () => {
-    it('passes all rows through when filterModel is empty', () => {
-        const { result } = renderHook(() => useGridRowPipeline(BASE_PARAMS));
-        expect(result.current.filteredRows).toHaveLength(5);
-    });
-
-    it('filters rows by string contains operator', () => {
-        const { result } = renderHook(() => useGridRowPipeline({
-            ...BASE_PARAMS,
-            filterModel: { items: [{ id: 'f1', field: 'name', operator: 'contains' as const, value: 'al' }] },
-        }));
-        // 'Alice' contains 'al' (case-insensitive); 'Carol' does not ('car-o-l')
-        expect(result.current.filteredRows.map(r => r.id)).toEqual([1]);
-    });
-
-    it('filterMode=server passes rows through unfiltered', () => {
-        const { result } = renderHook(() => useGridRowPipeline({
-            ...BASE_PARAMS,
-            filterMode: 'server',
-            // dataSource required: hook only bypasses filtering when both filterMode=server AND dataSource are set
-            dataSource: {} as never,
-            filterModel: { items: [{ id: 'f1', field: 'name', operator: 'contains' as const, value: 'Alice' }] },
-        }));
-        expect(result.current.filteredRows).toHaveLength(5);
-    });
-});
-
-describe('useGridRowPipeline — sorting', () => {
-    it('sorts rows ascending by field', () => {
-        const { result } = renderHook(() => useGridRowPipeline({
-            ...BASE_PARAMS,
-            sortModel: [{ field: 'age', sort: 'asc' }],
-        }));
-        const ages = result.current.sortedUnpinnedRows.map(r => r.age);
-        expect(ages).toEqual([22, 25, 28, 30, 35]);
-    });
-
-    it('sorts rows descending by field', () => {
-        const { result } = renderHook(() => useGridRowPipeline({
-            ...BASE_PARAMS,
-            sortModel: [{ field: 'age', sort: 'desc' }],
-        }));
-        const ages = result.current.sortedUnpinnedRows.map(r => r.age);
-        expect(ages).toEqual([35, 30, 28, 25, 22]);
-    });
-
-    it('sortingMode=server passes rows through unsorted', () => {
-        const { result } = renderHook(() => useGridRowPipeline({
-            ...BASE_PARAMS,
-            sortingMode: 'server',
-            // dataSource required: hook only bypasses sorting when both sortingMode=server AND dataSource are set
-            dataSource: {} as never,
-            sortModel: [{ field: 'age', sort: 'asc' }],
-        }));
-        // Rows stay in original order
-        expect(result.current.sortedUnpinnedRows.map(r => r.id)).toEqual([1, 2, 3, 4, 5]);
-    });
-});
-
-describe('useGridRowPipeline — pagination', () => {
-    it('returns first pageSize rows on page 0', () => {
-        const { result } = renderHook(() => useGridRowPipeline({
-            ...BASE_PARAMS,
-            pagination: true,
-            effectivePaginationModel: { page: 0, pageSize: 3 },
-        }));
-        expect(result.current.paginatedUnpinnedRows.map(r => r.id)).toEqual([1, 2, 3]);
-    });
-
-    it('returns correct offset slice on page 1', () => {
-        const { result } = renderHook(() => useGridRowPipeline({
-            ...BASE_PARAMS,
-            pagination: true,
-            effectivePaginationModel: { page: 1, pageSize: 3 },
-        }));
-        expect(result.current.paginatedUnpinnedRows.map(r => r.id)).toEqual([4, 5]);
-    });
-
-    it('paginationMode=server returns all rows unsliced', () => {
-        const { result } = renderHook(() => useGridRowPipeline({
-            ...BASE_PARAMS,
-            pagination: true,
-            paginationMode: 'server',
-            dataSource: {} as never,
-            effectivePaginationModel: { page: 0, pageSize: 2 },
-        }));
-        expect(result.current.paginatedUnpinnedRows).toHaveLength(5);
-    });
-});

package/lib/hooks/features/useAggregation.test.ts

@@ -1,175 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { renderHook } from '@testing-library/react';
-import { useAggregation, formatAggregationValue } from './useAggregation';
-
-const ROWS = [
-    { id: 1, salary: 50000, dept: 'Eng', active: true },
-    { id: 2, salary: 60000, dept: 'Eng', active: false },
-    { id: 3, salary: 70000, dept: 'HR', active: true },
-    { id: 4, salary: null, dept: 'HR', active: true },
-    { id: 5, salary: 80000, dept: 'Eng', active: null },
-];
-
-describe('formatAggregationValue', () => {
-    it('returns em-dash for null', () => {
-        expect(formatAggregationValue(null, 'sum')).toBe('—');
-    });
-    it('formats avg with up to 2 decimal places', () => {
-        expect(formatAggregationValue(1234.5678, 'avg')).toBe('1,234.57');
-    });
-    it('formats non-avg numbers without decimals', () => {
-        expect(formatAggregationValue(1234567, 'sum')).toBe('1,234,567');
-    });
-    it('converts non-numeric to string', () => {
-        expect(formatAggregationValue('Engineering', 'unique')).toBe('Engineering');
-    });
-});
-
-describe('useAggregation — client-side', () => {
-    it('returns empty result when no aggregation model', () => {
-        const { result } = renderHook(() =>
-            useAggregation({ rows: ROWS, aggregationModel: {}, isServerSide: false })
-        );
-        expect(result.current.aggregationResult).toEqual({});
-    });
-
-    it('computes sum correctly, skipping nulls', () => {
-        const { result } = renderHook(() =>
-            useAggregation({
-                rows: ROWS,
-                aggregationModel: { salary: 'sum' },
-                isServerSide: false,
-            })
-        );
-        expect(result.current.aggregationResult.salary).toBe(260000);
-    });
-
-    it('computes avg correctly', () => {
-        const { result } = renderHook(() =>
-            useAggregation({
-                rows: ROWS,
-                aggregationModel: { salary: 'avg' },
-                isServerSide: false,
-            })
-        );
-        expect(result.current.aggregationResult.salary).toBeCloseTo(65000);
-    });
-
-    it('computes count of non-null values', () => {
-        const { result } = renderHook(() =>
-            useAggregation({
-                rows: ROWS,
-                aggregationModel: { salary: 'count' },
-                isServerSide: false,
-            })
-        );
-        expect(result.current.aggregationResult.salary).toBe(4);
-    });
-
-    it('computes min and max', () => {
-        const { result } = renderHook(() =>
-            useAggregation({
-                rows: ROWS,
-                aggregationModel: { salary: 'min' },
-                isServerSide: false,
-            })
-        );
-        expect(result.current.aggregationResult.salary).toBe(50000);
-
-        const { result: r2 } = renderHook(() =>
-            useAggregation({
-                rows: ROWS,
-                aggregationModel: { salary: 'max' },
-                isServerSide: false,
-            })
-        );
-        expect(r2.current.aggregationResult.salary).toBe(80000);
-    });
-
-    it('computes unique count', () => {
-        const { result } = renderHook(() =>
-            useAggregation({
-                rows: ROWS,
-                aggregationModel: { dept: 'unique' },
-                isServerSide: false,
-            })
-        );
-        expect(result.current.aggregationResult.dept).toBe(2);
-    });
-
-    it('handles unknown function gracefully — skips the field', () => {
-        const { result } = renderHook(() =>
-            useAggregation({
-                rows: ROWS,
-                aggregationModel: { salary: 'median' as 'sum' },
-                isServerSide: false,
-            })
-        );
-        expect(result.current.aggregationResult.salary).toBeUndefined();
-    });
-
-    it('returns {} and does not mutate state when isServerSide=true', () => {
-        const { result } = renderHook(() =>
-            useAggregation({
-                rows: ROWS,
-                aggregationModel: { salary: 'sum' },
-                isServerSide: true,
-            })
-        );
-        // No dataSource → serverResult stays {}
-        expect(result.current.aggregationResult).toEqual({});
-    });
-
-    it('returns serverAggregationResults when provided', () => {
-        const serverResults = { salary: 999999 };
-        const { result } = renderHook(() =>
-            useAggregation({
-                rows: ROWS,
-                aggregationModel: { salary: 'sum' },
-                isServerSide: true,
-                serverAggregationResults: serverResults,
-            })
-        );
-        expect(result.current.aggregationResult).toEqual(serverResults);
-    });
-
-    it('skips aggregation when function not in availableAggregationFunctions', () => {
-        const columns = [{ field: 'salary', availableAggregationFunctions: ['avg', 'count'] }];
-        const { result } = renderHook(() =>
-            useAggregation({
-                rows: ROWS,
-                columns,
-                aggregationModel: { salary: 'sum' },
-                isServerSide: false,
-            })
-        );
-        // 'sum' is not in the allowed list, so the result should be absent
-        expect(result.current.aggregationResult.salary).toBeUndefined();
-    });
-
-    it('computes aggregation when function is in availableAggregationFunctions', () => {
-        const columns = [{ field: 'salary', availableAggregationFunctions: ['sum', 'avg'] }];
-        const { result } = renderHook(() =>
-            useAggregation({
-                rows: ROWS,
-                columns,
-                aggregationModel: { salary: 'sum' },
-                isServerSide: false,
-            })
-        );
-        expect(result.current.aggregationResult.salary).toBe(260000);
-    });
-
-    it('does not restrict aggregation when availableAggregationFunctions is absent', () => {
-        const columns = [{ field: 'salary' }];
-        const { result } = renderHook(() =>
-            useAggregation({
-                rows: ROWS,
-                columns,
-                aggregationModel: { salary: 'sum' },
-                isServerSide: false,
-            })
-        );
-        expect(result.current.aggregationResult.salary).toBe(260000);
-    });
-});

package/lib/hooks/features/usePivot.test.ts

@@ -1,202 +0,0 @@
-/**
- * Tests for usePivot — including regression tests for grand total correctness.
- *
- * Bug (fixed): avg/min/max grand total was computed by re-aggregating
- * per-row pivot values instead of re-computing from the raw source rows.
- * This produced wrong results whenever groups had unequal sizes.
- *
- * Example of the failure:
- *   Group A: avg salary = (30k + 50k) / 2 = 40k
- *   Group B: avg salary = (90k) / 1 = 90k
- *   Summing those per-row averages → 130k / 2 = 65k  ← WRONG
- *   Correct grand avg → (30k + 50k + 90k) / 3 = 56.67k
- */
-
-import { describe, it, expect } from 'vitest';
-import { renderHook } from '@testing-library/react';
-import { usePivot } from './usePivot';
-import type { GridColDef } from '../../types';
-import type { GridPivotModel } from '../../types';
-
-const COLS: GridColDef[] = [
-    { field: 'dept',   headerName: 'Department', width: 120 },
-    { field: 'region', headerName: 'Region',     width: 120 },
-    { field: 'salary', headerName: 'Salary',     width: 120, type: 'number' },
-];
-
-// Intentionally uneven groups so naive "average of averages" gives wrong results.
-//
-// dept=Eng  → salaries [30000, 50000]  → avg=40000, min=30000, max=50000
-// dept=HR   → salaries [90000]         → avg=90000, min=90000, max=90000
-//
-// Grand total correct:
-//   avg = (30000+50000+90000)/3 ≈ 56666.67
-//   min = 30000
-//   max = 90000
-const ROWS = [
-    { id: 1, dept: 'Eng', region: 'US', salary: 30000 },
-    { id: 2, dept: 'Eng', region: 'US', salary: 50000 },
-    { id: 3, dept: 'HR',  region: 'US', salary: 90000 },
-];
-
-const MODEL_NO_COL_FIELDS: GridPivotModel = {
-    rowFields:    ['dept'],
-    columnFields: [],
-    valueFields:  [
-        { field: 'salary', aggFn: 'sum'   },
-        { field: 'salary', aggFn: 'avg'   },
-        { field: 'salary', aggFn: 'count' },
-        { field: 'salary', aggFn: 'min'   },
-        { field: 'salary', aggFn: 'max'   },
-    ],
-};
-
-function grandTotalRow(pivotRows: ReturnType<typeof usePivot>['pivotRows']) {
-    return pivotRows.find(r => r.id === '__pivot_grand_total__')!;
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Basic functionality
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('usePivot — basic', () => {
-    it('returns isValid=false when disabled', () => {
-        const { result } = renderHook(() =>
-            usePivot(ROWS, COLS, MODEL_NO_COL_FIELDS, false)
-        );
-        expect(result.current.isValid).toBe(false);
-        expect(result.current.pivotRows).toHaveLength(0);
-    });
-
-    it('returns isValid=false when valueFields is empty', () => {
-        const { result } = renderHook(() =>
-            usePivot(ROWS, COLS, { ...MODEL_NO_COL_FIELDS, valueFields: [] }, true)
-        );
-        expect(result.current.isValid).toBe(false);
-    });
-
-    it('produces one pivot row per unique rowField value plus grand total', () => {
-        const { result } = renderHook(() =>
-            usePivot(ROWS, COLS, MODEL_NO_COL_FIELDS, true)
-        );
-        // 2 groups (Eng, HR) + 1 grand total
-        expect(result.current.pivotRows).toHaveLength(3);
-        expect(result.current.isValid).toBe(true);
-    });
-
-    it('computes per-group sum correctly', () => {
-        const model: GridPivotModel = {
-            ...MODEL_NO_COL_FIELDS,
-            valueFields: [{ field: 'salary', aggFn: 'sum' }],
-        };
-        const { result } = renderHook(() => usePivot(ROWS, COLS, model, true));
-        const rows = result.current.pivotRows;
-        const eng = rows.find(r => r.dept === 'Eng')!;
-        const hr  = rows.find(r => r.dept === 'HR')!;
-
-        expect(eng['salarysum']).toBe(80000);
-        expect(hr['salarysum']).toBe(90000);
-    });
-});
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Regression: grand total avg/min/max
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('usePivot — grand total regression', () => {
-    it('grand total sum = sum of all raw values', () => {
-        const model: GridPivotModel = {
-            ...MODEL_NO_COL_FIELDS,
-            valueFields: [{ field: 'salary', aggFn: 'sum' }],
-        };
-        const { result } = renderHook(() => usePivot(ROWS, COLS, model, true));
-        const gt = grandTotalRow(result.current.pivotRows);
-        expect(gt['salarysum']).toBe(170000);
-    });
-
-    it('grand total avg = raw mean, NOT average of per-group averages', () => {
-        // The naive bug: (40000 + 90000) / 2 = 65000
-        // The correct value: (30000 + 50000 + 90000) / 3 ≈ 56666.67
-        const model: GridPivotModel = {
-            ...MODEL_NO_COL_FIELDS,
-            valueFields: [{ field: 'salary', aggFn: 'avg' }],
-        };
-        const { result } = renderHook(() => usePivot(ROWS, COLS, model, true));
-        const gt = grandTotalRow(result.current.pivotRows);
-
-        const correct = (30000 + 50000 + 90000) / 3;
-        const bugged  = (40000 + 90000) / 2;
-
-        expect(gt['salaryavg']).toBeCloseTo(correct, 2);
-        expect(gt['salaryavg']).not.toBeCloseTo(bugged, 2);
-    });
-
-    it('grand total min = minimum across ALL raw rows, not minimum of per-group minimums', () => {
-        // With equal-size groups the two approaches coincidentally match.
-        // This dataset has unequal groups, so we must use raw data.
-        const model: GridPivotModel = {
-            ...MODEL_NO_COL_FIELDS,
-            valueFields: [{ field: 'salary', aggFn: 'min' }],
-        };
-        const { result } = renderHook(() => usePivot(ROWS, COLS, model, true));
-        const gt = grandTotalRow(result.current.pivotRows);
-        expect(gt['salarymin']).toBe(30000);
-    });
-
-    it('grand total max = maximum across ALL raw rows', () => {
-        const model: GridPivotModel = {
-            ...MODEL_NO_COL_FIELDS,
-            valueFields: [{ field: 'salary', aggFn: 'max' }],
-        };
-        const { result } = renderHook(() => usePivot(ROWS, COLS, model, true));
-        const gt = grandTotalRow(result.current.pivotRows);
-        expect(gt['salarymax']).toBe(90000);
-    });
-
-    it('grand total count = total number of non-null raw values', () => {
-        const model: GridPivotModel = {
-            ...MODEL_NO_COL_FIELDS,
-            valueFields: [{ field: 'salary', aggFn: 'count' }],
-        };
-        const { result } = renderHook(() => usePivot(ROWS, COLS, model, true));
-        const gt = grandTotalRow(result.current.pivotRows);
-        // sum of per-group counts = 2 + 1 = 3, which also equals total count here.
-        expect(gt['salarycount']).toBe(3);
-    });
-
-    it('grand total avg ignores null salary values', () => {
-        const rowsWithNull = [
-            ...ROWS,
-            { id: 4, dept: 'Eng', region: 'US', salary: null as unknown as number },
-        ];
-        const model: GridPivotModel = {
-            ...MODEL_NO_COL_FIELDS,
-            valueFields: [{ field: 'salary', aggFn: 'avg' }],
-        };
-        const { result } = renderHook(() => usePivot(rowsWithNull, COLS, model, true));
-        const gt = grandTotalRow(result.current.pivotRows);
-
-        // null must be excluded: (30000+50000+90000)/3 not /4
-        const correct = (30000 + 50000 + 90000) / 3;
-        expect(gt['salaryavg']).toBeCloseTo(correct, 2);
-    });
-});
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Pivot with column fields (colKeys drive dynamic column generation)
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('usePivot — with columnFields', () => {
-    it('produces one pivot column per unique columnField value × valueField', () => {
-        const model: GridPivotModel = {
-            rowFields:    ['dept'],
-            columnFields: ['region'],
-            valueFields:  [{ field: 'salary', aggFn: 'sum' }],
-        };
-        const { result } = renderHook(() => usePivot(ROWS, COLS, model, true));
-        // colKeys = ['US'] → 1 col per valueField = 1 column (+ dept label column)
-        expect(result.current.colKeys).toEqual(['US']);
-        // Total pivot columns = 1 row-field col + 1 value col
-        expect(result.current.pivotColumns).toHaveLength(2);
-    });
-});

package/lib/hooks/useRowGrouping.test.ts

@@ -1,137 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { renderHook } from '@testing-library/react';
-import { useRowGrouping } from './useRowGrouping';
-
-const ROWS = [
-    { id: 1, dept: 'Engineering', name: 'Alice' },
-    { id: 2, dept: 'Engineering', name: 'Bob' },
-    { id: 3, dept: 'HR', name: 'Carol' },
-];
-
-const GET_ROW_ID = (row: { id: number }) => row.id;
-const GROUPING_MODEL = ['dept'];
-const AGGREGATION_MODEL = {};
-
-const BASE_PARAMS = {
-    rows: ROWS,
-    getRowId: GET_ROW_ID,
-    rowGroupingModel: GROUPING_MODEL,
-    aggregationModel: AGGREGATION_MODEL,
-};
-
-describe('useRowGrouping — rowMetaMap', () => {
-    it('includes treeDepth for group rows', () => {
-        const { result } = renderHook(() => useRowGrouping(BASE_PARAMS));
-        const map = result.current.rowMetaMap;
-        // Group rows are at depth 0 (top-level)
-        let foundGroupAtDepth0 = false;
-        map.forEach((meta, _id) => {
-            if (meta.isGroupRow) {
-                expect(meta.treeDepth).toBe(0);
-                foundGroupAtDepth0 = true;
-            }
-        });
-        expect(foundGroupAtDepth0).toBe(true);
-    });
-
-    it('includes treeDepth for leaf rows', () => {
-        const { result } = renderHook(() => useRowGrouping(BASE_PARAMS));
-        const map = result.current.rowMetaMap;
-        // Leaf rows (original rows) are at depth 1 (under the group)
-        let foundLeafAtDepth1 = false;
-        map.forEach((meta, _id) => {
-            if (!meta.isGroupRow) {
-                expect(meta.treeDepth).toBe(1);
-                foundLeafAtDepth1 = true;
-            }
-        });
-        expect(foundLeafAtDepth1).toBe(true);
-    });
-
-    it('sets isGroupRow true for group rows and false for leaves', () => {
-        const { result } = renderHook(() => useRowGrouping(BASE_PARAMS));
-        const map = result.current.rowMetaMap;
-        // Leaf rows have numeric ids (1, 2, 3)
-        expect(map.get(1)?.isGroupRow).toBe(false);
-        expect(map.get(2)?.isGroupRow).toBe(false);
-        expect(map.get(3)?.isGroupRow).toBe(false);
-        // Group rows use auto-generated string ids
-        let groupCount = 0;
-        map.forEach((meta) => {
-            if (meta.isGroupRow) groupCount++;
-        });
-        // Two groups: Engineering and HR
-        expect(groupCount).toBe(2);
-    });
-
-    it('includes all rows (group + leaf) in the map', () => {
-        const { result } = renderHook(() => useRowGrouping(BASE_PARAMS));
-        const map = result.current.rowMetaMap;
-        // 3 leaf rows + 2 group rows = 5 entries
-        expect(map.size).toBe(5);
-    });
-
-    it('has hasChildren true for group rows and false for leaf rows', () => {
-        const { result } = renderHook(() => useRowGrouping(BASE_PARAMS));
-        const map = result.current.rowMetaMap;
-        expect(map.get(1)?.hasChildren).toBe(false);
-        map.forEach((meta) => {
-            if (meta.isGroupRow) {
-                expect(meta.hasChildren).toBe(true);
-            }
-        });
-    });
-
-    it('populates groupLabel from groupingValueFormatter when provided', () => {
-        const formatter = ({ field, value }: { field: string; value: unknown }) =>
-            `${String(field).toUpperCase()}: ${String(value)}`;
-        const columns = [{ field: 'dept', groupingValueFormatter: formatter }];
-        const { result } = renderHook(() =>
-            useRowGrouping({ ...BASE_PARAMS, columns })
-        );
-        const map = result.current.rowMetaMap;
-        let foundFormatted = false;
-        map.forEach((meta) => {
-            if (meta.isGroupRow) {
-                expect(meta.groupLabel).toMatch(/^DEPT:/);
-                foundFormatted = true;
-            }
-        });
-        expect(foundFormatted).toBe(true);
-    });
-
-    it('uses default field: value label when groupingValueFormatter is absent', () => {
-        const { result } = renderHook(() => useRowGrouping(BASE_PARAMS));
-        const map = result.current.rowMetaMap;
-        map.forEach((meta) => {
-            if (meta.isGroupRow) {
-                expect(meta.groupLabel).toMatch(/^dept:/);
-            }
-        });
-    });
-});
-
-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 }];
-        const { result } = renderHook(() =>
-            useRowGrouping({ ...BASE_PARAMS, columns })
-        );
-        const map = result.current.rowMetaMap;
-        // With groupable:false on 'dept', no group rows should exist
-        let groupCount = 0;
-        map.forEach((meta) => { if (meta.isGroupRow) groupCount++; });
-        expect(groupCount).toBe(0);
-    });
-
-    it('still groups when groupable is true (explicit)', () => {
-        const columns = [{ field: 'dept', groupable: true as const }];
-        const { result } = renderHook(() =>
-            useRowGrouping({ ...BASE_PARAMS, columns })
-        );
-        const map = result.current.rowMetaMap;
-        let groupCount = 0;
-        map.forEach((meta) => { if (meta.isGroupRow) groupCount++; });
-        expect(groupCount).toBe(2);
-    });
-});