@svgrid/enterprise 1.2.0 → 2.0.0

package/src/export-xls.ts

@@ -0,0 +1,196 @@
+/**
+ * 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'
+import type { ExportColumn } from './export'
+import type { RowData } from '@svgrid/grid'
+import type { SerializeOptions } from './export-serialize'
+
+// Control chars illegal in XML 1.0 - strip so a stray \x00 can't corrupt the file.
+const INVALID_XML = /[\x00-\x08\x0B\x0C\x0E-\x1F]/g
+function xmlEscape(s: string): string {
+  return s
+    .replace(INVALID_XML, '')
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+}
+
+/** A worksheet cell reduced to what SpreadsheetML needs. */
+type XlsCell = { type: 'Number' | 'DateTime' | 'String'; value: string; styleId?: string; href?: string }
+
+/** SpreadsheetML wants ISO-8601 with no timezone for a DateTime cell. */
+function toSpreadsheetDate(d: Date): string {
+  // yyyy-mm-ddThh:mm:ss.000
+  const p = (n: number, 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<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> {
+  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
+
+  // Build a style table. Each distinct combination of (numFmt, fill, color,
+  // bold, align) becomes one <Style>, referenced from cells via ss:StyleID.
+  type StyleDesc = {
+    numFmt?: string
+    fill?: string
+    color?: string
+    bold?: boolean
+    align?: 'left' | 'center' | 'right'
+  }
+  const styleCache = new Map<string, string>()
+  const styleDefs: string[] = [
+    '<Style ss:ID="sHeader"><Font ss:Bold="1"/><Interior ss:Color="#F2F2F2" ss:Pattern="Solid"/></Style>',
+  ]
+  const cap = (a: 'left' | 'center' | 'right') => (a === 'right' ? 'Right' : a === 'center' ? 'Center' : 'Left')
+  const styleIdFor = (d: StyleDesc): string | undefined => {
+    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: string[] = []
+    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: ExportColumn<TData>, row: TData, r: number, c: number): XlsCell {
+    const href = col.link?.(row) || undefined
+    const v = cellVisual?.(r, c)
+    const style = (numFmt?: string) =>
+      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 as unknown as Record<string, unknown>)[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: number) => 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: XlsCell): string => {
+    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: string[] = [`<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>'
+  )
+}

package/src/export-xlsx-roundtrip.test.ts

@@ -0,0 +1,120 @@
+import { describe, expect, it } from 'vitest'
+import JSZip from 'jszip'
+import { buildXlsxParts, packageXlsx, type XlsxCell } from './export-ooxml'
+
+// A real round-trip: build parts -> zip with the REAL jszip -> unzip -> assert
+// every part survives byte-for-byte AND each XML part is well-formed. This is
+// the safety net the string-matching tests can't give: if the hand-written
+// OOXML is malformed or the package is broken, this fails before Excel does.
+
+/** True when jsdom's DOMParser accepts `xml` as well-formed. */
+function isWellFormed(xml: string): boolean {
+  const doc = new DOMParser().parseFromString(xml, 'application/xml')
+  // jsdom emits a <parsererror> element (in the docElement) for invalid XML.
+  return doc.getElementsByTagName('parsererror').length === 0
+}
+
+const model = {
+  sheetName: 'Report 2026',
+  header: ['Company', 'Price', 'When', 'Ratio', 'Note'],
+  rows: [
+    [
+      { t: 's', value: 'ACME & Co <"x">' },
+      { t: 'n', value: 19.95, numFmt: '"$"#,##0.00', align: 'right', fill: '#fee2e2', color: '#991b1b', bold: true },
+      { t: 'd', value: new Date('2026-03-04T00:00:00Z'), numFmt: 'yyyy-mm-dd' },
+      { t: 'n', value: 0.42, numFmt: '0.00%' },
+      { t: 's', value: 'ok', link: 'https://x.test/a?b=1&c=2' },
+    ],
+    [
+      { t: 's', value: 'Globex' },
+      { t: 'n', value: -1000 },
+      { t: 'd', value: new Date('2026-06-01T00:00:00Z'), numFmt: 'yyyy-mm-dd' },
+      { t: 'n', value: 0 },
+      { t: 's', value: '' },
+    ],
+  ] as XlsxCell[][],
+  widths: [160, 90, 110, 80, 120],
+  freezeHeader: true,
+  freezeColumns: 1,
+  condFormats: [
+    { kind: 'dataBar' as const, colIdx: 1, color: '#3b82f6' },
+    { kind: 'colorScale' as const, colIdx: 3, colors: ['#dcfce7', '#fef9c3', '#fee2e2'] },
+  ],
+}
+
+describe('xlsx round-trip (real jszip + XML validation)', () => {
+  it('packages, unzips, and every part survives + is well-formed XML', async () => {
+    const parts = buildXlsxParts(model)
+    const blob = await packageXlsx(parts, JSZip)
+    expect(blob).toBeInstanceOf(Blob)
+    expect(blob.size).toBeGreaterThan(0)
+
+    const zip = await JSZip.loadAsync(await blob.arrayBuffer())
+
+    for (const [path, expected] of Object.entries(parts)) {
+      const entry = zip.file(path)
+      expect(entry, `missing entry ${path}`).toBeTruthy()
+      const content = await entry!.async('string')
+      expect(content, `mismatch for ${path}`).toBe(expected) // byte-for-byte survive
+      if (path.endsWith('.xml') || path.endsWith('.rels')) {
+        expect(isWellFormed(content), `malformed XML in ${path}`).toBe(true)
+      }
+    }
+  })
+
+  it('the worksheet re-parses into the expected structure', async () => {
+    const parts = buildXlsxParts(model)
+    const zip = await JSZip.loadAsync(await (await packageXlsx(parts, JSZip)).arrayBuffer())
+    const sheetXml = await zip.file('xl/worksheets/sheet1.xml')!.async('string')
+    const doc = new DOMParser().parseFromString(sheetXml, 'application/xml')
+
+    // header + 2 data rows
+    expect(doc.getElementsByTagName('row')).toHaveLength(3)
+    // freeze pane present
+    expect(doc.getElementsByTagName('pane')).toHaveLength(1)
+    // two native conditional-formatting rules
+    expect(doc.getElementsByTagName('conditionalFormatting')).toHaveLength(2)
+    // the hyperlink survived with a rel id
+    expect(doc.getElementsByTagName('hyperlink')).toHaveLength(1)
+    // special chars were escaped, not corrupting the XML
+    expect(sheetXml).toContain('ACME &amp; Co &lt;&quot;x&quot;&gt;')
+  })
+
+  it('an Excel Table (with totals row) packages + re-parses as valid XML', async () => {
+    const parts = buildXlsxParts({
+      ...model,
+      table: { name: 'Table1', totalsRow: true, totalsFns: [undefined, 'sum', undefined, 'sum', undefined] },
+    })
+    const zip = await JSZip.loadAsync(await (await packageXlsx(parts, JSZip)).arrayBuffer())
+
+    const tableXml = await zip.file('xl/tables/table1.xml')!.async('string')
+    expect(isWellFormed(tableXml)).toBe(true)
+    const tdoc = new DOMParser().parseFromString(tableXml, 'application/xml')
+    expect(tdoc.getElementsByTagName('tableColumn')).toHaveLength(5)
+    expect(tableXml).toContain('totalsRowCount="1"')
+
+    const sheetXml = await zip.file('xl/worksheets/sheet1.xml')!.async('string')
+    expect(isWellFormed(sheetXml)).toBe(true)
+    // header + 2 data rows + totals row = 4 rows
+    expect(new DOMParser().parseFromString(sheetXml, 'application/xml').getElementsByTagName('row')).toHaveLength(4)
+    expect(sheetXml).toContain('SUBTOTAL(109,Table1[Price])')
+
+    // Content types + sheet rels reference the table part.
+    expect(await zip.file('[Content_Types].xml')!.async('string')).toContain('spreadsheetml.table+xml')
+    expect(isWellFormed(await zip.file('xl/worksheets/_rels/sheet1.xml.rels')!.async('string'))).toBe(true)
+  })
+
+  it('workbook + styles re-parse and reference the sheet', async () => {
+    const parts = buildXlsxParts(model)
+    const zip = await JSZip.loadAsync(await (await packageXlsx(parts, JSZip)).arrayBuffer())
+    const wb = new DOMParser().parseFromString(await zip.file('xl/workbook.xml')!.async('string'), 'application/xml')
+    expect(wb.getElementsByTagName('sheet')).toHaveLength(1)
+    expect(wb.getElementsByTagName('sheet')[0]!.getAttribute('name')).toBe('Report 2026')
+
+    const styles = await zip.file('xl/styles.xml')!.async('string')
+    expect(isWellFormed(styles)).toBe(true)
+    // fills index 0 (none) + 1 (gray125) are required to precede customs
+    expect(styles).toContain('patternType="none"')
+    expect(styles).toContain('patternType="gray125"')
+  })
+})

package/src/export-xlsx.test.ts

@@ -0,0 +1,150 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+// Plain xlsx now goes through our native OOXML writer. Capture the parts a
+// fake JSZip receives (instead of building a real .xlsx / touching the DOM).
+const captured: { parts: Record<string, string> } = { parts: {} }
+vi.mock('jszip', () => ({
+  default: class {
+    file(path: string, data: string) {
+      captured.parts[path] = data
+    }
+    async generateAsync() {
+      return new Blob([])
+    }
+  },
+}))
+vi.mock('./export-serialize', async (importOriginal) => {
+  const actual = (await importOriginal()) as Record<string, unknown>
+  return { ...actual, downloadBlobFile: () => {} }
+})
+
+import { exportGrid } from './export'
+import { setLicenseKey } from './license'
+
+type Row = { name: string; price: number; when: string; ratio: number }
+const rows: Row[] = [
+  { name: 'ACME', price: 19.95, when: '2026-03-04', ratio: 42 },
+  { name: 'Globex', price: 1000, when: '2026-06-01', ratio: 8 },
+]
+
+function makeApi() {
+  const columns = [
+    { id: 'name', field: 'name', header: 'Company', visible: true },
+    { id: 'price', field: 'price', header: 'Price', visible: true, format: { type: 'currency', currency: 'USD' } },
+    { id: 'when', field: 'when', header: 'Date', visible: true, format: { type: 'date', pattern: 'y-m-d' } },
+    { id: 'ratio', field: 'ratio', header: 'Ratio', visible: true, format: { type: 'percent', valueIsPercentPoints: true } },
+  ]
+  return {
+    getDisplayedRows: () => rows,
+    getSelectedRows: () => [],
+    getData: () => rows,
+    getColumns: () => columns,
+    getState: () => ({ grouping: [] }),
+    getColumnPinning: () => ({ left: [], right: [] }),
+  } as any
+}
+
+beforeEach(() => {
+  captured.parts = {}
+  setLicenseKey('SVENTERPRISE-DEV-TEST')
+})
+
+describe('native xlsx export', () => {
+  it('writes typed numbers/dates with number formats, freeze, and widths', async () => {
+    await exportGrid(makeApi(), { format: 'xlsx', filename: 'orders' })
+    const sheet = captured.parts['xl/worksheets/sheet1.xml']!
+    const styles = captured.parts['xl/styles.xml']!
+    expect(sheet).toContain('<v>19.95</v>') // real number, not "$19.95" text
+    expect(sheet).toMatch(/<v>0\.42<\/v>|<v>0.42<\/v>/) // percent points -> fraction
+    expect(styles).toContain('formatCode="&quot;$&quot;#,##0.00"') // currency numFmt
+    expect(styles).toContain('0.00%') // percent numFmt
+    expect(sheet).toContain('state="frozen"') // freeze header
+    expect(sheet).toContain('<cols>') // auto-fit widths
+  })
+
+  it('carries a predicate rule as a real per-cell fill', async () => {
+    await exportGrid(makeApi(), {
+      format: 'xlsx',
+      conditionalFormats: [
+        { type: 'rule', columns: ['price'], when: ({ value }) => Number(value) >= 1000, background: '#fee2e2' },
+      ],
+    })
+    // The CF fill lands in styles.xml (Smart could never do this).
+    expect(captured.parts['xl/styles.xml']).toContain('fgColor rgb="FFFEE2E2"')
+  })
+
+  it('turns data bars / color scales into native Excel conditional formatting', async () => {
+    await exportGrid(makeApi(), {
+      format: 'xlsx',
+      conditionalFormats: [
+        { type: 'dataBar', columns: ['price'], color: '#3b82f6' },
+        { type: 'colorScale', columns: ['ratio'], min: '#dcfce7', max: '#fee2e2' },
+      ],
+    })
+    const sheet = captured.parts['xl/worksheets/sheet1.xml']!
+    expect(sheet).toContain('type="dataBar"')
+    expect(sheet).toContain('type="colorScale"')
+    // Excel computes these, so there are NO per-cell CF fills baked into styles.
+    expect(captured.parts['xl/styles.xml']).not.toContain('patternType="solid"')
+  })
+
+  it('rawValues:true writes plain numbers without number formats', async () => {
+    await exportGrid(makeApi(), { format: 'xlsx', rawValues: true })
+    const sheet = captured.parts['xl/worksheets/sheet1.xml']!
+    expect(sheet).toContain('<v>42</v>') // raw ratio, not 0.42
+    expect(captured.parts['xl/styles.xml']).not.toContain('0.00%')
+  })
+
+  it('renders cell hyperlinks from a column link hook', async () => {
+    await exportGrid(makeApi(), {
+      format: 'xlsx',
+      columns: [{ field: 'name', header: 'Company', link: (r: Row) => `https://x.test/${r.name}` }],
+    })
+    expect(captured.parts['xl/worksheets/sheet1.xml']).toContain('<hyperlinks>')
+    expect(captured.parts['xl/worksheets/_rels/sheet1.xml.rels']).toContain('Target="https://x.test/ACME"')
+  })
+
+  it('auto-freezes from the grid pinned columns', async () => {
+    const api = makeApi()
+    api.getColumnPinning = () => ({ left: ['name'], right: [] })
+    await exportGrid(api, { format: 'xlsx' })
+    expect(captured.parts['xl/worksheets/sheet1.xml']).toContain('xSplit="1"')
+  })
+
+  it('precisionSafe writes long integer IDs as text (not a rounded number)', async () => {
+    const big = 1234567890123456 // 16 digits: > 1e15 but exactly representable
+    const api = {
+      getDisplayedRows: () => [{ id: big, name: 'A' }],
+      getSelectedRows: () => [],
+      getData: () => [{ id: big, name: 'A' }],
+      getColumns: () => [
+        { id: 'id', field: 'id', header: 'ID', visible: true, format: { type: 'number', options: { maximumFractionDigits: 0, useGrouping: false } } },
+        { id: 'name', field: 'name', header: 'Name', visible: true },
+      ],
+      getState: () => ({ grouping: [] }),
+      getColumnPinning: () => ({ left: [], right: [] }),
+    } as any
+    await exportGrid(api, { format: 'xlsx', precisionSafe: true })
+    const sheet = captured.parts['xl/worksheets/sheet1.xml']!
+    expect(sheet).toContain('t="inlineStr"><is><t xml:space="preserve">1234567890123456')
+    expect(sheet).not.toContain('<v>1234567890123456</v>')
+    // without precisionSafe it stays a real number
+    captured.parts = {}
+    await exportGrid(api, { format: 'xlsx' })
+    expect(captured.parts['xl/worksheets/sheet1.xml']).toContain('<v>1234567890123456</v>')
+  })
+
+  it('wraps the data in an Excel Table with a totals row + SUM formula', async () => {
+    await exportGrid(makeApi(), { format: 'xlsx', excelTable: { totalsRow: true } })
+    const table = captured.parts['xl/tables/table1.xml']!
+    expect(table).toContain('<table ')
+    expect(table).toContain('totalsRowCount="1"')
+    expect(table).toContain('<autoFilter')
+    expect(table).toContain('totalsRowFunction="sum"') // numeric columns
+    const sheet = captured.parts['xl/worksheets/sheet1.xml']!
+    expect(sheet).toContain('<tableParts')
+    expect(sheet).toContain('SUBTOTAL(109,Table1[Price])')
+    expect(captured.parts['xl/worksheets/_rels/sheet1.xml.rels']).toContain('/relationships/table')
+    expect(captured.parts['[Content_Types].xml']).toContain('spreadsheetml.table+xml')
+  })
+})