@opencorestack/opengridx 2.1.0 → 3.0.1

package/lib/hooks/useRowGrouping.test.ts

@@ -1,298 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { renderHook, act } 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 — 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 }];
-        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);
-    });
-});
-
-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/useTreeData.test.ts

@@ -1,83 +0,0 @@
-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/utils/aggregation/aggregation.test.ts

@@ -1,16 +0,0 @@
-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();
-    });
-});

package/lib/utils/export/exportToExcelAdvanced.test.ts

@@ -1,109 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import ExcelJS from 'exceljs';
-import { exportToExcelAdvanced } from './exportToExcelAdvanced';
-import type { GridColDef, GridGroupedExportRow, GridRowModel } from '../../types';
-
-type Row = GridRowModel & { id: number; dept: string; salary: number };
-
-const columns: GridColDef<Row>[] = [
-    { field: 'dept', headerName: 'Department' },
-    { field: 'salary', headerName: 'Salary', type: 'number' },
-];
-
-const flatRows: Row[] = [
-    { id: 1, dept: 'Engineering', salary: 90000 },
-    { id: 2, dept: 'Engineering', salary: 85000 },
-    { id: 3, dept: 'Marketing', salary: 70000 },
-];
-
-const groupedRows: GridGroupedExportRow[] = [
-    { type: 'group-header', depth: 0, groupField: 'dept', groupValue: 'Engineering' },
-    { type: 'leaf', depth: 1, row: flatRows[0] },
-    { type: 'leaf', depth: 1, row: flatRows[1] },
-    { type: 'group-subtotal', depth: 0, groupField: 'dept', groupValue: 'Engineering', aggregatedValues: { salary: 175000 } },
-    { type: 'group-header', depth: 0, groupField: 'dept', groupValue: 'Marketing' },
-    { type: 'leaf', depth: 1, row: flatRows[2] },
-    { type: 'group-subtotal', depth: 0, groupField: 'dept', groupValue: 'Marketing', aggregatedValues: { salary: 70000 } },
-    { type: 'grand-total', depth: 0, aggregatedValues: { salary: 245000 } },
-];
-
-let capturedBlob: Blob | null = null;
-const origCreateObjectURL = URL.createObjectURL;
-const origRevokeObjectURL = URL.revokeObjectURL;
-const origClick = HTMLAnchorElement.prototype.click;
-
-beforeEach(() => {
-    capturedBlob = null;
-    URL.createObjectURL = (blob: Blob) => { capturedBlob = blob; return 'blob:mock'; };
-    URL.revokeObjectURL = () => {};
-    HTMLAnchorElement.prototype.click = () => {};
-});
-
-afterEach(() => {
-    URL.createObjectURL = origCreateObjectURL;
-    URL.revokeObjectURL = origRevokeObjectURL;
-    HTMLAnchorElement.prototype.click = origClick;
-});
-
-async function readSheet(): Promise<ExcelJS.Worksheet> {
-    const wb = new ExcelJS.Workbook();
-    await wb.xlsx.load(await capturedBlob!.arrayBuffer());
-    return wb.worksheets[0];
-}
-
-const rowValues = (ws: ExcelJS.Worksheet) =>
-    ws.getSheetValues().slice(1).map(r => (Array.isArray(r) ? r.slice(1) : []));
-
-describe('exportToExcelAdvanced — flat', () => {
-    it('writes a header row and one row per record when groupedRows is absent', async () => {
-        await exportToExcelAdvanced(flatRows, columns);
-        const ws = await readSheet();
-        expect(rowValues(ws)).toEqual([
-            ['Department', 'Salary'],
-            ['Engineering', 90000],
-            ['Engineering', 85000],
-            ['Marketing', 70000],
-        ]);
-    });
-});
-
-describe('exportToExcelAdvanced — grouped', () => {
-    it('writes group headers, leaves, subtotals and a single grand total in order', async () => {
-        await exportToExcelAdvanced(flatRows, columns, {
-            groupedRows,
-            aggregationModel: { salary: 'sum' },
-            aggregationResult: { salary: 245000 },
-            sheets: [{ name: 'Data', includeSummary: true }],
-        });
-        const ws = await readSheet();
-        expect(rowValues(ws)).toEqual([
-            ['Department', 'Salary'],
-            ['Department: Engineering'],
-            ['Engineering', 90000],
-            ['Engineering', 85000],
-            ['Subtotal', 175000],
-            ['Department: Marketing'],
-            ['Marketing', 70000],
-            ['Subtotal', 70000],
-            ['Grand Total', 245000],
-        ]);
-    });
-
-    it('outlines leaf rows one level below their group header', async () => {
-        await exportToExcelAdvanced(flatRows, columns, { groupedRows });
-        const ws = await readSheet();
-        expect(ws.getRow(2).outlineLevel ?? 0).toBe(0);
-        expect(ws.getRow(3).outlineLevel).toBe(1);
-        expect(ws.getRow(4).outlineLevel).toBe(1);
-    });
-
-    it('uses groupingValueFormatter for group-header labels', async () => {
-        const cols: GridColDef<Row>[] = [
-            { ...columns[0], groupingValueFormatter: ({ value }) => `Dept ${String(value)}` },
-            columns[1],
-        ];
-        await exportToExcelAdvanced(flatRows, cols, { groupedRows });
-        const ws = await readSheet();
-        expect(ws.getRow(2).getCell(1).value).toBe('Dept Engineering');
-    });
-});

package/lib/utils/export/exportToPdf.test.ts

@@ -1,120 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import type { GridColDef, GridRowModel } from '../../types';
-
-// --- jsPDF mocks ---
-const mockAutoTable = vi.fn();
-const mockSave = vi.fn();
-const mockSetFontSize = vi.fn();
-const mockSetFont = vi.fn();
-const mockSetTextColor = vi.fn();
-const mockText = vi.fn();
-const mockLine = vi.fn();
-const mockSetDrawColor = vi.fn();
-const mockSetLineWidth = vi.fn();
-const mockAddImage = vi.fn();
-const mockSetPage = vi.fn();
-
-class MockJsPDF {
-    save = mockSave;
-    setFontSize = mockSetFontSize;
-    setFont = mockSetFont;
-    setTextColor = mockSetTextColor;
-    text = mockText;
-    line = mockLine;
-    setDrawColor = mockSetDrawColor;
-    setLineWidth = mockSetLineWidth;
-    addImage = mockAddImage;
-    setPage = mockSetPage;
-    lastAutoTable = { finalY: 50 };
-    internal = {
-        pageSize: { getWidth: () => 297, getHeight: () => 210 },
-        getNumberOfPages: () => 1,
-    };
-    getNumberOfPages = () => 1;
-}
-
-vi.mock('jspdf', () => ({ default: MockJsPDF }));
-vi.mock('jspdf-autotable', () => ({ default: mockAutoTable }));
-
-const sampleColumns: GridColDef[] = [
-    { field: 'name', headerName: 'Name', width: 150 },
-    { field: 'salary', headerName: 'Salary', width: 120, valueFormatter: ({ value }) => `$${value}` },
-    { field: 'hidden', headerName: 'Hidden', width: 100, exportable: false },
-    { field: '__check__', headerName: '', width: 50 },
-];
-
-const sampleRows: GridRowModel[] = [
-    { id: 1, name: 'Alice', salary: 90000, hidden: 'secret' },
-    { id: 2, name: 'Bob', salary: 80000, hidden: 'secret' },
-];
-
-describe('exportToPdf', () => {
-    beforeEach(() => {
-        mockAutoTable.mockClear();
-        mockSave.mockClear();
-        mockText.mockClear();
-        mockAddImage.mockClear();
-    });
-
-    it('calls doc.save with the correct filename', async () => {
-        const { exportToPdf } = await import('./exportToPdf');
-        await exportToPdf(sampleRows, sampleColumns, { fileName: 'my-report' });
-        expect(mockSave).toHaveBeenCalledWith('my-report.pdf');
-    });
-
-    it('uses default filename "export.pdf" when not provided', async () => {
-        const { exportToPdf } = await import('./exportToPdf');
-        await exportToPdf(sampleRows, sampleColumns);
-        expect(mockSave).toHaveBeenCalledWith('export.pdf');
-    });
-
-    it('excludes columns with exportable: false and system columns', async () => {
-        const { exportToPdf } = await import('./exportToPdf');
-        await exportToPdf(sampleRows, sampleColumns);
-        const call = mockAutoTable.mock.calls[0][1];
-        // head should only have Name and Salary — not Hidden or __check__
-        expect(call.head[0]).toEqual(['Name', 'Salary']);
-    });
-
-    it('applies valueFormatter to cell values', async () => {
-        const { exportToPdf } = await import('./exportToPdf');
-        await exportToPdf(sampleRows, sampleColumns);
-        const call = mockAutoTable.mock.calls[0][1];
-        // salary column should be formatted
-        expect(call.body[0][1]).toBe('$90000');
-        expect(call.body[1][1]).toBe('$80000');
-    });
-
-    it('filters to selectedRows when provided', async () => {
-        const { exportToPdf } = await import('./exportToPdf');
-        await exportToPdf(sampleRows, sampleColumns, { selectedRows: [1] });
-        const call = mockAutoTable.mock.calls[0][1];
-        expect(call.body).toHaveLength(1);
-        expect(call.body[0][0]).toBe('Alice');
-    });
-
-    it('appends aggregation footer when aggregationResult is provided', async () => {
-        const { exportToPdf } = await import('./exportToPdf');
-        await exportToPdf(sampleRows, sampleColumns, {
-            aggregationResult: { salary: 170000 },
-            aggregationModel: { salary: 'sum' },
-        });
-        const call = mockAutoTable.mock.calls[0][1];
-        expect(call.foot).toBeDefined();
-        expect(call.foot[0][1]).toBe('$170000');
-    });
-
-    it('renders title text when title option is set', async () => {
-        const { exportToPdf } = await import('./exportToPdf');
-        await exportToPdf(sampleRows, sampleColumns, { title: 'Sales Report' });
-        // doc.text should have been called with the title
-        const textCalls = mockText.mock.calls.map((c: unknown[]) => c[0]);
-        expect(textCalls.some((t: unknown) => t === 'Sales Report')).toBe(true);
-    });
-
-    it('throws descriptive error when jspdf is not installed', async () => {
-        // This test uses a different mock setup — skip in unit suite,
-        // documented as an integration concern
-        expect(true).toBe(true);
-    });
-});