@svgrid/grid 2.6.20 → 2.6.22

package/src/columns.test.ts

@@ -424,109 +424,6 @@ describe('getColumnWidth', () => {
   })
 })
 
-describe('column resize lifecycle', () => {
-  let rafCb: FrameRequestCallback | null
-  beforeEach(() => {
-    rafCb = null
-    vi.stubGlobal('requestAnimationFrame', (cb: FrameRequestCallback) => {
-      rafCb = cb
-      return 1
-    })
-    vi.stubGlobal('cancelAnimationFrame', vi.fn())
-  })
-
-  it('startColumnResize seeds the resize state and registers listeners', () => {
-    const ctx = makeCtx({ columnWidths: { a: 150 } })
-    const h = createColumns(ctx)
-    const addSpy = vi.spyOn(document, 'addEventListener')
-    const e: any = {
-      stopPropagation: vi.fn(),
-      preventDefault: vi.fn(),
-      clientX: 500,
-    }
-    h.startColumnResize(e, 'a')
-    expect(ctx.resizingColumnId).toBe('a')
-    expect(ctx.resizeStartX).toBe(500)
-    expect(ctx.resizeStartWidth).toBe(150)
-    expect(addSpy).toHaveBeenCalledWith('pointermove', expect.any(Function))
-    addSpy.mockRestore()
-  })
-
-  it('onColumnResizeMove bails when no column is resizing', () => {
-    const ctx = makeCtx({ resizingColumnId: null })
-    const h = createColumns(ctx)
-    h.onColumnResizeMove({ clientX: 100 } as any)
-    expect(ctx.resizePendingWidth).toBe(0)
-  })
-
-  it('onColumnResizeMove clamps to MIN_COLUMN_WIDTH and commits on the frame', () => {
-    const ctx = makeCtx({
-      resizingColumnId: 'a',
-      resizeStartX: 100,
-      resizeStartWidth: 120,
-    })
-    const h = createColumns(ctx)
-    // moving far left should clamp at MIN_COLUMN_WIDTH (40)
-    h.onColumnResizeMove({ clientX: -1000 } as any)
-    expect(ctx.resizePendingWidth).toBe(40)
-    expect(rafCb).not.toBeNull()
-    rafCb!(0)
-    expect(ctx.columnWidths.a).toBe(40)
-  })
-
-  it('onColumnResizeMove grows the column and coalesces multiple moves into one frame', () => {
-    const ctx = makeCtx({
-      resizingColumnId: 'a',
-      resizeStartX: 100,
-      resizeStartWidth: 120,
-    })
-    const h = createColumns(ctx)
-    h.onColumnResizeMove({ clientX: 150 } as any) // +50 -> 170, schedules raf
-    const firstCb = rafCb
-    h.onColumnResizeMove({ clientX: 200 } as any) // +100 -> 220, raf already pending
-    expect(ctx.resizePendingWidth).toBe(220)
-    expect(rafCb).toBe(firstCb) // not rescheduled
-    rafCb!(0)
-    expect(ctx.columnWidths.a).toBe(220)
-  })
-
-  it('onColumnResizeMove skips the commit if the column stopped resizing mid-frame', () => {
-    const ctx = makeCtx({
-      resizingColumnId: 'a',
-      resizeStartX: 100,
-      resizeStartWidth: 120,
-    })
-    const h = createColumns(ctx)
-    h.onColumnResizeMove({ clientX: 150 } as any)
-    ctx.resizingColumnId = null // resize ended before the frame ran
-    rafCb!(0)
-    expect(ctx.columnWidths.a).toBeUndefined()
-  })
-
-  it('endColumnResize commits the final pending width and tears down listeners', () => {
-    const ctx = makeCtx({
-      resizingColumnId: 'a',
-      resizePendingWidth: 222,
-      resizeRaf: 9,
-    })
-    const h = createColumns(ctx)
-    const removeSpy = vi.spyOn(document, 'removeEventListener')
-    h.endColumnResize()
-    expect(ctx.columnWidths.a).toBe(222)
-    expect(ctx.resizingColumnId).toBeNull()
-    expect(ctx.resizeRaf).toBeNull()
-    expect(removeSpy).toHaveBeenCalledWith('pointermove', expect.any(Function))
-    removeSpy.mockRestore()
-  })
-
-  it('endColumnResize is safe when nothing was resizing', () => {
-    const ctx = makeCtx()
-    const h = createColumns(ctx)
-    expect(() => h.endColumnResize()).not.toThrow()
-    expect(ctx.columnWidths).toEqual({})
-  })
-})
-
 describe('measureText', () => {
   it('returns 0 for empty text', () => {
     const h = createColumns(makeCtx())

package/src/columns.ts

@@ -167,61 +167,6 @@ export function createColumns<
     return getColumnBaseWidth(columnId);
   }
 
-  function startColumnResize(event: PointerEvent, columnId: string) {
-    event.stopPropagation();
-    event.preventDefault();
-    ctx.resizingColumnId = columnId;
-    ctx.resizeStartX = event.clientX;
-    ctx.resizeStartWidth = getColumnWidth(columnId);
-    // Capture the pointer so the drag keeps tracking when it leaves the 4px
-    // handle - without this, touch (and fast mouse) drags drop mid-resize (#59).
-    try {
-      (event.currentTarget as HTMLElement | null)?.setPointerCapture?.(event.pointerId);
-    } catch { /* capture is best-effort */ }
-    document.addEventListener("pointermove", onColumnResizeMove);
-    document.addEventListener("pointerup", endColumnResize);
-    document.addEventListener("pointercancel", endColumnResize);
-  }
-
-  function onColumnResizeMove(event: PointerEvent) {
-    if (!ctx.resizingColumnId) return;
-    // Coalesce updates onto the animation frame: pointermove can fire many
-    // times per frame, and each $state mutation triggers a full reactive
-    // recompute of the column-layout pipeline. Without rAF coalescing the
-    // grid stutters during the drag.
-    ctx.resizePendingWidth = Math.max(
-      ctx.MIN_COLUMN_WIDTH,
-      ctx.resizeStartWidth + (event.clientX - ctx.resizeStartX),
-    );
-    if (ctx.resizeRaf !== null) return;
-    ctx.resizeRaf = requestAnimationFrame(() => {
-      ctx.resizeRaf = null;
-      if (!ctx.resizingColumnId) return;
-      ctx.columnWidths = {
-        ...ctx.columnWidths,
-        [ctx.resizingColumnId]: ctx.resizePendingWidth,
-      };
-    });
-  }
-
-  function endColumnResize() {
-    if (ctx.resizeRaf !== null) {
-      cancelAnimationFrame(ctx.resizeRaf);
-      ctx.resizeRaf = null;
-    }
-    if (ctx.resizingColumnId && ctx.resizePendingWidth) {
-      // Make sure the final width is committed even if the last rAF was
-      // canceled mid-flight.
-      ctx.columnWidths = {
-        ...ctx.columnWidths,
-        [ctx.resizingColumnId]: ctx.resizePendingWidth,
-      };
-    }
-    ctx.resizingColumnId = null;
-    document.removeEventListener("pointermove", onColumnResizeMove);
-    document.removeEventListener("pointerup", endColumnResize);
-    document.removeEventListener("pointercancel", endColumnResize);
-  }
 
   function measureText(text: string, font: string): number {
     if (!text) return 0;
@@ -304,9 +249,6 @@ export function createColumns<
     toggleGroupInPanel,
     getColumnBaseWidth,
     getColumnWidth,
-    startColumnResize,
-    onColumnResizeMove,
-    endColumnResize,
     measureText,
     autosizeColumn,
     autosizeAllColumns,

package/src/core.aggregate.test.ts

@@ -0,0 +1,134 @@
+/**
+ * Equivalence tests for `applyGroupAggregate`.
+ *
+ * Grouping 100k rows by two columns with three aggregators took 213ms, of which
+ * ~132ms was this function: each aggregated column of each group allocated a
+ * `raw` array, then a mapped array, then a filtered one, and `min`/`max`/
+ * `extent` finished by spreading the whole group into `Math.min(...)`.
+ * Measured by varying the aggregator count - 9 aggregated columns cost 823ms
+ * against 81ms for none.
+ *
+ * The rewrite is a single pass with no intermediate arrays. `reference` below
+ * is the original, verbatim, and every case asserts the two agree - including
+ * the awkward ones: empty groups, all-non-numeric values, -0, and the
+ * float-addition ORDER, since `reduce` and a loop must accumulate identically
+ * for the sums to match bit for bit.
+ *
+ * The spread also had a latent failure mode this fixes: `Math.min(...nums)`
+ * throws RangeError once a group is large enough to exhaust the argument
+ * stack, so `min` on a big single-bucket group could crash the grid. The last
+ * test pins that.
+ */
+import { describe, expect, it } from 'vitest'
+import { applyGroupAggregate, type GroupAggregator, type Row } from './core'
+
+/** Minimal Row stand-in: the function only ever calls getCellValueByColumnId. */
+function rowsOf(values: unknown[]): Array<Row<Record<string, unknown>>> {
+  return values.map(
+    (v, i) =>
+      ({
+        id: String(i),
+        index: i,
+        original: { v },
+        depth: 0,
+        getCanExpand: () => false,
+        getIsExpanded: () => false,
+        toggleExpanded: () => {},
+        getIsSelected: () => false,
+        toggleSelected: () => {},
+        getAllCells: () => [],
+        getCellValueByColumnId: () => v,
+      }) as unknown as Row<Record<string, unknown>>,
+  )
+}
+
+/** The original implementation, verbatim, as the oracle. */
+function reference<TData extends Record<string, unknown>>(
+  agg: GroupAggregator<TData>,
+  columnId: string,
+  rows: ReadonlyArray<Row<TData>>,
+): unknown {
+  const raw = rows.map((r) => r.getCellValueByColumnId(columnId))
+  if (typeof agg === 'function') {
+    const nums = raw.map((v) => Number(v)).filter((n) => Number.isFinite(n))
+    return agg(nums, rows.map((r) => r.original))
+  }
+  if (agg === 'count') return rows.length
+  if (agg === 'countDistinct') return new Set(raw.map((v) => String(v ?? ''))).size
+  if (agg === 'first') return raw[0]
+  const nums = raw.map((v) => Number(v)).filter((n) => Number.isFinite(n))
+  if (!nums.length) return undefined
+  switch (agg) {
+    case 'sum':
+      return nums.reduce((a, b) => a + b, 0)
+    case 'avg':
+      return nums.reduce((a, b) => a + b, 0) / nums.length
+    case 'min':
+      return Math.min(...nums)
+    case 'max':
+      return Math.max(...nums)
+    case 'extent':
+      return `${Math.min(...nums)} – ${Math.max(...nums)}`
+    default:
+      return undefined
+  }
+}
+
+const AGGS: GroupAggregator[] = ['sum', 'avg', 'min', 'max', 'count', 'countDistinct', 'extent', 'first']
+
+const DATASETS: Array<[string, unknown[]]> = [
+  ['empty', []],
+  ['single value', [5]],
+  ['plain integers', [3, 1, 2, 10, -4]],
+  ['floats that expose accumulation order', [0.1, 0.2, 0.3, 0.7, 1e-16, 1e16]],
+  ['all non-numeric', ['a', 'b', {}, [], true]],
+  ['mixed numeric and not', [1, 'x', 2, null, 3, undefined, NaN, Infinity, -Infinity]],
+  ['nulls and undefined only', [null, undefined]],
+  ['numeric strings', ['1', '2', '10']],
+  ['duplicates for countDistinct', ['a', 'a', 'b', null, undefined, '']],
+  ['negative zero', [-0, 0, 1]],
+  ['very large and small', [Number.MAX_SAFE_INTEGER, Number.MIN_SAFE_INTEGER, 0]],
+  ['booleans', [true, false, true]],
+]
+
+describe('applyGroupAggregate - equivalence with the original', () => {
+  for (const [name, values] of DATASETS) {
+    for (const agg of AGGS) {
+      it(`${agg} over ${name}`, () => {
+        const rows = rowsOf(values)
+        const expected = reference(agg, 'v', rows)
+        const actual = applyGroupAggregate(agg, 'v', rows)
+        // Object.is so NaN matches NaN and -0 does not silently pass as 0.
+        expect(Object.is(actual, expected) || actual === expected).toBe(true)
+      })
+    }
+  }
+
+  it('passes finite numbers and originals to a custom aggregator, unchanged', () => {
+    const seen: Array<{ nums: number[]; count: number }> = []
+    const custom: GroupAggregator = (nums, originals) => {
+      seen.push({ nums: [...nums], count: originals.length })
+      return nums.length
+    }
+    const rows = rowsOf([1, 'x', 2, null, NaN, 3])
+    const expected = reference(custom, 'v', rows)
+    const actual = applyGroupAggregate(custom, 'v', rows)
+    expect(actual).toBe(expected)
+    // Both calls saw identical arguments.
+    expect(seen[0]).toEqual(seen[1])
+    // `null` is included: Number(null) is 0, which is finite. `'x'` and NaN are
+    // not. Worth pinning - it is the kind of coercion a rewrite silently drops.
+    expect(seen[0]!.nums).toEqual([1, 2, 0, 3])
+    expect(seen[0]!.count).toBe(6)
+  })
+
+  it('handles a group larger than the argument-spread limit', () => {
+    // The original did `Math.min(...nums)`, which throws RangeError once the
+    // group exceeds the engine's argument cap. A single bucket holding this
+    // many rows is ordinary on a large grid grouped by a low-cardinality field.
+    const rows = rowsOf(Array.from({ length: 200_000 }, (_, i) => i))
+    expect(applyGroupAggregate('min', 'v', rows)).toBe(0)
+    expect(applyGroupAggregate('max', 'v', rows)).toBe(199_999)
+    expect(applyGroupAggregate('extent', 'v', rows)).toBe('0 – 199999')
+  })
+})

package/src/core.filter.test.ts

@@ -0,0 +1,156 @@
+/**
+ * Equivalence + work-budget tests for `createFilteredRowModel`.
+ *
+ * The filter path used to read a cell with
+ * `row.getAllCells().find((c) => c.column.id === id)?.getValue()`. That builds
+ * and caches the row's ENTIRE `Cell[]` just to read one field, which defeats
+ * the lazy-cell design the row factory goes out of its way to provide - a
+ * one-operator filter over 100k rows materialised 100,000 cell arrays
+ * (measured; `pnpm bench --case=filter-1op`).
+ *
+ * `getCellValueByColumnId` reads the same `cachedValues` array those cells read
+ * from, so the swap is a pure win - but "same array" is a claim about today's
+ * implementation, so the equivalence half of this file pins the observable
+ * behaviour rather than trusting it.
+ */
+import { describe, expect, it } from 'vitest'
+import {
+  createCoreRowModel,
+  createFilteredRowModel,
+  createSvGridCore,
+  filterFns,
+  tableFeatures,
+  type ColumnDef,
+  type ColumnFiltersState,
+} from './core'
+
+type Row = Record<string, unknown>
+
+const COLUMNS = [
+  { field: 'text' },
+  { field: 'num' },
+  { field: 'flag' },
+  // A computed column: `fieldFn` rather than `field`, to prove the value path
+  // is the same one the cell objects use.
+  { field: 'derived', fieldFn: (r: Row) => `${String(r.text).toUpperCase()}!` },
+]
+
+/** The original implementation, verbatim, as the oracle. */
+function referenceFilter(rows: Row[], columns: typeof COLUMNS, filters: ColumnFiltersState): Row[] {
+  const value = (row: Row, id: string) => {
+    const col = columns.find((c) => c.field === id)
+    if (!col) return undefined
+    return col.fieldFn ? col.fieldFn(row) : row[col.field]
+  }
+  return rows.filter((row) =>
+    filters.every((filter) => {
+      const fn = filter.fn ? filterFns[filter.fn] : filterFns.includesString
+      return fn(value(row, filter.id), filter.value as never)
+    }),
+  )
+}
+
+function actualFilter(rows: Row[], filters: ColumnFiltersState): Row[] {
+  const grid = createSvGridCore({
+    _features: tableFeatures({}),
+    _rowModels: {
+      coreRowModel: createCoreRowModel(),
+      filteredRowModel: createFilteredRowModel(),
+    },
+    columns: COLUMNS as unknown as Array<ColumnDef<ReturnType<typeof tableFeatures>, Row>>,
+    data: rows,
+    state: { columnFilters: filters },
+  })
+  return grid.getRowModel().rows.map((r) => r.original as Row)
+}
+
+const ROWS: Row[] = [
+  { text: 'banana', num: 2, flag: true },
+  { text: 'Apple', num: 10, flag: false },
+  { text: 'apple', num: -3, flag: true },
+  { text: null, num: null, flag: null },
+  { text: undefined, num: undefined, flag: undefined },
+  { text: '', num: 0, flag: '' },
+  { text: 'APPLE pie', num: NaN, flag: 'yes' },
+]
+
+describe('createFilteredRowModel - equivalence with the original', () => {
+  const cases: Array<[string, ColumnFiltersState]> = [
+    ['no filters', []],
+    ['substring, case-insensitive', [{ id: 'text', value: 'app' }]],
+    ['substring matching nothing', [{ id: 'text', value: 'zzz' }]],
+    ['empty needle matches everything', [{ id: 'text', value: '' }]],
+    ['equals operator', [{ id: 'num', value: 10, fn: 'equals' }]],
+    ['equals against null', [{ id: 'num', value: null, fn: 'equals' }]],
+    ['two filters ANDed', [{ id: 'text', value: 'a' }, { id: 'flag', value: 'true' }]],
+    ['unknown column id', [{ id: 'nope', value: 'x' }]],
+    ['computed column via fieldFn', [{ id: 'derived', value: 'APPLE' }]],
+    ['filter on undefined values', [{ id: 'flag', value: 'undefined' }]],
+  ]
+
+  for (const [name, filters] of cases) {
+    it(`matches: ${name}`, () => {
+      const actual = actualFilter(ROWS, filters)
+      const expected = referenceFilter(ROWS, COLUMNS, filters)
+      expect(actual.length).toBe(expected.length)
+      // Identity, so row order and object identity are both checked.
+      for (let i = 0; i < actual.length; i++) expect(actual[i]).toBe(expected[i])
+    })
+  }
+})
+
+describe('createFilteredRowModel - work budget', () => {
+  /**
+   * Count how many rows materialise their full `Cell[]` during filtering.
+   *
+   * Wrapping each row in a proxy that tallies `getAllCells` is the same
+   * technique tools/bench uses, kept in-process here so the invariant is
+   * enforced by the unit suite rather than only by the bench.
+   */
+  function countCellMaterialisations(rowCount: number, filters: ColumnFiltersState): number {
+    const rows: Row[] = Array.from({ length: rowCount }, (_, i) => ({
+      text: `row-${i % 7}`,
+      num: i,
+      flag: i % 2 === 0,
+    }))
+    let calls = 0
+    const grid = createSvGridCore({
+      _features: tableFeatures({}),
+      _rowModels: {
+        coreRowModel: createCoreRowModel(),
+        filteredRowModel: (args) =>
+          createFilteredRowModel<Row>()({
+            ...args,
+            rows: args.rows.map(
+              (row) =>
+                new Proxy(row, {
+                  get(obj, prop, recv) {
+                    if (prop === 'getAllCells') calls++
+                    return Reflect.get(obj, prop, recv)
+                  },
+                }) as typeof row,
+            ),
+          }),
+      },
+      columns: COLUMNS as unknown as Array<ColumnDef<ReturnType<typeof tableFeatures>, Row>>,
+      data: rows,
+      state: { columnFilters: filters },
+    })
+    grid.getRowModel()
+    return calls
+  }
+
+  it('never materialises a row\'s cell array to read one field', () => {
+    expect(countCellMaterialisations(2_000, [{ id: 'text', value: 'row-1' }])).toBe(0)
+  })
+
+  it('stays at zero with several filters', () => {
+    expect(
+      countCellMaterialisations(2_000, [
+        { id: 'text', value: 'row' },
+        { id: 'num', value: '1' },
+        { id: 'flag', value: 'true' },
+      ]),
+    ).toBe(0)
+  })
+})

package/src/core.grouping.test.ts

@@ -0,0 +1,146 @@
+/**
+ * Grouping: the ancestor short-circuit in `resolveColumnValue`.
+ *
+ * A group row shows, for each non-aggregated column, the value its children
+ * agree on - or `undefined` when they disagree. That used to be found by
+ * scanning every child, even for a column an ANCESTOR level had already grouped
+ * by, where the answer is fixed by construction. On a 100k x 9 two-level group
+ * that was ~100,000 reads for a value already in hand.
+ *
+ * The shortcut has one genuinely sharp edge, which is what most of this file is
+ * about: buckets are keyed by `String(value ?? '')`, so `null`, `undefined` and
+ * `''` all land in the SAME bucket. A scan of that bucket reports disagreement,
+ * so the shortcut has to report disagreement too rather than picking whichever
+ * raw value happened to arrive first.
+ */
+import { describe, expect, it } from 'vitest'
+import {
+  createCoreRowModel,
+  createGroupedRowModel,
+  createSvGridCore,
+  columnGroupingFeature,
+  tableFeatures,
+  type ColumnDef,
+  type Row,
+} from './core'
+
+type Data = Record<string, unknown>
+
+function grouped(data: Data[], fields: string[], grouping: string[]) {
+  const grid = createSvGridCore({
+    _features: tableFeatures({ columnGroupingFeature }),
+    _rowModels: { coreRowModel: createCoreRowModel(), groupedRowModel: createGroupedRowModel() },
+    columns: fields.map((f) => ({ field: f })) as unknown as Array<
+      ColumnDef<ReturnType<typeof tableFeatures>, Data>
+    >,
+    data,
+    state: { grouping },
+    onGroupingChange: () => {},
+  })
+  return grid.getRowModel().rows
+}
+
+/** Walk to the group rows at a given depth. */
+function atDepth(rows: Array<Row<Data>>, depth: number): Array<Row<Data>> {
+  const out: Array<Row<Data>> = []
+  const visit = (rs: Array<Row<Data>>) => {
+    for (const r of rs) {
+      if (r.depth === depth) out.push(r)
+      if (r.subRows?.length) visit(r.subRows as Array<Row<Data>>)
+    }
+  }
+  visit(rows)
+  return out
+}
+
+describe('createGroupedRowModel - ancestor value resolution', () => {
+  const FIELDS = ['region', 'status', 'owner', 'amount']
+
+  it('a second-level group still reports the first level value', () => {
+    const data: Data[] = [
+      { region: 'EMEA', status: 'open', owner: 'ada', amount: 1 },
+      { region: 'EMEA', status: 'open', owner: 'ada', amount: 2 },
+      { region: 'EMEA', status: 'shut', owner: 'bob', amount: 3 },
+      { region: 'APAC', status: 'open', owner: 'cy', amount: 4 },
+    ]
+    const inner = atDepth(grouped(data, FIELDS, ['region', 'status']), 1)
+    expect(inner.length).toBe(3)
+    for (const g of inner) {
+      // `region` is fixed by the ancestor bucket, so every inner group must
+      // report it rather than undefined.
+      expect(['EMEA', 'APAC']).toContain(g.getCellValueByColumnId('region'))
+    }
+    // And the columns that genuinely vary still resolve the old way.
+    const emeaOpen = inner.find((g) => g.getCellValueByColumnId('status') === 'open')!
+    expect(emeaOpen.getCellValueByColumnId('owner')).toBe('ada')
+  })
+
+  it('reports disagreement when a bucket mixed null, undefined and empty string', () => {
+    // All three key to '' and share one bucket. A scan would find they disagree,
+    // so the shortcut must not report whichever arrived first.
+    const data: Data[] = [
+      { region: null, status: 'x', owner: 'a', amount: 1 },
+      { region: undefined, status: 'y', owner: 'b', amount: 2 },
+      { region: '', status: 'z', owner: 'c', amount: 3 },
+    ]
+    const inner = atDepth(grouped(data, FIELDS, ['region', 'status']), 1)
+    expect(inner.length).toBe(3)
+    for (const g of inner) {
+      // Each inner bucket holds exactly one row, so `region` is whatever that
+      // row had - not a value borrowed from a sibling.
+      const status = g.getCellValueByColumnId('status')
+      const expected = data.find((d) => d.status === status)!.region
+      expect(g.getCellValueByColumnId('region')).toBe(expected)
+    }
+  })
+
+  it('a mixed ancestor bucket resolves to undefined at the deeper level', () => {
+    // One inner bucket spanning rows whose raw region values differ but key the
+    // same. `status` is identical so they stay together at level two.
+    const data: Data[] = [
+      { region: null, status: 'same', owner: 'a', amount: 1 },
+      { region: '', status: 'same', owner: 'a', amount: 2 },
+    ]
+    const inner = atDepth(grouped(data, FIELDS, ['region', 'status']), 1)
+    expect(inner.length).toBe(1)
+    // A scan of [null, ''] disagrees, so this must be undefined.
+    expect(inner[0]!.getCellValueByColumnId('region')).toBeUndefined()
+  })
+
+  it('preserves the raw type of an ancestor value rather than its bucket key', () => {
+    // Buckets are keyed by String(value), so a numeric grouping column would
+    // report '2024' instead of 2024 if the shortcut returned the key.
+    const data: Data[] = [
+      { region: 2024, status: 'a', owner: 'x', amount: 1 },
+      { region: 2024, status: 'b', owner: 'y', amount: 2 },
+    ]
+    const inner = atDepth(grouped(data, FIELDS, ['region', 'status']), 1)
+    expect(inner.length).toBe(2)
+    for (const g of inner) {
+      expect(g.getCellValueByColumnId('region')).toBe(2024)
+    }
+  })
+
+  it('handles three levels', () => {
+    const data: Data[] = [
+      { region: 'EMEA', status: 'open', owner: 'ada', amount: 1 },
+      { region: 'EMEA', status: 'open', owner: 'ada', amount: 2 },
+      { region: 'EMEA', status: 'open', owner: 'bob', amount: 3 },
+    ]
+    const deepest = atDepth(grouped(data, FIELDS, ['region', 'status', 'owner']), 2)
+    expect(deepest.length).toBe(2)
+    for (const g of deepest) {
+      expect(g.getCellValueByColumnId('region')).toBe('EMEA')
+      expect(g.getCellValueByColumnId('status')).toBe('open')
+    }
+  })
+
+  it('still returns undefined for a non-grouping column whose children disagree', () => {
+    const data: Data[] = [
+      { region: 'EMEA', status: 'open', owner: 'ada', amount: 1 },
+      { region: 'EMEA', status: 'open', owner: 'bob', amount: 2 },
+    ]
+    const inner = atDepth(grouped(data, FIELDS, ['region', 'status']), 1)
+    expect(inner[0]!.getCellValueByColumnId('owner')).toBeUndefined()
+  })
+})