refactor(tables): extract selection-to-chip helpers into utils so they are testable

Follow-up I owed on the previous round: the copy path's eligibility rule and the
context builder were module-private in a ~4,600-line component with no test file,
so the last two fixes to them were reasoned rather than covered — and both were
wrong on the first attempt.

Moves selectedColumnIds and buildTableSelectionContext to the existing
table-grid/utils.ts (which already owns RowSelection, DisplayColumn and
getColumnId), and extracts the copy decision as canWriteRowsWithChip.
writeLoadedRowsWithChip keeps only the clipboard and toast effects, so the pure
rule can be tested without a DOM. utils.ts stays free of side effects.

New utils.test.ts covers the two limits that were conflated — a selection past
the chip cap still qualifies (the context caps its own rowIds), one past
MAX_COPY_ROWS defers to the paged path — plus the all-columns collapse and both
caps. Verified to fail against the old chip-cap gate.

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/table-grid.tsx

@@ -12,11 +12,7 @@ import { useParams } from 'next/navigation'
 import { usePostHog } from 'posthog-js/react'
 import type { RunLimit, RunMode, TableFindMatch } from '@/lib/api/contracts/tables'
 import { attachSelectionContextToClipboard } from '@/lib/copilot/chat/selection-clipboard'
-import {
-  buildTableSelectionLabel,
-  MAX_TABLE_SELECTION_COLUMNS,
-  MAX_TABLE_SELECTION_ROWS,
-} from '@/lib/copilot/chat/selection-context'
+import { MAX_TABLE_SELECTION_ROWS } from '@/lib/copilot/chat/selection-context'
 import { captureEvent } from '@/lib/posthog/client'
 import type {
   ColumnDefinition,
@@ -69,7 +65,9 @@ import { AddRowButton, SelectAllCheckbox, TableColGroup } from './table-primitiv
 import type { DisplayColumn } from './types'
 import {
   buildHeaderGroups,
+  buildTableSelectionContext,
   type CellCoord,
+  canWriteRowsWithChip,
   checkboxColLayout,
   classifyExecStatusMix,
   collectRowSnapshots,
@@ -85,6 +83,7 @@ import {
   rowSelectionIncludes,
   rowSelectionIsEmpty,
   rowSelectionMaterialize,
+  selectedColumnIds,
 } from './utils'
 
 const logger = createLogger('TableView')
@@ -314,63 +313,11 @@ function cellToText(value: unknown, column?: DisplayColumn): string {
   return typeof value === 'object' ? JSON.stringify(value) : String(value)
 }
 
-/** Column ids spanned by a normalized selection's column range. */
-function selectedColumnIds(
-  columns: DisplayColumn[],
-  selection: { startCol: number; endCol: number }
-): string[] {
-  const ids: string[] = []
-  for (let c = selection.startCol; c <= selection.endCol && c < columns.length; c++) {
-    ids.push(getColumnId(columns[c]))
-  }
-  return ids
-}
-
-/**
- * Materializes a `table_selection` chat context from a grid selection, applying
- * the shared row/column caps. `columnIds` narrows the context to a cell range; a
- * range covering every column is equivalent to whole rows, so it collapses to an
- * open scope (the server then includes all columns, and stays correct if the
- * schema changes). Returns null before the table name has loaded or when nothing
- * is selected.
- */
-function buildTableSelectionContext(opts: {
-  tableId: string
-  tableName: string | undefined
-  totalColumnCount: number
-  rowIds: string[]
-  columnIds?: string[]
-}): ChatContext | null {
-  const { tableId, tableName, totalColumnCount, columnIds } = opts
-  if (!tableName || opts.rowIds.length === 0) return null
-  const rowIds = opts.rowIds.slice(0, MAX_TABLE_SELECTION_ROWS)
-  const scopedColumnIds =
-    columnIds && columnIds.length > 0 && columnIds.length < totalColumnCount
-      ? columnIds.slice(0, MAX_TABLE_SELECTION_COLUMNS)
-      : undefined
-  return {
-    kind: 'table_selection',
-    tableId,
-    tableName,
-    label: buildTableSelectionLabel(tableName, rowIds.length, scopedColumnIds?.length),
-    rowIds,
-    ...(scopedColumnIds ? { columnIds: scopedColumnIds } : {}),
-  }
-}
-
 /**
  * Copies `rows` synchronously on the copy event so a chat-selection chip can
- * ride alongside the tab-separated text. The paged `writeSelectionToClipboard`
- * cannot do this: its async Clipboard API write replaces the whole clipboard and
- * so cannot carry a custom MIME type.
- *
- * Taking this path requires a chip to carry, `rows` being the complete copy, and
- * a set within the chip cap; otherwise the canonical paged path handles the
- * copy, including its row loading and truncation notice.
+ * ride alongside the tab-separated text. Eligibility lives in
+ * {@link canWriteRowsWithChip}; this owns only the clipboard and toast effects.
  *
- * @param complete - Whether `rows` is everything this copy should contain. False
- * when the paged path would load rows this caller cannot see yet, so deferring
- * to it copies strictly more.
  * @returns True when it handled the copy, false to fall through to the paged path.
  */
 function writeLoadedRowsWithChip(opts: {
@@ -381,15 +328,16 @@ function writeLoadedRowsWithChip(opts: {
   context: ChatContext | null
 }): boolean {
   const { rows, context } = opts
-  // Bounded by the TEXT limit, not the chip's row cap: `context` already slices
-  // itself to MAX_TABLE_SELECTION_ROWS, so a larger selection still copies in
-  // full here and carries a chip for as many rows as a chip can reference —
-  // matching what Add to Chat does with the same selection. Gating on the chip
-  // cap instead would drop the chip entirely on the async fall-through, which
-  // cannot carry a custom MIME. Past MAX_COPY_ROWS the paged path must take
-  // over, since it owns truncation and the notice that goes with it.
-  if (!context || !opts.complete || rows.length === 0) return false
-  if (rows.length > TABLE_LIMITS.MAX_COPY_ROWS) return false
+  if (
+    !canWriteRowsWithChip({
+      rowCount: rows.length,
+      complete: opts.complete,
+      hasContext: Boolean(context),
+    }) ||
+    !context
+  ) {
+    return false
+  }
   opts.clipboardData?.setData(
     'text/plain',
     rows.map((row) => opts.buildCells(row).join('\t')).join('\n')

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/utils.test.ts

@@ -0,0 +1,102 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it } from 'vitest'
+import {
+  MAX_TABLE_SELECTION_COLUMNS,
+  MAX_TABLE_SELECTION_ROWS,
+} from '@/lib/copilot/chat/selection-context'
+import { TABLE_LIMITS } from '@/lib/table/constants'
+import type { DisplayColumn } from './types'
+import { buildTableSelectionContext, canWriteRowsWithChip, selectedColumnIds } from './utils'
+
+function columns(count: number): DisplayColumn[] {
+  return Array.from({ length: count }, (_, i) => ({
+    id: `c${i}`,
+    name: `Col ${i}`,
+  })) as unknown as DisplayColumn[]
+}
+
+const rowIds = (count: number) => Array.from({ length: count }, (_, i) => `r${i}`)
+
+describe('selectedColumnIds', () => {
+  it('returns the ids the range spans', () => {
+    expect(selectedColumnIds(columns(5), { startCol: 1, endCol: 3 })).toEqual(['c1', 'c2', 'c3'])
+  })
+
+  it('stops at the last column when the range overruns', () => {
+    expect(selectedColumnIds(columns(2), { startCol: 0, endCol: 9 })).toEqual(['c0', 'c1'])
+  })
+})
+
+describe('buildTableSelectionContext', () => {
+  const base = { tableId: 't1', tableName: 'Sales', totalColumnCount: 3 }
+
+  it('returns null before the table name has loaded, or with nothing selected', () => {
+    expect(buildTableSelectionContext({ ...base, tableName: undefined, rowIds: ['r1'] })).toBeNull()
+    expect(buildTableSelectionContext({ ...base, rowIds: [] })).toBeNull()
+  })
+
+  it('caps rows at the chip limit and labels the capped count, not the requested one', () => {
+    const context = buildTableSelectionContext({
+      ...base,
+      rowIds: rowIds(MAX_TABLE_SELECTION_ROWS + 250),
+    })
+
+    expect(context?.kind).toBe('table_selection')
+    if (context?.kind !== 'table_selection') throw new Error('expected a table_selection')
+    expect(context.rowIds).toHaveLength(MAX_TABLE_SELECTION_ROWS)
+    expect(context.label).toContain(`${MAX_TABLE_SELECTION_ROWS} rows`)
+  })
+
+  it('collapses a range covering every column to an open scope', () => {
+    // Equivalent to whole rows — leaving it open keeps the server correct if the
+    // schema changes, instead of pinning a now-stale column list.
+    const context = buildTableSelectionContext({
+      ...base,
+      rowIds: ['r1'],
+      columnIds: ['c0', 'c1', 'c2'],
+    })
+
+    if (context?.kind !== 'table_selection') throw new Error('expected a table_selection')
+    expect(context.columnIds).toBeUndefined()
+  })
+
+  it('keeps a narrower range scoped, capped at the column limit', () => {
+    const context = buildTableSelectionContext({
+      ...base,
+      totalColumnCount: MAX_TABLE_SELECTION_COLUMNS + 50,
+      rowIds: ['r1'],
+      columnIds: Array.from({ length: MAX_TABLE_SELECTION_COLUMNS + 10 }, (_, i) => `c${i}`),
+    })
+
+    if (context?.kind !== 'table_selection') throw new Error('expected a table_selection')
+    expect(context.columnIds).toHaveLength(MAX_TABLE_SELECTION_COLUMNS)
+  })
+})
+
+describe('canWriteRowsWithChip', () => {
+  const ok = { rowCount: 10, complete: true, hasContext: true }
+
+  it('allows a complete, in-bounds selection that has a chip to carry', () => {
+    expect(canWriteRowsWithChip(ok)).toBe(true)
+  })
+
+  it('defers when there is no chip, nothing selected, or the paged path would load more', () => {
+    expect(canWriteRowsWithChip({ ...ok, hasContext: false })).toBe(false)
+    expect(canWriteRowsWithChip({ ...ok, rowCount: 0 })).toBe(false)
+    expect(canWriteRowsWithChip({ ...ok, complete: false })).toBe(false)
+  })
+
+  it('stays allowed past the chip row cap — the context caps itself', () => {
+    // Gating on MAX_TABLE_SELECTION_ROWS here would drop the chip entirely on
+    // the async fall-through, while Add to Chat on the same selection still
+    // produces a capped chip.
+    expect(canWriteRowsWithChip({ ...ok, rowCount: MAX_TABLE_SELECTION_ROWS + 100 })).toBe(true)
+  })
+
+  it('defers past the text copy limit, which owns truncation', () => {
+    expect(canWriteRowsWithChip({ ...ok, rowCount: TABLE_LIMITS.MAX_COPY_ROWS })).toBe(true)
+    expect(canWriteRowsWithChip({ ...ok, rowCount: TABLE_LIMITS.MAX_COPY_ROWS + 1 })).toBe(false)
+  })
+})

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/utils.ts

@@ -1,4 +1,9 @@
 import type { ActiveDispatch } from '@/lib/api/contracts/tables'
+import {
+  buildTableSelectionLabel,
+  MAX_TABLE_SELECTION_COLUMNS,
+  MAX_TABLE_SELECTION_ROWS,
+} from '@/lib/copilot/chat/selection-context'
 import type {
   ColumnDefinition,
   RowExecutionMetadata,
@@ -7,7 +12,9 @@ import type {
   WorkflowGroup,
 } from '@/lib/table'
 import { getColumnId } from '@/lib/table/column-keys'
+import { TABLE_LIMITS } from '@/lib/table/constants'
 import { areGroupDepsSatisfied, areOutputsFilled } from '@/lib/table/deps'
+import type { ChatContext } from '@/stores/panel'
 import type { DeletedRowSnapshot } from '@/stores/table/types'
 import type { DisplayColumn } from './types'
 
@@ -351,3 +358,72 @@ export function collectRowSnapshots(rows: Iterable<TableRowType>): DeletedRowSna
   }
   return snapshots
 }
+
+/** Column ids spanned by a normalized selection's column range. */
+export function selectedColumnIds(
+  columns: DisplayColumn[],
+  selection: { startCol: number; endCol: number }
+): string[] {
+  const ids: string[] = []
+  for (let c = selection.startCol; c <= selection.endCol && c < columns.length; c++) {
+    ids.push(getColumnId(columns[c]))
+  }
+  return ids
+}
+
+/**
+ * Materializes a `table_selection` chat context from a grid selection, applying
+ * the shared row/column caps. `columnIds` narrows the context to a cell range; a
+ * range covering every column is equivalent to whole rows, so it collapses to an
+ * open scope (the server then includes all columns, and stays correct if the
+ * schema changes). Returns null before the table name has loaded or when nothing
+ * is selected.
+ */
+export function buildTableSelectionContext(opts: {
+  tableId: string
+  tableName: string | undefined
+  totalColumnCount: number
+  rowIds: string[]
+  columnIds?: string[]
+}): ChatContext | null {
+  const { tableId, tableName, totalColumnCount, columnIds } = opts
+  if (!tableName || opts.rowIds.length === 0) return null
+  const rowIds = opts.rowIds.slice(0, MAX_TABLE_SELECTION_ROWS)
+  const scopedColumnIds =
+    columnIds && columnIds.length > 0 && columnIds.length < totalColumnCount
+      ? columnIds.slice(0, MAX_TABLE_SELECTION_COLUMNS)
+      : undefined
+  return {
+    kind: 'table_selection',
+    tableId,
+    tableName,
+    label: buildTableSelectionLabel(tableName, rowIds.length, scopedColumnIds?.length),
+    rowIds,
+    ...(scopedColumnIds ? { columnIds: scopedColumnIds } : {}),
+  }
+}
+
+/**
+ * Whether a copy can be written synchronously on the event — the only way a
+ * chat-selection chip survives, since the paged path's async Clipboard API write
+ * replaces the whole clipboard and cannot carry a custom MIME type.
+ *
+ * Bounded by the TEXT limit, not the chip's row cap: a context slices its own
+ * `rowIds` to {@link MAX_TABLE_SELECTION_ROWS}, so a larger selection should
+ * still copy in full here and carry a chip for as many rows as a chip can
+ * reference — matching what Add to Chat does with the same selection. Gating on
+ * the chip cap instead drops the chip entirely. Past `MAX_COPY_ROWS` the paged
+ * path must take over, because it owns truncation and its user-facing notice.
+ *
+ * @param complete - Whether the caller's rows are everything the copy should
+ * contain. False when the paged path would load rows the caller cannot see yet,
+ * so deferring to it copies strictly more.
+ */
+export function canWriteRowsWithChip(opts: {
+  rowCount: number
+  complete: boolean
+  hasContext: boolean
+}): boolean {
+  if (!opts.hasContext || !opts.complete) return false
+  return opts.rowCount > 0 && opts.rowCount <= TABLE_LIMITS.MAX_COPY_ROWS
+}