test: add missing Fns tests and add test coverage report

Author: KevinVandy

.github/workflows/pr.yml

@@ -40,6 +40,20 @@ jobs:
       - name: Stop Nx Agents
         if: ${{ always() }}
         run: npx nx-cloud stop-all-agents
+  coverage:
+    name: Coverage Report
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        with:
+          persist-credentials: false
+      - name: Setup Tools
+        uses: tanstack/config/.github/setup@e4b48f16568324f76f467aa4c2aac2f05db632c3 # main
+      - name: Collect Coverage
+        run: pnpm --filter "@tanstack/table-core" test:coverage
+      - name: Write Coverage Summary
+        run: node scripts/coverage-summary.mjs packages/table-core/coverage/coverage-summary.json "table-core Coverage" >> "$GITHUB_STEP_SUMMARY"
   preview:
     name: Preview
     runs-on: ubuntu-latest

package.json

@@ -66,6 +66,7 @@
     "@tanstack/typedoc-config": "0.3.3",
     "@testing-library/jest-dom": "^6.9.1",
     "@types/node": "^26.0.0",
+    "@vitest/coverage-v8": "4.1.9",
     "eslint": "^10.5.0",
     "jsdom": "^29.1.1",
     "knip": "^6.16.1",

packages/table-core/package.json

@@ -70,6 +70,7 @@
     "clean": "rimraf ./build && rimraf ./dist",
     "lint:fix": "eslint ./src --fix",
     "test:eslint": "eslint ./src",
+    "test:coverage": "vitest run --coverage",
     "test:lib": "vitest",
     "test:lib:dev": "pnpm test:lib --watch",
     "test:types": "tsc && tsc -p tests/tsconfig.declaration-emit.json",

packages/table-core/tests/unit/fns/aggregationFns.test.ts

@@ -1,10 +1,14 @@
 import { describe, expect, it } from 'vitest'
 import {
+  aggregationFn_count,
   aggregationFn_extent,
   aggregationFn_max,
   aggregationFn_mean,
+  aggregationFn_median,
   aggregationFn_min,
   aggregationFn_sum,
+  aggregationFn_unique,
+  aggregationFn_uniqueCount,
 } from '../../../src'
 
 function makeRows(values: Array<unknown>) {
@@ -45,3 +49,53 @@ describe('Aggregation Functions', () => {
     expect(aggregationFn_mean('value', rows)).toBe(2)
   })
 })
+
+describe('median', () => {
+  it('returns undefined for empty groups', () => {
+    expect(aggregationFn_median('value', makeRows([]) as any)).toBeUndefined()
+  })
+
+  it('returns the single value for one-row groups', () => {
+    expect(aggregationFn_median('value', makeRows([5]) as any)).toBe(5)
+  })
+
+  it('returns the middle value for odd-length groups', () => {
+    expect(aggregationFn_median('value', makeRows([3, 1, 2]) as any)).toBe(2)
+  })
+
+  it('averages the two middle values for even-length groups', () => {
+    expect(aggregationFn_median('value', makeRows([4, 1, 3, 2]) as any)).toBe(
+      2.5,
+    )
+  })
+
+  it('returns undefined when any value is not a number', () => {
+    expect(
+      aggregationFn_median('value', makeRows([1, '2', 3]) as any),
+    ).toBeUndefined()
+  })
+})
+
+describe('unique / uniqueCount', () => {
+  it('collects distinct values in first-seen order', () => {
+    expect(
+      aggregationFn_unique('value', makeRows(['a', 'b', 'a', 'c']) as any),
+    ).toEqual(['a', 'b', 'c'])
+  })
+
+  it('counts distinct values with Set semantics', () => {
+    expect(
+      aggregationFn_uniqueCount(
+        'value',
+        makeRows(['a', 'b', 'a', null, null]) as any,
+      ),
+    ).toBe(3)
+  })
+})
+
+describe('count', () => {
+  it('counts leaf rows and ignores the column id', () => {
+    expect(aggregationFn_count('anything', makeRows([1, 2, 3]) as any)).toBe(3)
+    expect(aggregationFn_count('anything', makeRows([]) as any)).toBe(0)
+  })
+})

packages/table-core/tests/unit/fns/filterFns.test.ts

@@ -7,6 +7,7 @@ import {
   filterFn_equalsStringSensitive,
   filterFn_greaterThan,
   filterFn_greaterThanOrEqualTo,
+  filterFn_inNumberRange,
   filterFn_includesString,
   filterFn_includesStringSensitive,
   filterFn_lessThan,
@@ -571,7 +572,7 @@ describe('Filter Functions', () => {
     })
 
     describe('filterFns.between.autoRemove', () => {
-      const autoRemove = filterFns.between.autoRemove!
+      const autoRemove = filterFns.between.autoRemove
 
       it('should auto-remove when both endpoints are undefined', () => {
         expect(autoRemove([undefined, undefined])).toBe(true)
@@ -595,7 +596,7 @@ describe('Filter Functions', () => {
     })
 
     describe('filterFns.betweenInclusive.autoRemove', () => {
-      const autoRemove = filterFns.betweenInclusive.autoRemove!
+      const autoRemove = filterFns.betweenInclusive.autoRemove
 
       it('should auto-remove when both endpoints are undefined', () => {
         expect(autoRemove([undefined, undefined])).toBe(true)
@@ -727,7 +728,7 @@ describe('Filter Functions', () => {
     })
 
     describe('filterFns.arrHas.autoRemove', () => {
-      const autoRemove = filterFns.arrHas.autoRemove!
+      const autoRemove = filterFns.arrHas.autoRemove
 
       it('should auto-remove when the filter value is undefined', () => {
         expect(autoRemove(undefined)).toBe(true)
@@ -747,3 +748,50 @@ describe('Filter Functions', () => {
     })
   })
 })
+
+describe('Number Range Filters', () => {
+  describe('filterFn_inNumberRange', () => {
+    it('should match values inclusively within the range', () => {
+      const row = mockRows[0]! // age 30
+
+      expect(filterFn_inNumberRange(row, 'age', [29, 31])).toBe(true)
+      expect(filterFn_inNumberRange(row, 'age', [30, 30])).toBe(true)
+      expect(filterFn_inNumberRange(row, 'age', [31, 40])).toBe(false)
+      expect(filterFn_inNumberRange(row, 'age', [10, 29])).toBe(false)
+    })
+
+    it('should coerce string endpoints in resolveFilterValue', () => {
+      expect(filterFn_inNumberRange.resolveFilterValue(['29', '31'])).toEqual([
+        29, 31,
+      ])
+    })
+
+    it('should treat null and non-numeric endpoints as open-ended', () => {
+      expect(filterFn_inNumberRange.resolveFilterValue([null, 31])).toEqual([
+        -Infinity,
+        31,
+      ])
+      expect(filterFn_inNumberRange.resolveFilterValue([29, 'abc'])).toEqual([
+        29,
+        Infinity,
+      ])
+    })
+
+    it('should swap reversed ranges', () => {
+      expect(filterFn_inNumberRange.resolveFilterValue([31, 29])).toEqual([
+        29, 31,
+      ])
+    })
+
+    it('should auto-remove only fully empty ranges', () => {
+      const autoRemove = filterFn_inNumberRange.autoRemove
+
+      expect(autoRemove(undefined)).toBe(true)
+      expect(autoRemove([null, null])).toBe(true)
+      expect(autoRemove(['', ''])).toBe(true)
+      expect(autoRemove([5, undefined])).toBe(false)
+      expect(autoRemove([undefined, 10])).toBe(false)
+      expect(autoRemove([0, 10])).toBe(false)
+    })
+  })
+})

packages/table-core/tests/unit/fns/sortFns.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from 'vitest'
 import {
+  reSplitAlphaNumeric,
   sortFn_alphanumeric,
   sortFn_alphanumericCaseSensitive,
   sortFn_basic,
@@ -276,3 +277,25 @@ describe('sortFn_datetime', () => {
     expect(cmp(sortFn_datetime, new Date(Number.NaN), 1000)).toBe(0)
   })
 })
+
+describe('reSplitAlphaNumeric', () => {
+  it('should keep plain text as a single segment', () => {
+    expect('apple'.split(reSplitAlphaNumeric)).toEqual(['apple'])
+  })
+
+  it('should capture numeric runs as their own segments', () => {
+    expect('item10'.split(reSplitAlphaNumeric)).toEqual(['item', '10', ''])
+    expect('a1b22c'.split(reSplitAlphaNumeric)).toEqual([
+      'a',
+      '1',
+      'b',
+      '22',
+      'c',
+    ])
+  })
+
+  it('should handle leading digits and empty strings', () => {
+    expect('10abc'.split(reSplitAlphaNumeric)).toEqual(['', '10', 'abc'])
+    expect(''.split(reSplitAlphaNumeric)).toEqual([''])
+  })
+})

packages/table-core/tests/unit/helpers/columnHelper.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, it } from 'vitest'
+import { constructTable, createColumnHelper } from '../../../src'
+import { testFeatures } from '../../fixtures/features'
+
+type Person = {
+  firstName: string
+  lastName: string
+}
+
+const features = testFeatures({})
+
+const helper = createColumnHelper<typeof features, Person>()
+
+describe('createColumnHelper', () => {
+  it('accessor should create an accessorKey column def from a key', () => {
+    const columnDef = helper.accessor('firstName', { header: 'First Name' })
+
+    expect(columnDef).toEqual({
+      accessorKey: 'firstName',
+      header: 'First Name',
+    })
+  })
+
+  it('accessor should create an accessorFn column def from a function', () => {
+    const accessorFn = (row: Person) => row.lastName.toUpperCase()
+    const columnDef = helper.accessor(accessorFn, { id: 'lastName' })
+
+    expect(columnDef).toEqual({
+      accessorFn,
+      id: 'lastName',
+    })
+  })
+
+  it('display and group should return the column def unchanged', () => {
+    const displayDef = { id: 'actions', header: 'Actions' }
+    const groupDef = {
+      id: 'name',
+      header: 'Name',
+      columns: helper.columns([helper.accessor('firstName', {})]),
+    }
+
+    expect(helper.display(displayDef)).toBe(displayDef)
+    expect(helper.group(groupDef)).toBe(groupDef)
+  })
+
+  it('columns should return the array unchanged', () => {
+    const columns = [
+      helper.accessor('firstName', {}),
+      helper.accessor('lastName', { id: 'lastName' }),
+    ]
+
+    expect(helper.columns(columns)).toBe(columns)
+  })
+
+  it('helper-built column defs should resolve values on a real table', () => {
+    const columns = helper.columns([
+      helper.accessor('firstName', {}),
+      helper.accessor((row) => row.lastName.toUpperCase(), { id: 'shouty' }),
+      helper.display({ id: 'actions', header: 'Actions' }),
+    ])
+    const table = constructTable<typeof features, Person>({
+      features,
+      columns,
+      data: [{ firstName: 'Tanner', lastName: 'Linsley' }],
+    })
+    const row = table.getRowModel().rows[0]!
+
+    expect(table.getAllLeafColumns().map((column) => column.id)).toEqual([
+      'firstName',
+      'shouty',
+      'actions',
+    ])
+    expect(row.getValue('firstName')).toBe('Tanner')
+    expect(row.getValue('shouty')).toBe('LINSLEY')
+    expect(row.getValue('actions')).toBeUndefined()
+  })
+})