@opencorestack/opengridx 3.0.1 → 3.2.0

package/lib/utils/export/exportToPdf.ts

@@ -57,8 +57,49 @@ interface AutoTableOptions {
     showFoot?: string;
     showHead?: string;
     margin?: { top: number; left: number; right: number; bottom: number };
+    willDrawPage?: (data: AutoTableHookData) => void;
 }
 
+/** The part of jspdf-autotable's hook data used here; `settings` and `cursor` are the table's live objects. */
+interface AutoTableHookData {
+    settings: { showHead: string };
+    cursor: { y: number } | null;
+}
+
+type AutoTableFn = (doc: JsPDFDoc, opts: AutoTableOptions) => void;
+
+/** How the work is sliced. Output does not depend on these values; tests shrink them. */
+export interface PdfExportTuning {
+    /** Longest stretch of synchronous work before yielding to the event loop, in ms. */
+    sliceMs: number;
+    /** Table rows drawn by the first autoTable call; later calls adapt to `sliceMs`. Rounded to even. */
+    renderChunkRows: number;
+    /** Resize later chunks to fit `sliceMs` (default behaviour); false keeps every chunk at `renderChunkRows`. */
+    adaptive: boolean;
+}
+
+const DEFAULT_TUNING: PdfExportTuning = { sliceMs: 30, renderChunkRows: 40, adaptive: true };
+
+/** Default `maxRows`: above this a PDF is tens of MB and takes seconds to build and open. */
+export const PDF_MAX_ROWS_DEFAULT = 20_000;
+
+/**
+ * Let the browser paint and run other tasks. A macrotask on purpose: `scheduler.yield()` resumes
+ * ahead of queued tasks, which starves timers and React's scheduler (a progress bar would not
+ * update until the export finished).
+ */
+function yieldToEventLoop(): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, 0));
+}
+
+function abortError(): DOMException {
+    return new DOMException('PDF export was aborted', 'AbortError');
+}
+
+const now = (): number => (typeof performance !== 'undefined' ? performance.now() : Date.now());
+
+const evenAtLeast2 = (n: number): number => Math.max(2, Math.floor(n / 2) * 2);
+
 type Rgb = [number, number, number];
 
 const DEFAULT_HEADER_BACKGROUND: Rgb = [79, 70, 229];
@@ -144,21 +185,37 @@ const LINE_HEIGHT_MM_PER_PT = 1.15 * 0.3528;
 
 export function exportToPdf<R extends GridValidRowModel = GridRowModel>(rows: R[], columns: GridColDef<R>[], options?: PdfExportOptions<R>): Promise<void>;
 export function exportToPdf<R extends GridValidRowModel = GridRowModel>(rows: R[], columns: GridColDef[], options?: PdfExportOptions<R>): Promise<void>;
-export async function exportToPdf<R extends GridRowModel>(
+export function exportToPdf<R extends GridRowModel>(
     rows: R[],
     columns: GridColDef<R>[],
     options: PdfExportOptions<R> = {}
 ): Promise<void> {
+    return runPdfExport(rows, columns, options, DEFAULT_TUNING);
+}
+
+/** `exportToPdf` with explicit slicing. Internal: not part of the public API. */
+export async function runPdfExport<R extends GridRowModel>(
+    rows: R[],
+    columns: GridColDef<R>[],
+    options: PdfExportOptions<R>,
+    tuning: PdfExportTuning,
+): Promise<void> {
+    const { signal, onProgress } = options;
+    const checkAbort = (): void => {
+        if (signal?.aborted) throw abortError();
+    };
+    checkAbort();
+
     // Lazy-load peer deps — provides a clear error if not installed
     let JsPDF: new (opts: Record<string, unknown>) => JsPDFDoc;
-    let autoTable: (doc: JsPDFDoc, opts: AutoTableOptions) => void;
+    let autoTable: AutoTableFn;
     try {
         const [jspdfMod, autoTableMod] = await Promise.all([
             import('jspdf'),
             import('jspdf-autotable'),
         ]);
         JsPDF = jspdfMod.default as unknown as new (opts: Record<string, unknown>) => JsPDFDoc;
-        autoTable = autoTableMod.default as unknown as (doc: JsPDFDoc, opts: AutoTableOptions) => void;
+        autoTable = autoTableMod.default as unknown as AutoTableFn;
     } catch {
         throw new Error(
             "exportToPdf requires 'jspdf' and 'jspdf-autotable'. Run: npm install jspdf jspdf-autotable"
@@ -181,7 +238,21 @@ export async function exportToPdf<R extends GridRowModel>(
         fontSize = 9,
         groupedRows,
         font,
+        maxRows = PDF_MAX_ROWS_DEFAULT,
     } = options;
+    checkAbort();
+
+    // Time-sliced work: `maybeYield` yields once the current slice has run for `sliceMs`.
+    let sliceStart = now();
+    const maybeYield = async (): Promise<void> => {
+        if (now() - sliceStart < tuning.sliceMs) return;
+        await yieldToEventLoop();
+        checkAbort();
+        sliceStart = now();
+    };
+    const report = (phase: 'prepare' | 'render' | 'save', done: number, total: number): void => {
+        onProgress?.({ phase, done, total });
+    };
 
     const doc = new JsPDF({ orientation, unit: 'mm', format: 'a4' });
     const pageWidth = doc.internal.pageSize.getWidth();
@@ -274,30 +345,48 @@ export async function exportToPdf<R extends GridRowModel>(
     const aggregateTexts = (values: Record<string, unknown>): string[] =>
         exportColumns.map(col => formatExportAggregate(col, aggMod[col.field], values[col.field], values));
 
-    let body: string[][];
+    const body: string[][] = [];
     let foot: string[][] | undefined;
+    const pushRow = (cells: string[]): void => {
+        body.push(cells.map(pdfText));
+    };
 
     if (useGrouped) {
         // Grouped export: flatten the ordered list into body rows with indentation
-        body = [];
-        groupedRows.forEach((entry: GridGroupedExportRow) => {
+        const total = groupedRows.length;
+        report('prepare', 0, total);
+        for (let index = 0; index < total; index++) {
+            const entry: GridGroupedExportRow = groupedRows[index];
             const indent = '  '.repeat(entry.depth * 2);
             if (entry.type === 'group-header') {
                 const label = `${indent}${groupHeaderLabel(entry, columns)}`;
-                body.push(exportColumns.map((_, i) => i === 0 ? label : ''));
+                pushRow(exportColumns.map((_, i) => i === 0 ? label : ''));
             } else if (entry.type === 'leaf' && entry.row) {
                 const row = entry.row as R;
-                body.push(exportColumns.map((col, i) => (i === 0 ? indent : '') + resolveValue(row, col)));
+                pushRow(exportColumns.map((col, i) => (i === 0 ? indent : '') + resolveValue(row, col)));
             } else if (entry.type === 'group-subtotal' && entry.aggregatedValues) {
                 const texts = aggregateTexts(entry.aggregatedValues);
-                body.push(texts.map((text, i) => (i === 0 ? `${indent}${summaryLabelText('Subtotal', text)}` : text)));
+                pushRow(texts.map((text, i) => (i === 0 ? `${indent}${summaryLabelText('Subtotal', text)}` : text)));
             } else if (entry.type === 'grand-total' && entry.aggregatedValues) {
                 const texts = aggregateTexts(entry.aggregatedValues);
-                foot = [texts.map((text, i) => (i === 0 ? summaryLabelText('Grand Total', text) : text))];
+                foot = [texts.map((text, i) => (i === 0 ? summaryLabelText('Grand Total', text) : text)).map(pdfText)];
             }
-        });
+            if ((index & 63) === 63) {
+                report('prepare', index + 1, total);
+                await maybeYield();
+            }
+        }
+        report('prepare', total, total);
     } else {
-        body = rowsToExport.map(row => exportColumns.map(col => resolveValue(row, col)));
+        const total = rowsToExport.length;
+        report('prepare', 0, total);
+        for (let index = 0; index < total; index++) {
+            pushRow(exportColumns.map(col => resolveValue(rowsToExport[index], col)));
+            if ((index & 63) === 63) {
+                report('prepare', index + 1, total);
+                await maybeYield();
+            }
+        }
 
         const totals = aggregationModel
             ? aggregationForExport(rowsToExport, hasSelection(selectedRows), columns, aggregationResult, aggregationModel)
@@ -305,12 +394,19 @@ export async function exportToPdf<R extends GridRowModel>(
         if (totals && aggregationModel) {
             const hasAgg = exportColumns.some(c => aggregationModel[c.field]);
             const texts = aggregateTexts(totals);
-            foot = [texts.map((text, i) => (i === 0 && hasAgg ? summaryLabelText('TOTAL', text) : text))];
+            foot = [texts.map((text, i) => (i === 0 && hasAgg ? summaryLabelText('TOTAL', text) : text)).map(pdfText)];
         }
+        report('prepare', total, total);
     }
+    checkAbort();
 
-    body = body.map(cells => cells.map(pdfText));
-    if (foot) foot = foot.map(cells => cells.map(pdfText));
+    if (body.length > maxRows && process.env.NODE_ENV !== 'production') {
+        console.warn(
+            `[exportToPdf] Exporting ${body.length} table rows (maxRows: ${maxRows}). PDFs this large are slow to build ` +
+            'and open and can reach tens of MB. Prefer exportToCsv or exportToExcelAdvanced for full-dataset exports, ' +
+            'or pass a larger `maxRows` to silence this warning.'
+        );
+    }
 
     if (replacedCharacters) {
         console.warn(
@@ -325,11 +421,8 @@ export async function exportToPdf<R extends GridRowModel>(
     const [hr, hg, hb] = hexToRgb(headerBackgroundColor, DEFAULT_HEADER_BACKGROUND);
     const [tr, tg, tb] = hexToRgb(headerTextColor, DEFAULT_HEADER_TEXT);
 
-    autoTable(doc, {
+    const baseTableOptions: Omit<AutoTableOptions, 'body' | 'startY'> = {
         head,
-        body,
-        ...(foot ? { foot } : {}),
-        startY,
         styles: { fontSize, cellPadding: 3, font: fontName, overflow: 'linebreak' },
         headStyles: {
             fillColor: [hr, hg, hb],
@@ -343,10 +436,59 @@ export async function exportToPdf<R extends GridRowModel>(
             ? { footStyles: { fillColor: [241, 245, 249], fontStyle: 'bold', textColor: [0, 0, 0] } }
             : {}),
         columnStyles,
-        showFoot: foot ? 'lastPage' : 'never',
         showHead: 'everyPage',
         margin: { top: MARGIN, left: MARGIN, right: MARGIN, bottom: MARGIN + 6 },
-    });
+    };
+
+    // The body is drawn as a series of autoTable calls, each continuing where the previous one
+    // ended, so the drawing phase yields too. Column widths are fixed (columnStyles), chunks hold
+    // an even number of rows (alternate shading keeps its parity), only the last chunk carries the
+    // footer, and a continuation chunk skips the header on the page it starts on but repeats it on
+    // every page it adds: the same pages a single call would produce.
+    const totalRows = body.length;
+    report('render', 0, totalRows);
+    let drawn = 0;
+    let chunkRows = evenAtLeast2(tuning.renderChunkRows);
+    do {
+        const chunk = body.slice(drawn, drawn + chunkRows);
+        const isFirst = drawn === 0;
+        const isLast = drawn + chunk.length >= totalRows;
+        const continueY = isFirst ? startY : doc.lastAutoTable.finalY;
+        let firstPageOfChunk = true;
+        const started = now();
+        autoTable(doc, {
+            ...baseTableOptions,
+            body: chunk,
+            ...(isLast && foot ? { foot } : {}),
+            // A continuation starts at the top margin so autoTable's "does the table fit below
+            // startY" check never adds a page; the hook then moves the cursor to where the previous
+            // chunk ended, and each row breaks the page exactly as it would in a single table.
+            startY: isFirst ? startY : MARGIN,
+            showFoot: isLast && foot ? 'lastPage' : 'never',
+            ...(isFirst ? {} : {
+                willDrawPage: (data: AutoTableHookData) => {
+                    if (firstPageOfChunk) {
+                        firstPageOfChunk = false;
+                        // Same page as the previous chunk: its header is already drawn.
+                        data.settings.showHead = 'never';
+                        if (data.cursor) data.cursor.y = continueY;
+                    } else {
+                        data.settings.showHead = 'everyPage';
+                    }
+                },
+            }),
+        });
+        drawn += chunk.length;
+        report('render', drawn, totalRows);
+        const elapsed = now() - started;
+        // Aim each call at one slice; grow at most 4x at a time.
+        if (tuning.adaptive) chunkRows = evenAtLeast2(elapsed > 0 ? Math.min(chunkRows * 4, chunkRows * (tuning.sliceMs / elapsed)) : chunkRows * 4);
+        if (!isLast) {
+            await yieldToEventLoop();
+            checkAbort();
+            sliceStart = now();
+        }
+    } while (drawn < totalRows);
 
     // Two-pass page numbering — stamp all pages after the table is fully rendered
     // so each stamp reads the correct final total (not the running count during draw)
@@ -361,7 +503,11 @@ export async function exportToPdf<R extends GridRowModel>(
             pageHeight - 8,
             { align: 'right' }
         );
+        await maybeYield();
     }
 
+    checkAbort();
+    report('save', 0, 1);
     doc.save(`${fileName}.pdf`);
+    report('save', 1, 1);
 }

package/lib/utils/export/index.ts

@@ -690,4 +690,4 @@ function downloadFile(content: string, fileName: string, mimeType: string): void
 }
 
 export { exportToPdf } from './exportToPdf';
-export type { PdfExportOptions } from '../../types';
+export type { PdfExportOptions, PdfExportProgress } from '../../types';

package/lib/utils/pivot/index.ts

@@ -18,7 +18,7 @@ import {
     isEmptyAggregateValue,
 } from '../aggregation';
 import { createRowFilter } from '../filtering';
-import { compareValues } from '../sorting';
+import { applySortDirection, callSortComparator, compareValues } from '../sorting';
 import { buildColumnLookup } from '../columnLookup';
 import { getCellValue, getFormattedValue } from '../values';
 
@@ -256,7 +256,16 @@ export function computePivot(
     if (sortModel && sortModel.length > 0) {
         kept = [...kept].sort((a, b) => {
             for (const item of sortModel) {
-                const c = compareValues(sortValue(a.row, item.field), sortValue(b.row, item.field), item.sort, typeOf(item.field));
+                const va = sortValue(a.row, item.field);
+                const vb = sortValue(b.row, item.field);
+                const comparator = isRowField(item.field) ? colDefMap.get(item.field)?.sortComparator : undefined;
+                const c = comparator
+                    ? applySortDirection(callSortComparator(
+                        comparator,
+                        { id: a.row.id, field: item.field, row: a.row, value: va },
+                        { id: b.row.id, field: item.field, row: b.row, value: vb },
+                    ), item.sort)
+                    : compareValues(va, vb, item.sort, typeOf(item.field));
                 if (c !== 0) return c;
             }
             return 0;

package/lib/utils/sorting/index.ts

@@ -1,7 +1,7 @@
 
-import type { GridColDef, GridRowModel, GridSortDirection, GridSortItem } from '../../types';
+import type { GridColDef, GridRowId, GridRowModel, GridSortCellParams, GridSortDirection, GridSortItem } from '../../types';
 import type { GridColumnLookup } from '../columnLookup';
-import { getCellValue, toDate, toNumber } from '../values';
+import { getCellValue, toDate, toNumber, warnCallbackFailure } from '../values';
 
 /**
  * Language-aware string order: accented letters sort next to their base letter instead of after
@@ -68,7 +68,8 @@ function compareSortKeys(a: SortKey, b: SortKey): number {
   return a.num < b.num ? -1 : a.num > b.num ? 1 : 0;
 }
 
-function applyDirection(comparison: number, direction: 'asc' | 'desc'): number {
+/** Reverse an ascending comparison for 'desc'. */
+export function applySortDirection(comparison: number, direction: 'asc' | 'desc'): number {
   if (comparison === 0) return 0;
   return direction === 'asc' ? comparison : -comparison;
 }
@@ -83,27 +84,62 @@ export function compareValues(
   direction: 'asc' | 'desc',
   type?: GridColDef['type']
 ): number {
-  return applyDirection(compareSortKeys(toSortKey(a, type), toSortKey(b, type)), direction);
+  return applySortDirection(compareSortKeys(toSortKey(a, type), toSortKey(b, type)), direction);
 }
 
+/** A column's `sortComparator`, as the sorting utils call it. */
+export type GridSortComparatorFn = NonNullable<GridColDef['sortComparator']>;
+
+/**
+ * Call a consumer `sortComparator`, containing failures: a throw or a non-finite result reads as 0
+ * (equal), with a one-time dev warning per column, so one bad comparison cannot break the sort.
+ */
+export function callSortComparator(
+  comparator: GridSortComparatorFn,
+  a: GridSortCellParams,
+  b: GridSortCellParams
+): number {
+  let result: number;
+  try {
+    result = comparator(a.value, b.value, a, b);
+  } catch (error) {
+    warnCallbackFailure(`sortComparator:${a.field}`, `sortComparator for column "${a.field}" threw; the values are treated as equal`, error);
+    return 0;
+  }
+  if (typeof result !== 'number' || Number.isNaN(result)) {
+    warnCallbackFailure(`sortComparator:${a.field}:nan`, `sortComparator for column "${a.field}" returned ${String(result)}; the values are treated as equal`, undefined);
+    return 0;
+  }
+  return result;
+}
+
+const defaultRowId = (row: GridRowModel): GridRowId => row.id;
+
 /**
  * Compare two rows by a sort model, reading cells through `valueGetter` and using each column's
- * `type`. Returns 0 when every key is equal.
+ * `type` (or its `sortComparator`). Returns 0 when every key is equal.
  */
 export function compareRowsBySortModel(
   a: GridRowModel,
   b: GridRowModel,
   sortModel: readonly GridSortItem[],
-  columns?: GridColumnLookup
+  columns?: GridColumnLookup,
+  getRowId: (row: GridRowModel) => GridRowId = defaultRowId
 ): number {
   for (const sortItem of sortModel) {
     const colDef = columns?.byField.get(sortItem.field);
-    const comparison = compareValues(
-      getCellValue(a, sortItem.field, colDef),
-      getCellValue(b, sortItem.field, colDef),
-      sortItem.sort,
-      colDef?.type
-    );
+    const va = getCellValue(a, sortItem.field, colDef);
+    const vb = getCellValue(b, sortItem.field, colDef);
+    const comparison = colDef?.sortComparator
+      ? applySortDirection(
+          callSortComparator(
+            colDef.sortComparator,
+            { id: getRowId(a), field: sortItem.field, row: a, value: va },
+            { id: getRowId(b), field: sortItem.field, row: b, value: vb }
+          ),
+          sortItem.sort
+        )
+      : compareValues(va, vb, sortItem.sort, colDef?.type);
     if (comparison !== 0) return comparison;
   }
   return 0;
@@ -112,28 +148,42 @@ export function compareRowsBySortModel(
 export function sortRows<R extends GridRowModel>(
   rows: R[],
   sortModel: GridSortItem[],
-  columns?: GridColumnLookup
+  columns?: GridColumnLookup,
+  getRowId: (row: R) => GridRowId = defaultRowId
 ): R[] {
   if (sortModel.length === 0) {
     return rows;
   }
   return sortItemsBySortModel(rows, sortModel, (row, sortItem) => {
     const colDef = columns?.byField.get(sortItem.field);
-    return { value: getCellValue(row, sortItem.field, colDef), type: colDef?.type };
+    const value = getCellValue(row, sortItem.field, colDef);
+    return {
+      value,
+      type: colDef?.type,
+      comparator: colDef?.sortComparator,
+      params: colDef?.sortComparator ? { id: getRowId(row), field: sortItem.field, row, value } : undefined,
+    };
   });
 }
 
-/** The value an item sorts by for one sort key, and the column type used to compare it. */
+/** The value an item sorts by for one sort key, and how to compare it. */
 export interface GridSortValue {
   value: unknown;
   type?: GridColDef['type'];
+  /**
+   * The column's `sortComparator`. Two items are compared with it when both carry the same one
+   * (with their `params`); otherwise the built-in comparison of `value` / `type` applies.
+   */
+  comparator?: GridSortComparatorFn;
+  /** The params passed to `comparator` for this item; `value` here is what the comparator sees. */
+  params?: GridSortCellParams;
 }
 
 /**
- * Stable sort of any items by a sort model. `readValue` gives the value (and column type) an item
- * sorts by for each sort key; it is called once per item and key, not once per comparison. Used by
- * the flat pipeline and by tree data / row grouping, whose synthetic group rows sort by their
- * grouping value or label instead of a cell.
+ * Stable sort of any items by a sort model. `readValue` gives the value (and column type or
+ * comparator) an item sorts by for each sort key; it is called once per item and key, not once per
+ * comparison. Used by the flat pipeline and by tree data / row grouping, whose synthetic group rows
+ * sort by their grouping value or label instead of a cell.
  */
 export function sortItemsBySortModel<T>(
   items: readonly T[],
@@ -146,15 +196,18 @@ export function sortItemsBySortModel<T>(
 
   // Read and normalize every sort value once, instead of calling valueGetter and parsing dates
   // O(n log n) times inside the comparator.
-  const keys = sortModel.map(sortItem => items.map(item => {
-    const { value, type } = readValue(item, sortItem);
-    return toSortKey(value, type);
-  }));
+  const values = sortModel.map(sortItem => items.map(item => readValue(item, sortItem)));
+  const keys = values.map(column => column.map(({ value, type }) => toSortKey(value, type)));
 
   const order = items.map((_, index) => index);
   order.sort((ia, ib) => {
     for (let k = 0; k < sortModel.length; k++) {
-      const comparison = applyDirection(compareSortKeys(keys[k][ia], keys[k][ib]), sortModel[k].sort);
+      const a = values[k][ia];
+      const b = values[k][ib];
+      const ascending = a.comparator && a.comparator === b.comparator && a.params && b.params
+        ? callSortComparator(a.comparator, a.params, b.params)
+        : compareSortKeys(keys[k][ia], keys[k][ib]);
+      const comparison = applySortDirection(ascending, sortModel[k].sort);
       if (comparison !== 0) return comparison;
     }
     return ia - ib;

package/llms.txt

@@ -1,6 +1,6 @@
 # OpenGridX — AI Agent Context
 # Package: @opencorestack/opengridx
-# Version: 3.0.1
+# Version: 3.2.0
 # Docs: https://opencorestack.github.io/OpenGridX/
 # This file is machine-readable. AI developers: start here.
 
@@ -248,8 +248,9 @@ There are no getRowClassName / getCellClassName / theme props: use GridColDef.ce
 | align             | 'left'/'center'/'right'                                | Cell content alignment                     |
 | headerAlign       | 'left'/'center'/'right'                                | Header content alignment                   |
 | sortable          | boolean (default true)                                 | Enable sorting                             |
+| sortComparator    | (v1, v2, params1, params2) => number                   | Custom ascending comparator (3.1.0+). v1/v2 are valueGetter values incl. null/undefined; params { id, field, row, value }. Negated for desc; multi-sort tie-break chain; groups by grouping value; tree siblings; pivot row labels. Throw/NaN = 0. Ignored in server sortingMode |
 | filterable        | boolean (default true)                                 | Enable filtering and quick search          |
-| resizable         | boolean (default true)                                 | Enable resize handle (mouse, touch, Alt+Arrow on header) |
+| resizable         | boolean (default true)                                 | Enable resize handle (mouse, touch, Alt+Arrow on header); double-click or Enter on the handle auto-sizes to content (3.1.0+) |
 | hideable          | boolean (default true)                                 | Allow hiding via toolbar / column menu     |
 | pinnable          | boolean (default true)                                 | Allow pinning via column menu (does not affect drag-reorder) |
 | exportable        | boolean (default true)                                 | Include in CSV/Excel/JSON/Print/PDF exports and clipboard copy |
@@ -298,6 +299,10 @@ apiRef.current.setPageSize(size)
 // Scroll
 apiRef.current.scrollToIndexes({ rowIndex, colIndex })
 
+// Auto-size to header + rendered cells, clamped to minWidth/maxWidth (3.1.0+)
+apiRef.current.autosizeColumn(field)
+apiRef.current.autosizeColumns(fields?)
+
 // Clipboard
 apiRef.current.copySelectedRows()      // → Promise<void>; rejects if the write fails. Copies every selected row that passes
                                        //   the filter (all pages, collapsed groups, pinned rows), visible columns in screen order
@@ -492,10 +497,13 @@ await exportToExcelAdvanced(rows, columns, {
 });
 exportToJson(rows, columns, { fileName: 'export.json' });
 await exportToPdf(rows, columns, { fileName: 'export', title: 'My Report' });
+// 3.2.0+: large PDFs — progress, cancel, size warning (never throws)
+await exportToPdf(rows, columns, { onProgress: ({ phase, done, total }) => {}, signal: controller.signal, maxRows: 20000 });
 await printGrid(rows, columns, 'My Report Title');
 ```
 
 - Every export accepts `selectedRows`, `getRowId` (pass the grid's getRowId so ids match), `aggregationResult` + `aggregationModel` (totals row) and `groupedRows` from `apiRef.current.getGroupedExportRows()`.
+- exportToPdf (3.2.0+) works in ~30 ms slices and yields between them (prepare and render phases), so the page stays responsive; only jsPDF's final save is one synchronous step. `onProgress({ phase: 'prepare'|'render'|'save', done, total })`; `signal` abort rejects with DOMException 'AbortError' and saves nothing; above `maxRows` (default 20000) a dev console.warn recommends exportToCsv / exportToExcelAdvanced. Output (pages, positions) is the same as before.
 - CSV and exportToExcel neutralise formulas: text starting with = + - @ tab or CR gets a leading `'` (`escapeFormulas: false` opts out).
 - exportToExcel writes HTML: a `.xlsx` fileName is saved as `.xls` with a console warning.
 - Columns with `exportable: false` are left out everywhere; `valueGetter` and `valueFormatter` are applied.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencorestack/opengridx",
-  "version": "3.0.1",
+  "version": "3.2.0",
   "description": "OpenGridX: High-performance React data infrastructure. Unlock advanced Row Grouping, Excel Export, and Column Pinning without the usual \"Pro\" gatekeeping. Built for speed, scale, and complete architectural freedom. Fully open, virtualization-ready, and feature-complete.",
   "type": "module",
   "main": "./dist/opengridx.umd.js",