@opencorestack/opengridx 2.1.0 → 3.0.1

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

@@ -1,176 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { renderHook, act } from '@testing-library/react';
-import React from 'react';
-import { useGridKeyboardNavigation } from './useGridKeyboardNavigation';
-
-// Helper: build a minimal React.KeyboardEvent mock
-function keyEvent(key: string): React.KeyboardEvent {
-    return {
-        key,
-        preventDefault: vi.fn(),
-        stopPropagation: vi.fn(),
-        nativeEvent: new KeyboardEvent('keydown', { key }),
-        isDefaultPrevented: () => false,
-        isPropagationStopped: () => false,
-        persist: vi.fn(),
-        bubbles: true,
-        cancelable: true,
-        defaultPrevented: false,
-        eventPhase: 0,
-        isTrusted: false,
-        timeStamp: 0,
-        type: 'keydown',
-        currentTarget: null,
-        target: null,
-        shiftKey: false,
-        ctrlKey: false,
-        metaKey: false,
-        altKey: false,
-    } as unknown as React.KeyboardEvent;
-}
-
-const ROWS = [
-    { id: 1, name: 'Alice' },
-    { id: 2, name: 'Bob' },
-    { id: 3, name: 'Carol' },
-];
-
-const NAV_COLS = [
-    { field: 'name' },
-    { field: 'age' },
-];
-
-const MOCK_EDITING = {
-    editingCell: null,
-    startCellEdit: vi.fn(),
-    stopCellEdit: vi.fn(),
-};
-
-const MOCK_VIRTUALIZATION = {
-    cumulativeHeights: [52, 104, 156],
-    pinnedTopHeight: 0,
-    columnMetrics: null,
-};
-
-const BASE_PARAMS = {
-    allRenderableRows: ROWS,
-    navigationColumns: NAV_COLS,
-    checkboxSelection: false,
-    selectedRowIds: new Set<number | string>(),
-    handleSelectionChange: vi.fn(),
-    handleDetailPanelToggle: vi.fn(),
-    editingHandlers: MOCK_EDITING,
-    setKeyboardMode: vi.fn(),
-    sortModel: [],
-    handleSort: vi.fn(),
-    isCellEditable: undefined,
-    pagination: false,
-    pageSize: 100,
-    virtualization: MOCK_VIRTUALIZATION,
-    viewportRef: { current: null } as React.RefObject<HTMLDivElement | null>,
-};
-
-describe('useGridKeyboardNavigation — arrow keys', () => {
-    it('ArrowDown moves focusedCell to the next row', () => {
-        const { result } = renderHook(() => useGridKeyboardNavigation(BASE_PARAMS));
-        act(() => { result.current.setFocusedCell({ id: 1, field: 'name' }); });
-        act(() => { result.current.handleKeyDown(keyEvent('ArrowDown')); });
-        expect(result.current.focusedCell).toEqual({ id: 2, field: 'name' });
-    });
-
-    it('ArrowUp at header row does not move above it', () => {
-        const { result } = renderHook(() => useGridKeyboardNavigation(BASE_PARAMS));
-        // HEADER is the topmost position; ArrowUp from there should not move
-        act(() => { result.current.setFocusedCell({ id: 'HEADER', field: 'name' }); });
-        act(() => { result.current.handleKeyDown(keyEvent('ArrowUp')); });
-        expect(result.current.focusedCell?.id).toBe('HEADER');
-    });
-
-    it('ArrowDown at last row — no change', () => {
-        const { result } = renderHook(() => useGridKeyboardNavigation(BASE_PARAMS));
-        // ROWS has 3 entries; last row id is 3
-        const lastRow = ROWS[ROWS.length - 1];
-        act(() => { result.current.setFocusedCell({ id: lastRow.id, field: 'name' }); });
-        act(() => { result.current.handleKeyDown(keyEvent('ArrowDown')); });
-        expect(result.current.focusedCell?.id).toBe(lastRow.id);
-    });
-
-    it('ArrowRight moves focusedCell to next column', () => {
-        const { result } = renderHook(() => useGridKeyboardNavigation(BASE_PARAMS));
-        act(() => { result.current.setFocusedCell({ id: 1, field: 'name' }); });
-        act(() => { result.current.handleKeyDown(keyEvent('ArrowRight')); });
-        expect(result.current.focusedCell?.field).toBe('age');
-    });
-
-    it('ArrowLeft at header first column does not move left', () => {
-        const { result } = renderHook(() => useGridKeyboardNavigation(BASE_PARAMS));
-        // HEADER + first col is the leftmost position; wrap-left would require r=-2 which is out of bounds
-        act(() => { result.current.setFocusedCell({ id: 'HEADER', field: 'name' }); });
-        act(() => { result.current.handleKeyDown(keyEvent('ArrowLeft')); });
-        expect(result.current.focusedCell?.field).toBe('name');
-    });
-});
-
-describe('useGridKeyboardNavigation — Home / End', () => {
-    it('Home moves to first column', () => {
-        const { result } = renderHook(() => useGridKeyboardNavigation(BASE_PARAMS));
-        act(() => { result.current.setFocusedCell({ id: 1, field: 'age' }); });
-        act(() => { result.current.handleKeyDown(keyEvent('Home')); });
-        expect(result.current.focusedCell?.field).toBe('name');
-    });
-
-    it('End moves to last column', () => {
-        const { result } = renderHook(() => useGridKeyboardNavigation(BASE_PARAMS));
-        act(() => { result.current.setFocusedCell({ id: 1, field: 'name' }); });
-        act(() => { result.current.handleKeyDown(keyEvent('End')); });
-        expect(result.current.focusedCell?.field).toBe('age');
-    });
-});
-
-describe('useGridKeyboardNavigation — editing', () => {
-    it('Enter calls startCellEdit on an editable cell', () => {
-        const startCellEdit = vi.fn();
-        const params = {
-            ...BASE_PARAMS,
-            editingHandlers: { ...MOCK_EDITING, startCellEdit },
-            navigationColumns: [{ field: 'name', editable: true }],
-        };
-        const { result } = renderHook(() => useGridKeyboardNavigation(params));
-        act(() => { result.current.setFocusedCell({ id: 1, field: 'name' }); });
-        act(() => { result.current.handleKeyDown(keyEvent('Enter')); });
-        expect(startCellEdit).toHaveBeenCalledWith(
-            expect.objectContaining({ id: 1, field: 'name' })
-        );
-    });
-
-    it('Escape calls stopCellEdit with cancel=true when editing', () => {
-        const stopCellEdit = vi.fn();
-        const params = {
-            ...BASE_PARAMS,
-            editingHandlers: {
-                editingCell: { id: 1, field: 'name', value: 'Alice' },
-                startCellEdit: vi.fn(),
-                stopCellEdit,
-            },
-        };
-        const { result } = renderHook(() => useGridKeyboardNavigation(params));
-        act(() => { result.current.setFocusedCell({ id: 1, field: 'name' }); });
-        act(() => { result.current.handleKeyDown(keyEvent('Escape')); });
-        expect(stopCellEdit).toHaveBeenCalledWith({ cancel: true });
-    });
-});
-
-describe('useGridKeyboardNavigation — selection', () => {
-    it('Space toggles checkbox selection on focused row', () => {
-        const handleSelectionChange = vi.fn();
-        const { result } = renderHook(() => useGridKeyboardNavigation({
-            ...BASE_PARAMS,
-            checkboxSelection: true,
-            handleSelectionChange,
-        }));
-        // Space only fires handleSelectionChange when field === '__checkbox_col__'
-        act(() => { result.current.setFocusedCell({ id: 2, field: '__checkbox_col__' }); });
-        act(() => { result.current.handleKeyDown(keyEvent(' ')); });
-        expect(handleSelectionChange).toHaveBeenCalledWith(2, true);
-    });
-});

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);
-    });
-});