@svgrid/enterprise 2.5.2 → 2.6.0

package/src/export-xls.ts

@@ -1,199 +0,0 @@
-/**
- * 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.
-// 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: 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

@@ -1,120 +0,0 @@
-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

@@ -1,150 +0,0 @@
-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')
-  })
-})