@opendata-ai/openchart-engine 8.0.0-rc.9 → 8.1.0

package/src/tables/__tests__/compile-table.test.ts

@@ -1,236 +0,0 @@
-import type { CompileTableOptions } from '@opendata-ai/openchart-core';
-import { describe, expect, it } from 'vitest';
-import { compileTable } from '../../compile';
-
-const sampleData = [
-  { name: 'Alice', age: 30, score: 88.5 },
-  { name: 'Bob', age: 25, score: 92.1 },
-  { name: 'Charlie', age: 35, score: 76.3 },
-  { name: 'Diana', age: 28, score: 95.0 },
-];
-
-const baseSpec = {
-  type: 'table' as const,
-  data: sampleData,
-  columns: [
-    { key: 'name', label: 'Name' },
-    { key: 'age', label: 'Age' },
-    { key: 'score', label: 'Score' },
-  ],
-};
-
-const baseOptions: CompileTableOptions = {
-  width: 800,
-  height: 600,
-};
-
-describe('compileTable', () => {
-  it('produces a valid TableLayout from a basic spec', () => {
-    const layout = compileTable(baseSpec, baseOptions);
-
-    expect(layout.columns).toHaveLength(3);
-    expect(layout.rows).toHaveLength(4);
-    expect(layout.theme).toBeDefined();
-    expect(layout.chrome).toBeDefined();
-    expect(layout.search.enabled).toBe(false);
-    expect(layout.stickyFirstColumn).toBe(false);
-    expect(layout.compact).toBe(false);
-  });
-
-  it('formats cell values correctly', () => {
-    const layout = compileTable(baseSpec, baseOptions);
-
-    // First row, first cell should be "Alice"
-    const firstRow = layout.rows[0];
-    expect(firstRow.cells[0].formattedValue).toBe('Alice');
-    // Age should be formatted as number
-    expect(firstRow.cells[1].formattedValue).toBe('30');
-    // Score should be formatted with decimal
-    expect(firstRow.cells[2].formattedValue).toBe('88.50');
-  });
-
-  it('applies d3-format strings to numeric columns', () => {
-    const spec = {
-      ...baseSpec,
-      columns: [{ key: 'name' }, { key: 'age', format: '.1f' }, { key: 'score', format: ',.0f' }],
-    };
-    const layout = compileTable(spec, baseOptions);
-
-    expect(layout.rows[0].cells[1].formattedValue).toBe('30.0');
-    expect(layout.rows[0].cells[2].formattedValue).toBe('89');
-  });
-
-  it('right-aligns number columns by default', () => {
-    const layout = compileTable(baseSpec, baseOptions);
-
-    // name should be left, age and score should be right
-    expect(layout.columns[0].align).toBe('left');
-    expect(layout.columns[1].align).toBe('right');
-    expect(layout.columns[2].align).toBe('right');
-  });
-
-  it('generates stable row IDs from data index', () => {
-    const layout = compileTable(baseSpec, baseOptions);
-
-    expect(layout.rows[0].id).toBe('0');
-    expect(layout.rows[1].id).toBe('1');
-    expect(layout.rows[2].id).toBe('2');
-    expect(layout.rows[3].id).toBe('3');
-  });
-
-  it('uses rowKey for row IDs when specified', () => {
-    const spec = { ...baseSpec, rowKey: 'name' };
-    const layout = compileTable(spec, baseOptions);
-
-    expect(layout.rows[0].id).toBe('Alice');
-    expect(layout.rows[1].id).toBe('Bob');
-    expect(layout.rows[2].id).toBe('Charlie');
-    expect(layout.rows[3].id).toBe('Diana');
-  });
-
-  it('applies tabular-nums font variant on number cells', () => {
-    const layout = compileTable(baseSpec, baseOptions);
-
-    // age cell should have tabular-nums
-    const ageCell = layout.rows[0].cells[1];
-    expect(ageCell.style.fontVariant).toBe('tabular-nums');
-
-    // name cell should not
-    const nameCell = layout.rows[0].cells[0];
-    expect(nameCell.style.fontVariant).toBeUndefined();
-  });
-
-  it('computes reasonable column widths (header text not clipped)', () => {
-    const layout = compileTable(baseSpec, baseOptions);
-
-    for (const col of layout.columns) {
-      // Each column should be at least 60px
-      expect(col.width).toBeGreaterThanOrEqual(60);
-    }
-  });
-
-  it('computes chrome from spec', () => {
-    const spec = {
-      ...baseSpec,
-      chrome: { title: 'Test Table', subtitle: 'A test' },
-    };
-    const layout = compileTable(spec, baseOptions);
-
-    expect(layout.chrome.title?.text).toBe('Test Table');
-    expect(layout.chrome.subtitle?.text).toBe('A test');
-  });
-
-  it('produces valid a11y metadata', () => {
-    const spec = {
-      ...baseSpec,
-      chrome: { title: 'Student Scores' },
-    };
-    const layout = compileTable(spec, baseOptions);
-
-    expect(layout.a11y.caption).toBe('Table: Student Scores');
-    expect(layout.a11y.summary).toContain('3 columns');
-    expect(layout.a11y.summary).toContain('4 rows');
-  });
-
-  it('handles empty data gracefully', () => {
-    // Validation catches empty data, so we test with a minimal valid dataset
-    const spec = {
-      type: 'table' as const,
-      data: [{ x: 1 }],
-      columns: [{ key: 'x' }],
-    };
-    const layout = compileTable(spec, baseOptions);
-    expect(layout.rows).toHaveLength(1);
-  });
-
-  it('preserves original data in row.data', () => {
-    const layout = compileTable(baseSpec, baseOptions);
-
-    expect(layout.rows[0].data).toBe(sampleData[0]);
-    expect(layout.rows[0].data.name).toBe('Alice');
-  });
-
-  it('throws for non-table spec', () => {
-    expect(() =>
-      compileTable(
-        {
-          mark: 'line',
-          data: [
-            { date: '2020-01-01', y: 2 },
-            { date: '2021-01-01', y: 4 },
-          ],
-          encoding: {
-            x: { field: 'date', type: 'temporal' },
-            y: { field: 'y', type: 'quantitative' },
-          },
-        },
-        baseOptions,
-      ),
-    ).toThrow('Use compileChart instead');
-  });
-
-  it('determines column cellType from visual features', () => {
-    const spec = {
-      type: 'table' as const,
-      data: [
-        {
-          val: 10,
-          cat: 'A',
-          trend: [1, 2, 3],
-          bar: 50,
-          img: 'http://example.com/a.png',
-          flag: 'US',
-        },
-      ],
-      columns: [
-        { key: 'val', heatmap: { palette: 'blue' } },
-        { key: 'cat', categoryColors: { A: '#ff0000' } },
-        { key: 'trend', sparkline: { type: 'line' as const } },
-        { key: 'bar', bar: {} },
-        { key: 'img', image: {} },
-        { key: 'flag', flag: true },
-      ],
-    };
-    const layout = compileTable(spec, baseOptions);
-
-    expect(layout.columns[0].cellType).toBe('heatmap');
-    expect(layout.columns[1].cellType).toBe('category');
-    expect(layout.columns[2].cellType).toBe('sparkline');
-    expect(layout.columns[3].cellType).toBe('bar');
-    expect(layout.columns[4].cellType).toBe('image');
-    expect(layout.columns[5].cellType).toBe('flag');
-  });
-
-  it('applies dark mode theme', () => {
-    const layout = compileTable(baseSpec, { ...baseOptions, darkMode: true });
-    expect(layout.theme.isDark).toBe(true);
-  });
-
-  it('includes resolved animation when spec has animation: true', () => {
-    const layout = compileTable({ ...baseSpec, animation: true }, baseOptions);
-    expect(layout.animation).toBeDefined();
-    expect(layout.animation!.enter).toBeDefined();
-    expect(layout.animation!.enter!.duration).toBe(500);
-    expect(layout.animation!.enter!.staggerDelay).toBe(80);
-  });
-
-  it('includes resolved animation with custom config', () => {
-    const layout = compileTable(
-      { ...baseSpec, animation: { enter: { duration: 800, ease: 'snappy' } } },
-      baseOptions,
-    );
-    expect(layout.animation).toBeDefined();
-    expect(layout.animation!.enter!.duration).toBe(800);
-    expect(layout.animation!.enter!.ease).toBe('snappy');
-  });
-
-  it('does not include animation when spec omits it', () => {
-    const layout = compileTable(baseSpec, baseOptions);
-    expect(layout.animation).toBeUndefined();
-  });
-
-  it('does not include animation when spec has animation: false', () => {
-    const layout = compileTable({ ...baseSpec, animation: false }, baseOptions);
-    expect(layout.animation).toBeUndefined();
-  });
-});

package/src/tables/__tests__/format-cells.test.ts

@@ -1,143 +0,0 @@
-import type { ColumnConfig } from '@opendata-ai/openchart-core';
-import { describe, expect, it } from 'vitest';
-import { formatCell, formatValueForSearch } from '../format-cells';
-
-describe('formatCell', () => {
-  it('formats null as empty string', () => {
-    const col: ColumnConfig = { key: 'x' };
-    const result = formatCell(null, col);
-    expect(result.formattedValue).toBe('');
-    expect(result.value).toBeNull();
-  });
-
-  it('formats undefined as empty string', () => {
-    const col: ColumnConfig = { key: 'x' };
-    const result = formatCell(undefined, col);
-    expect(result.formattedValue).toBe('');
-    expect(result.value).toBeUndefined();
-  });
-
-  it('applies d3-format string to numbers', () => {
-    const col: ColumnConfig = { key: 'x', format: ',.0f' };
-    const result = formatCell(1234567, col);
-    expect(result.formattedValue).toBe('1,234,567');
-  });
-
-  it('applies d3-format with dollar sign', () => {
-    const col: ColumnConfig = { key: 'x', format: '$,.2f' };
-    const result = formatCell(1234.5, col);
-    expect(result.formattedValue).toBe('$1,234.50');
-  });
-
-  it('applies d3-format with percentage', () => {
-    const col: ColumnConfig = { key: 'x', format: '.1%' };
-    const result = formatCell(0.456, col);
-    expect(result.formattedValue).toBe('45.6%');
-  });
-
-  it('auto-formats numbers without explicit format', () => {
-    const col: ColumnConfig = { key: 'x' };
-    const result = formatCell(42, col);
-    // Should produce some formatted string (formatNumber)
-    expect(result.formattedValue).toBeTruthy();
-    expect(typeof result.formattedValue).toBe('string');
-  });
-
-  it('formats Date values', () => {
-    const col: ColumnConfig = { key: 'x' };
-    const date = new Date('2023-06-15');
-    const result = formatCell(date, col);
-    expect(result.formattedValue).toBeTruthy();
-    expect(typeof result.formattedValue).toBe('string');
-  });
-
-  it('handles NaN gracefully (not numeric, falls through to String)', () => {
-    const col: ColumnConfig = { key: 'x' };
-    const result = formatCell(NaN, col);
-    // NaN is not isFinite, so falls through to String(NaN)
-    expect(result.formattedValue).toBe('NaN');
-  });
-
-  it('handles Infinity gracefully (not numeric, falls through to String)', () => {
-    const col: ColumnConfig = { key: 'x' };
-    const result = formatCell(Infinity, col);
-    expect(result.formattedValue).toBe('Infinity');
-  });
-
-  it('handles -Infinity gracefully', () => {
-    const col: ColumnConfig = { key: 'x' };
-    const result = formatCell(-Infinity, col);
-    expect(result.formattedValue).toBe('-Infinity');
-  });
-
-  it('does not crash on invalid d3-format string', () => {
-    const col: ColumnConfig = { key: 'x', format: '%%%invalid%%%' };
-    // Should not throw, falls through to auto-format
-    const result = formatCell(42, col);
-    expect(result.formattedValue).toBeTruthy();
-  });
-
-  it('formats plain strings as-is', () => {
-    const col: ColumnConfig = { key: 'x' };
-    const result = formatCell('hello world', col);
-    expect(result.formattedValue).toBe('hello world');
-  });
-
-  it('formats booleans as strings', () => {
-    const col: ColumnConfig = { key: 'x' };
-    const result = formatCell(true, col);
-    expect(result.formattedValue).toBe('true');
-  });
-
-  it('preserves raw value in output', () => {
-    const col: ColumnConfig = { key: 'x' };
-    const result = formatCell(42, col);
-    expect(result.value).toBe(42);
-  });
-
-  it('returns empty style object', () => {
-    const col: ColumnConfig = { key: 'x' };
-    const result = formatCell('test', col);
-    expect(result.style).toBeDefined();
-  });
-
-  it('d3-format string ignored for non-numeric values', () => {
-    const col: ColumnConfig = { key: 'x', format: ',.0f' };
-    const result = formatCell('not a number', col);
-    expect(result.formattedValue).toBe('not a number');
-  });
-
-  it('supports literal suffix format .0f%', () => {
-    const col: ColumnConfig = { key: 'x', format: '.0f%' };
-    const result = formatCell(32.5, col);
-    expect(result.formattedValue).toBe('33%');
-  });
-
-  it('supports literal suffix format $,.2~fT', () => {
-    const col: ColumnConfig = { key: 'x', format: '$,.2~fT' };
-    const result = formatCell(3.75, col);
-    expect(result.formattedValue).toBe('$3.75T');
-  });
-});
-
-describe('formatValueForSearch', () => {
-  it('returns empty string for null', () => {
-    const col: ColumnConfig = { key: 'x' };
-    expect(formatValueForSearch(null, col)).toBe('');
-  });
-
-  it('formats numbers with d3-format for search', () => {
-    const col: ColumnConfig = { key: 'x', format: ',.0f' };
-    expect(formatValueForSearch(1234, col)).toBe('1,234');
-  });
-
-  it('falls back to String for non-numeric values', () => {
-    const col: ColumnConfig = { key: 'x' };
-    expect(formatValueForSearch('hello', col)).toBe('hello');
-  });
-
-  it('supports literal suffix format in search', () => {
-    const col: ColumnConfig = { key: 'x', format: '.0f%' };
-    expect(formatValueForSearch(32.5, col)).toBe('33%');
-  });
-});

package/src/tables/__tests__/heatmap.test.ts

@@ -1,148 +0,0 @@
-import type { ColumnConfig, ResolvedTheme } from '@opendata-ai/openchart-core';
-import { adaptTheme, contrastRatio, resolveTheme } from '@opendata-ai/openchart-core';
-import { describe, expect, it } from 'vitest';
-import { computeHeatmapColors } from '../heatmap';
-
-function getTheme(dark = false): ResolvedTheme {
-  const theme = resolveTheme();
-  return dark ? adaptTheme(theme) : theme;
-}
-
-describe('computeHeatmapColors', () => {
-  const data = [{ value: 0 }, { value: 25 }, { value: 50 }, { value: 75 }, { value: 100 }];
-
-  const column: ColumnConfig = {
-    key: 'value',
-    heatmap: { palette: 'blue' },
-  };
-
-  it('assigns lighter colors to lower values and darker to higher', () => {
-    const theme = getTheme();
-    const colors = computeHeatmapColors(data, column, theme, false);
-
-    // Domain-minimum row (value=0) is skipped so the normal row
-    // background shows through instead of an opaque low-end color.
-    expect(colors.size).toBe(4);
-    expect(colors.has(0)).toBe(false);
-
-    const lowBg = colors.get(1)!.backgroundColor!;
-    const highBg = colors.get(4)!.backgroundColor!;
-
-    expect(lowBg).not.toBe(highBg);
-  });
-
-  it('text color meets AA contrast against background', () => {
-    const theme = getTheme();
-    const colors = computeHeatmapColors(data, column, theme, false);
-
-    for (const [, style] of colors) {
-      const bg = style.backgroundColor!;
-      const fg = style.color!;
-      const ratio = contrastRatio(fg, bg);
-      // Should pick black or white, both of which should exceed 3:1
-      expect(ratio).toBeGreaterThanOrEqual(3);
-    }
-  });
-
-  it('supports custom domain', () => {
-    const col: ColumnConfig = {
-      key: 'value',
-      heatmap: { palette: 'blue', domain: [0, 200] },
-    };
-    const theme = getTheme();
-    const colors = computeHeatmapColors(data, col, theme, false);
-
-    // value=0 sits at the domain minimum and is skipped
-    expect(colors.size).toBe(4);
-  });
-
-  it('values outside custom domain are clamped', () => {
-    const col: ColumnConfig = {
-      key: 'value',
-      heatmap: { palette: 'blue', domain: [25, 75] },
-    };
-    const theme = getTheme();
-    const colors = computeHeatmapColors(data, col, theme, false);
-
-    // value=0 clamps to domain[0]=25, which is the minimum, so it's skipped
-    expect(colors.has(0)).toBe(false);
-    // value=100 clamps to domain max and gets colored
-    expect(colors.has(4)).toBe(true);
-  });
-
-  it('supports colorByField', () => {
-    const dataWithLabel = [
-      { label: 'A', score: 10 },
-      { label: 'B', score: 90 },
-    ];
-    const col: ColumnConfig = {
-      key: 'label',
-      heatmap: { palette: 'blue', colorByField: 'score' },
-    };
-    const theme = getTheme();
-    const colors = computeHeatmapColors(dataWithLabel, col, theme, false);
-
-    // score=10 is the domain minimum and is skipped; only score=90 gets colored
-    expect(colors.size).toBe(1);
-    expect(colors.has(1)).toBe(true);
-  });
-
-  it('returns empty map for non-numeric columns', () => {
-    const nonNumericData = [{ value: 'hello' }, { value: 'world' }];
-    const theme = getTheme();
-    const colors = computeHeatmapColors(nonNumericData, column, theme, false);
-    expect(colors.size).toBe(0);
-  });
-
-  it('returns empty map when no heatmap config', () => {
-    const col: ColumnConfig = { key: 'value' };
-    const theme = getTheme();
-    const colors = computeHeatmapColors(data, col, theme, false);
-    expect(colors.size).toBe(0);
-  });
-
-  it('adapts colors for dark mode', () => {
-    const theme = getTheme(true);
-    const colors = computeHeatmapColors(data, column, theme, true);
-
-    // Domain-minimum row skipped
-    expect(colors.size).toBe(4);
-    for (const [, style] of colors) {
-      const bg = style.backgroundColor!;
-      const fg = style.color!;
-      const ratio = contrastRatio(fg, bg);
-      expect(ratio).toBeGreaterThanOrEqual(3);
-    }
-  });
-
-  it('custom palette arrays are adapted for dark mode', () => {
-    const col: ColumnConfig = {
-      key: 'value',
-      heatmap: { palette: ['#fca5a5', '#c44e52'], domain: [0, 100] },
-    };
-    const lightTheme = getTheme(false);
-    const darkTheme = getTheme(true);
-    const lightColors = computeHeatmapColors(data, col, lightTheme, false);
-    const darkColors = computeHeatmapColors(data, col, darkTheme, true);
-
-    // Domain-minimum row (value=0) is skipped in both modes
-    expect(lightColors.has(0)).toBe(false);
-    expect(darkColors.has(0)).toBe(false);
-
-    // The high-end color gets adapted for dark mode
-    const lightHighBg = lightColors.get(4)!.backgroundColor!;
-    const darkHighBg = darkColors.get(4)!.backgroundColor!;
-    expect(darkHighBg).not.toBe(lightHighBg);
-  });
-
-  it('supports array of color stops as palette', () => {
-    const col: ColumnConfig = {
-      key: 'value',
-      heatmap: { palette: ['#ffffff', '#ff0000'] },
-    };
-    const theme = getTheme();
-    const colors = computeHeatmapColors(data, col, theme, false);
-    // Domain-minimum row skipped
-    expect(colors.size).toBe(4);
-  });
-});

package/src/tables/__tests__/pagination.test.ts

@@ -1,78 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { paginateData } from '../pagination';
-
-const data = Array.from({ length: 50 }, (_, i) => ({ id: i, value: i * 10 }));
-
-describe('paginateData', () => {
-  it('returns the correct page slice', () => {
-    const result = paginateData(data, 0, 10);
-    expect(result.rows).toHaveLength(10);
-    expect(result.rows[0].id).toBe(0);
-    expect(result.rows[9].id).toBe(9);
-  });
-
-  it('returns correct second page', () => {
-    const result = paginateData(data, 1, 10);
-    expect(result.rows).toHaveLength(10);
-    expect(result.rows[0].id).toBe(10);
-    expect(result.rows[9].id).toBe(19);
-  });
-
-  it('returns correct last page (partial)', () => {
-    // 50 items, page size 15 = 4 pages (15+15+15+5)
-    const result = paginateData(data, 3, 15);
-    expect(result.rows).toHaveLength(5);
-    expect(result.rows[0].id).toBe(45);
-  });
-
-  it('clamps page to valid range (too high)', () => {
-    const result = paginateData(data, 999, 10);
-    expect(result.page).toBe(4); // Last page (0-indexed)
-    expect(result.rows).toHaveLength(10);
-    expect(result.rows[0].id).toBe(40);
-  });
-
-  it('clamps page to valid range (negative)', () => {
-    const result = paginateData(data, -5, 10);
-    expect(result.page).toBe(0);
-    expect(result.rows[0].id).toBe(0);
-  });
-
-  it('computes totalPages correctly', () => {
-    const result = paginateData(data, 0, 10);
-    expect(result.totalPages).toBe(5);
-    expect(result.totalRows).toBe(50);
-  });
-
-  it('computes totalPages for non-even division', () => {
-    const result = paginateData(data, 0, 15);
-    expect(result.totalPages).toBe(4); // ceil(50/15) = 4
-  });
-
-  it('handles disabled pagination (pageSize <= 0)', () => {
-    const result = paginateData(data, 0, 0);
-    expect(result.rows).toHaveLength(50);
-    expect(result.totalPages).toBe(1);
-    expect(result.page).toBe(0);
-  });
-
-  it('handles negative pageSize as disabled', () => {
-    const result = paginateData(data, 0, -10);
-    expect(result.rows).toHaveLength(50);
-    expect(result.totalPages).toBe(1);
-  });
-
-  it('handles empty data', () => {
-    const result = paginateData([], 0, 10);
-    expect(result.rows).toHaveLength(0);
-    expect(result.totalRows).toBe(0);
-    expect(result.totalPages).toBe(1);
-    expect(result.page).toBe(0);
-  });
-
-  it('handles single row', () => {
-    const result = paginateData([{ id: 1 }], 0, 10);
-    expect(result.rows).toHaveLength(1);
-    expect(result.totalPages).toBe(1);
-  });
-});

package/src/tables/__tests__/search.test.ts

@@ -1,94 +0,0 @@
-import type { ColumnConfig } from '@opendata-ai/openchart-core';
-import { describe, expect, it } from 'vitest';
-import { buildSearchIndex, filterBySearch } from '../search';
-
-const data = [
-  { name: 'Alice Smith', age: 30, score: 88.5 },
-  { name: 'Bob Johnson', age: 25, score: 92.1 },
-  { name: 'Charlie Brown', age: 35, score: 76.3 },
-];
-
-const columns: ColumnConfig[] = [{ key: 'name' }, { key: 'age' }, { key: 'score' }];
-
-describe('buildSearchIndex', () => {
-  it('builds an index for all rows', () => {
-    const index = buildSearchIndex(data, columns);
-    expect(index.size).toBe(3);
-    expect(index.has(0)).toBe(true);
-    expect(index.has(1)).toBe(true);
-    expect(index.has(2)).toBe(true);
-  });
-
-  it('includes all column values in the search string', () => {
-    const index = buildSearchIndex(data, columns);
-    const row0 = index.get(0)!;
-    expect(row0).toContain('alice');
-    expect(row0).toContain('30');
-  });
-
-  it('lowercases all values', () => {
-    const index = buildSearchIndex(data, columns);
-    const row0 = index.get(0)!;
-    // Should be lowercase
-    expect(row0).not.toContain('Alice');
-    expect(row0).toContain('alice');
-  });
-});
-
-describe('filterBySearch', () => {
-  it('returns all data for empty query', () => {
-    const index = buildSearchIndex(data, columns);
-    const indices = [0, 1, 2];
-    const result = filterBySearch(data, '', index, indices);
-    expect(result.data).toHaveLength(3);
-    expect(result.indices).toEqual([0, 1, 2]);
-  });
-
-  it('returns all data for whitespace-only query', () => {
-    const index = buildSearchIndex(data, columns);
-    const indices = [0, 1, 2];
-    const result = filterBySearch(data, '   ', index, indices);
-    expect(result.data).toHaveLength(3);
-  });
-
-  it('filters by substring match', () => {
-    const index = buildSearchIndex(data, columns);
-    const indices = [0, 1, 2];
-    const result = filterBySearch(data, 'alice', index, indices);
-    expect(result.data).toHaveLength(1);
-    expect(result.data[0].name).toBe('Alice Smith');
-    expect(result.indices).toEqual([0]);
-  });
-
-  it('is case insensitive', () => {
-    const index = buildSearchIndex(data, columns);
-    const indices = [0, 1, 2];
-    const result = filterBySearch(data, 'ALICE', index, indices);
-    expect(result.data).toHaveLength(1);
-    expect(result.data[0].name).toBe('Alice Smith');
-  });
-
-  it('matches across formatted numeric values', () => {
-    const index = buildSearchIndex(data, columns);
-    const indices = [0, 1, 2];
-    // Search for a number value
-    const result = filterBySearch(data, '35', index, indices);
-    expect(result.data).toHaveLength(1);
-    expect(result.data[0].name).toBe('Charlie Brown');
-  });
-
-  it('returns empty when no match', () => {
-    const index = buildSearchIndex(data, columns);
-    const indices = [0, 1, 2];
-    const result = filterBySearch(data, 'zzz_no_match', index, indices);
-    expect(result.data).toHaveLength(0);
-    expect(result.indices).toHaveLength(0);
-  });
-
-  it('preserves original indices through filtering', () => {
-    const index = buildSearchIndex(data, columns);
-    const indices = [0, 1, 2];
-    const result = filterBySearch(data, 'brown', index, indices);
-    expect(result.indices).toEqual([2]);
-  });
-});