@svgrid/enterprise 2.5.2 → 2.6.0

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>');
+}