@svgrid/enterprise 2.5.3 → 2.6.0

package/dist/export-pdf.js

@@ -0,0 +1,144 @@
+/**
+ * PDF export via our own pdfmake document definition, instead of the vendored
+ * Smart exporter's basic table dump. This gives real control over the page:
+ * size / orientation / margins, a repeated header row on every page, automatic
+ * "Page X of Y" + generated-date footer, per-column alignment and widths, an
+ * optional title / subtitle / logo, and theme colors (header fill + zebra).
+ *
+ * `buildPdfDocDefinition` is a PURE function (no pdfmake, no DOM) returning the
+ * docDefinition object, so it's fully unit-testable; `exportGrid` feeds the
+ * result to `pdfMake.createPdf(def).download(...)`.
+ */
+/**
+ * Build a pdfmake docDefinition from resolved columns + formatted string rows.
+ * `now` is injected for a deterministic footer date in tests.
+ */
+export function buildPdfDocDefinition(params) {
+    const { columns } = params;
+    const o = params.opts ?? {};
+    const now = params.now ?? new Date(0);
+    const fontSize = o.fontSize ?? 8;
+    const headerColor = o.headerColor ?? '#334155';
+    const headerTextColor = o.headerTextColor ?? '#ffffff';
+    const zebra = o.zebra ?? true;
+    const zebraColor = o.zebraColor ?? '#f1f5f9';
+    const groupColor = o.groupColor ?? '#e2e8f0';
+    const groupTextColor = o.groupTextColor ?? '#0f172a';
+    const subtotalColor = o.subtotalColor ?? '#f8fafc';
+    const repeatHeader = o.repeatHeader ?? true;
+    const orientation = o.pageOrientation ??
+        (columns.length > (o.autoLandscapeThreshold ?? 8) ? 'landscape' : 'portrait');
+    const widths = Array.isArray(o.columnWidths)
+        ? o.columnWidths
+        : columns.map(() => (o.columnWidths === 'auto' ? 'auto' : '*'));
+    // Header row.
+    const headerRow = columns.map((c) => ({
+        text: c.header,
+        bold: true,
+        alignment: c.align ?? 'left',
+        color: headerTextColor,
+        fillColor: headerColor,
+    }));
+    // Normalize to a structured body: `body` wins, else wrap flat `rows`.
+    const model = params.body ?? (params.rows ?? []).map((cells) => ({ kind: 'data', cells }));
+    // Track which body-row indices are plain data rows, so zebra striping only
+    // hits those (group / subtotal rows carry their own fill).
+    const dataCellStyle = params.dataCellStyle;
+    const dataCellLink = params.dataCellLink;
+    let dataOrdinal = 0;
+    const dataRowIdx = new Set();
+    const bodyCells = [headerRow];
+    model.forEach((row, i) => {
+        const bi = i + 1; // +1 for the header row
+        if (row.kind === 'group') {
+            const first = {
+                text: row.label,
+                bold: true,
+                color: groupTextColor,
+                fillColor: groupColor,
+                colSpan: columns.length,
+                margin: [(row.level ?? 0) * 12, 2, 0, 2],
+            };
+            const rest = Array.from({ length: Math.max(0, columns.length - 1) }, () => ({ text: '' }));
+            bodyCells.push([first, ...rest]);
+        }
+        else if (row.kind === 'subtotal') {
+            bodyCells.push(columns.map((c, ci) => ({
+                text: row.cells[ci] ?? '',
+                bold: true,
+                alignment: c.align ?? 'left',
+                fillColor: subtotalColor,
+            })));
+        }
+        else {
+            dataRowIdx.add(bi);
+            const ord = dataOrdinal++;
+            bodyCells.push(columns.map((c, ci) => {
+                const cell = { text: row.cells[ci] ?? '', alignment: c.align ?? 'left' };
+                const s = dataCellStyle?.(ord, ci);
+                if (s) {
+                    if (s.fill)
+                        cell.fillColor = s.fill;
+                    if (s.color)
+                        cell.color = s.color;
+                    if (s.bold)
+                        cell.bold = true;
+                }
+                const href = dataCellLink?.(ord, ci);
+                if (href) {
+                    cell.link = href;
+                    cell.decoration = 'underline';
+                    if (!s?.color)
+                        cell.color = '#2563eb';
+                }
+                return cell;
+            }));
+        }
+    });
+    const table = {
+        table: {
+            headerRows: repeatHeader ? 1 : 0,
+            dontBreakRows: true,
+            widths,
+            body: bodyCells,
+        },
+        layout: {
+            // Zebra fill: only plain data rows (group / subtotal have their own).
+            fillColor: (rowIndex) => zebra && rowIndex > 0 && rowIndex % 2 === 0 && dataRowIdx.has(rowIndex) ? zebraColor : null,
+            hLineWidth: () => 0.5,
+            vLineWidth: () => 0.5,
+            hLineColor: () => '#e2e8f0',
+            vLineColor: () => '#e2e8f0',
+            paddingTop: () => 3,
+            paddingBottom: () => 3,
+            paddingLeft: () => 5,
+            paddingRight: () => 5,
+        },
+    };
+    const content = [];
+    if (o.logo)
+        content.push({ image: o.logo, width: o.logoWidth ?? 90, margin: [0, 0, 0, 8] });
+    if (o.title)
+        content.push({ text: o.title, fontSize: fontSize + 8, bold: true, margin: [0, 0, 0, 2] });
+    if (o.subtitle)
+        content.push({ text: o.subtitle, fontSize: fontSize + 1, color: '#64748b', margin: [0, 0, 0, 8] });
+    content.push(table);
+    const def = {
+        pageSize: o.pageSize ?? 'A4',
+        pageOrientation: orientation,
+        pageMargins: o.margins ?? [28, 34, 28, 34],
+        defaultStyle: { fontSize },
+        content,
+    };
+    if (o.showPageNumbers ?? true) {
+        const dateStr = now.toISOString().slice(0, 10);
+        def.footer = (currentPage, pageCount) => ({
+            margin: [28, 6, 28, 0],
+            columns: [
+                { text: dateStr, alignment: 'left', fontSize: 7, color: '#94a3b8' },
+                { text: `Page ${currentPage} of ${pageCount}`, alignment: 'right', fontSize: 7, color: '#94a3b8' },
+            ],
+        });
+    }
+    return def;
+}

package/dist/export-print.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Pure HTML builder for the print view. `printGrid` opens this document in a
+ * new window and calls `window.print()`, so the user can print or "Save as
+ * PDF" using the browser's own engine (great font + CSS fidelity, CJK / RTL,
+ * zero dependency). Kept pure (no DOM) so it's unit-testable.
+ *
+ * The upgrades over a plain table dump: page size / orientation / margins via
+ * `@page`, a header row that repeats on every printed page
+ * (`display: table-header-group`), per-column alignment, zebra striping, and an
+ * optional title / subtitle / logo band. Browsers add their own page-number
+ * header/footer through the print dialog.
+ */
+export type PrintDocOptions = {
+    title?: string;
+    subtitle?: string;
+    /** Logo data URL, shown above the title. */
+    logo?: string;
+    /** Logo width in px. Default 120. */
+    logoWidth?: number;
+    orientation?: 'portrait' | 'landscape';
+    /** `@page size` keyword, e.g. 'A4' | 'Letter'. Combined with orientation. */
+    pageSize?: string;
+    /** `@page margin`, e.g. '14mm'. Default '14mm'. */
+    margin?: string;
+    /** Zebra-stripe rows. Default true. */
+    zebra?: boolean;
+    zebraColor?: string;
+    /** Header row background. Default '#f1f5f9'. */
+    headerColor?: string;
+    headerTextColor?: string;
+    /** Body font size in pt. Default 9. */
+    fontSize?: number;
+};
+/**
+ * Build a standalone, print-ready HTML document from resolved columns +
+ * pre-formatted string rows.
+ */
+export type PrintCellVisual = {
+    fill?: string;
+    color?: string;
+    bold?: boolean;
+    icon?: string;
+};
+export declare function buildPrintDocument(params: {
+    columns: ReadonlyArray<{
+        header: string;
+        align?: 'left' | 'center' | 'right';
+    }>;
+    rows: ReadonlyArray<ReadonlyArray<string>>;
+    /** Per-data-cell conditional-format visual. */
+    cellStyle?: (rowIdx: number, colIdx: number) => PrintCellVisual | undefined;
+    /** Per-data-cell hyperlink URL. */
+    cellLink?: (rowIdx: number, colIdx: number) => string | undefined;
+    opts?: PrintDocOptions;
+}): string;

package/dist/export-print.js

@@ -0,0 +1,91 @@
+/**
+ * Pure HTML builder for the print view. `printGrid` opens this document in a
+ * new window and calls `window.print()`, so the user can print or "Save as
+ * PDF" using the browser's own engine (great font + CSS fidelity, CJK / RTL,
+ * zero dependency). Kept pure (no DOM) so it's unit-testable.
+ *
+ * The upgrades over a plain table dump: page size / orientation / margins via
+ * `@page`, a header row that repeats on every printed page
+ * (`display: table-header-group`), per-column alignment, zebra striping, and an
+ * optional title / subtitle / logo band. Browsers add their own page-number
+ * header/footer through the print dialog.
+ */
+const HTML_ESCAPE = {
+    '&': '&',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#39;',
+};
+function esc(value) {
+    const s = value == null ? '' : String(value);
+    return s.replace(/[&<>"']/g, (c) => HTML_ESCAPE[c]);
+}
+export function buildPrintDocument(params) {
+    const { columns, rows } = params;
+    const cellStyle = params.cellStyle;
+    const cellLink = params.cellLink;
+    const o = params.opts ?? {};
+    const orientation = o.orientation ?? 'portrait';
+    const size = o.pageSize ? `${o.pageSize} ${orientation}` : orientation;
+    const margin = o.margin ?? '14mm';
+    const zebra = o.zebra ?? true;
+    const zebraColor = o.zebraColor ?? '#f6f8fa';
+    const headerColor = o.headerColor ?? '#f1f5f9';
+    const headerTextColor = o.headerTextColor ?? '#0f172a';
+    const fontSize = o.fontSize ?? 9;
+    const alignStyle = (a) => a && a !== 'left' ? ` style="text-align:${a}"` : '';
+    const thead = '<thead><tr>' +
+        columns.map((c) => `<th${alignStyle(c.align)}>${esc(c.header)}</th>`).join('') +
+        '</tr></thead>';
+    const cellHtml = (c, value, ri, ci) => {
+        const styles = [];
+        if (c.align && c.align !== 'left')
+            styles.push(`text-align:${c.align}`);
+        const cf = cellStyle?.(ri, ci);
+        if (cf?.fill)
+            styles.push(`background:${cf.fill}`);
+        if (cf?.color)
+            styles.push(`color:${cf.color}`);
+        if (cf?.bold)
+            styles.push('font-weight:700');
+        const style = styles.length ? ` style="${styles.join(';')}"` : '';
+        let text = cf?.icon ? `${esc(cf.icon)} ${esc(value)}` : esc(value);
+        const href = cellLink?.(ri, ci);
+        if (href)
+            text = `<a href="${esc(href)}">${text}</a>`;
+        return `<td${style}>${text}</td>`;
+    };
+    const tbody = '<tbody>' +
+        rows
+            .map((r, ri) => '<tr>' + columns.map((c, ci) => cellHtml(c, r[ci] ?? '', ri, ci)).join('') + '</tr>')
+            .join('') +
+        '</tbody>';
+    const band = [];
+    if (o.logo)
+        band.push(`<img class="logo" src="${esc(o.logo)}" alt="" />`);
+    if (o.title)
+        band.push(`<h1>${esc(o.title)}</h1>`);
+    if (o.subtitle)
+        band.push(`<p class="subtitle">${esc(o.subtitle)}</p>`);
+    return `<!DOCTYPE html>
+<html><head><meta charset="utf-8"><title>${esc(o.title ?? 'Grid')}</title>
+<style>
+  @page { size: ${size}; margin: ${margin}; }
+  @media print { body { -webkit-print-color-adjust: exact; print-color-adjust: exact; } }
+  body { font-family: -apple-system, "Segoe UI", Roboto, sans-serif; color: #111; margin: 0; }
+  .logo { max-height: ${o.logoWidth ? '' : '48px'}; width: ${o.logoWidth ? `${o.logoWidth}px` : 'auto'}; display: block; margin-bottom: 8px; }
+  h1 { font-size: 16pt; margin: 0 0 2px 0; }
+  .subtitle { font-size: 10pt; color: #64748b; margin: 0 0 10px 0; }
+  table { border-collapse: collapse; width: 100%; font-size: ${fontSize}pt; }
+  thead { display: table-header-group; }
+  tr { break-inside: avoid; }
+  th, td { border: 1px solid #cbd5e1; padding: 4px 7px; text-align: left; }
+  th { background: ${headerColor}; color: ${headerTextColor}; font-weight: 700; }
+  ${zebra ? `tbody tr:nth-child(even) { background: ${zebraColor}; }` : ''}
+</style></head>
+<body>
+  ${band.join('\n  ')}
+  <table>${thead}${tbody}</table>
+</body></html>`;
+}

package/{src/export-serialize.ts → dist/export-serialize.d.ts}

@@ -1,24 +1,11 @@
-/**
- * The text serializers + delivery helpers moved into the FREE grid package
- * (CSV / TSV / JSON export + clipboard now ship in @svgrid/grid). Enterprise
- * re-uses that one implementation for its richer paths (styled HTML, xls, the
- * xlsx/pdf blob download) instead of maintaining a second copy.
- *
- * Kept as a thin re-export from the Svelte-free `@svgrid/grid/format` subpath
- * so existing imports (and the test mocks that target this module path) keep
- * working unchanged.
- */
-export {
-  serializeDelimited,
-  serializeJson,
-  serializeHtml,
-  serializeMarkdown,
-  serializeXml,
-  downloadBlobFile,
-  downloadTextFile,
-  copyTextToClipboard,
-  type CsvOptions,
-  type SerializeOptions,
-  type SerializeProgress,
-  type ExportCellVisual,
-} from '@svgrid/grid/format'
+/**
+ * The text serializers + delivery helpers moved into the FREE grid package
+ * (CSV / TSV / JSON export + clipboard now ship in @svgrid/grid). Enterprise
+ * re-uses that one implementation for its richer paths (styled HTML, xls, the
+ * xlsx/pdf blob download) instead of maintaining a second copy.
+ *
+ * Kept as a thin re-export from the Svelte-free `@svgrid/grid/format` subpath
+ * so existing imports (and the test mocks that target this module path) keep
+ * working unchanged.
+ */
+export { serializeDelimited, serializeJson, serializeHtml, serializeMarkdown, serializeXml, downloadBlobFile, downloadTextFile, copyTextToClipboard, type CsvOptions, type SerializeOptions, type SerializeProgress, type ExportCellVisual, } from '@svgrid/grid/format';

package/dist/export-serialize.js

@@ -0,0 +1,11 @@
+/**
+ * The text serializers + delivery helpers moved into the FREE grid package
+ * (CSV / TSV / JSON export + clipboard now ship in @svgrid/grid). Enterprise
+ * re-uses that one implementation for its richer paths (styled HTML, xls, the
+ * xlsx/pdf blob download) instead of maintaining a second copy.
+ *
+ * Kept as a thin re-export from the Svelte-free `@svgrid/grid/format` subpath
+ * so existing imports (and the test mocks that target this module path) keep
+ * working unchanged.
+ */
+export { serializeDelimited, serializeJson, serializeHtml, serializeMarkdown, serializeXml, downloadBlobFile, downloadTextFile, copyTextToClipboard, } from '@svgrid/grid/format';

package/dist/export-xls.d.ts

@@ -0,0 +1,26 @@
+import type { ExportColumn } from './export';
+import type { RowData } from '@svgrid/grid';
+import type { SerializeOptions } from './export-serialize';
+/**
+ * Serialize rows to an Excel 2003 XML Spreadsheet (`.xls`) document string.
+ * Streams in chunks with `onProgress` + `AbortSignal`, matching the other
+ * native writers.
+ */
+export declare function serializeSpreadsheetML<TData extends RowData>(sheetName: string, cols: ReadonlyArray<ExportColumn<TData>>, rows: ReadonlyArray<TData>, opts?: SerializeOptions & {
+    rawValues?: boolean;
+    /** Freeze the header row. Default false. */
+    freezeHeader?: boolean;
+    /** Freeze this many leading columns. Default 0. */
+    freezeColumns?: number;
+    /** Per-column pixel widths (converted to points). */
+    widths?: ReadonlyArray<number>;
+    /** Per-cell conditional-format visual (fill / color / bold / icon). */
+    cellVisual?: (rowIdx: number, colIdx: number) => {
+        fill?: string;
+        color?: string;
+        bold?: boolean;
+        icon?: string;
+    } | undefined;
+    /** Write long integer IDs (>15 sig digits) as text so they survive. */
+    precisionSafe?: boolean;
+}): Promise<string>;

package/dist/export-xls.js

@@ -0,0 +1,157 @@
+/**
+ * Legacy `.xls` export via the Excel 2003 XML Spreadsheet format
+ * (SpreadsheetML, `urn:schemas-microsoft-com:office:spreadsheet`). This is the
+ * "old compatibility" path: it opens natively in Excel 97-2003 and every
+ * newer Excel / LibreOffice / Numbers as a REAL spreadsheet - typed numeric
+ * and date cells (so sums/sort still work) with number formats - and needs no
+ * peer dependency (unlike xlsx, which needs jszip).
+ *
+ * We generate typed cells from the column `format`: number / currency /
+ * percent become `ss:Type="Number"` with a NumberFormat style, dates become
+ * `ss:Type="DateTime"`, everything else is a formatted `String`. An
+ * `exportValue` hook still wins and is emitted as a String.
+ */
+import { formatValueForExport, toExcelNumFmt, valueForExcel } from '@svgrid/grid/format';
+// Control chars illegal in XML 1.0 - strip so a stray \x00 can't corrupt the file.
+// See export-ooxml.ts: XML 1.0 has no representation for these at all, so a
+// control character has to be dropped before it reaches the file.
+// eslint-disable-next-line no-control-regex
+const INVALID_XML = /[\x00-\x08\x0B\x0C\x0E-\x1F]/g;
+function xmlEscape(s) {
+    return s
+        .replace(INVALID_XML, '')
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+/** SpreadsheetML wants ISO-8601 with no timezone for a DateTime cell. */
+function toSpreadsheetDate(d) {
+    // yyyy-mm-ddThh:mm:ss.000
+    const p = (n, w = 2) => String(n).padStart(w, '0');
+    return (`${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}` +
+        `T${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}.000`);
+}
+/**
+ * Serialize rows to an Excel 2003 XML Spreadsheet (`.xls`) document string.
+ * Streams in chunks with `onProgress` + `AbortSignal`, matching the other
+ * native writers.
+ */
+export async function serializeSpreadsheetML(sheetName, cols, rows, opts = {}) {
+    const chunk = Math.max(1, opts.chunkRows ?? 5000);
+    const total = rows.length;
+    const rawValues = opts.rawValues === true;
+    const cellVisual = opts.cellVisual;
+    const precisionSafe = opts.precisionSafe === true;
+    const styleCache = new Map();
+    const styleDefs = [
+        '<Style ss:ID="sHeader"><Font ss:Bold="1"/><Interior ss:Color="#F2F2F2" ss:Pattern="Solid"/></Style>',
+    ];
+    const cap = (a) => (a === 'right' ? 'Right' : a === 'center' ? 'Center' : 'Left');
+    const styleIdFor = (d) => {
+        const hasAlign = d.align && d.align !== 'left';
+        if (!d.numFmt && !d.fill && !d.color && !d.bold && !hasAlign)
+            return undefined;
+        const key = `${d.numFmt ?? ''}|${d.fill ?? ''}|${d.color ?? ''}|${d.bold ? 'b' : ''}|${d.align ?? ''}`;
+        const existing = styleCache.get(key);
+        if (existing)
+            return existing;
+        const id = `s${styleCache.size + 1}`;
+        // SpreadsheetML element order: Alignment, Font, Interior, NumberFormat.
+        const parts = [];
+        if (hasAlign)
+            parts.push(`<Alignment ss:Horizontal="${cap(d.align)}"/>`);
+        if (d.color || d.bold)
+            parts.push(`<Font${d.color ? ` ss:Color="${d.color}"` : ''}${d.bold ? ' ss:Bold="1"' : ''}/>`);
+        if (d.fill)
+            parts.push(`<Interior ss:Color="${d.fill}" ss:Pattern="Solid"/>`);
+        if (d.numFmt)
+            parts.push(`<NumberFormat ss:Format="${xmlEscape(d.numFmt)}"/>`);
+        styleDefs.push(`<Style ss:ID="${id}">${parts.join('')}</Style>`);
+        styleCache.set(key, id);
+        return id;
+    };
+    function cellFor(col, row, r, c) {
+        const href = col.link?.(row) || undefined;
+        const v = cellVisual?.(r, c);
+        const style = (numFmt) => styleIdFor({ numFmt, fill: v?.fill, color: v?.color, bold: v?.bold, align: col.align });
+        if (col.exportValue) {
+            const ev = col.exportValue(row);
+            const text = ev == null ? '' : String(ev);
+            return { type: 'String', value: v?.icon ? `${v.icon} ${text}` : text, styleId: style(), href };
+        }
+        const raw = row[col.field];
+        // An icon-set glyph forces a string cell (icon + formatted value).
+        if (v?.icon) {
+            const disp = rawValues ? String(raw ?? '') : formatValueForExport(raw, col.format);
+            return { type: 'String', value: `${v.icon} ${disp}`, styleId: style(), href };
+        }
+        const unsafe = (n) => precisionSafe && Math.abs(n) >= 1e15;
+        if (rawValues) {
+            const s = raw == null ? '' : String(raw);
+            const asNum = typeof raw === 'number' && Number.isFinite(raw) && !unsafe(raw);
+            return asNum
+                ? { type: 'Number', value: s, styleId: style(), href }
+                : { type: 'String', value: s, styleId: style(), href };
+        }
+        const typed = valueForExcel(raw, col.format);
+        if (typed.ok) {
+            const numFmt = toExcelNumFmt(col.format);
+            if (typed.value instanceof Date) {
+                return { type: 'DateTime', value: toSpreadsheetDate(typed.value), styleId: style(numFmt), href };
+            }
+            if (unsafe(typed.value))
+                return { type: 'String', value: String(typed.value), styleId: style(), href };
+            return { type: 'Number', value: String(typed.value), styleId: style(numFmt), href };
+        }
+        return { type: 'String', value: formatValueForExport(raw, col.format), styleId: style(), href };
+    }
+    const cellXml = (c) => {
+        const style = c.styleId ? ` ss:StyleID="${c.styleId}"` : '';
+        const href = c.href ? ` ss:HRef="${xmlEscape(c.href)}"` : '';
+        return `<Cell${style}${href}><Data ss:Type="${c.type}">${xmlEscape(c.value)}</Data></Cell>`;
+    };
+    // <Column> width elements (SpreadsheetML width is in points; ~0.75pt/px).
+    const columnXml = opts.widths
+        ? opts.widths.map((px) => `<Column ss:Width="${Math.round(px * 0.75)}"/>`).join('')
+        : '';
+    // Freeze panes: header row and/or leading columns.
+    const freezeCols = Math.max(0, Math.floor(opts.freezeColumns ?? 0));
+    const worksheetOptions = opts.freezeHeader || freezeCols > 0
+        ? '<WorksheetOptions xmlns="urn:schemas-microsoft-com:office:excel">' +
+            '<FreezePanes/><FrozenNoSplit/>' +
+            (opts.freezeHeader ? '<SplitHorizontal>1</SplitHorizontal><TopRowBottomPane>1</TopRowBottomPane>' : '') +
+            (freezeCols > 0 ? `<SplitVertical>${freezeCols}</SplitVertical><LeftColumnRightPane>${freezeCols}</LeftColumnRightPane>` : '') +
+            '<ActivePane>2</ActivePane></WorksheetOptions>'
+        : '';
+    // Header row (bold style).
+    const headerCells = cols
+        .map((c) => `<Cell ss:StyleID="sHeader"><Data ss:Type="String">${xmlEscape(c.header ?? c.field)}</Data></Cell>`)
+        .join('');
+    const bodyRows = [`<Row>${headerCells}</Row>`];
+    for (let i = 0; i < total; i++) {
+        if (opts.signal?.aborted)
+            throw new DOMException('Export aborted', 'AbortError');
+        const row = rows[i];
+        const cells = cols.map((c, ci) => cellXml(cellFor(c, row, i, ci))).join('');
+        bodyRows.push(`<Row>${cells}</Row>`);
+        if (i > 0 && i % chunk === 0) {
+            opts.onProgress?.({ phase: 'serialize', ratio: i / total, row: i, total });
+            await new Promise((resolve) => setTimeout(resolve, 0));
+        }
+    }
+    opts.onProgress?.({ phase: 'serialize', ratio: 1, row: total, total });
+    return ('<?xml version="1.0"?>\n' +
+        '<?mso-application progid="Excel.Sheet"?>\n' +
+        '<Workbook xmlns="urn:schemas-microsoft-com:office:spreadsheet"' +
+        ' xmlns:o="urn:schemas-microsoft-com:office:office"' +
+        ' xmlns:x="urn:schemas-microsoft-com:office:excel"' +
+        ' xmlns:ss="urn:schemas-microsoft-com:office:spreadsheet"' +
+        ' xmlns:html="http://www.w3.org/TR/REC-html40">' +
+        `<Styles>${styleDefs.join('')}</Styles>` +
+        `<Worksheet ss:Name="${xmlEscape(sheetName.slice(0, 31) || 'Sheet1')}">` +
+        `<Table>${columnXml}${bodyRows.join('')}</Table>` +
+        worksheetOptions +
+        '</Worksheet>' +
+        '</Workbook>');
+}