@svgrid/grid 1.0.0

package/src/filtering/excel-filters.test.ts

@@ -0,0 +1,131 @@
+/**
+ * Unit tests for applyExcelFilter. Every operator + edge case.
+ */
+import { describe, expect, it } from 'vitest'
+import { applyExcelFilter, type ExcelFilter } from './excel-filters'
+
+const make = (
+  operator: ExcelFilter['operator'],
+  value?: unknown,
+  valueTo?: unknown,
+): ExcelFilter => ({
+  id: 'col',
+  operator,
+  value,
+  valueTo,
+})
+
+describe('applyExcelFilter - basic operators (smoke regression)', () => {
+  it('supports text operators (contains, startsWith, equals)', () => {
+    expect(applyExcelFilter('alphabet', make('contains', 'pha'))).toBe(true)
+    expect(applyExcelFilter('alphabet', make('startsWith', 'alp'))).toBe(true)
+    expect(applyExcelFilter('alphabet', make('equals', 'alphabet'))).toBe(true)
+  })
+
+  it('supports numeric operators (greaterThan, between)', () => {
+    expect(applyExcelFilter(15, make('greaterThan', 10))).toBe(true)
+    expect(applyExcelFilter(15, make('between', 10, 20))).toBe(true)
+  })
+
+  it('supports blank checks', () => {
+    expect(applyExcelFilter('', make('isBlank'))).toBe(true)
+    expect(applyExcelFilter('x', make('isBlank'))).toBe(false)
+  })
+})
+
+describe('applyExcelFilter - contains', () => {
+  it('matches case-insensitive substrings', () => {
+    expect(applyExcelFilter('Hello World', make('contains', 'world'))).toBe(true)
+    expect(applyExcelFilter('Hello World', make('contains', 'World'))).toBe(true)
+  })
+  it('returns false when substring absent', () => {
+    expect(applyExcelFilter('Hello', make('contains', 'xyz'))).toBe(false)
+  })
+  it('treats empty filter value as universal match', () => {
+    expect(applyExcelFilter('anything', make('contains', ''))).toBe(true)
+  })
+  it('coerces null cell to empty string', () => {
+    expect(applyExcelFilter(null, make('contains', 'x'))).toBe(false)
+    expect(applyExcelFilter(null, make('contains', ''))).toBe(true)
+  })
+})
+
+describe('applyExcelFilter - equals', () => {
+  it('matches case-insensitively', () => {
+    expect(applyExcelFilter('Boston', make('equals', 'boston'))).toBe(true)
+  })
+  it('rejects partial matches', () => {
+    expect(applyExcelFilter('Boston', make('equals', 'bost'))).toBe(false)
+  })
+  it('treats null as empty', () => {
+    expect(applyExcelFilter(null, make('equals', ''))).toBe(true)
+  })
+})
+
+describe('applyExcelFilter - startsWith', () => {
+  it('matches a prefix case-insensitively', () => {
+    expect(applyExcelFilter('Brooklyn', make('startsWith', 'brook'))).toBe(true)
+    expect(applyExcelFilter('Brooklyn', make('startsWith', 'lyn'))).toBe(false)
+  })
+})
+
+describe('applyExcelFilter - greaterThan', () => {
+  it('compares numerically when both sides parse as numbers', () => {
+    expect(applyExcelFilter(100, make('greaterThan', 99))).toBe(true)
+    expect(applyExcelFilter('100', make('greaterThan', 50))).toBe(true)
+    expect(applyExcelFilter(50, make('greaterThan', 50))).toBe(false)
+  })
+  it('falls back to string comparison when either side is non-numeric', () => {
+    expect(applyExcelFilter('banana', make('greaterThan', 'apple'))).toBe(true)
+    expect(applyExcelFilter('apple', make('greaterThan', 'banana'))).toBe(false)
+  })
+  it('treats null on either side as empty string in the fallback', () => {
+    expect(applyExcelFilter(null, make('greaterThan', 'a'))).toBe(false)
+    expect(applyExcelFilter('a', make('greaterThan', null))).toBe(true)
+  })
+})
+
+describe('applyExcelFilter - lessThan', () => {
+  it('compares numerically when both sides parse', () => {
+    expect(applyExcelFilter(10, make('lessThan', 20))).toBe(true)
+    expect(applyExcelFilter(20, make('lessThan', 10))).toBe(false)
+  })
+  it('falls back to string comparison', () => {
+    expect(applyExcelFilter('apple', make('lessThan', 'banana'))).toBe(true)
+  })
+  it('treats nulls as empty strings in fallback', () => {
+    expect(applyExcelFilter(null, make('lessThan', 'a'))).toBe(true)
+  })
+})
+
+describe('applyExcelFilter - between', () => {
+  it('includes both endpoints', () => {
+    expect(applyExcelFilter(5, make('between', 1, 10))).toBe(true)
+    expect(applyExcelFilter(1, make('between', 1, 10))).toBe(true)
+    expect(applyExcelFilter(10, make('between', 1, 10))).toBe(true)
+  })
+  it('excludes values outside the range', () => {
+    expect(applyExcelFilter(0, make('between', 1, 10))).toBe(false)
+    expect(applyExcelFilter(11, make('between', 1, 10))).toBe(false)
+  })
+  it('treats undefined endpoints as 0', () => {
+    expect(applyExcelFilter(0, make('between'))).toBe(true)
+    expect(applyExcelFilter(1, make('between'))).toBe(false)
+  })
+  it('treats null cell as 0', () => {
+    expect(applyExcelFilter(null, make('between', -1, 1))).toBe(true)
+  })
+})
+
+describe('applyExcelFilter - isBlank', () => {
+  it('matches null, undefined, and whitespace-only strings', () => {
+    expect(applyExcelFilter(null, make('isBlank'))).toBe(true)
+    expect(applyExcelFilter(undefined, make('isBlank'))).toBe(true)
+    expect(applyExcelFilter('', make('isBlank'))).toBe(true)
+    expect(applyExcelFilter('   ', make('isBlank'))).toBe(true)
+  })
+  it('rejects non-blank content', () => {
+    expect(applyExcelFilter('x', make('isBlank'))).toBe(false)
+    expect(applyExcelFilter(0, make('isBlank'))).toBe(false)
+  })
+})

package/src/filtering/excel-filters.ts

@@ -0,0 +1,101 @@
+export type ExcelFilterOperator =
+  | 'contains'
+  | 'equals'
+  | 'startsWith'
+  | 'greaterThan'
+  | 'lessThan'
+  | 'between'
+  | 'isBlank'
+
+export type ExcelFilter = {
+  id: string
+  operator: ExcelFilterOperator
+  value?: unknown
+  valueTo?: unknown
+}
+
+export type ExcelFilterOptions = {
+  /**
+   * BCP-47 locale tag (or fallback list) for accent- and case-
+   * insensitive text comparison. When set, "café", "Café" and "CAFÉ"
+   * all match "cafe" without strain.
+   *
+   * Implementation: NFD-decompose both sides, strip combining marks
+   * (diacritics), then locale-aware lowercase. This is the standard
+   * "lowercase + asciifolding" pipeline used by Elasticsearch, Postgres
+   * (with `unaccent`), and Lucene. Cheap, deterministic, no Collator
+   * round-trip.
+   */
+  locale?: string | ReadonlyArray<string>
+}
+
+// U+0300..U+036F is the Combining Diacritical Marks block. After NFD
+// decomposition accented characters become "base char + combining mark";
+// stripping the marks leaves the bare ASCII base.
+const DIACRITIC_RE = /[̀-ͯ]/g
+
+/** NFD-decompose, strip combining marks (diacritics), then locale-aware
+ *  lowercase. The locale-aware lowercasing handles Turkish dotted-I /
+ *  dotless-i correctly when the consumer threads `"tr"` through. */
+export function normalizeForFilter(
+  s: string,
+  locale?: string | ReadonlyArray<string>,
+): string {
+  if (!s) return ''
+  const stripped = s.normalize('NFD').replace(DIACRITIC_RE, '')
+  return locale
+    ? stripped.toLocaleLowerCase(locale as string | string[])
+    : stripped.toLowerCase()
+}
+
+export function applyExcelFilter(
+  cellValue: unknown,
+  filter: ExcelFilter,
+  options?: ExcelFilterOptions,
+) {
+  const text = String(cellValue ?? '')
+  const normalizedText = normalizeForFilter(text, options?.locale)
+  const normalizedValue = normalizeForFilter(String(filter.value ?? ''), options?.locale)
+  switch (filter.operator) {
+    case 'contains':
+      return normalizedText.includes(normalizedValue)
+    case 'equals':
+      return normalizedText === normalizedValue
+    case 'startsWith':
+      return normalizedText.startsWith(normalizedValue)
+    case 'greaterThan': {
+      const a = Number(cellValue)
+      const b = Number(filter.value)
+      if (Number.isFinite(a) && Number.isFinite(b)) return a > b
+      return String(cellValue ?? '') > String(filter.value ?? '')
+    }
+    case 'lessThan': {
+      const a = Number(cellValue)
+      const b = Number(filter.value)
+      if (Number.isFinite(a) && Number.isFinite(b)) return a < b
+      return String(cellValue ?? '') < String(filter.value ?? '')
+    }
+    case 'between': {
+      // Two paths: numeric (coerce both endpoints with the historical
+      // `?? 0` fallback) and string (used when EITHER endpoint is a
+      // non-numeric string like an ISO date). Numeric wins when its
+      // operands are finite so callers passing numeric ages, prices, etc.
+      // see the historical inclusive-range behaviour.
+      const lo = filter.value   == null ? 0 : Number(filter.value)
+      const hi = filter.valueTo == null ? 0 : Number(filter.valueTo)
+      const a  = Number(cellValue ?? 0)
+      if (Number.isFinite(a) && Number.isFinite(lo) && Number.isFinite(hi)) {
+        return a >= lo && a <= hi
+      }
+      // Either endpoint is non-numeric (ISO date string, etc). Compare
+      // lexicographically - YYYY-MM-DD orders chronologically so the
+      // result matches user intent.
+      const s  = String(cellValue ?? '')
+      const sl = String(filter.value ?? '')
+      const sh = String(filter.valueTo ?? '')
+      return s >= sl && s <= sh
+    }
+    case 'isBlank':
+      return text.trim().length === 0
+  }
+}

package/src/filtering/locale-filter.test.ts

@@ -0,0 +1,220 @@
+/**
+ * Pure unit tests for the locale-aware text normalization + Excel
+ * filter pipeline. No DOM, no mounted grid - just the two exported
+ * helpers `normalizeForFilter` and `applyExcelFilter`.
+ *
+ * Covers:
+ *   - Diacritic stripping (Café → cafe)
+ *   - Composed / decomposed Unicode round-trip
+ *   - Locale-specific lowercasing (Turkish dotted-I)
+ *   - All Excel operators × locale option × accented inputs
+ *   - Edge cases: empty strings, null/undefined, numeric mixed with text
+ */
+
+import { describe, expect, it } from 'vitest'
+import {
+  applyExcelFilter,
+  normalizeForFilter,
+} from './excel-filters'
+
+describe('normalizeForFilter - diacritic stripping', () => {
+  it('strips Latin accents (NFD path)', () => {
+    expect(normalizeForFilter('Café')).toBe('cafe')
+    expect(normalizeForFilter('CAFÉ')).toBe('cafe')
+    expect(normalizeForFilter('München')).toBe('munchen')
+    expect(normalizeForFilter('São Paulo')).toBe('sao paulo')
+    expect(normalizeForFilter('Tōkyō')).toBe('tokyo')
+    expect(normalizeForFilter('Genève')).toBe('geneve')
+    expect(normalizeForFilter('Québec')).toBe('quebec')
+    expect(normalizeForFilter('Málaga')).toBe('malaga')
+    expect(normalizeForFilter('Brasília')).toBe('brasilia')
+  })
+
+  it('handles already-decomposed input (NFD-stable)', () => {
+    // "Café" composed (4 code points) vs decomposed (5 code points).
+    const composed = 'Café'.normalize('NFC')
+    const decomposed = 'Café'.normalize('NFD')
+    expect(normalizeForFilter(composed)).toBe('cafe')
+    expect(normalizeForFilter(decomposed)).toBe('cafe')
+  })
+
+  it('preserves base ASCII unchanged', () => {
+    expect(normalizeForFilter('Hello World')).toBe('hello world')
+    expect(normalizeForFilter('ABC-123')).toBe('abc-123')
+    expect(normalizeForFilter('email@example.com')).toBe('email@example.com')
+  })
+
+  it('returns empty string for empty / falsy input', () => {
+    expect(normalizeForFilter('')).toBe('')
+  })
+
+  it('keeps non-Latin alphabets intact', () => {
+    // The diacritic strip only touches the Combining Diacritical Marks
+    // block (U+0300..U+036F). CJK / Cyrillic / Arabic stay as-is.
+    expect(normalizeForFilter('東京')).toBe('東京')
+    expect(normalizeForFilter('Москва')).toBe('москва')
+    expect(normalizeForFilter('القاهرة')).toBe('القاهرة')
+  })
+})
+
+describe('normalizeForFilter - locale-aware lowercase', () => {
+  it('default (no locale) makes English "istanbul" match dotted Turkish "İstanbul"', () => {
+    // No locale: NFD decomposes İ → I + combining dot above; the dot is
+    // stripped; remaining 'I' becomes 'i' under default lowercase.
+    expect(normalizeForFilter('İstanbul')).toBe('istanbul')
+    expect(normalizeForFilter('istanbul')).toBe('istanbul')
+  })
+
+  it('Turkish locale honors dotted-I / dotless-i asymmetry', () => {
+    // With "tr-TR" the bare 'I' (post-dot-strip) lowercases to dotless
+    // 'ı'. This is intentional Turkish behavior and is why we expose a
+    // locale prop: consumers who explicitly want Turkish casing get it.
+    // English-typed "istanbul" then no longer matches Turkish "İstanbul"
+    // - locale-pickers should make that trade-off knowingly.
+    expect(normalizeForFilter('İSTANBUL', 'tr-TR')).toBe('ıstanbul')
+    expect(normalizeForFilter('I',        'tr-TR')).toBe('ı')
+  })
+
+  it('default (no locale) behaves like toLowerCase()', () => {
+    expect(normalizeForFilter('HELLO')).toBe('hello')
+    expect(normalizeForFilter('CafÉ')).toBe('cafe') // É
+  })
+
+  it('accepts an array of fallback locales', () => {
+    expect(normalizeForFilter('Café', ['fr-CA', 'en-US'])).toBe('cafe')
+  })
+
+  it('Greek / Cyrillic / German all fold cleanly', () => {
+    // Greek: stripped tones (oxia)
+    expect(normalizeForFilter('Αθήνα')).toBe('αθηνα')
+    // German: umlauts strip
+    expect(normalizeForFilter('Düsseldorf')).toBe('dusseldorf')
+    // Cyrillic: no diacritics, just locale-aware lowercase
+    expect(normalizeForFilter('Москва', 'ru-RU')).toBe('москва')
+  })
+})
+
+describe('applyExcelFilter - contains (locale-aware)', () => {
+  it('matches case + accent insensitively without a locale', () => {
+    const ok = applyExcelFilter('Café Genève', {
+      id: 'name', operator: 'contains', value: 'cafe geneve',
+    })
+    expect(ok).toBe(true)
+  })
+
+  it('matches with a German locale', () => {
+    const ok = applyExcelFilter('München', {
+      id: 'city', operator: 'contains', value: 'munch',
+    }, { locale: 'de-DE' })
+    expect(ok).toBe(true)
+  })
+
+  it('matches with a French locale', () => {
+    const ok = applyExcelFilter('Montréal', {
+      id: 'city', operator: 'contains', value: 'montreal',
+    }, { locale: 'fr-CA' })
+    expect(ok).toBe(true)
+  })
+
+  it('matches with a Portuguese locale', () => {
+    const ok = applyExcelFilter('São Paulo', {
+      id: 'city', operator: 'contains', value: 'sao paulo',
+    }, { locale: 'pt-BR' })
+    expect(ok).toBe(true)
+  })
+
+  it('rejects non-matching queries even with locale', () => {
+    const ok = applyExcelFilter('München', {
+      id: 'city', operator: 'contains', value: 'berlin',
+    }, { locale: 'de-DE' })
+    expect(ok).toBe(false)
+  })
+
+  it('empty needle matches every cell (includes "")', () => {
+    expect(applyExcelFilter('München', {
+      id: 'city', operator: 'contains', value: '',
+    })).toBe(true)
+  })
+})
+
+describe('applyExcelFilter - equals (locale-aware)', () => {
+  it('case + accent insensitive equals', () => {
+    expect(applyExcelFilter('Café', { id: 'x', operator: 'equals', value: 'CAFE' })).toBe(true)
+    expect(applyExcelFilter('Café', { id: 'x', operator: 'equals', value: 'cafe' })).toBe(true)
+    expect(applyExcelFilter('Café', { id: 'x', operator: 'equals', value: 'Café' })).toBe(true)
+  })
+
+  it('rejects when normalized strings differ', () => {
+    expect(applyExcelFilter('Café', { id: 'x', operator: 'equals', value: 'cafes' })).toBe(false)
+    expect(applyExcelFilter('Café', { id: 'x', operator: 'equals', value: 'café!' })).toBe(false)
+  })
+})
+
+describe('applyExcelFilter - startsWith (locale-aware)', () => {
+  it('matches stripped prefix', () => {
+    expect(applyExcelFilter('München-Schwabing', {
+      id: 'x', operator: 'startsWith', value: 'munchen',
+    })).toBe(true)
+  })
+
+  it('rejects mid-string match', () => {
+    expect(applyExcelFilter('Großmünchen', {
+      id: 'x', operator: 'startsWith', value: 'munchen',
+    })).toBe(false)
+  })
+})
+
+describe('applyExcelFilter - numeric operators (locale-independent)', () => {
+  it('greaterThan / lessThan / between still work', () => {
+    expect(applyExcelFilter(150, { id: 'price', operator: 'greaterThan', value: 100 })).toBe(true)
+    expect(applyExcelFilter(150, { id: 'price', operator: 'lessThan', value: 200 })).toBe(true)
+    expect(applyExcelFilter(150, {
+      id: 'price', operator: 'between', value: 100, valueTo: 200,
+    })).toBe(true)
+  })
+
+  it('between rejects out-of-range', () => {
+    expect(applyExcelFilter(50, {
+      id: 'price', operator: 'between', value: 100, valueTo: 200,
+    })).toBe(false)
+  })
+})
+
+describe('applyExcelFilter - isBlank', () => {
+  it('treats empty / whitespace-only as blank', () => {
+    expect(applyExcelFilter('',     { id: 'x', operator: 'isBlank' })).toBe(true)
+    expect(applyExcelFilter('   ',  { id: 'x', operator: 'isBlank' })).toBe(true)
+    expect(applyExcelFilter(null,   { id: 'x', operator: 'isBlank' })).toBe(true)
+    expect(applyExcelFilter(undefined, { id: 'x', operator: 'isBlank' })).toBe(true)
+  })
+
+  it('rejects non-blank cells', () => {
+    expect(applyExcelFilter('Café', { id: 'x', operator: 'isBlank' })).toBe(false)
+    expect(applyExcelFilter(' x ',  { id: 'x', operator: 'isBlank' })).toBe(false)
+  })
+})
+
+describe('applyExcelFilter - regression: pre-locale behavior preserved', () => {
+  // Before locale support, ASCII case-insensitive matching was the rule.
+  // Verify nothing regressed for the common path.
+  it('plain ASCII contains', () => {
+    expect(applyExcelFilter('Ada Lovelace', {
+      id: 'name', operator: 'contains', value: 'lovelace',
+    })).toBe(true)
+    expect(applyExcelFilter('Ada Lovelace', {
+      id: 'name', operator: 'contains', value: 'LOVELACE',
+    })).toBe(true)
+  })
+
+  it('plain ASCII equals', () => {
+    expect(applyExcelFilter('active', {
+      id: 'status', operator: 'equals', value: 'ACTIVE',
+    })).toBe(true)
+  })
+
+  it('plain ASCII startsWith', () => {
+    expect(applyExcelFilter('Linus Torvalds', {
+      id: 'name', operator: 'startsWith', value: 'linus',
+    })).toBe(true)
+  })
+})

package/src/flex-render.test.ts

@@ -0,0 +1,143 @@
+/**
+ * FlexRender tests. The component routes one of {content+context, cell,
+ * header, footer} into the right render path: string, RenderComponentConfig,
+ * RenderSnippetConfig, or raw value.
+ */
+import { describe, expect, it } from 'vitest'
+import { mount, unmount } from 'svelte'
+import FlexRender from './FlexRender.svelte'
+import { RenderComponentConfig, RenderSnippetConfig } from './render-component'
+
+function mountFlex(props: any) {
+  const target = document.createElement('div')
+  document.body.appendChild(target)
+  const app = mount(FlexRender, { target, props })
+  return {
+    target,
+    destroy: () => {
+      unmount(app)
+      target.remove()
+    },
+  }
+}
+
+describe('FlexRender', () => {
+  it('renders a plain string content directly', () => {
+    const { target, destroy } = mountFlex({
+      content: 'Hello header',
+      context: { column: {}, table: {} } as any,
+    })
+    try {
+      expect(target.textContent).toContain('Hello header')
+    } finally {
+      destroy()
+    }
+  })
+
+  it('calls a function content with the context and renders the result', () => {
+    const fn = (ctx: any) => `value=${ctx.value}`
+    const { target, destroy } = mountFlex({
+      content: fn,
+      context: { value: 42 } as any,
+    })
+    try {
+      expect(target.textContent).toContain('value=42')
+    } finally {
+      destroy()
+    }
+  })
+
+  it('renders nothing when content is undefined', () => {
+    const { target, destroy } = mountFlex({
+      content: undefined,
+      context: {} as any,
+    })
+    try {
+      expect(target.textContent?.trim()).toBe('')
+    } finally {
+      destroy()
+    }
+  })
+
+  it('pulls content + context from `cell` when provided', () => {
+    const cell = {
+      column: { columnDef: { cell: (ctx: any) => `row=${ctx.row.id}` } },
+      getContext: () => ({ row: { id: 7 } }),
+    }
+    const { target, destroy } = mountFlex({ cell } as any)
+    try {
+      expect(target.textContent).toContain('row=7')
+    } finally {
+      destroy()
+    }
+  })
+
+  it('pulls content + context from `header` when provided', () => {
+    const header = {
+      column: { columnDef: { header: 'Total' } },
+      getContext: () => ({}),
+    }
+    const { target, destroy } = mountFlex({ header } as any)
+    try {
+      expect(target.textContent).toContain('Total')
+    } finally {
+      destroy()
+    }
+  })
+
+  it('pulls content + context from `footer` when provided', () => {
+    const footer = {
+      column: { columnDef: { footer: 'Sum' } },
+      getContext: () => ({}),
+    }
+    const { target, destroy } = mountFlex({ footer } as any)
+    try {
+      expect(target.textContent).toContain('Sum')
+    } finally {
+      destroy()
+    }
+  })
+
+  it('renders a RenderComponentConfig result (smoke)', () => {
+    // Anonymous Svelte-like component would require compilation; we just
+    // exercise the constructor path so the discriminator branch executes.
+    const fn = () => new RenderComponentConfig(null as any, {} as any)
+    const { destroy } = mountFlex({
+      content: fn,
+      context: {} as any,
+    })
+    try {
+      // No throw means the discriminator was hit.
+      expect(true).toBe(true)
+    } finally {
+      destroy()
+    }
+  })
+
+  it('renders a RenderSnippetConfig result (smoke)', () => {
+    const fakeSnippet = (() => null) as any
+    const fn = () => new RenderSnippetConfig(fakeSnippet, undefined as any)
+    const { destroy } = mountFlex({
+      content: fn,
+      context: {} as any,
+    })
+    try {
+      expect(true).toBe(true)
+    } finally {
+      destroy()
+    }
+  })
+
+  it('renders a raw scalar value when the function returns one', () => {
+    const fn = () => 99
+    const { target, destroy } = mountFlex({
+      content: fn,
+      context: {} as any,
+    })
+    try {
+      expect(target.textContent).toContain('99')
+    } finally {
+      destroy()
+    }
+  })
+})

package/src/flex-render.ts

@@ -0,0 +1,3 @@
+/// <reference types="svelte" />
+
+export { default as FlexRender } from './FlexRender.svelte'

package/src/group-aggregate.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, it } from 'vitest'
+import { applyGroupAggregate } from './core'
+import type { Row } from './core'
+
+type R = { v: number; cat: string }
+
+// Minimal Row stubs - applyGroupAggregate only touches getCellValueByColumnId
+// and original.
+function rows(values: number[]): Row<R>[] {
+  return values.map(
+    (v) =>
+      ({
+        original: { v, cat: 'x' } as R,
+        getCellValueByColumnId: (id: string) => (id === 'v' ? v : 'x'),
+      }) as unknown as Row<R>,
+  )
+}
+
+describe('applyGroupAggregate', () => {
+  const r = rows([10, 20, 30])
+
+  it('sum / avg / min / max', () => {
+    expect(applyGroupAggregate('sum', 'v', r)).toBe(60)
+    expect(applyGroupAggregate('avg', 'v', r)).toBe(20)
+    expect(applyGroupAggregate('min', 'v', r)).toBe(10)
+    expect(applyGroupAggregate('max', 'v', r)).toBe(30)
+  })
+
+  it('count / countDistinct / first / extent', () => {
+    expect(applyGroupAggregate('count', 'v', r)).toBe(3)
+    expect(applyGroupAggregate('countDistinct', 'cat', r)).toBe(1)
+    expect(applyGroupAggregate('first', 'v', r)).toBe(10)
+    expect(applyGroupAggregate('extent', 'v', r)).toBe('10 – 30')
+  })
+
+  it('custom function receives numeric values + rows', () => {
+    const median = applyGroupAggregate(
+      (vals) => vals.sort((a, b) => a - b)[Math.floor(vals.length / 2)],
+      'v',
+      r,
+    )
+    expect(median).toBe(20)
+  })
+
+  it('numeric reducers ignore non-numeric and empty groups', () => {
+    expect(applyGroupAggregate('sum', 'v', rows([]))).toBeUndefined()
+  })
+})