@svgrid/enterprise 3.1.26 → 3.1.27

package/dist/export.js

@@ -1,3 +1,4 @@
+import { applyGroupAggregate } from '@svgrid/grid/core';
 // Import the pure formatters from the grid's Svelte-free `/format` subpath so
 // this module (and the enterprise unit tests) don't drag in SvGrid.svelte.
 import { formatValueForExport, toExcelNumFmt, valueForExcel } from '@svgrid/grid/format';
@@ -6,7 +7,10 @@ import { installSmartShim } from './smart-shim.js';
 import { downloadBlobFile, downloadTextFile, serializeDelimited, serializeHtml, serializeJson, serializeMarkdown, serializeXml, } from './export-serialize.js';
 import { serializeSpreadsheetML } from './export-xls.js';
 import { buildXlsxParts, packageXlsx } from './export-ooxml.js';
-import { buildPdfDocDefinition, pdfBlob, readGridPdfTheme, registerPdfFonts, resolvePdfCharts } from './export-pdf.js';
+import { buildPdfDocData, buildPdfDocDefinition, pdfBlob, PDF_ROBOTO_MISSING, readGridPdfTheme, registerPdfFont, registerPdfFonts, resolvePdfCharts } from './export-pdf.js';
+import { renderPdfInWorker } from './pdf-worker.js';
+/** Rows past which a PDF rendered on the page earns a warning: about a second of blocked page per thousand. */
+const LARGE_PDF_ROWS = 2000;
 import { buildConditionalResolver } from './export-conditional.js';
 /** Formats served by the native, dependency-free, streaming serializers. */
 const NATIVE_TEXT_FORMATS = [
@@ -102,6 +106,7 @@ export function resolveColumns(api, opts, sourceRows) {
             header: c.header,
             format: c.format,
             align: c.align,
+            aggregate: c.aggregate,
         }));
     }
     if (sourceRows.length > 0) {
@@ -550,27 +555,58 @@ function isSummableColumn(col) {
 }
 /**
  * Build a grouped PDF body: a bold group header per cluster (nested for
- * multi-level grouping), the cluster's data rows, then a subtotal row summing
- * the numeric / currency columns. Values use the same formatting as the grid.
+ * multi-level grouping), the cluster's data rows, a subtotal row, and a grand
+ * total at the end. A column totals with its own `aggregate` (avg, min, max,
+ * count, ...), as the grid's group rows do; without one, number and currency
+ * columns sum. Values and group names use the same formatting as the grid.
+ * Each data row carries its index in `rows`, so conditional formatting and
+ * links can find their row.
  */
-export function buildGroupedPdfBody(cols, rows, groupBy) {
+export function buildGroupedPdfBody(cols, rows, groupBy, opts = {}) {
     const out = [];
-    const headerOf = (field) => cols.find((c) => c.field === field)?.header ?? field;
-    // Put the "Subtotal" label in the first NON-numeric column; if every column
-    // is numeric, -1 means "don't overwrite a sum with the label".
-    const labelColIdx = cols.findIndex((c) => !isSummableColumn(c));
+    const colOf = (field) => cols.find((c) => c.field === field);
+    const aggOf = (c) => c.aggregate ?? (isSummableColumn(c) ? 'sum' : undefined);
+    const hasTotals = cols.some((c) => aggOf(c) !== undefined);
+    // The label goes in the first column that has no total of its own; if
+    // every column has one, -1 means "don't overwrite a total with the label".
+    const labelColIdx = cols.findIndex((c) => aggOf(c) === undefined);
+    const index = new Map();
+    rows.forEach((r, i) => index.set(r, i));
+    const field = (r, f) => r[f];
+    const total = (c, subset) => {
+        const agg = aggOf(c);
+        if (agg === undefined)
+            return '';
+        // The grid's own aggregator, over the same values the column shows.
+        const v = applyGroupAggregate(agg, c.field, subset.map((r) => ({ original: r, getCellValueByColumnId: () => field(r, c.field) })));
+        if (v == null || (typeof v === 'number' && !Number.isFinite(v)))
+            return '';
+        // A count is a number of rows, not an amount: no currency or percent.
+        if (agg === 'count' || agg === 'countDistinct')
+            return String(v);
+        if (Array.isArray(v))
+            return v.map((x) => formatValueForExport(x, c.format)).join(' - ');
+        return formatValueForExport(v, c.format);
+    };
+    const totalRow = (subset, label) => {
+        const cells = cols.map((c) => total(c, subset));
+        if (labelColIdx >= 0)
+            cells[labelColIdx] = label;
+        return { kind: 'subtotal', cells };
+    };
     const recurse = (subset, level) => {
         if (level >= groupBy.length) {
             for (const r of subset) {
-                out.push({ kind: 'data', cells: cols.map((c) => String(cellValueFor(c, r, false) ?? '')) });
+                out.push({ kind: 'data', cells: cols.map((c) => String(cellValueFor(c, r, false) ?? '')), source: index.get(r) });
             }
             return;
         }
-        const field = groupBy[level];
+        const groupField = groupBy[level];
+        const groupCol = colOf(groupField);
         // Preserve first-seen order of group keys.
         const buckets = new Map();
         for (const r of subset) {
-            const key = String(r[field] ?? '');
+            const key = String(field(r, groupField) ?? '');
             const bucket = buckets.get(key);
             if (bucket)
                 bucket.push(r);
@@ -578,26 +614,31 @@ export function buildGroupedPdfBody(cols, rows, groupBy) {
                 buckets.set(key, [r]);
         }
         for (const [key, groupRows] of buckets) {
-            out.push({ kind: 'group', label: `${headerOf(field)}: ${key} (${groupRows.length})`, level });
+            // The name as the grid shows it: a date group reads "Oct 3, 2026", not
+            // the timestamp it is keyed by.
+            const shown = groupCol ? String(cellValueFor(groupCol, groupRows[0], false) ?? key) : key;
+            out.push({ kind: 'group', label: `${groupCol?.header ?? groupField}: ${shown} (${groupRows.length})`, level });
             recurse(groupRows, level + 1);
-            // Subtotal row for the numeric columns of this cluster.
-            const hasSummable = cols.some(isSummableColumn);
-            if (hasSummable) {
-                const cells = cols.map((c) => {
-                    if (!isSummableColumn(c))
-                        return '';
-                    const sum = groupRows.reduce((a, r) => a + (Number(r[c.field]) || 0), 0);
-                    return formatValueForExport(sum, c.format);
-                });
-                if (labelColIdx >= 0)
-                    cells[labelColIdx] = `Subtotal (${key})`;
-                out.push({ kind: 'subtotal', cells });
-            }
+            if (hasTotals)
+                out.push(totalRow(groupRows, opts.labels?.subtotal?.(shown) ?? `Subtotal (${shown})`));
         }
     };
     recurse(rows, 0);
+    if (hasTotals && opts.grandTotal !== false && rows.length)
+        out.push(totalRow(rows, opts.labels?.total ?? 'Total'));
     return out;
 }
+/**
+ * Say so when the PDF holds text Roboto cannot draw. Without a `pdf.font` it
+ * prints as empty boxes, and nothing else would tell the developer why.
+ */
+function warnMissingGlyphs(texts) {
+    const hit = texts.find((t) => PDF_ROBOTO_MISSING.test(t));
+    if (hit === undefined)
+        return;
+    console.warn(`@svgrid/enterprise: the PDF has text its default font (Roboto) cannot draw, such as "${hit.slice(0, 40)}"; ` +
+        'it prints as empty boxes. Pass pdf.font with a font that covers it (Noto Sans CJK, Noto Sans Arabic, ...).');
+}
 /**
  * PDF export via our own pdfmake docDefinition (page setup, repeated header,
  * page numbers, per-column alignment/widths, title/logo, theme colors, and
@@ -605,18 +646,17 @@ export function buildGroupedPdfBody(cols, rows, groupBy) {
  * formatted display strings, so the PDF matches the grid.
  */
 async function exportPdf(api, opts) {
-    await ensureGlobals('pdf');
-    const pdfMake = globalThis.pdfMake;
-    if (!pdfMake) {
-        throw new Error('@svgrid/enterprise: pdf export requires the "pdfmake" peer dependency.');
-    }
     const sourceRows = resolveRowSource(api, opts.rows);
     if (sourceRows.length === 0) {
         throw new Error('@svgrid/enterprise: nothing to export - the grid has no rows');
     }
     const cols = resolveColumns(api, opts, sourceRows);
     const fields = cols.map((c) => c.field);
-    const columns = cols.map((c) => ({ header: c.header ?? c.field, align: c.align }));
+    // The grid's columns arrive with the alignment the screen uses; columns an
+    // app passes itself may not say, so a number or date format right-aligns,
+    // as it does on screen.
+    const alignOf = (c) => c.align ?? (c.format && ['number', 'currency', 'percent', 'date', 'datetime', 'time'].includes(String(c.format.type)) ? 'right' : undefined);
+    const columns = cols.map((c) => ({ header: c.header ?? c.field, align: alignOf(c) }));
     // Carry the grid's active grouping into group + subtotal rows (unless the
     // caller opted out or passed hierarchical), matching the xlsx outline path.
     const autoGrouping = opts.autoGroup !== false && !opts.groupBy?.length && !opts.hierarchical
@@ -648,33 +688,67 @@ async function exportPdf(api, opts) {
         return chartToPngBlob(el, { scale: 2 });
     });
     const now = new Date();
-    let def;
+    let params;
+    // A boolean prints as the grid's checkbox does: a tick for true and nothing
+    // for false, rather than the words. Only plain fields: a column with a
+    // format or an `exportValue` prints what it asks for.
+    const boolAt = (rowIdx, colIdx) => {
+        const col = cols[colIdx];
+        if (!col || col.exportValue || col.format)
+            return undefined;
+        const v = sourceRows[rowIdx]?.[col.field];
+        return typeof v === 'boolean' ? v : undefined;
+    };
+    const withTick = (v, b) => {
+        const icon = v?.icon ?? (b ? '✓' : undefined);
+        return v || icon ? { fill: v?.fill, color: v?.color, bold: v?.bold, icon, iconOnly: v?.iconOnly } : undefined;
+    };
     if (effGroupBy?.length) {
-        // Conditional formatting is skipped for grouped PDFs (group / subtotal
-        // rows own the layout); the grid colors still show on screen.
-        const body = buildGroupedPdfBody(cols, sourceRows, effGroupBy);
-        def = buildPdfDocDefinition({ columns, body, opts: pdfOpts, styles: opts.styles, theme, ...lines, charts, now });
+        const grouped = buildGroupedPdfBody(cols, sourceRows, effGroupBy, { grandTotal: pdfOpts.grandTotal, labels: pdfOpts.labels });
+        const body = grouped.map((row) => row.kind === 'data' && row.source !== undefined
+            ? { ...row, cells: row.cells.map((text, c) => (boolAt(row.source, c) === undefined ? text : '')) }
+            : row);
+        if (!pdfOpts.font)
+            warnMissingGlyphs(body.flatMap((r) => (r.kind === 'group' ? [r.label] : r.cells)));
+        // Data rows come out in group order; conditional formatting and links are
+        // looked up by each row's place in the exported rows.
+        const sources = body.flatMap((r) => (r.kind === 'data' ? [r.source ?? -1] : []));
+        const visual = buildConditionalResolver(cols, sourceRows, opts.conditionalFormats);
+        const link = buildLinkResolver(cols, sourceRows);
+        params = {
+            columns,
+            body,
+            dataCellStyle: (r, c) => {
+                const at = sources[r] ?? -1;
+                return at >= 0 ? withTick(visual(at, c), boolAt(at, c)) : undefined;
+            },
+            dataCellLink: link
+                ? (r, c) => {
+                    const at = sources[r] ?? -1;
+                    return at >= 0 ? link(at, c) : undefined;
+                }
+                : undefined,
+            opts: pdfOpts,
+            styles: opts.styles,
+            theme,
+            ...lines,
+            charts,
+            now,
+        };
     }
     else {
         const projected = await projectRows(sourceRows, cols, opts);
-        const dataRows = projected.slice(1).map((r) => fields.map((f) => String(r[f] ?? '')));
-        // Conditional formatting -> per-cell fill / color / bold + icon prefix.
+        const dataRows = projected.slice(1).map((r, ri) => fields.map((f, c) => (boolAt(ri, c) === undefined ? String(r[f] ?? '') : '')));
+        // Conditional formatting -> per-cell fill / color / bold, and the icon,
+        // which the builder draws (the icon sets' glyphs are not in the font).
         const visual = buildConditionalResolver(cols, sourceRows, opts.conditionalFormats);
-        for (let r = 0; r < dataRows.length; r++) {
-            for (let c = 0; c < cols.length; c++) {
-                const icon = visual(r, c)?.icon;
-                if (icon)
-                    dataRows[r][c] = `${icon} ${dataRows[r][c] ?? ''}`;
-            }
-        }
         const link = buildLinkResolver(cols, sourceRows);
-        def = buildPdfDocDefinition({
+        if (!pdfOpts.font)
+            warnMissingGlyphs([...columns.map((c) => c.header), ...dataRows.flat()]);
+        params = {
             columns,
             rows: dataRows,
-            dataCellStyle: (r, c) => {
-                const v = visual(r, c);
-                return v ? { fill: v.fill, color: v.color, bold: v.bold } : undefined;
-            },
+            dataCellStyle: (r, c) => withTick(visual(r, c), boolAt(r, c)),
             dataCellLink: link,
             opts: pdfOpts,
             styles: opts.styles,
@@ -683,11 +757,34 @@ async function exportPdf(api, opts) {
             merges: opts.merges,
             charts,
             now,
-        });
+        };
     }
     const filename = (opts.filename ?? 'grid').trim() || 'grid';
-    const blob = await pdfBlob(pdfMake.createPdf(def));
-    opts.onProgress?.({ phase: 'write', ratio: 1, total: sourceRows.length });
+    const total = sourceRows.length;
+    let blob;
+    if (pdfOpts.worker) {
+        // The document crosses to the worker as data; pdfmake is loaded there.
+        blob = await renderPdfInWorker(pdfOpts.worker, buildPdfDocData(params), {
+            font: pdfOpts.font,
+            signal: opts.signal,
+            onProgress: (ratio) => opts.onProgress?.({ phase: 'write', ratio, total }),
+        });
+    }
+    else {
+        if (total > LARGE_PDF_ROWS) {
+            console.warn(`@svgrid/enterprise: rendering a ${total.toLocaleString('en-US')}-row PDF on the page; pdfmake blocks it until done ` +
+                '(about a second per thousand rows). Pass pdf.worker to render in a worker instead.');
+        }
+        await ensureGlobals('pdf');
+        const pdfMake = globalThis.pdfMake;
+        if (!pdfMake) {
+            throw new Error('@svgrid/enterprise: pdf export requires the "pdfmake" peer dependency.');
+        }
+        if (pdfOpts.font)
+            registerPdfFont(pdfMake, pdfOpts.font);
+        blob = await pdfBlob(pdfMake.createPdf(buildPdfDocDefinition(params)));
+    }
+    opts.onProgress?.({ phase: 'write', ratio: 1, total });
     return deliver(blob, ensureExt(filename, 'pdf'), 'application/pdf', sourceRows.length, opts.download);
 }
 /**

package/dist/import.js

@@ -24,7 +24,7 @@
  * `print`, so unlicensed evaluation works but emits a one-time nudge.
  */
 import { assertEnterpriseLicensed } from './license.js';
-import { XLSX_MAX_COLS, XLSX_MAX_FILL, xlsxFillError, xlsxRangeError } from './xlsx-limits.js';
+import { createUnzipBudget, readZipEntry, XLSX_MAX_COLS, XLSX_MAX_FILL, xlsxFillError, xlsxRangeError } from './xlsx-limits.js';
 // ---------------------------------------------------------------------------
 // Lazy peer dependency: jszip (xlsx only)
 // ---------------------------------------------------------------------------
@@ -183,11 +183,12 @@ async function parseXlsx(file) {
     const J = await getJSZip();
     const buf = await file.arrayBuffer();
     const zip = await J.loadAsync(buf);
+    const budget = createUnzipBudget();
     // Read sharedStrings.xml if it exists.
     let sharedStrings = [];
     const ssEntry = zip.file('xl/sharedStrings.xml');
     if (ssEntry) {
-        const ssText = await ssEntry.async('string');
+        const ssText = await readZipEntry(ssEntry, 'string', budget);
         sharedStrings = parseSharedStrings(ssText);
     }
     // Read the FIRST sheet. Workbook.xml -> rels mapping is involved; for the
@@ -197,7 +198,7 @@ async function parseXlsx(file) {
     if (!sheetEntry) {
         throw new Error('@svgrid/enterprise: could not locate sheet1.xml in the .xlsx archive');
     }
-    const sheetText = await sheetEntry.async('string');
+    const sheetText = await readZipEntry(sheetEntry, 'string', budget);
     return parseSheetXml(sheetText, sharedStrings);
 }
 /** Pull every `<t>...</t>` out of sharedStrings.xml in document order. */

package/dist/index.d.ts

@@ -2,7 +2,7 @@ export { setLicenseKey, clearLicenseKey, getLicenseKey, isLicenseKeySet, hasVali
 export { parseLicenseExpiry } from './license-core.js';
 export { exportGrid, copyExportToClipboard, type ExportFormat, type ExportOptions, type ExportColumn, type ExportCellStyle, type ExportStyles, type ExportHeaderFooterLine, type ExportSheet, type ExportRowSource, type ExportProgress, type ExportResult, type ClipboardFormat, type ClipboardExportOptions, } from './export.js';
 export { default as SvExportMenu } from './SvExportMenu.svelte';
-export { buildPdfDocDefinition, resolvePdfCharts, resolvePdfVfs, registerPdfFonts, type PdfExportOptions, type PdfPageSize, type PdfChart, type PdfKpi, type PdfChartImage, type PdfVirtualFileSystem, type PdfMakeLike } from './export-pdf.js';
+export { buildPdfDocDefinition, buildPdfDocData, hydratePdfDoc, resolvePdfCharts, resolvePdfVfs, registerPdfFonts, registerPdfFont, type PdfExportOptions, type PdfDocData, type PdfDocParams, type PdfWorkerLike, type PdfPageSize, type PdfChart, type PdfKpi, type PdfChartImage, type PdfVirtualFileSystem, type PdfMakeLike, type PdfFont } from './export-pdf.js';
 export { printGrid, type PrintOptions } from './print.js';
 export { importData, readImportMatrix, mapImportMatrix, mapImportMatrixAsync, autoMapColumns, inferImportColumnTypes, type ImportFormat, type ImportFieldType, type ImportOptions, type ImportResult, type ImportProgress, type ImportColumnMap, type ImportColumnTypes, type ImportGridColumn, type ImportRowError, type ImportValidator, } from './import.js';
 export { default as SvImportDialog } from './SvImportDialog.svelte';

package/dist/index.js

@@ -8,7 +8,7 @@ licenseCovers, getLicenseEdition, nudgeEnterpriseFor, editionCovers, } from './l
 export { parseLicenseExpiry } from './license-core.js';
 export { exportGrid, copyExportToClipboard, } from './export.js';
 export { default as SvExportMenu } from './SvExportMenu.svelte';
-export { buildPdfDocDefinition, resolvePdfCharts, resolvePdfVfs, registerPdfFonts } from './export-pdf.js';
+export { buildPdfDocDefinition, buildPdfDocData, hydratePdfDoc, resolvePdfCharts, resolvePdfVfs, registerPdfFonts, registerPdfFont } from './export-pdf.js';
 export { printGrid } from './print.js';
 export { importData, readImportMatrix, mapImportMatrix, mapImportMatrixAsync, autoMapColumns, inferImportColumnTypes, } from './import.js';
 export { default as SvImportDialog } from './SvImportDialog.svelte';

package/dist/node/studio.js

@@ -16514,7 +16514,7 @@ function hasFieldConditions(schema) {
 *
 * `version.test.ts` asserts this matches `package.json`, so the two cannot drift.
 */
-var SVGRID_VERSION = "3.1.26";
+var SVGRID_VERSION = "3.1.27";
 /**
 * The version of `@svgrid/grid`, which releases on its own line: enterprise is
 * on 3.1.x while the grid is on 3.0.x.

package/dist/pdf-worker.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Render a PDF export in a worker, so a large report does not freeze the
+ * page. pdfmake lays out and writes the whole document in one synchronous
+ * run, about a millisecond per row of eight columns on a desktop machine:
+ * a 20,000-row export held the main thread for over twenty seconds.
+ *
+ * The app owns the worker file, so any bundler builds it:
+ *
+ * ```ts
+ * // pdf.worker.ts
+ * import { servePdfWorker } from '@svgrid/enterprise/pdf-worker'
+ * servePdfWorker()
+ * ```
+ *
+ * ```ts
+ * await api.exportData({
+ *   format: 'pdf',
+ *   pdf: { worker: () => new Worker(new URL('./pdf.worker.ts', import.meta.url), { type: 'module' }) },
+ * })
+ * ```
+ *
+ * The main thread builds the document as plain data (`buildPdfDocData`) and
+ * posts it here with the font, if any; the worker loads pdfmake, attaches
+ * the layout and footer functions (`hydratePdfDoc`), renders, and posts the
+ * bytes back with progress along the way.
+ */
+import { type PdfDocData, type PdfFont, type PdfMakeLike, type PdfWorkerLike } from './export-pdf.js';
+export type { PdfWorkerLike };
+/** Tags this channel's messages, so a worker shared with other traffic ignores the rest. */
+export declare const PDF_WORKER_CHANNEL = "svgrid-pdf";
+export type PdfWorkerRequest = {
+    channel: typeof PDF_WORKER_CHANNEL;
+    id: number;
+    doc: PdfDocData;
+    font?: PdfFont;
+};
+export type PdfWorkerReply = {
+    channel: typeof PDF_WORKER_CHANNEL;
+    id: number;
+    progress: number;
+} | {
+    channel: typeof PDF_WORKER_CHANNEL;
+    id: number;
+    pdf: ArrayBuffer;
+} | {
+    channel: typeof PDF_WORKER_CHANNEL;
+    id: number;
+    error: string;
+};
+/** The pdfmake calls rendering needs, in either the 0.2 or the 0.3 shape. */
+export type PdfMakeRenderer = PdfMakeLike & {
+    fonts?: Record<string, unknown>;
+    addFonts?: (fonts: Record<string, unknown>) => void;
+    createPdf(def: unknown): {
+        getBuffer(cb?: (bytes: Uint8Array) => void, options?: {
+            progressCallback?: (progress: number) => void;
+        }): unknown;
+    };
+};
+/** The part of a worker's global scope (or a `MessagePort`) this needs. */
+export type PdfWorkerScope = {
+    postMessage(message: unknown, transfer?: Transferable[]): void;
+    addEventListener(type: 'message', listener: (event: MessageEvent) => void): void;
+    removeEventListener(type: 'message', listener: (event: MessageEvent) => void): void;
+};
+/**
+ * Render a document from `buildPdfDocData` with the pdfmake given. The
+ * worker's half of the export, exported so it can run anywhere pdfmake does.
+ */
+export declare function renderPdfDoc(doc: PdfDocData, pdfMake: PdfMakeRenderer, opts?: {
+    font?: PdfFont;
+    onProgress?: (progress: number) => void;
+}): Promise<Uint8Array>;
+export type ServePdfWorkerOptions = {
+    /** Where to listen. Default: the worker's global scope. */
+    scope?: PdfWorkerScope;
+    /** How to get pdfmake. Default: import the installed `pdfmake` peer. */
+    loadPdfMake?: () => Promise<PdfMakeRenderer>;
+};
+/** Answer PDF export requests from the main thread. Call it once, in the worker. */
+export declare function servePdfWorker(options?: ServePdfWorkerOptions): {
+    dispose(): void;
+};
+/**
+ * The main thread's half: post the document to a fresh worker, report its
+ * progress, and resolve with the PDF. An abort terminates the worker.
+ */
+export declare function renderPdfInWorker(makeWorker: () => PdfWorkerLike, doc: PdfDocData, opts?: {
+    font?: PdfFont;
+    signal?: AbortSignal;
+    onProgress?: (progress: number) => void;
+}): Promise<Blob>;

package/dist/pdf-worker.js

@@ -0,0 +1,147 @@
+/// <reference path="./pdfmake-shims.d.ts" />
+/**
+ * Render a PDF export in a worker, so a large report does not freeze the
+ * page. pdfmake lays out and writes the whole document in one synchronous
+ * run, about a millisecond per row of eight columns on a desktop machine:
+ * a 20,000-row export held the main thread for over twenty seconds.
+ *
+ * The app owns the worker file, so any bundler builds it:
+ *
+ * ```ts
+ * // pdf.worker.ts
+ * import { servePdfWorker } from '@svgrid/enterprise/pdf-worker'
+ * servePdfWorker()
+ * ```
+ *
+ * ```ts
+ * await api.exportData({
+ *   format: 'pdf',
+ *   pdf: { worker: () => new Worker(new URL('./pdf.worker.ts', import.meta.url), { type: 'module' }) },
+ * })
+ * ```
+ *
+ * The main thread builds the document as plain data (`buildPdfDocData`) and
+ * posts it here with the font, if any; the worker loads pdfmake, attaches
+ * the layout and footer functions (`hydratePdfDoc`), renders, and posts the
+ * bytes back with progress along the way.
+ */
+import { hydratePdfDoc, registerPdfFont, registerPdfFonts } from './export-pdf.js';
+/** Tags this channel's messages, so a worker shared with other traffic ignores the rest. */
+export const PDF_WORKER_CHANNEL = 'svgrid-pdf';
+/**
+ * Render a document from `buildPdfDocData` with the pdfmake given. The
+ * worker's half of the export, exported so it can run anywhere pdfmake does.
+ */
+export function renderPdfDoc(doc, pdfMake, opts = {}) {
+    if (opts.font)
+        registerPdfFont(pdfMake, opts.font);
+    const def = hydratePdfDoc(doc);
+    return new Promise((resolve, reject) => {
+        const done = (bytes) => resolve(bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes));
+        try {
+            // 0.2 calls back; 0.3 returns a promise and ignores the callback.
+            const returned = pdfMake.createPdf(def).getBuffer(done, { progressCallback: opts.onProgress });
+            if (returned && typeof returned.then === 'function') {
+                ;
+                returned.then(done, reject);
+            }
+        }
+        catch (err) {
+            reject(err);
+        }
+    });
+}
+async function loadPdfMake() {
+    // @ts-ignore - "pdfmake" is an optional peerDependency
+    const mod = (await import('pdfmake/build/pdfmake'));
+    // @ts-ignore - "pdfmake" is an optional peerDependency
+    const vfs = await import('pdfmake/build/vfs_fonts');
+    const pdfMake = (mod.default ?? mod);
+    if (!registerPdfFonts(pdfMake, vfs)) {
+        throw new Error('"pdfmake/build/vfs_fonts" did not contain a font map; the installed pdfmake is not one this export knows.');
+    }
+    // createPdf reads `pdfMake.tableLayouts` off the global, and a bundled
+    // import never sets that global, so without this every render failed with
+    // "Cannot read properties of undefined (reading 'tableLayouts')". The page
+    // side does the same in ensureGlobals.
+    ;
+    globalThis.pdfMake = pdfMake;
+    return pdfMake;
+}
+/** Answer PDF export requests from the main thread. Call it once, in the worker. */
+export function servePdfWorker(options = {}) {
+    const scope = options.scope ?? globalThis;
+    const load = options.loadPdfMake ?? loadPdfMake;
+    let pdfMake = null;
+    const reply = (message, transfer) => scope.postMessage(message, transfer);
+    const listener = async (event) => {
+        const msg = event.data;
+        if (!msg || msg.channel !== PDF_WORKER_CHANNEL || typeof msg.id !== 'number' || !msg.doc)
+            return;
+        const { id, doc, font } = msg;
+        try {
+            pdfMake ?? (pdfMake = load());
+            // pdfmake reports progress per item drawn: a 5,000-row table sent
+            // 79,129 messages. One per percent is enough for a progress bar.
+            let sent = -1;
+            const bytes = await renderPdfDoc(doc, await pdfMake, {
+                font,
+                onProgress: (progress) => {
+                    if (progress < 1 && progress - sent < 0.01)
+                        return;
+                    sent = progress;
+                    reply({ channel: PDF_WORKER_CHANNEL, id, progress });
+                },
+            });
+            // A copy of exactly these bytes, handed over rather than cloned.
+            const pdf = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+            reply({ channel: PDF_WORKER_CHANNEL, id, pdf }, [pdf]);
+        }
+        catch (err) {
+            pdfMake = null;
+            reply({ channel: PDF_WORKER_CHANNEL, id, error: err instanceof Error ? err.message : String(err) });
+        }
+    };
+    scope.addEventListener('message', listener);
+    return { dispose: () => scope.removeEventListener('message', listener) };
+}
+let nextJob = 1;
+/**
+ * The main thread's half: post the document to a fresh worker, report its
+ * progress, and resolve with the PDF. An abort terminates the worker.
+ */
+export function renderPdfInWorker(makeWorker, doc, opts = {}) {
+    const worker = makeWorker();
+    const id = nextJob++;
+    return new Promise((resolve, reject) => {
+        const finish = () => {
+            opts.signal?.removeEventListener('abort', onAbort);
+            worker.terminate();
+        };
+        const onAbort = () => {
+            finish();
+            reject(new DOMException('Export aborted', 'AbortError'));
+        };
+        if (opts.signal?.aborted)
+            return onAbort();
+        opts.signal?.addEventListener('abort', onAbort, { once: true });
+        worker.addEventListener('message', (event) => {
+            const msg = event.data;
+            if (!msg || msg.channel !== PDF_WORKER_CHANNEL || msg.id !== id)
+                return;
+            if ('progress' in msg)
+                return opts.onProgress?.(msg.progress);
+            finish();
+            if ('pdf' in msg)
+                resolve(new Blob([msg.pdf], { type: 'application/pdf' }));
+            else
+                reject(new Error(`@svgrid/enterprise: the PDF worker failed: ${msg.error}`));
+        });
+        worker.addEventListener('error', (event) => {
+            finish();
+            reject(new Error(`@svgrid/enterprise: the PDF worker failed to start or crashed: ${event.message || 'no message'}. Check that it calls servePdfWorker().`));
+        });
+        const request = { channel: PDF_WORKER_CHANNEL, id, doc, ...(opts.font ? { font: opts.font } : {}) };
+        worker.postMessage(request);
+    });
+}

package/dist/sheet/ods-document.js

@@ -17,6 +17,7 @@ import { colToLetters, lettersToCol } from './address.js';
 import { tokenize } from './tokenize.js';
 import { formatKeyAt } from './format-store.js';
 import { linkAt } from './links.js';
+import { createUnzipBudget, readZipEntry } from '../xlsx-limits.js';
 import { threadAt } from './comments.js';
 import { loadZip } from './xlsx-document.js';
 import { accountingParts, accountingPattern } from './number-format.js';
@@ -747,6 +748,7 @@ function durationSeconds(text) {
 export async function documentFromOds(file, JSZip) {
     const Zip = await loadZip(JSZip);
     const zip = await Zip.loadAsync(file);
+    const budget = createUnzipBudget();
     const parts = {};
     const pending = [];
     zip.forEach((path, entry) => {
@@ -755,7 +757,7 @@ export async function documentFromOds(file, JSZip) {
         if (!/\.(xml)$/i.test(path))
             return;
         const clean = path.replace(/^\//, '');
-        pending.push(entry.async('string').then((text) => { parts[clean] = text; }));
+        pending.push(readZipEntry(entry, 'string', budget).then((text) => { parts[clean] = text; }));
     });
     await Promise.all(pending);
     return sheetStateFromOds(parts);

package/dist/sheet/open-file.js

@@ -14,6 +14,7 @@ import { documentFromXlsxParts, loadZip } from './xlsx-document.js';
 import { sheetStateFromOds } from './ods-document.js';
 import { sheetStateFromCsv } from './csv.js';
 import { isXlsFile, sheetStateFromXls } from './xls-document.js';
+import { createUnzipBudget, readZipEntry } from '../xlsx-limits.js';
 /** A picture travels as the data URL the document holds, as in the xlsx reader. */
 const MEDIA_PREFIX = 'xl/media/';
 const mediaTypeOf = (path) => {
@@ -31,6 +32,7 @@ export async function readSpreadsheetFile(file, JSZip) {
     }
     const Zip = await loadZip(JSZip);
     const zip = await Zip.loadAsync(file);
+    const budget = createUnzipBudget();
     const parts = {};
     const pending = [];
     zip.forEach((path, entry) => {
@@ -38,12 +40,12 @@ export async function readSpreadsheetFile(file, JSZip) {
             return;
         const clean = path.replace(/^\//, '');
         if (clean.startsWith(MEDIA_PREFIX)) {
-            pending.push(entry.async('base64').then((base64) => { parts[clean] = `data:${mediaTypeOf(clean)};base64,${base64}`; }));
+            pending.push(readZipEntry(entry, 'base64', budget).then((base64) => { parts[clean] = `data:${mediaTypeOf(clean)};base64,${base64}`; }));
             return;
         }
         if (!/\.(xml|rels|vml)$/i.test(clean))
             return;
-        pending.push(entry.async('string').then((text) => { parts[clean] = text; }));
+        pending.push(readZipEntry(entry, 'string', budget).then((text) => { parts[clean] = text; }));
     });
     await Promise.all(pending);
     if (parts['content.xml'] && !parts['xl/workbook.xml'])