@svgrid/grid 2.2.31 → 2.2.32

package/src/group-display.ts

@@ -70,6 +70,89 @@ export function insertGroupFooters<R>(rows: ReadonlyArray<R>, opts: GroupFooterO
   return out
 }
 
+export type GroupPaginationOptions<R> = {
+  /** Depth of a row (group rows and their descendants). */
+  getDepth: (row: R) => number
+  /** True when a row is a group (banner) row. */
+  isGroup: (row: R) => boolean
+  /**
+   * True when a group row is expanded. Defaults to treating every group as
+   * expanded. This matters: an EXPANDED group is a header, reprinted above its
+   * children and costing no page budget, while a COLLAPSED group is the visible
+   * unit itself and must consume a slot - otherwise a fully collapsed grid has
+   * no budget-consuming rows at all and every page comes back empty.
+   */
+  isExpanded?: (row: R) => boolean
+  pageIndex: number
+  pageSize: number
+}
+
+export type GroupPaginationResult<R> = {
+  /** The rows to render for this page: the page's budget-consuming rows, each
+   *  preceded by whichever ancestor banners have not been printed yet. */
+  rows: R[]
+  /** Budget-consuming rows across every page - what the pager divides by.
+   *  Data rows plus collapsed group rows; expanded banners do not count. */
+  dataRowCount: number
+}
+
+/**
+ * Paginate a grouped row list by DATA rows, repeating each page's ancestor
+ * group headers.
+ *
+ * Slicing the flat grouped list directly counts group banners against
+ * `pageSize`, so `pageSize: 10` over ten groups of two shows almost no data
+ * (#73). Here only non-group rows consume the page budget, and a page reprints
+ * the group chain its first rows sit under - the same thing a spreadsheet does
+ * when a grouped table breaks across pages.
+ *
+ * Ancestors are tracked with a depth stack rather than parent pointers, so this
+ * works on the already-flattened expanded model and needs nothing from the row
+ * objects but depth and group-ness.
+ */
+export function paginateGroupedRows<R>(
+  rows: ReadonlyArray<R>,
+  opts: GroupPaginationOptions<R>,
+): GroupPaginationResult<R> {
+  const { getDepth, isGroup, isExpanded, pageIndex, pageSize } = opts
+  const expanded = isExpanded ?? (() => true)
+  const start = pageIndex * pageSize
+  const end = start + pageSize
+
+  const out: R[] = []
+  // Expanded banners currently open, outermost first. `printed` marks the ones
+  // this page has already emitted, so a group spanning rows 3-8 prints its
+  // banner once, not once per row.
+  const openGroups: Array<{ row: R; printed: boolean }> = []
+  let unitsSeen = 0
+
+  for (const row of rows) {
+    const depth = getDepth(row)
+    // A row at depth <= an open banner's depth closes it.
+    while (openGroups.length > 0 && getDepth(openGroups[openGroups.length - 1]!.row) >= depth) {
+      openGroups.pop()
+    }
+    if (isGroup(row) && expanded(row)) {
+      // A header for rows that follow: reprinted per page, costs no budget.
+      openGroups.push({ row, printed: false })
+      continue
+    }
+    // Everything else is a visible unit: a data row, or a collapsed group
+    // standing in for its whole subtree.
+    const index = unitsSeen
+    unitsSeen += 1
+    if (index < start || index >= end) continue
+    for (const g of openGroups) {
+      if (g.printed) continue
+      g.printed = true
+      out.push(g.row)
+    }
+    out.push(row)
+  }
+
+  return { rows: out, dataRowCount: unitsSeen }
+}
+
 export type AutoGroupColumnSpec = {
   /** Synthetic column id (e.g. `__autoGroup` or `__group_<field>`). */
   id: string

package/src/index.ts

@@ -32,6 +32,8 @@ export {
   createGroupedRowModel,
   createPaginatedRowModel,
   createSortedRowModel,
+  createTreeRowModel,
+  flattenTreeData,
   applyGroupAggregate,
   filterFns,
   rowExpandingFeature,
@@ -52,6 +54,8 @@ export {
   type Column,
   type ColumnDef,
   type ColumnDefTemplate,
+  type GridColumnDef,
+  type GridColumns,
   type GroupAggregator,
   type Header,
   type HeaderContext,
@@ -62,6 +66,8 @@ export {
   type SvGrid as SvGridInstance,
   type SvGridOptions,
   type TableFeatures,
+  type TreeRowModelOptions,
+  type FlattenTreeOptions,
   type Updater,
 } from './core'
 
@@ -671,10 +677,13 @@ export {
 export {
   insertGroupFooters,
   buildAutoGroupColumns,
+  paginateGroupedRows,
   type GroupDisplayType,
   type GroupFooterOptions,
   type AutoGroupColumnSpec,
   type AutoGroupResult,
+  type GroupPaginationOptions,
+  type GroupPaginationResult,
 } from './group-display'
 export { getKeyboardIntent, getNextActiveCell, type GridKeyboardIntent } from './keyboard'
 export { createVirtualizer } from './virtualization/virtualizer'

package/src/keyboard-handlers.ts

@@ -249,6 +249,23 @@ export function createKeyboard<
     // expands a collapsed group row, ArrowLeft collapses an expanded one,
     // instead of moving the active cell (treegrid-style). Leaves fall through
     // to normal navigation.
+    // Client tree data gets the same ArrowRight/ArrowLeft contract, driven off
+    // the row model rather than consumer callbacks.
+    if (ctx.props.treeData && (intent === "moveRight" || intent === "moveLeft")) {
+      const row = ctx.allRows[current.rowIndex];
+      if (row?.getCanExpand?.()) {
+        const expanded = row.getIsExpanded?.() ?? false;
+        if (intent === "moveRight" && !expanded) {
+          row.toggleExpanded?.();
+          return;
+        }
+        if (intent === "moveLeft" && expanded) {
+          row.toggleExpanded?.();
+          return;
+        }
+      }
+    }
+
     const serverGroup = ctx.props.serverGroup;
     if (serverGroup && (intent === "moveRight" || intent === "moveLeft")) {
       const data = ctx.allRows[current.rowIndex]?.original;

package/src/list-power.test.ts

@@ -19,8 +19,8 @@ describe('groupOptions', () => {
   it('buckets by group in first-seen order and preserves the flat index', () => {
     const groups = groupOptions(opts)
     expect(groups.map((g) => g.group)).toEqual(['Americas', 'Europe'])
-    expect(groups[0].options.map((o) => o.index)).toEqual([0, 1])
-    expect(groups[1].options.map((o) => o.index)).toEqual([2, 3])
+    expect(groups[0]!.options.map((o) => o.index)).toEqual([0, 1])
+    expect(groups[1]!.options.map((o) => o.index)).toEqual([2, 3])
     expect(hasGroups(opts)).toBe(true)
   })
   it('returns a single null group when nothing is grouped', () => {

package/src/menus.test.ts

@@ -557,8 +557,8 @@ describe('createMenus - contextMenuItems', () => {
     expect(labels).toContain('Remove row')
     expect(labels).toContain('Remove column')
     // no leading/trailing separator
-    expect(items[0].separator).toBeFalsy()
-    expect(items[items.length - 1].separator).toBeFalsy()
+    expect(items[0]!.separator).toBeFalsy()
+    expect(items[items.length - 1]!.separator).toBeFalsy()
   })
 
   it('built-in run wiring invokes clipboard helpers', () => {
@@ -627,8 +627,8 @@ describe('createMenus - contextMenuItems', () => {
     const m = createMenus(ctx)
     const items = m.contextMenuItems()
     expect(items.map((i) => i.key)).toEqual(['shown'])
-    expect(items[0].disabled).toBe(true)
-    items[0].run!()
+    expect(items[0]!.disabled).toBe(true)
+    items[0]!.run!()
     expect(action).toHaveBeenCalled()
   })
 

package/src/named-views.coverage.test.ts

@@ -144,7 +144,7 @@ describe('attachAutoSavedView', () => {
     const off = attachAutoSavedView(host, views, { intervalMs: 500 })
     expect(views.has('__autosave')).toBe(false)
     // mutate the host state, then let the poller tick
-    host.set({ sorting: [{ id: 'new', desc: false }], columnFilters: [] } as SvGridViewState)
+    host.set({ sorting: [{ id: 'new', desc: false }], columnFilters: [] } as unknown as SvGridViewState)
     vi.advanceTimersByTime(500)
     expect(views.has('__autosave')).toBe(true)
     off()
@@ -164,7 +164,7 @@ describe('attachAutoSavedView', () => {
     const host = fakeHost({ sorting: [] })
     const views = createNamedViews(host, { storage: memoryViews() })
     const off = attachAutoSavedView(host, views, { name: 'mySlot', intervalMs: 200 })
-    host.set({ sorting: [{ id: 'q', desc: true }], columnFilters: [] } as SvGridViewState)
+    host.set({ sorting: [{ id: 'q', desc: true }], columnFilters: [] } as unknown as SvGridViewState)
     vi.advanceTimersByTime(200)
     expect(views.has('mySlot')).toBe(true)
     off()
@@ -185,7 +185,7 @@ describe('attachAutoSavedView', () => {
     const host = {
       getState: () => {
         if (throwing) throw new Error('boom')
-        return { sorting: [], columnFilters: [] } as SvGridViewState
+        return { sorting: [], columnFilters: [] } as unknown as SvGridViewState
       },
       setState: vi.fn(),
     }

package/src/recurrence.ts

@@ -189,8 +189,9 @@ const ORD: Record<number, string> = { 1: 'first', 2: 'second', 3: 'third', 4: 'f
 
 // Where in the month a monthly / yearly rule lands, as a phrase.
 function whereInMonth(r: RecurrenceRule, wd: ReadonlyArray<string>, ord: Record<number, string>): string {
-  if (r.weekOfMonth != null && r.weekdays && r.weekdays.length) {
-    return `the ${ord[r.weekOfMonth] ?? r.weekOfMonth} ${wd[r.weekdays[0]]}`
+  const firstWeekday = r.weekdays?.[0]
+  if (r.weekOfMonth != null && firstWeekday != null) {
+    return `the ${ord[r.weekOfMonth] ?? r.weekOfMonth} ${wd[firstWeekday]}`
   }
   if (r.day === -1) return 'the last day'
   if (r.day != null && r.day < 0) return `the ${-r.day} day(s) from the end`

package/src/row-resize.test.ts

@@ -97,8 +97,8 @@ describe('rowResize - strip injection', () => {
       expect(strip!.style.cursor).toBe('row-resize')
     }
     // Gutter cells become a positioning context with visible overflow.
-    expect(gutterOf(rows[0]).style.position).toBe('relative')
-    expect(gutterOf(rows[0]).style.overflow).toBe('visible')
+    expect(gutterOf(rows[0]!).style.position).toBe('relative')
+    expect(gutterOf(rows[0]!).style.overflow).toBe('visible')
     action.destroy()
   })
 
@@ -106,12 +106,12 @@ describe('rowResize - strip injection', () => {
     const { host, rows } = buildGrid([{}])
     track(host)
     const action = rowResize(host, { onResize: vi.fn() })
-    expect(rows[0].querySelectorAll(`.${STRIP_CLASS}`).length).toBe(1)
+    expect(rows[0]!.querySelectorAll(`.${STRIP_CLASS}`).length).toBe(1)
     // Trigger the MutationObserver by appending an unrelated node.
-    gutterOf(rows[0]).appendChild(document.createElement('span'))
+    gutterOf(rows[0]!).appendChild(document.createElement('span'))
     await Promise.resolve()
     await new Promise((r) => setTimeout(r, 0))
-    expect(rows[0].querySelectorAll(`.${STRIP_CLASS}`).length).toBe(1)
+    expect(rows[0]!.querySelectorAll(`.${STRIP_CLASS}`).length).toBe(1)
     action.destroy()
   })
 
@@ -124,10 +124,10 @@ describe('rowResize - strip injection', () => {
     ])
     track(host)
     const action = rowResize(host, { onResize: vi.fn() })
-    expect(stripOf(rows[0])).toBeNull()
-    expect(stripOf(rows[1])).toBeNull()
-    expect(stripOf(rows[2])).toBeNull()
-    expect(stripOf(rows[3])).not.toBeNull()
+    expect(stripOf(rows[0]!)).toBeNull()
+    expect(stripOf(rows[1]!)).toBeNull()
+    expect(stripOf(rows[2]!)).toBeNull()
+    expect(stripOf(rows[3]!)).not.toBeNull()
     action.destroy()
   })
 
@@ -159,9 +159,9 @@ describe('rowResize - strip injection', () => {
   it('does not override an already-positioned gutter cell', () => {
     const { host, rows } = buildGrid([{}])
     track(host)
-    gutterOf(rows[0]).style.position = 'sticky'
+    gutterOf(rows[0]!).style.position = 'sticky'
     const action = rowResize(host, { onResize: vi.fn() })
-    expect(gutterOf(rows[0]).style.position).toBe('sticky')
+    expect(gutterOf(rows[0]!).style.position).toBe('sticky')
     action.destroy()
   })
 
@@ -169,8 +169,8 @@ describe('rowResize - strip injection', () => {
     const { host, rows } = buildGrid([{}, {}])
     track(host)
     const action = rowResize(host, { onResize: vi.fn(), disabled: true })
-    expect(stripOf(rows[0])).toBeNull()
-    expect(stripOf(rows[1])).toBeNull()
+    expect(stripOf(rows[0]!)).toBeNull()
+    expect(stripOf(rows[1]!)).toBeNull()
     action.destroy()
   })
 })
@@ -183,11 +183,11 @@ describe('rowResize - drag', () => {
   it('reports the new height on pointerup and fires move callbacks', () => {
     const { host, rows } = buildGrid([{ rowIndex: 0 }])
     track(host)
-    mockRowHeight(rows[0], 32)
+    mockRowHeight(rows[0]!, 32)
     const onResize = vi.fn()
     const onResizeMove = vi.fn()
     const action = rowResize(host, { onResize, onResizeMove })
-    const strip = stripOf(rows[0])!
+    const strip = stripOf(rows[0]!)!
 
     strip.dispatchEvent(pointer('pointerdown', { clientY: 100 }))
     expect(strip.classList.contains('is-resizing')).toBe(true)
@@ -196,7 +196,7 @@ describe('rowResize - drag', () => {
     // Drag down 20px -> 52.
     window.dispatchEvent(pointer('pointermove', { clientY: 120 }))
     expect(onResizeMove).toHaveBeenLastCalledWith(0, 52)
-    expect(rows[0].style.height).toBe('52px')
+    expect(rows[0]!.style.height).toBe('52px')
 
     window.dispatchEvent(pointer('pointerup', { clientY: 120 }))
     expect(onResize).toHaveBeenCalledWith(0, 52)
@@ -208,10 +208,10 @@ describe('rowResize - drag', () => {
   it('clamps the height to the min bound', () => {
     const { host, rows } = buildGrid([{ rowIndex: 0 }])
     track(host)
-    mockRowHeight(rows[0], 32)
+    mockRowHeight(rows[0]!, 32)
     const onResize = vi.fn()
     const action = rowResize(host, { onResize, min: 24 })
-    const strip = stripOf(rows[0])!
+    const strip = stripOf(rows[0]!)!
     strip.dispatchEvent(pointer('pointerdown', { clientY: 100 }))
     // Drag far up -> would be negative, clamps to 24.
     window.dispatchEvent(pointer('pointerup', { clientY: 0 }))
@@ -222,10 +222,10 @@ describe('rowResize - drag', () => {
   it('clamps the height to the max bound', () => {
     const { host, rows } = buildGrid([{ rowIndex: 0 }])
     track(host)
-    mockRowHeight(rows[0], 32)
+    mockRowHeight(rows[0]!, 32)
     const onResize = vi.fn()
     const action = rowResize(host, { onResize, max: 50 })
-    const strip = stripOf(rows[0])!
+    const strip = stripOf(rows[0]!)!
     strip.dispatchEvent(pointer('pointerdown', { clientY: 100 }))
     window.dispatchEvent(pointer('pointerup', { clientY: 1000 }))
     expect(onResize).toHaveBeenCalledWith(0, 50)
@@ -235,10 +235,10 @@ describe('rowResize - drag', () => {
   it('works without an onResizeMove callback (optional)', () => {
     const { host, rows } = buildGrid([{ rowIndex: 0 }])
     track(host)
-    mockRowHeight(rows[0], 30)
+    mockRowHeight(rows[0]!, 30)
     const onResize = vi.fn()
     const action = rowResize(host, { onResize })
-    const strip = stripOf(rows[0])!
+    const strip = stripOf(rows[0]!)!
     strip.dispatchEvent(pointer('pointerdown', { clientY: 50 }))
     expect(() => window.dispatchEvent(pointer('pointermove', { clientY: 60 }))).not.toThrow()
     window.dispatchEvent(pointer('pointerup', { clientY: 60 }))
@@ -270,11 +270,11 @@ describe('rowResize - pointerdown guards', () => {
   it('ignores pointerdown when disabled', () => {
     const { host, rows } = buildGrid([{ rowIndex: 0 }])
     track(host)
-    mockRowHeight(rows[0], 32)
+    mockRowHeight(rows[0]!, 32)
     const onResize = vi.fn()
     // Start enabled so a strip exists, then disable via update.
     const action = rowResize(host, { onResize })
-    const strip = stripOf(rows[0])!
+    const strip = stripOf(rows[0]!)!
     action.update({ onResize, disabled: true })
     // update removes strips, but dispatch on the (now-detached) strip anyway:
     // even if it were still in the DOM, current.disabled short-circuits.
@@ -289,7 +289,7 @@ describe('rowResize - pointerdown guards', () => {
     track(host)
     const onResize = vi.fn()
     const action = rowResize(host, { onResize })
-    gutterOf(rows[0]).dispatchEvent(pointer('pointerdown', { clientY: 10 }))
+    gutterOf(rows[0]!).dispatchEvent(pointer('pointerdown', { clientY: 10 }))
     expect(document.body.style.cursor).toBe('')
     action.destroy()
   })
@@ -298,10 +298,10 @@ describe('rowResize - pointerdown guards', () => {
     const { host, rows } = buildGrid([{}])
     track(host)
     // Remove the data-svgrid-row marker so rowIndexOf returns NaN.
-    rows[0].querySelector('[data-svgrid-row]')!.removeAttribute('data-svgrid-row')
+    rows[0]!.querySelector('[data-svgrid-row]')!.removeAttribute('data-svgrid-row')
     const onResize = vi.fn()
     const action = rowResize(host, { onResize })
-    const strip = stripOf(rows[0])!
+    const strip = stripOf(rows[0]!)!
     strip.dispatchEvent(pointer('pointerdown', { clientY: 10 }))
     expect(document.body.style.cursor).toBe('')
     expect(strip.classList.contains('is-resizing')).toBe(false)
@@ -333,14 +333,14 @@ describe('rowResize - update + destroy', () => {
     track(host)
     const onResize = vi.fn()
     const action = rowResize(host, { onResize, disabled: false })
-    expect(stripOf(rows[0])).not.toBeNull()
+    expect(stripOf(rows[0]!)).not.toBeNull()
 
     action.update({ onResize, disabled: true })
-    expect(stripOf(rows[0])).toBeNull()
-    expect(stripOf(rows[1])).toBeNull()
+    expect(stripOf(rows[0]!)).toBeNull()
+    expect(stripOf(rows[1]!)).toBeNull()
 
     action.update({ onResize, disabled: false })
-    expect(stripOf(rows[0])).not.toBeNull()
+    expect(stripOf(rows[0]!)).not.toBeNull()
     action.destroy()
   })
 
@@ -348,29 +348,29 @@ describe('rowResize - update + destroy', () => {
     const { host, rows } = buildGrid([{}])
     track(host)
     const action = rowResize(host, { onResize: vi.fn() })
-    const firstStrip = stripOf(rows[0])
+    const firstStrip = stripOf(rows[0]!)
     // Same disabled value -> decorate is NOT called, strip stays the same node.
     action.update({ onResize: vi.fn() })
-    expect(stripOf(rows[0])).toBe(firstStrip)
+    expect(stripOf(rows[0]!)).toBe(firstStrip)
     action.destroy()
   })
 
   it('destroy removes all strips and detaches listeners', () => {
     const { host, rows } = buildGrid([{ rowIndex: 0 }])
     track(host)
-    mockRowHeight(rows[0], 32)
+    mockRowHeight(rows[0]!, 32)
     const onResize = vi.fn()
     const action = rowResize(host, { onResize })
-    expect(stripOf(rows[0])).not.toBeNull()
+    expect(stripOf(rows[0]!)).not.toBeNull()
 
     action.destroy()
-    expect(stripOf(rows[0])).toBeNull()
+    expect(stripOf(rows[0]!)).toBeNull()
 
     // After destroy the pointerdown listener is gone; re-create a strip
     // manually and confirm no drag starts.
     const strip = document.createElement('div')
     strip.className = STRIP_CLASS
-    gutterOf(rows[0]).appendChild(strip)
+    gutterOf(rows[0]!).appendChild(strip)
     strip.dispatchEvent(pointer('pointerdown', { clientY: 10 }))
     expect(document.body.style.cursor).toBe('')
   })
@@ -378,14 +378,14 @@ describe('rowResize - update + destroy', () => {
   it('uses default min=20 / max=320 when bounds are omitted', () => {
     const { host, rows } = buildGrid([{ rowIndex: 0 }])
     track(host)
-    mockRowHeight(rows[0], 100)
+    mockRowHeight(rows[0]!, 100)
     const onResize = vi.fn()
     const action = rowResize(host, { onResize })
-    const strip = stripOf(rows[0])!
+    const strip = stripOf(rows[0]!)!
     strip.dispatchEvent(pointer('pointerdown', { clientY: 0 }))
     // Drag way past max -> clamps to 320.
     window.dispatchEvent(pointer('pointermove', { clientY: 10000 }))
-    expect(rows[0].style.height).toBe('320px')
+    expect(rows[0]!.style.height).toBe('320px')
     // Drag way below min -> clamps to 20.
     window.dispatchEvent(pointer('pointerup', { clientY: -10000 }))
     expect(onResize).toHaveBeenCalledWith(0, 20)

package/src/scheduler-model.ts

@@ -797,7 +797,7 @@ export function timelineAxis(
   } else if (view === 'timelineYear') {
     const y = rangeStart.getFullYear()
     for (let m = 0; m < 12; m++) {
-      ticks.push(mk(new Date(y, m, 1), new Date(y, m + 1, 1), TL_MO[m]))
+      ticks.push(mk(new Date(y, m, 1), new Date(y, m + 1, 1), TL_MO[m]!))
     }
     majors = groupMajors(
       ticks,

package/src/server-data-source.coverage.test.ts

@@ -22,7 +22,7 @@ describe('createServerDataSource - request params', () => {
   })
 
   it('setFilter resets to page 0', async () => {
-    const getRows = vi.fn(async () => ({ rows: [], rowCount: 100 }))
+    const getRows = vi.fn(async (_req: ServerRequest) => ({ rows: [], rowCount: 100 }))
     const ctl = createServerDataSource<Row>({ getRows }, { pageSize: 10, onChange: () => {} })
     ctl.setPage(3)
     await flush()

package/src/server-group-model.test.ts

@@ -23,16 +23,16 @@ function makeGroupSource(data: Row[], delay = 0): ServerDataSource<Row> & { call
       this.calls += 1
       if (delay) await new Promise((r) => setTimeout(r, delay))
       const subset = data.filter((r) =>
-        req.groupKeys.every((k, i) => String((r as Record<string, unknown>)[req.groupBy[i]!]) === k),
+        req.groupKeys!.every((k, i) => String((r as Record<string, unknown>)[req.groupBy![i]!]) === k),
       )
-      const level = req.groupKeys.length
-      if (level < req.groupBy.length) {
-        const field = req.groupBy[level]!
+      const level = req.groupKeys!.length
+      if (level < req.groupBy!.length) {
+        const field = req.groupBy![level]!
         const map = new Map<string, Record<string, unknown>>()
         for (const r of subset) {
           const key = String((r as Record<string, unknown>)[field])
           const agg = map.get(key) ?? { [field]: (r as Record<string, unknown>)[field] }
-          for (const a of req.aggregations) {
+          for (const a of req.aggregations!) {
             const cur = (agg[a.col] as number) ?? 0
             agg[a.col] = a.fn === 'count' ? cur + 1 : cur + ((r as Record<string, unknown>)[a.col] as number)
           }
@@ -241,7 +241,7 @@ function makeTreeSource(nodes: Node[]): ServerDataSource<Node> & { calls: number
     calls: 0,
     async getRows(req) {
       this.calls += 1
-      const parent = req.groupKeys.length ? req.groupKeys[req.groupKeys.length - 1] : null
+      const parent = req.groupKeys!.length ? req.groupKeys![req.groupKeys!.length - 1] : null
       const children = nodes.filter((n) => (n.parentId ?? null) === (parent ?? null))
       return { rows: children, rowCount: children.length }
     },

package/src/spreadsheet.test.ts

@@ -9,7 +9,6 @@ if (typeof globalThis.CSS === 'undefined') {
   // @ts-expect-error - minimal shim for the test environment
   globalThis.CSS = { escape: (s: string) => s.replace(/["\\]/g, '\\$&') }
 } else if (typeof globalThis.CSS.escape !== 'function') {
-  // @ts-expect-error - augment partial CSS object
   globalThis.CSS.escape = (s: string) => s.replace(/["\\]/g, '\\$&')
 }
 

package/src/svgrid-wrapper.types.ts

@@ -1,18 +1,14 @@
 import type { CellFormatConfig, ColumnDef, RowData, SvGridOptions, TableFeatures } from './core'
 // Type-only import (the reverse of SvGrid.types importing SvGridApi); TS resolves the
 // type-level cycle. Backs the generic key/value typing of `setOption` / `getOption`.
-import type { Props } from './SvGrid.types'
+import type { FilterOperator, Props } from './SvGrid.types'
 import type { GridExportOptions, GridClipboardOptions } from './export-format'
 import type { ChartSpec, ChartType } from './chart'
 
-export type SvGridFilterOperator =
-  | 'contains'
-  | 'equals'
-  | 'startsWith'
-  | 'greaterThan'
-  | 'lessThan'
-  | 'between'
-  | 'isBlank'
+// Aliased to the core union rather than restated: the API surfaces below hand
+// back whatever the grid actually filtered with, so a hand-maintained subset
+// here silently mistypes operators like 'endsWith' that reach callers at runtime.
+export type SvGridFilterOperator = FilterOperator
 
 /**
  * A serializable snapshot of everything that makes up the current "view":
@@ -247,6 +243,12 @@ export type SvGridApi<
    */
   setFacetFilter(columnId: string, values: ReadonlyArray<string> | null): void
   clearFilter(columnId: string): void
+  /**
+   * Drop cached async `editorOptions` so the next render refetches them.
+   * Omit `columnId` to clear every column. Only affects columns whose
+   * `editorOptions` returns a Promise - static lists are never refetched.
+   */
+  refreshEditorOptions(columnId?: string): void
   /**
    * Clear every active column filter (menu, filter-row, set-list, and global).
    * Resets the grid to "no filtering" in a single call.