@createiq/htmldiff 1.0.5-beta.0 → 1.0.5-beta.1

package/test/TableDiff.bench.ts

@@ -0,0 +1,244 @@
+import { readFileSync } from 'node:fs'
+import { bench, describe, expect } from 'vitest'
+import HtmlDiff from '../src/HtmlDiff'
+
+// Helpers for generating synthetic table fixtures inline so each scenario
+// is self-describing and doesn't require external HTML files.
+
+function buildTable(rows: number, cols: number, cellContent: (r: number, c: number) => string): string {
+  const out: string[] = ['<table>']
+  for (let r = 0; r < rows; r++) {
+    out.push('<tr>')
+    for (let c = 0; c < cols; c++) {
+      out.push(`<td>${cellContent(r, c)}</td>`)
+    }
+    out.push('</tr>')
+  }
+  out.push('</table>')
+  return out.join('')
+}
+
+function defaultCell(r: number, c: number): string {
+  return `Row ${r} Col ${c} content with a few words to diff`
+}
+
+function nTables(n: number, rows: number, cols: number, prefix: string): string {
+  const out: string[] = []
+  for (let t = 0; t < n; t++) {
+    out.push(`<h2>Table ${t}</h2>`)
+    out.push(buildTable(rows, cols, (r, c) => `${prefix} t${t} r${r} c${c}`))
+  }
+  return out.join('')
+}
+
+const benchOptions = { iterations: 20, warmupIterations: 5 } as const
+
+describe('TableDiff — small table baseline', () => {
+  const oldHtml = buildTable(10, 3, defaultCell)
+  const newHtml = oldHtml
+
+  bench(
+    'small 10x3 — no changes',
+    () => {
+      expect(HtmlDiff.execute(oldHtml, newHtml)).toBeTruthy()
+    },
+    benchOptions
+  )
+})
+
+describe('TableDiff — small table single edit', () => {
+  const oldHtml = buildTable(10, 3, defaultCell)
+  const newHtml = buildTable(10, 3, (r, c) => (r === 4 && c === 1 ? 'Edited content here' : defaultCell(r, c)))
+
+  bench(
+    'small 10x3 — single cell edit',
+    () => {
+      expect(HtmlDiff.execute(oldHtml, newHtml)).toBeTruthy()
+    },
+    benchOptions
+  )
+})
+
+describe('TableDiff — small table content shift across cells', () => {
+  // Shift content one cell to the right within each row: tests cell-by-cell
+  // positional preprocessing (the most-common row-shift mistake).
+  const cells: string[][] = []
+  for (let r = 0; r < 10; r++) {
+    const row: string[] = []
+    for (let c = 0; c < 3; c++) row.push(defaultCell(r, c))
+    cells.push(row)
+  }
+  const oldHtml = buildTable(10, 3, (r, c) => cells[r][c])
+  const newHtml = buildTable(10, 3, (r, c) => (c === 0 ? '' : cells[r][c - 1]))
+
+  bench(
+    'small 10x3 — content shifted right',
+    () => {
+      expect(HtmlDiff.execute(oldHtml, newHtml)).toBeTruthy()
+    },
+    benchOptions
+  )
+})
+
+describe('TableDiff — row added', () => {
+  const oldHtml = buildTable(10, 3, defaultCell)
+  const newHtml = buildTable(11, 3, (r, c) =>
+    r < 5 ? defaultCell(r, c) : r === 5 ? `Inserted row col ${c}` : defaultCell(r - 1, c)
+  )
+
+  bench(
+    'small 10→11 rows × 3 cols — row added',
+    () => {
+      expect(HtmlDiff.execute(oldHtml, newHtml)).toBeTruthy()
+    },
+    benchOptions
+  )
+})
+
+describe('TableDiff — column added', () => {
+  const oldHtml = buildTable(10, 3, defaultCell)
+  const newHtml = buildTable(10, 4, (r, c) =>
+    c < 2 ? defaultCell(r, c) : c === 2 ? `Inserted col cell r${r}` : defaultCell(r, c - 1)
+  )
+
+  bench(
+    'small 10×3→10×4 — column added',
+    () => {
+      expect(HtmlDiff.execute(oldHtml, newHtml)).toBeTruthy()
+    },
+    benchOptions
+  )
+})
+
+describe('TableDiff — horizontal merge (colspan)', () => {
+  // Old: <tr><td>a</td><td>b</td><td>c</td></tr>
+  // New: <tr><td colspan=2>a b</td><td>c</td></tr>
+  const oldHtml = '<table><tr><td>Apple</td><td>Banana</td><td>Cherry</td></tr></table>'
+  const newHtml = '<table><tr><td colspan="2">Apple Banana</td><td>Cherry</td></tr></table>'
+
+  bench(
+    'horizontal merge — single row colspan',
+    () => {
+      expect(HtmlDiff.execute(oldHtml, newHtml)).toBeTruthy()
+    },
+    benchOptions
+  )
+})
+
+describe('TableDiff — vertical merge (rowspan)', () => {
+  // Old: 3 rows of single cells; New: row 0 has rowspan=3, rows 1-2 empty.
+  const oldHtml = '<table><tr><td>One</td></tr><tr><td>Two</td></tr><tr><td>Three</td></tr></table>'
+  const newHtml = '<table><tr><td rowspan="3">One Two Three</td></tr><tr></tr><tr></tr></table>'
+
+  bench(
+    'vertical merge — single col rowspan',
+    () => {
+      expect(HtmlDiff.execute(oldHtml, newHtml)).toBeTruthy()
+    },
+    benchOptions
+  )
+})
+
+describe('TableDiff — medium table single edit', () => {
+  const oldHtml = buildTable(50, 10, defaultCell)
+  const newHtml = buildTable(50, 10, (r, c) => (r === 25 && c === 5 ? 'Edited mid-table' : defaultCell(r, c)))
+
+  bench(
+    'medium 50x10 — single edit',
+    () => {
+      expect(HtmlDiff.execute(oldHtml, newHtml)).toBeTruthy()
+    },
+    benchOptions
+  )
+})
+
+describe('TableDiff — large table stress test', () => {
+  const oldHtml = buildTable(500, 5, defaultCell)
+  const newHtml = buildTable(500, 5, (r, c) => (r === 250 && c === 2 ? 'Edited deep row' : defaultCell(r, c)))
+
+  bench(
+    'large 500x5 — single edit',
+    () => {
+      expect(HtmlDiff.execute(oldHtml, newHtml)).toBeTruthy()
+    },
+    { iterations: 5, warmupIterations: 2 }
+  )
+})
+
+describe('TableDiff — wide table stress test', () => {
+  const oldHtml = buildTable(5, 50, defaultCell)
+  const newHtml = buildTable(5, 50, (r, c) => (r === 2 && c === 25 ? 'Edited wide table' : defaultCell(r, c)))
+
+  bench(
+    'wide 5x50 — single edit',
+    () => {
+      expect(HtmlDiff.execute(oldHtml, newHtml)).toBeTruthy()
+    },
+    benchOptions
+  )
+})
+
+describe('TableDiff — many tables in one input', () => {
+  const oldHtml = nTables(5, 10, 3, 'old')
+  // Edit one cell in each of the 5 tables to exercise preprocessTables iteration.
+  const newHtml = nTables(5, 10, 3, 'new')
+
+  bench(
+    '5 tables × 10x3 — all-cells edited',
+    () => {
+      expect(HtmlDiff.execute(oldHtml, newHtml)).toBeTruthy()
+    },
+    benchOptions
+  )
+})
+
+describe('TableDiff — real-world fixture (input1 vs input2)', () => {
+  const input1 = readFileSync('test/input1.html', 'utf8')
+  const input2 = readFileSync('test/input2.html', 'utf8')
+
+  bench(
+    'input1.html vs input2.html',
+    () => {
+      expect(HtmlDiff.execute(input1, input2)).toBeTruthy()
+    },
+    { iterations: 3, warmupIterations: 1 }
+  )
+})
+
+describe('TableDiff — pathological 100x100 sparse edits', () => {
+  // 100x100 = 10,000 cells. Sparse edits (5 cells) — checks per-cell
+  // recursion overhead and lcsAlign DP cost when dimensions match.
+  const oldHtml = buildTable(100, 100, defaultCell)
+  const newHtml = buildTable(100, 100, (r, c) => {
+    const edited =
+      (r === 0 && c === 0) ||
+      (r === 50 && c === 50) ||
+      (r === 99 && c === 99) ||
+      (r === 25 && c === 75) ||
+      (r === 75 && c === 25)
+    return edited ? `Edited r${r} c${c}` : defaultCell(r, c)
+  })
+
+  bench(
+    '100x100 — sparse edits (same dimensions, positional path)',
+    () => {
+      expect(HtmlDiff.execute(oldHtml, newHtml)).toBeTruthy()
+    },
+    { iterations: 3, warmupIterations: 1 }
+  )
+})
+
+describe('TableDiff — pathological 100x100 row-LCS', () => {
+  // 100x100 with a row deletion — forces lcsAlign over 100 row keys, each
+  // ~3-4KB long after content. Tests row-key whitespace-normalization cost.
+  const oldHtml = buildTable(100, 100, defaultCell)
+  const newHtml = buildTable(99, 100, (r, c) => defaultCell(r < 50 ? r : r + 1, c))
+
+  bench(
+    '100x100 → 99x100 — row deleted (row-LCS path)',
+    () => {
+      expect(HtmlDiff.execute(oldHtml, newHtml)).toBeTruthy()
+    },
+    { iterations: 3, warmupIterations: 1 }
+  )
+})