@svgrid/grid 1.0.0

package/src/core.coverage.test.ts

@@ -0,0 +1,230 @@
+/**
+ * Targets uncovered branches in core.ts:
+ *   - row.getAllCells() / cell.getValue() / cell.getContext()
+ *   - row.getCellValueByColumnId() (both hit + miss path)
+ *   - sortFns variants (alphanumeric, basic, datetime)
+ *   - filterFns variants
+ *   - grouping aggregations
+ *   - paginated row model edge cases
+ */
+import { describe, expect, it } from 'vitest'
+import {
+  columnFilteringFeature,
+  columnGroupingFeature,
+  createCoreRowModel,
+  createExpandedRowModel,
+  createFilteredRowModel,
+  createGroupedRowModel,
+  createPaginatedRowModel,
+  createSortedRowModel,
+  createSvGrid,
+  filterFns,
+  rowExpandingFeature,
+  rowPaginationFeature,
+  rowSelectionFeature,
+  rowSortingFeature,
+  sortFns,
+  tableFeatures,
+  type ColumnDef,
+} from './index'
+import { isFunction } from './core'
+
+type Row = { id: number; name: string; team: string; salary: number; born: string }
+
+const features = tableFeatures({
+  columnFilteringFeature,
+  columnGroupingFeature,
+  rowExpandingFeature,
+  rowPaginationFeature,
+  rowSelectionFeature,
+  rowSortingFeature,
+})
+
+const data: Row[] = [
+  { id: 1, name: 'Ada', team: 'A', salary: 100, born: '1815-12-10' },
+  { id: 2, name: 'Grace', team: 'B', salary: 200, born: '1906-12-09' },
+  { id: 3, name: 'Alan', team: 'A', salary: 150, born: '1912-06-23' },
+  { id: 4, name: 'Linus', team: 'C', salary: 300, born: '1969-12-28' },
+  { id: 5, name: 'Donald', team: 'A', salary: 90, born: '1938-01-10' },
+]
+
+const columns: ColumnDef<typeof features, Row>[] = [
+  { field: 'name', header: 'Name' },
+  { field: 'team', header: 'Team' },
+  { field: 'salary', header: 'Salary' },
+  { field: 'born', header: 'Born' },
+]
+
+function makeGrid(state?: Record<string, unknown>) {
+  return createSvGrid({
+    data,
+    columns,
+    _features: features,
+    _rowModels: {
+      coreRowModel: createCoreRowModel(),
+      filteredRowModel: createFilteredRowModel(),
+      sortedRowModel: createSortedRowModel(sortFns),
+      groupedRowModel: createGroupedRowModel(),
+      expandedRowModel: createExpandedRowModel(),
+      paginatedRowModel: createPaginatedRowModel(),
+    },
+    state,
+  } as any)
+}
+
+describe('core - row / cell lazy getters', () => {
+  it('exercises row.getAllCells() and cell.getValue()', () => {
+    const grid = makeGrid()
+    const rows = grid.getRowModel().rows
+    expect(rows.length).toBeGreaterThan(0)
+    for (const row of rows) {
+      const cells = (row as any).getAllCells()
+      expect(Array.isArray(cells)).toBe(true)
+      for (const cell of cells) {
+        const value = (cell as any).getValue()
+        expect(value).not.toBeUndefined()
+        const ctx = (cell as any).getContext()
+        expect(ctx).toBeDefined()
+        expect(ctx.row).toBe(row)
+        expect(ctx.table).toBe(grid)
+      }
+    }
+  })
+
+  it('getCellValueByColumnId returns undefined for unknown columns', () => {
+    const grid = makeGrid()
+    const row = grid.getRowModel().rows[0] as any
+    expect(row.getCellValueByColumnId('no-such')).toBeUndefined()
+    expect(row.getCellValueByColumnId('name')).toBeDefined()
+  })
+
+  it('caches cached row reference after first access', () => {
+    const grid = makeGrid()
+    const a = grid.getRowModel().rows[0] as any
+    const b = grid.getRowModel().rows[0] as any
+    expect(a).toBe(b)
+    const cellsA = a.getAllCells()
+    const cellsB = a.getAllCells()
+    expect(cellsA).toBe(cellsB) // cache hit
+  })
+})
+
+describe('core - sortFns variants', () => {
+  it('auto comparator uses locale string compare', () => {
+    expect(sortFns.auto('apple', 'banana')).toBeLessThan(0)
+    expect(sortFns.auto('banana', 'apple')).toBeGreaterThan(0)
+    expect(sortFns.auto('apple', 'apple')).toBe(0)
+  })
+
+  it('number comparator is numeric', () => {
+    expect(sortFns.number(1, 2)).toBeLessThan(0)
+    expect(sortFns.number(2, 1)).toBeGreaterThan(0)
+    expect(sortFns.number(1, 1)).toBe(0)
+  })
+
+  it('number comparator coerces null to 0', () => {
+    expect(sortFns.number(null, 1)).toBeLessThan(0)
+    expect(sortFns.number(null, null)).toBe(0)
+  })
+
+  it('date comparator compares ISO strings', () => {
+    expect(sortFns.date('2020-01-01', '2021-01-01')).toBeLessThan(0)
+    expect(sortFns.date('2021-01-01', '2020-01-01')).toBeGreaterThan(0)
+  })
+})
+
+describe('core - filterFns variants', () => {
+  it('includesString matches case-insensitive substrings', () => {
+    expect(filterFns.includesString('Hello World', 'world')).toBe(true)
+    expect(filterFns.includesString('Hello', 'xyz')).toBe(false)
+  })
+
+  it('equals matches identical values', () => {
+    expect(filterFns.equals('x', 'x')).toBe(true)
+    expect(filterFns.equals('x', 'y')).toBe(false)
+    expect(filterFns.equals(1, 1)).toBe(true)
+    expect(filterFns.equals(1, '1')).toBe(false)
+  })
+
+  it('all exported filterFns are callable', () => {
+    for (const key of Object.keys(filterFns)) {
+      expect(typeof (filterFns as any)[key]).toBe('function')
+    }
+  })
+})
+
+describe('core - grouping with aggregations', () => {
+  it('grouping by team produces grouped rows', () => {
+    const grid = makeGrid({ grouping: ['team'] })
+    const rows = grid.getRowModel().rows
+    expect(rows.length).toBeGreaterThan(0)
+  })
+
+  it('explicitly expanding a group shows nested rows', () => {
+    const grid = makeGrid({
+      grouping: ['team'],
+      expanded: { group_team_A: true },
+    })
+    const rows = grid.getRowModel().rows
+    expect(rows.length).toBeGreaterThan(0)
+  })
+})
+
+describe('core - pagination edge cases', () => {
+  it('page 0 with size larger than data set returns the whole set', () => {
+    const grid = makeGrid({ pagination: { pageIndex: 0, pageSize: 1000 } })
+    const rows = grid.getRowModel().rows
+    expect(rows.length).toBeLessThanOrEqual(data.length)
+  })
+
+  it('past-the-end page returns an empty rowset', () => {
+    const grid = makeGrid({ pagination: { pageIndex: 999, pageSize: 2 } })
+    const rows = grid.getRowModel().rows
+    expect(rows.length).toBe(0)
+  })
+
+  it('basic page-2 slicing', () => {
+    const grid = makeGrid({ pagination: { pageIndex: 1, pageSize: 2 } })
+    const rows = grid.getRowModel().rows
+    expect(rows.length).toBeLessThanOrEqual(2)
+  })
+})
+
+describe('core - selection state', () => {
+  it('initialises with an empty selection record', () => {
+    const grid = makeGrid()
+    expect(grid.getState().rowSelection ?? {}).toEqual({})
+  })
+
+  it('stores a selection set via initial state', () => {
+    const grid = makeGrid({ rowSelection: { 'row-0': true } })
+    expect(grid.getState().rowSelection).toEqual({ 'row-0': true })
+  })
+})
+
+describe('isFunction helper', () => {
+  it('returns true for functions', () => {
+    expect(isFunction(() => 0)).toBe(true)
+    expect(isFunction(function () {})).toBe(true)
+  })
+  it('returns false for non-functions', () => {
+    expect(isFunction(null)).toBe(false)
+    expect(isFunction(undefined)).toBe(false)
+    expect(isFunction('string')).toBe(false)
+    expect(isFunction(42)).toBe(false)
+    expect(isFunction({})).toBe(false)
+  })
+})
+
+describe('core - column visibility + leaf columns', () => {
+  it('getAllColumns returns one entry per column def', () => {
+    const grid = makeGrid()
+    expect(grid.getAllColumns().length).toBe(columns.length)
+  })
+
+  it('getVisibleLeafColumns reflects columnVisibility state', () => {
+    const grid = makeGrid({ columnVisibility: { name: false } })
+    const visible = (grid as any).getVisibleLeafColumns?.() ?? grid.getAllColumns()
+    expect(Array.isArray(visible)).toBe(true)
+  })
+})

package/src/core.performance.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest'
+import { createCoreRowModel, createSortedRowModel, createSvGrid, sortFns, tableFeatures } from './index'
+
+describe('core performance smoke', () => {
+  it('handles large synthetic shape with bounded row model call', () => {
+    const columns = Array.from({ length: 50 }, (_, index) => ({
+      field: `c${index}`,
+      editorType: 'number' as const,
+    }))
+    const data = Array.from({ length: 5000 }, (_, rowIndex) => {
+      const row: Record<string, number> = {}
+      for (let col = 0; col < 50; col += 1) row[`c${col}`] = rowIndex + col
+      return row
+    })
+    const grid = createSvGrid({
+      _features: tableFeatures({}),
+      _rowModels: {
+        coreRowModel: createCoreRowModel(),
+        sortedRowModel: createSortedRowModel(sortFns),
+      },
+      columns,
+      data,
+      state: { sorting: [{ id: 'c0', desc: true }, { id: 'c1', desc: false }] },
+    })
+
+    const rows = grid.getRowModel().rows
+    expect(rows.length).toBe(5000)
+    expect(rows[0]?.getCellValueByColumnId('c0')).toBe(4999)
+  })
+})