@opencorestack/opengridx 3.9.0 → 3.10.0

package/lib/utils/export/excelCells.ts

@@ -0,0 +1,244 @@
+// Cell values, number formats, widths, images and borders of the .xlsx export (exportToExcelAdvanced).
+
+import type { GridColDef, GridRowModel } from '../../types';
+import { formatExportValue, getRawExportValue } from './exportShared';
+import type { ExcelColumnStyle } from './exportToExcelAdvanced';
+
+/** The only values handed to ExcelJS. Objects are never passed through, because ExcelJS reads
+ * `{ formula }`, `{ hyperlink }`, `{ richText }` and `{ error }` objects as live cell content. */
+type ExcelCellValue = string | number | boolean | Date | null;
+
+/** A subtotal / total cell value, with the number format it needs when it differs from the column's. */
+export interface AggregateCell {
+    value: ExcelCellValue;
+    numFmt?: string;
+}
+
+type CellKind = 'number' | 'boolean' | 'date' | 'string';
+
+function cellKind(colDef: GridColDef<GridRowModel>, value: unknown): CellKind {
+    if (colDef.type === 'number') return 'number';
+    if (colDef.type === 'boolean') return 'boolean';
+    if (colDef.type === 'date') return 'date';
+    if (typeof value === 'number') return 'number';
+    if (typeof value === 'boolean') return 'boolean';
+    if (value instanceof Date) return 'date';
+    return 'string';
+}
+
+/**
+ * Excel date serials carry no timezone and are read as wall-clock time, while ExcelJS converts a
+ * Date from its UTC instant. Re-anchor the local wall-clock fields at UTC so the cell shows the
+ * date and time the grid shows. Invalid dates become null.
+ */
+export function toExcelDate(date: Date): Date | null {
+    if (Number.isNaN(date.getTime())) return null;
+    return new Date(Date.UTC(
+        date.getFullYear(), date.getMonth(), date.getDate(),
+        date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds(),
+    ));
+}
+
+const ISO_DATE_ONLY = /^(\d{4})-(\d{2})-(\d{2})$/;
+const ISO_DATE_TIME = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:?\d{2})?$/i;
+const NUMERIC_STRING = /^[-+]?(?:\d+\.?\d*|\.\d+)(?:e[-+]?\d+)?$/i;
+
+/** A date-column value as a Date: null when missing or invalid, undefined when not a date at all. */
+function dateCellValue(value: unknown): Date | null | undefined {
+    if (value instanceof Date) return toExcelDate(value);
+    if (typeof value === 'number') return Number.isFinite(value) ? toExcelDate(new Date(value)) : null;
+    if (typeof value !== 'string') return undefined;
+    const text = value.trim();
+    const dateOnly = ISO_DATE_ONLY.exec(text);
+    if (dateOnly) {
+        // A calendar date: already wall-clock, so build it at UTC directly.
+        const [year, month, day] = [Number(dateOnly[1]), Number(dateOnly[2]), Number(dateOnly[3])];
+        const date = new Date(Date.UTC(year, month - 1, day));
+        return date.getUTCMonth() === month - 1 && date.getUTCDate() === day ? date : undefined;
+    }
+    if (ISO_DATE_TIME.test(text)) {
+        const date = new Date(text.replace(' ', 'T'));
+        return Number.isNaN(date.getTime()) ? undefined : toExcelDate(date);
+    }
+    return undefined;
+}
+
+/**
+ * A native value for a number / boolean / date cell: null for an empty cell (missing, NaN,
+ * Infinity, Invalid Date), undefined when the value is not of that kind (e.g. 'n/a' in a
+ * number column).
+ */
+function typedCellValue(kind: Exclude<CellKind, 'string'>, value: unknown): number | boolean | Date | null | undefined {
+    if (value == null || value === '') return null;
+    if (kind === 'number') {
+        if (typeof value === 'number') return Number.isFinite(value) ? value : null;
+        if (typeof value === 'bigint') {
+            const n = Number(value);
+            return Number.isSafeInteger(n) ? n : undefined;
+        }
+        if (typeof value === 'string' && NUMERIC_STRING.test(value.trim())) {
+            const n = Number(value.trim());
+            return Number.isFinite(n) ? n : undefined;
+        }
+        return undefined;
+    }
+    if (kind === 'boolean') {
+        if (typeof value === 'boolean') return value;
+        if (typeof value === 'string') {
+            const text = value.trim().toLowerCase();
+            if (text === 'true') return true;
+            if (text === 'false') return false;
+        }
+        return undefined;
+    }
+    return dateCellValue(value);
+}
+
+/** Any value as inert cell content: primitives and Dates as themselves, objects as JSON text. */
+function inertCellValue(value: unknown): ExcelCellValue {
+    if (value == null) return null;
+    if (typeof value === 'string' || typeof value === 'boolean') return value;
+    if (typeof value === 'number') return Number.isFinite(value) ? value : null;
+    if (value instanceof Date) return toExcelDate(value);
+    if (typeof value === 'object') {
+        try {
+            return JSON.stringify(value) ?? String(value);
+        } catch {
+            return String(value);
+        }
+    }
+    return String(value);
+}
+
+/**
+ * The value of a data cell. Number, boolean and date cells are native (their `valueFormatter` is
+ * not used, so Excel's number format applies); a value that is missing or not of the column's
+ * kind falls back to the text the grid shows. Other cells get the `valueFormatter` text.
+ */
+export function dataCellValue(row: GridRowModel, col: GridColDef<GridRowModel>): ExcelCellValue {
+    const raw = getRawExportValue(row, col);
+    const kind = cellKind(col, raw);
+    if (kind !== 'string') {
+        const typed = typedCellValue(kind, raw);
+        if (typed != null) return typed;
+        if (!col.valueFormatter) return typed === null ? null : inertCellValue(raw);
+    }
+    return col.valueFormatter ? formatExportValue(row, col, raw) : inertCellValue(raw);
+}
+
+// ─── Number formats ──────────────────────────────────────────────────────────
+
+export const INTEGER_FORMAT = '#,##0';
+const DECIMAL_FORMAT = '#,##0.##';
+
+/**
+ * Default format for a number-column value. '#,##0.##' alone shows whole numbers with a trailing
+ * decimal point in Excel ("5."), so whole numbers get '#,##0'.
+ */
+function defaultNumberFormat(value: number): string {
+    return Number.isInteger(value) ? INTEGER_FORMAT : DECIMAL_FORMAT;
+}
+
+export function columnNumFmt(colDef: GridColDef<GridRowModel>, style: ExcelColumnStyle | undefined): string | undefined {
+    if (style?.numFmt) return style.numFmt;
+    if (colDef.type === 'date') return 'yyyy-mm-dd';
+    return undefined;
+}
+
+/** The number format for a native cell value, or undefined to keep the column's format. */
+export function cellNumFmt(colDef: GridColDef<GridRowModel>, style: ExcelColumnStyle | undefined, value: ExcelCellValue): string | undefined {
+    if (style?.numFmt || typeof value !== 'number' || colDef.type !== 'number') return undefined;
+    return defaultNumberFormat(value);
+}
+
+// ─── Column display width (chars) ────────────────────────────────────────────
+
+export function colWidth(colDef: GridColDef<GridRowModel>, override?: number): number {
+    if (override != null) return override;
+    const px = (colDef.width ?? 120) as number;
+    return Math.min(60, Math.max(8, (px - 5) / 7));
+}
+
+// ─── Image helpers ────────────────────────────────────────────────────────────
+
+type SupportedImageExt = 'png' | 'jpeg' | 'gif';
+
+/**
+ * The image format from the file's magic bytes. Excel can only show PNG, JPEG and GIF here; SVG,
+ * WebP, AVIF and anything else return null so the URL text is written instead.
+ */
+function detectImageExtension(bytes: Uint8Array): SupportedImageExt | null {
+    if (bytes.length >= 8 && bytes[0] === 0x89 && bytes[1] === 0x50 && bytes[2] === 0x4e && bytes[3] === 0x47) return 'png';
+    if (bytes.length >= 3 && bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff) return 'jpeg';
+    if (bytes.length >= 6 && bytes[0] === 0x47 && bytes[1] === 0x49 && bytes[2] === 0x46 && bytes[3] === 0x38) return 'gif';
+    return null;
+}
+
+/** The image URL of an embedImage cell: the cell value after `valueGetter`. */
+export function imageUrlOf(row: GridRowModel, col: GridColDef<GridRowModel>): string | null {
+    const value = getRawExportValue(row, col);
+    return typeof value === 'string' && value ? value : null;
+}
+
+/**
+ * Fetch a list of image URLs in parallel.
+ * CORS failures and unsupported formats are logged and skipped — raw URL text is written to the
+ * cell instead so data is never silently lost.
+ */
+export async function fetchImages(
+    urls: string[]
+): Promise<Map<string, { buffer: ArrayBuffer; extension: SupportedImageExt }>> {
+    const settled = await Promise.allSettled(
+        urls.map(async (url) => {
+            let bytes: Uint8Array;
+            if (url.startsWith('data:')) {
+                // ── data: URI — decode base64 directly, no network needed ──────────
+                const b64 = url.slice(url.indexOf(',') + 1);
+                const binary = atob(b64);
+                bytes = new Uint8Array(binary.length);
+                for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+            } else {
+                // ── Remote URL — fetch with CORS ──────────────────────────────────
+                const res = await fetch(url, { mode: 'cors' });
+                if (!res.ok) throw new Error(`HTTP ${res.status}`);
+                bytes = new Uint8Array(await res.arrayBuffer());
+            }
+            const ext = detectImageExtension(bytes);
+            if (!ext) throw new Error('unsupported image format (only PNG, JPEG and GIF can be embedded)');
+            return { url, buffer: bytes.slice().buffer, ext };
+        })
+    );
+    const map = new Map<string, { buffer: ArrayBuffer; extension: SupportedImageExt }>();
+    settled.forEach((result, i) => {
+        if (result.status === 'fulfilled') {
+            map.set(result.value.url, { buffer: result.value.buffer, extension: result.value.ext });
+        } else {
+            console.warn(
+                `[exportToExcelAdvanced] Cannot embed image "${urls[i]}" ` +
+                `(CORS/network error or unsupported format — raw URL written as fallback):`,
+                result.reason
+            );
+        }
+    });
+    return map;
+}
+
+/** Convert '#rrggbb' or '#rgb' to ExcelJS ARGB 'FFrrggbb' */
+export function argb(hex: string): string {
+    const clean = hex.replace('#', '');
+    if (clean.length === 3) {
+        return 'FF' + clean.split('').map(c => c + c).join('');
+    }
+    if (clean.length === 6) {
+        return 'FF' + clean;
+    }
+    return 'FF' + clean.padEnd(6, '0');
+}
+
+export function bottomBorder(): Partial<import('exceljs').Borders> {
+    return { bottom: { style: 'medium', color: { argb: 'FFcbd5e1' } } };
+}
+
+export function topBorder(): Partial<import('exceljs').Borders> {
+    return { top: { style: 'medium', color: { argb: 'FFcbd5e1' } } };
+}

package/lib/utils/export/exportCsv.ts

@@ -0,0 +1,179 @@
+
+import type {
+    GridColDef,
+    GridRowId,
+    GridRowModel,
+    GridValidRowModel,
+    GridAggregationModel,
+    GridGroupedExportRow,
+} from '../../types';
+import { groupHeaderLabel } from './groupLabel';
+import {
+    aggregationForExport,
+    getExportColumns,
+    hasSelection,
+    isNonTextValue,
+    neutralizeFormula,
+    rowsForExport,
+    shouldExportGrouped,
+    summaryLabelText,
+} from './exportShared';
+
+export interface CsvExportOptions<R extends GridValidRowModel = GridRowModel> {
+    fileName?: string;
+    includeHeaders?: boolean;
+    delimiter?: string;
+    /**
+     * Export only these row IDs. A non-empty selection takes precedence over `groupedRows` (the
+     * selected rows are exported flat), and the totals row is recomputed over the selected rows.
+     */
+    selectedRows?: (string | number)[];
+    /**
+     * The grid's `getRowId`, when it has one: `selectedRows` holds those ids, and the grid does not
+     * copy them onto `row.id` (v3.0+). Defaults to `row.id`.
+     */
+    getRowId?: (row: R) => GridRowId;
+    aggregationResult?: Record<string, unknown> | null;
+    aggregationModel?: GridAggregationModel | null;
+    /** When provided, emits group headers, leaf rows, subtotals, and a grand total instead of a flat row list. */
+    groupedRows?: GridGroupedExportRow[];
+    /**
+     * Prefix text cells that start with `=`, `+`, `-`, `@`, tab or carriage return with `'`, so
+     * spreadsheet apps show them as text instead of running them as formulas (CSV injection).
+     * Plain signed numbers are left alone. Default: `true`
+     * @since v3.0
+     */
+    escapeFormulas?: boolean;
+    /**
+     * Start the file with a UTF-8 byte-order mark, so Excel reads non-ASCII text (é, ü, ₹, 中文)
+     * correctly. Default: `true`
+     * @since v3.0
+     */
+    bom?: boolean;
+}
+import { aggregateTexts, downloadFile, exportCell } from './exportRows';
+
+export interface CsvExportOptions<R extends GridValidRowModel = GridRowModel> {
+    fileName?: string;
+    includeHeaders?: boolean;
+    delimiter?: string;
+    /**
+     * Export only these row IDs. A non-empty selection takes precedence over `groupedRows` (the
+     * selected rows are exported flat), and the totals row is recomputed over the selected rows.
+     */
+    selectedRows?: (string | number)[];
+    /**
+     * The grid's `getRowId`, when it has one: `selectedRows` holds those ids, and the grid does not
+     * copy them onto `row.id` (v3.0+). Defaults to `row.id`.
+     */
+    getRowId?: (row: R) => GridRowId;
+    aggregationResult?: Record<string, unknown> | null;
+    aggregationModel?: GridAggregationModel | null;
+    /** When provided, emits group headers, leaf rows, subtotals, and a grand total instead of a flat row list. */
+    groupedRows?: GridGroupedExportRow[];
+    /**
+     * Prefix text cells that start with `=`, `+`, `-`, `@`, tab or carriage return with `'`, so
+     * spreadsheet apps show them as text instead of running them as formulas (CSV injection).
+     * Plain signed numbers are left alone. Default: `true`
+     * @since v3.0
+     */
+    escapeFormulas?: boolean;
+    /**
+     * Start the file with a UTF-8 byte-order mark, so Excel reads non-ASCII text (é, ü, ₹, 中文)
+     * correctly. Default: `true`
+     * @since v3.0
+     */
+    bom?: boolean;
+}
+
+const UTF8_BOM = String.fromCharCode(0xfeff);
+
+export function exportToCsv<R extends GridValidRowModel = GridRowModel>(rows: R[], columns: GridColDef<R>[], options?: CsvExportOptions<R>): void;
+export function exportToCsv<R extends GridValidRowModel = GridRowModel>(rows: R[], columns: GridColDef[], options?: CsvExportOptions<R>): void;
+export function exportToCsv<R extends GridRowModel>(
+    rows: R[],
+    columns: GridColDef<R>[],
+    options: CsvExportOptions<R> = {}
+): void {
+    const {
+        fileName = 'export.csv',
+        includeHeaders = true,
+        delimiter = ',',
+        selectedRows,
+        groupedRows,
+        escapeFormulas = true,
+        bom = true,
+    } = options;
+
+    const exportColumns = getExportColumns(columns);
+    const aggModel = options.aggregationModel || {};
+    const field = (text: string, fromNonText = false): string =>
+        escapeCSV(escapeFormulas ? neutralizeFormula(text, fromNonText) : text, delimiter);
+    const headerLine = () => exportColumns.map(col => field(col.headerName || col.field)).join(delimiter) + '\n';
+
+    let csvContent = '';
+
+    if (shouldExportGrouped(groupedRows, selectedRows)) {
+        // Grouped export path
+        if (includeHeaders) csvContent += headerLine();
+        groupedRows.forEach(entry => {
+            const indent = '  '.repeat(entry.depth);
+            if (entry.type === 'group-header') {
+                const labelText = groupHeaderLabel(entry, columns);
+                const label = escapeCSV(indent + (escapeFormulas ? neutralizeFormula(labelText) : labelText), delimiter);
+                csvContent += exportColumns.map((_, i) => (i === 0 ? label : '')).join(delimiter) + '\n';
+            } else if (entry.type === 'leaf' && entry.row) {
+                const row = entry.row as R;
+                const cells = exportColumns.map((col, i) => {
+                    const cell = exportCell(row, col);
+                    const text = escapeFormulas ? neutralizeFormula(cell.text, cell.fromNonText) : cell.text;
+                    return escapeCSV((i === 0 ? indent : '') + text, delimiter);
+                });
+                csvContent += cells.join(delimiter) + '\n';
+            } else if ((entry.type === 'group-subtotal' || entry.type === 'grand-total') && entry.aggregatedValues) {
+                const values = entry.aggregatedValues;
+                const label = entry.type === 'grand-total' ? 'Grand Total' : `${indent}Subtotal`;
+                const texts = aggregateTexts(exportColumns, values, aggModel);
+                const cells = exportColumns.map((col, i) => (i === 0
+                    ? escapeCSV(summaryLabelText(label, texts[0]), delimiter)
+                    : field(texts[i], isNonTextValue(values[col.field]))));
+                csvContent += cells.join(delimiter) + '\n';
+            }
+        });
+    } else {
+        const rowsToExport = rowsForExport(rows, selectedRows, options.getRowId);
+
+        if (rowsToExport.length === 0) {
+            console.warn('No rows to export');
+            return;
+        }
+
+        if (includeHeaders) csvContent += headerLine();
+
+        rowsToExport.forEach(row => {
+            const values = exportColumns.map(col => {
+                const cell = exportCell(row, col);
+                return field(cell.text, cell.fromNonText);
+            });
+            csvContent += values.join(delimiter) + '\n';
+        });
+
+        const aggResult = aggregationForExport(rowsToExport, hasSelection(selectedRows), columns, options.aggregationResult, options.aggregationModel);
+        if (aggResult) {
+            const aggLabels = exportColumns.map(col => field(aggModel[col.field] ? aggModel[col.field].toUpperCase() : ''));
+            csvContent += aggLabels.join(delimiter) + '\n';
+            const texts = aggregateTexts(exportColumns, aggResult, aggModel);
+            csvContent += exportColumns.map((col, i) => field(texts[i], isNonTextValue(aggResult[col.field]))).join(delimiter) + '\n';
+        }
+    }
+
+    downloadFile((bom ? UTF8_BOM : '') + csvContent, fileName, 'text/csv;charset=utf-8;');
+}
+
+/** Quote a CSV field when it contains the delimiter, a quote, or a line break (LF or a bare CR). */
+function escapeCSV(value: string, delimiter: string): string {
+    if ((delimiter !== '' && value.includes(delimiter)) || value.includes('"') || value.includes('\n') || value.includes('\r')) {
+        return `"${value.replace(/"/g, '""')}"`;
+    }
+    return value;
+}

package/lib/utils/export/exportExcelHtml.ts

@@ -0,0 +1,220 @@
+
+import type {
+    GridColDef,
+    GridRowId,
+    GridRowModel,
+    GridValidRowModel,
+    GridAggregationModel,
+    GridGroupedExportRow,
+} from '../../types';
+import { groupHeaderLabel } from './groupLabel';
+import {
+    aggregationForExport,
+    escapeHTML,
+    getExportColumns,
+    hasSelection,
+    isNonTextValue,
+    neutralizeFormula,
+    rowsForExport,
+    sanitizeSheetName,
+    shouldExportGrouped,
+    summaryLabelText,
+} from './exportShared';
+
+export interface CsvExportOptions<R extends GridValidRowModel = GridRowModel> {
+    fileName?: string;
+    includeHeaders?: boolean;
+    delimiter?: string;
+    /**
+     * Export only these row IDs. A non-empty selection takes precedence over `groupedRows` (the
+     * selected rows are exported flat), and the totals row is recomputed over the selected rows.
+     */
+    selectedRows?: (string | number)[];
+    /**
+     * The grid's `getRowId`, when it has one: `selectedRows` holds those ids, and the grid does not
+     * copy them onto `row.id` (v3.0+). Defaults to `row.id`.
+     */
+    getRowId?: (row: R) => GridRowId;
+    aggregationResult?: Record<string, unknown> | null;
+    aggregationModel?: GridAggregationModel | null;
+    /** When provided, emits group headers, leaf rows, subtotals, and a grand total instead of a flat row list. */
+    groupedRows?: GridGroupedExportRow[];
+    /**
+     * Prefix text cells that start with `=`, `+`, `-`, `@`, tab or carriage return with `'`, so
+     * spreadsheet apps show them as text instead of running them as formulas (CSV injection).
+     * Plain signed numbers are left alone. Default: `true`
+     * @since v3.0
+     */
+    escapeFormulas?: boolean;
+    /**
+     * Start the file with a UTF-8 byte-order mark, so Excel reads non-ASCII text (é, ü, ₹, 中文)
+     * correctly. Default: `true`
+     * @since v3.0
+     */
+    bom?: boolean;
+}
+import {
+    aggregateTexts,
+    downloadFile,
+    exportCell,
+    type ExportCell,
+} from './exportRows';
+
+export interface ExcelExportOptions<R extends GridValidRowModel = GridRowModel> {
+    /**
+     * Output filename. The file is an HTML table that Excel opens as a legacy `.xls` workbook, so a
+     * `.xlsx` extension is replaced with `.xls` (Excel refuses HTML content named `.xlsx`). Use
+     * `exportToExcelAdvanced` for a real `.xlsx`. Default: `'export.xls'`
+     */
+    fileName?: string;
+    /** Sheet tab name. Characters Excel rejects are replaced and the name is cut to 31 characters. Default: `'Sheet1'` */
+    sheetName?: string;
+    includeHeaders?: boolean;
+    /**
+     * Export only these row IDs. A non-empty selection takes precedence over `groupedRows` (the
+     * selected rows are exported flat), and the totals rows are recomputed over the selected rows.
+     */
+    selectedRows?: (string | number)[];
+    /**
+     * The grid's `getRowId`, when it has one: `selectedRows` holds those ids, and the grid does not
+     * copy them onto `row.id` (v3.0+). Defaults to `row.id`.
+     */
+    getRowId?: (row: R) => GridRowId;
+    aggregationResult?: Record<string, unknown> | null;
+    aggregationModel?: GridAggregationModel | null;
+    /** When provided, emits group headers, leaf rows, subtotals, and a grand total instead of a flat row list. */
+    groupedRows?: GridGroupedExportRow[];
+    /**
+     * Prefix text cells that start with `=`, `+`, `-`, `@`, tab or carriage return with `'`, so
+     * Excel does not run them as formulas. Default: `true`
+     * @since v3.0
+     */
+    escapeFormulas?: boolean;
+}
+
+/** Excel's text number format: the cell keeps its text as typed (leading zeros, long ids, "1-2"). */
+const XLS_TEXT_CLASS = 'ogx-xls-text';
+
+/**
+ * Whether an HTML-Excel data cell should be marked as text. Number, date and boolean columns, and
+ * values that are numbers, dates or booleans, are left for Excel to type.
+ */
+function isXlsTextCell<R extends GridRowModel>(col: GridColDef<R>, raw: unknown): boolean {
+    return col.type !== 'number' && col.type !== 'date' && col.type !== 'boolean' && !isNonTextValue(raw);
+}
+
+function xlsFileName(fileName: string): string {
+    if (!/\.xlsx$/i.test(fileName)) return fileName;
+    const corrected = fileName.replace(/\.xlsx$/i, '.xls');
+    console.warn(
+        `[exportToExcel] "${fileName}" renamed to "${corrected}": exportToExcel writes an HTML table that Excel ` +
+        'refuses to open as .xlsx. Use exportToExcelAdvanced for a real .xlsx file.'
+    );
+    return corrected;
+}
+
+export function exportToExcel<R extends GridValidRowModel = GridRowModel>(rows: R[], columns: GridColDef<R>[], options?: ExcelExportOptions<R>): void;
+export function exportToExcel<R extends GridValidRowModel = GridRowModel>(rows: R[], columns: GridColDef[], options?: ExcelExportOptions<R>): void;
+export function exportToExcel<R extends GridRowModel>(
+    rows: R[],
+    columns: GridColDef<R>[],
+    options: ExcelExportOptions<R> = {}
+): void {
+    const {
+        fileName = 'export.xls',
+        sheetName = 'Sheet1',
+        includeHeaders = true,
+        selectedRows,
+        groupedRows,
+        escapeFormulas = true,
+    } = options;
+
+    const exportColumns = getExportColumns(columns);
+    const aggModel = options.aggregationModel || {};
+    const cellText = (text: string, fromNonText = false): string =>
+        escapeHTML(escapeFormulas ? neutralizeFormula(text, fromNonText) : text);
+    const textTd = (html: string): string => `<td class="${XLS_TEXT_CLASS}">${html}</td>`;
+
+    const header = '<html xmlns:o="urn:schemas-microsoft-com:office:office" xmlns:x="urn:schemas-microsoft-com:office:excel" xmlns="http://www.w3.org/TR/REC-html40">'
+        + '<head><!--[if gte mso 9]><xml><x:ExcelWorkbook><x:ExcelWorksheets><x:ExcelWorksheet>'
+        + `<x:Name>${escapeHTML(sanitizeSheetName(sheetName))}</x:Name>`
+        + '<x:WorksheetOptions><x:DisplayGridlines/></x:WorksheetOptions></x:ExcelWorksheet></x:ExcelWorksheets></x:ExcelWorkbook></xml><![endif]-->'
+        + `<meta charset="UTF-8"><style>.${XLS_TEXT_CLASS}{mso-number-format:"\\@";}</style></head><body><table border="1">`;
+
+    let html = header;
+
+    if (includeHeaders) {
+        html += '<thead><tr>';
+        exportColumns.forEach(col => { html += `<th class="${XLS_TEXT_CLASS}">${cellText(col.headerName || col.field)}</th>`; });
+        html += '</tr></thead>';
+    }
+
+    html += '<tbody>';
+
+    const dataCell = (cell: ExportCell, col: GridColDef<R>, prefix = ''): string => {
+        const content = prefix + cellText(cell.text, cell.fromNonText);
+        return isXlsTextCell(col, cell.raw) ? textTd(content) : `<td>${content}</td>`;
+    };
+
+    if (shouldExportGrouped(groupedRows, selectedRows)) {
+        groupedRows.forEach(entry => {
+            const indent = '  '.repeat(entry.depth * 2);
+            if (entry.type === 'group-header') {
+                html += `<tr style="font-weight:bold;background:#e8eaf6;">`;
+                html += `<td colspan="${exportColumns.length}" class="${XLS_TEXT_CLASS}">${escapeHTML(indent)}${cellText(groupHeaderLabel(entry, columns))}</td>`;
+                html += '</tr>';
+            } else if (entry.type === 'leaf' && entry.row) {
+                const row = entry.row as R;
+                html += '<tr>';
+                exportColumns.forEach((col, i) => { html += dataCell(exportCell(row, col), col, i === 0 ? escapeHTML(indent) : ''); });
+                html += '</tr>';
+            } else if ((entry.type === 'group-subtotal' || entry.type === 'grand-total') && entry.aggregatedValues) {
+                const values = entry.aggregatedValues;
+                const label = entry.type === 'grand-total' ? 'Grand Total' : `${indent}Subtotal`;
+                const texts = aggregateTexts(exportColumns, values, aggModel);
+                html += `<tr style="font-weight:bold;background:#f5f5f5;">`;
+                exportColumns.forEach((col, i) => {
+                    if (i === 0) { html += textTd(escapeHTML(summaryLabelText(label, texts[0]))); return; }
+                    html += texts[i] ? `<td style="text-align:right;">${cellText(texts[i], isNonTextValue(values[col.field]))}</td>` : '<td></td>';
+                });
+                html += '</tr>';
+            }
+        });
+    } else {
+        const rowsToExport = rowsForExport(rows, selectedRows, options.getRowId);
+
+        if (rowsToExport.length === 0) {
+            console.warn('No rows to export');
+            return;
+        }
+
+        rowsToExport.forEach(row => {
+            html += '<tr>';
+            exportColumns.forEach(col => { html += dataCell(exportCell(row, col), col); });
+            html += '</tr>';
+        });
+
+        const aggResult = aggregationForExport(rowsToExport, hasSelection(selectedRows), columns, options.aggregationResult, options.aggregationModel);
+        if (aggResult) {
+            html += '<tr style="font-size: 11px; color: #666; background-color: #f5f5f5;">';
+            exportColumns.forEach(col => {
+                html += aggModel[col.field]
+                    ? `<td style="text-align:right;font-weight:bold;">${escapeHTML(aggModel[col.field].toUpperCase())}</td>`
+                    : '<td></td>';
+            });
+            html += '</tr><tr style="font-weight:bold;background-color:#f5f5f5;">';
+            const texts = aggregateTexts(exportColumns, aggResult, aggModel);
+            exportColumns.forEach((col, i) => {
+                html += texts[i] ? `<td style="text-align:right;">${cellText(texts[i], isNonTextValue(aggResult[col.field]))}</td>` : '<td></td>';
+            });
+            html += '</tr>';
+        }
+    }
+
+    html += '</tbody></table></body></html>';
+    downloadFile(html, xlsFileName(fileName), 'application/vnd.ms-excel');
+}
+
+// ============================================================================
+// JSON Export
+// ============================================================================