@svgrid/grid 2.6.2 → 2.6.4

package/src/svgrid.displayed-rows.test.ts

@@ -0,0 +1,144 @@
+/**
+ * `api.getDisplayedRows()` returns the TData rows the body is rendering.
+ *
+ * The subtle case is what counts as "not a data row". Grouping banners are
+ * synthetic - they wrap an aggregate and must be skipped. Tree parents also
+ * have `subRows`, but they are real data rows that render their own cells, so
+ * they must be INCLUDED. A `subRows.length` test cannot tell the two apart and
+ * silently dropped every tree parent (and, through it, every tree parent in an
+ * enterprise export, whose default row source is this method).
+ */
+import { afterEach, describe, expect, it } from 'vitest'
+import { mount, unmount } from 'svelte'
+import SvGrid from './SvGrid.svelte'
+import {
+  columnGroupingFeature,
+  createCoreRowModel,
+  createExpandedRowModel,
+  createFilteredRowModel,
+  createGroupedRowModel,
+  createPaginatedRowModel,
+  createSortedRowModel,
+  rowExpandingFeature,
+  rowSortingFeature,
+  sortFns,
+  tableFeatures,
+} from './index'
+import type { SvGridApi } from './index'
+
+const features = tableFeatures({ rowSortingFeature, columnGroupingFeature, rowExpandingFeature })
+const tick = async (n = 3) => {
+  for (let i = 0; i < n; i++) await new Promise((r) => setTimeout(r, 0))
+}
+
+const mounted: Array<() => void> = []
+afterEach(() => {
+  while (mounted.length) mounted.pop()!()
+})
+
+function mountGrid(rows: unknown[], cols: unknown, extra: Record<string, unknown> = {}) {
+  const target = document.createElement('div')
+  document.body.appendChild(target)
+  let api: SvGridApi<never, never> | null = null
+  const app = mount(SvGrid, {
+    target,
+    props: {
+      data: rows,
+      columns: cols,
+      features,
+      _rowModels: {
+        coreRowModel: createCoreRowModel(),
+        filteredRowModel: createFilteredRowModel(),
+        sortedRowModel: createSortedRowModel(sortFns),
+        groupedRowModel: createGroupedRowModel(),
+        expandedRowModel: createExpandedRowModel(),
+        paginatedRowModel: createPaginatedRowModel(),
+      },
+      containerHeight: 600,
+      virtualization: false,
+      onApiReady: (next: SvGridApi<never, never>) => (api = next),
+      ...extra,
+    } as never,
+  })
+  mounted.push(() => unmount(app))
+  return { target, get api() { return api! } }
+}
+
+const flat = [
+  { id: 1, name: 'Ada', department: 'Engineering' },
+  { id: 2, name: 'Grace', department: 'Engineering' },
+  { id: 3, name: 'Linus', department: 'Operations' },
+]
+const flatCols = [
+  { field: 'name', header: 'Name', width: 150 },
+  { field: 'department', header: 'Department', width: 180 },
+]
+
+const tree = [
+  { id: 1, managerId: null, name: 'Ada' },
+  { id: 2, managerId: 1, name: 'Grace' },
+  { id: 3, managerId: 2, name: 'Alan' },
+  { id: 4, managerId: 1, name: 'Linus' },
+]
+const treeCols = [{ field: 'name', header: 'Name', width: 200 }]
+const treeData = { parentField: 'managerId', column: 'name' }
+const names = (api: SvGridApi<never, never>) =>
+  api.getDisplayedRows().map((r: { name: string }) => r.name)
+
+describe('flat grid', () => {
+  it('returns every row', async () => {
+    const g = mountGrid(flat, flatCols)
+    await tick()
+    expect(names(g.api)).toEqual(['Ada', 'Grace', 'Linus'])
+  })
+})
+
+describe('tree data', () => {
+  it('includes parent rows once expanded - they are real data rows', async () => {
+    const g = mountGrid(tree, treeCols, { treeData })
+    await tick()
+    g.api.expandAllGroups()
+    await tick()
+    // Every row the body paints, parents included.
+    expect(names(g.api)).toEqual(['Ada', 'Grace', 'Alan', 'Linus'])
+    expect(g.target.querySelectorAll('tbody tr').length).toBe(4)
+  })
+
+  it('tracks collapse - a hidden branch is not "displayed"', async () => {
+    const g = mountGrid(tree, treeCols, { treeData, getRowId: (r: { id: number }) => String(r.id) })
+    await tick()
+    // Open Ada only; Grace's own child stays hidden.
+    g.api.setRowExpanded('1', true)
+    await tick()
+    expect(names(g.api)).toEqual(['Ada', 'Grace', 'Linus'])
+    expect(g.target.querySelectorAll('tbody tr').length).toBe(3)
+  })
+
+  it('matches the rendered row count at every expansion level', async () => {
+    const g = mountGrid(tree, treeCols, { treeData })
+    await tick()
+    expect(g.api.getDisplayedRows()).toHaveLength(g.target.querySelectorAll('tbody tr').length)
+    g.api.expandAllGroups()
+    await tick()
+    expect(g.api.getDisplayedRows()).toHaveLength(g.target.querySelectorAll('tbody tr').length)
+  })
+})
+
+describe('grouping', () => {
+  it('still excludes synthetic group banners', async () => {
+    const g = mountGrid(flat, flatCols, { groupBy: ['department'] })
+    await tick()
+    g.api.expandAllGroups()
+    await tick()
+    // 2 banners + 3 leaves rendered, but only the 3 leaves are data rows.
+    expect(g.target.querySelectorAll('tbody tr').length).toBe(5)
+    expect(names(g.api)).toEqual(['Ada', 'Grace', 'Linus'])
+  })
+
+  it('returns nothing while every group is collapsed', async () => {
+    const g = mountGrid(flat, flatCols, { groupBy: ['department'] })
+    await tick()
+    expect(g.api.getDisplayedRows()).toEqual([])
+    expect(g.target.querySelectorAll('tbody tr').length).toBe(2)
+  })
+})

package/src/svgrid.features.test.ts

@@ -1,157 +1,157 @@
-import { describe, expect, it } from 'vitest'
-import {
-  columnFilteringFeature,
-  columnGroupingFeature,
-  createCoreRowModel,
-  createExpandedRowModel,
-  createFilteredRowModel,
-  createGroupedRowModel,
-  createPaginatedRowModel,
-  createSortedRowModel,
-  createSvGrid,
-  rowExpandingFeature,
-  rowSelectionFeature,
-  rowSortingFeature,
-  sortFns,
-  subscribeSvGrid,
-  tableFeatures,
-} from './index'
-import type { ColumnDef } from './index'
-
-type Person = { firstName: string; age: number; status?: string }
-
-describe('SvGrid features', () => {
-  it('supports sorting and pagination row model pipeline', () => {
-    const _features = tableFeatures({
-      columnFilteringFeature,
-      columnGroupingFeature,
-      rowExpandingFeature,
-      rowSelectionFeature,
-      rowSortingFeature,
-    })
-    const columns: Array<ColumnDef<typeof _features, Person>> = [
-      { field: 'firstName' },
-      { field: 'age' },
-    ]
-    const data: Array<Person> = [
-      { firstName: 'John', age: 40, status: 'pending' },
-      { firstName: 'Amy', age: 22, status: 'active' },
-      { firstName: 'Kate', age: 31, status: 'active' },
-    ]
-
-    const grid = createSvGrid({
-      _features,
-      _rowModels: {
-        coreRowModel: createCoreRowModel(),
-        filteredRowModel: createFilteredRowModel(),
-        sortedRowModel: createSortedRowModel(sortFns),
-        groupedRowModel: createGroupedRowModel(),
-        expandedRowModel: createExpandedRowModel(),
-        paginatedRowModel: createPaginatedRowModel(),
-      },
-      columns,
-      data,
-      state: {
-        columnFilters: [{ id: 'firstName', value: 'a', fn: 'includesString' }],
-        grouping: ['status'],
-        expanded: { group_status_active: true },
-        sorting: [{ id: 'age', desc: false }],
-        pagination: { pageIndex: 0, pageSize: 2 },
-      },
-    })
-
-    const rows = grid.getRowModel().rows
-    expect(rows).toHaveLength(1)
-    expect(rows[0]?.id).toContain('group_status_')
-  })
-
-  it('supports row selection and expansion toggles', () => {
-    const _features = tableFeatures({
-      rowExpandingFeature,
-      rowSelectionFeature,
-    })
-    const columns: Array<ColumnDef<typeof _features, Person>> = [
-      { field: 'firstName' },
-    ]
-    const data: Array<Person> = [
-      { firstName: 'Amy', age: 22 },
-    ]
-    const grid = createSvGrid({
-      _features,
-      _rowModels: {
-        coreRowModel: createCoreRowModel(),
-      },
-      columns,
-      data,
-    })
-    const row = grid.getRowModel().rows[0]
-    expect(row).toBeDefined()
-    row?.toggleSelected()
-    row?.toggleExpanded()
-    expect(row?.getIsSelected()).toBe(true)
-    expect(row?.getIsExpanded()).toBe(true)
-  })
-
-  it('supports selector subscriptions with stable shape', () => {
-    const _features = tableFeatures({ rowSortingFeature })
-    const grid = createSvGrid({
-      _features,
-      _rowModels: {
-        coreRowModel: createCoreRowModel(),
-      },
-      columns: [{ field: 'firstName' }],
-      data: [{ firstName: 'Amy', age: 22 }],
-    })
-    const selected = subscribeSvGrid(grid, (state) => ({
-      sorting: state.sorting,
-      pageIndex: state.pagination?.pageIndex ?? 0,
-    }))
-    expect(selected.current.pageIndex).toBe(0)
-  })
-
-  it('supports active cell movement primitives', () => {
-    const _features = tableFeatures({ rowSortingFeature })
-    const grid = createSvGrid({
-      _features,
-      _rowModels: { coreRowModel: createCoreRowModel() },
-      columns: [
-        { field: 'firstName' },
-        { field: 'age' },
-      ],
-      data: [
-        { firstName: 'Amy', age: 22 },
-        { firstName: 'John', age: 40 },
-      ],
-    })
-
-    grid.moveActiveCell({ rowDelta: 1, colDelta: 1 })
-    expect(grid.getState().activeCell.rowIndex).toBe(1)
-    expect(grid.getState().activeCell.colIndex).toBe(1)
-  })
-
-  it('supports multi-column sorting clauses', () => {
-    const _features = tableFeatures({ rowSortingFeature })
-    const grid = createSvGrid({
-      _features,
-      _rowModels: {
-        coreRowModel: createCoreRowModel(),
-        sortedRowModel: createSortedRowModel(sortFns),
-      },
-      columns: [
-        { field: 'firstName' },
-        { field: 'age', editorType: 'number' },
-      ],
-      data: [
-        { firstName: 'Amy', age: 20 },
-        { firstName: 'Amy', age: 30 },
-        { firstName: 'Bob', age: 10 },
-      ],
-      state: { sorting: [{ id: 'firstName', desc: false }, { id: 'age', desc: true }] },
-    })
-
-    const rows = grid.getRowModel().rows
-    expect(rows[0]?.original.firstName).toBe('Amy')
-    expect(rows[0]?.original.age).toBe(30)
-    expect(rows[1]?.original.age).toBe(20)
-  })
-})
+import { describe, expect, it } from 'vitest'
+import {
+  columnFilteringFeature,
+  columnGroupingFeature,
+  createCoreRowModel,
+  createExpandedRowModel,
+  createFilteredRowModel,
+  createGroupedRowModel,
+  createPaginatedRowModel,
+  createSortedRowModel,
+  createSvGrid,
+  rowExpandingFeature,
+  rowSelectionFeature,
+  rowSortingFeature,
+  sortFns,
+  subscribeSvGrid,
+  tableFeatures,
+} from './index'
+import type { ColumnDef } from './index'
+
+type Person = { firstName: string; age: number; status?: string }
+
+describe('SvGrid features', () => {
+  it('supports sorting and pagination row model pipeline', () => {
+    const _features = tableFeatures({
+      columnFilteringFeature,
+      columnGroupingFeature,
+      rowExpandingFeature,
+      rowSelectionFeature,
+      rowSortingFeature,
+    })
+    const columns: Array<ColumnDef<typeof _features, Person>> = [
+      { field: 'firstName' },
+      { field: 'age' },
+    ]
+    const data: Array<Person> = [
+      { firstName: 'John', age: 40, status: 'pending' },
+      { firstName: 'Amy', age: 22, status: 'active' },
+      { firstName: 'Kate', age: 31, status: 'active' },
+    ]
+
+    const grid = createSvGrid({
+      _features,
+      _rowModels: {
+        coreRowModel: createCoreRowModel(),
+        filteredRowModel: createFilteredRowModel(),
+        sortedRowModel: createSortedRowModel(sortFns),
+        groupedRowModel: createGroupedRowModel(),
+        expandedRowModel: createExpandedRowModel(),
+        paginatedRowModel: createPaginatedRowModel(),
+      },
+      columns,
+      data,
+      state: {
+        columnFilters: [{ id: 'firstName', value: 'a', fn: 'includesString' }],
+        grouping: ['status'],
+        expanded: { group_status_active: true },
+        sorting: [{ id: 'age', desc: false }],
+        pagination: { pageIndex: 0, pageSize: 2 },
+      },
+    })
+
+    const rows = grid.getRowModel().rows
+    expect(rows).toHaveLength(1)
+    expect(rows[0]?.id).toContain('group_status_')
+  })
+
+  it('supports row selection and expansion toggles', () => {
+    const _features = tableFeatures({
+      rowExpandingFeature,
+      rowSelectionFeature,
+    })
+    const columns: Array<ColumnDef<typeof _features, Person>> = [
+      { field: 'firstName' },
+    ]
+    const data: Array<Person> = [
+      { firstName: 'Amy', age: 22 },
+    ]
+    const grid = createSvGrid({
+      _features,
+      _rowModels: {
+        coreRowModel: createCoreRowModel(),
+      },
+      columns,
+      data,
+    })
+    const row = grid.getRowModel().rows[0]
+    expect(row).toBeDefined()
+    row?.toggleSelected()
+    row?.toggleExpanded()
+    expect(row?.getIsSelected()).toBe(true)
+    expect(row?.getIsExpanded()).toBe(true)
+  })
+
+  it('supports selector subscriptions with stable shape', () => {
+    const _features = tableFeatures({ rowSortingFeature })
+    const grid = createSvGrid({
+      _features,
+      _rowModels: {
+        coreRowModel: createCoreRowModel(),
+      },
+      columns: [{ field: 'firstName' }],
+      data: [{ firstName: 'Amy', age: 22 }],
+    })
+    const selected = subscribeSvGrid(grid, (state) => ({
+      sorting: state.sorting,
+      pageIndex: state.pagination?.pageIndex ?? 0,
+    }))
+    expect(selected.current.pageIndex).toBe(0)
+  })
+
+  it('supports active cell movement primitives', () => {
+    const _features = tableFeatures({ rowSortingFeature })
+    const grid = createSvGrid({
+      _features,
+      _rowModels: { coreRowModel: createCoreRowModel() },
+      columns: [
+        { field: 'firstName' },
+        { field: 'age' },
+      ],
+      data: [
+        { firstName: 'Amy', age: 22 },
+        { firstName: 'John', age: 40 },
+      ],
+    })
+
+    grid.moveActiveCell({ rowDelta: 1, colDelta: 1 })
+    expect(grid.getState().activeCell.rowIndex).toBe(1)
+    expect(grid.getState().activeCell.colIndex).toBe(1)
+  })
+
+  it('supports multi-column sorting clauses', () => {
+    const _features = tableFeatures({ rowSortingFeature })
+    const grid = createSvGrid({
+      _features,
+      _rowModels: {
+        coreRowModel: createCoreRowModel(),
+        sortedRowModel: createSortedRowModel(sortFns),
+      },
+      columns: [
+        { field: 'firstName' },
+        { field: 'age', editorType: 'number' },
+      ],
+      data: [
+        { firstName: 'Amy', age: 20 },
+        { firstName: 'Amy', age: 30 },
+        { firstName: 'Bob', age: 10 },
+      ],
+      state: { sorting: [{ id: 'firstName', desc: false }, { id: 'age', desc: true }] },
+    })
+
+    const rows = grid.getRowModel().rows
+    expect(rows[0]?.original.firstName).toBe('Amy')
+    expect(rows[0]?.original.age).toBe(30)
+    expect(rows[1]?.original.age).toBe(20)
+  })
+})