niuma-ui 1.1.11 → 1.2.0

package/src/__tests__/table-edit-utils.spec.ts

@@ -1,194 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { h, isVNode } from 'vue'
-import {
-  RS_TABLE_NULL_DRAFT,
-  booleanToEditText,
-  coerceBoolean,
-  isBooleanToggleColumn,
-  isNullDraft,
-  navigateEditableCell,
-  parseCellEditInput,
-  parseClipboardGrid,
-  plainTextFromCellDisplay,
-  resolveColumnCommitOn,
-  resolveColumnDisplayContent,
-  resolveColumnEditTrigger,
-  resolveColumnRawValue,
-  stripNumberDecorations,
-  resolveCellEditText,
-  usesOverlayEditor,
-  validateCellValue,
-} from '../components/table/table-edit-utils'
-
-describe('table-edit-utils editors', () => {
-  it('normalizes ISO datetime for date picker binding', () => {
-    expect(
-      resolveCellEditText(
-        { updatedAt: '2026-06-15T10:30:00' },
-        { key: 'updatedAt', title: '更新时间', valueType: 'datetime' },
-        0,
-      ),
-    ).toBe('2026-06-15 10:30:00')
-    expect(
-      resolveCellEditText(
-        { birthday: '2024-01-15' },
-        { key: 'birthday', title: '生日', valueType: 'date' },
-        0,
-      ),
-    ).toBe('2024-01-15')
-  })
-
-  it('edits UTC ISO as local and writes back without losing ms when unchanged', () => {
-    const raw = '2026-06-25T08:06:36.2263624Z'
-    const col = { key: 'addTime', title: 'addTime', valueType: 'datetime' as const }
-    const draft = resolveCellEditText({ addTime: raw }, col, 0)
-    const d = new Date('2026-06-25T08:06:36.226Z')
-    const pad = (n: number, w = 2) => String(n).padStart(w, '0')
-    expect(draft).toBe(
-      `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ` +
-        `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}.${pad(d.getMilliseconds(), 3)}`,
-    )
-    // 选择器通常去掉毫秒：秒级未变应还原原始串
-    const withoutMs = draft.replace(/\.\d+$/, '')
-    expect(parseCellEditInput(withoutMs, { addTime: raw }, col, 0)).toBe(raw)
-  })
-
-  it('stringifies object cell values for edit draft', () => {
-    const binary = { $binary: '566h55CG5ZGYMDAx' }
-    expect(
-      resolveCellEditText(
-        { userName: binary },
-        { key: 'userName', title: 'userName' },
-        0,
-      ),
-    ).toBe(JSON.stringify(binary))
-    expect(
-      resolveCellEditText(
-        { userName: binary },
-        {
-          key: 'userName',
-          title: 'userName',
-          formatter: (v) => (typeof v === 'object' ? JSON.stringify(v) : String(v)),
-        },
-        0,
-      ),
-    ).toBe(JSON.stringify(binary))
-  })
-
-  it('detects boolean toggle columns', () => {
-    expect(isBooleanToggleColumn({ key: 'a', title: 'A', valueType: 'boolean' })).toBe(true)
-    expect(isBooleanToggleColumn({ key: 'a', title: 'A', valueType: 'text' })).toBe(false)
-  })
-
-  it('uses change commit and click trigger for overlay editors', () => {
-    expect(usesOverlayEditor('select')).toBe(true)
-    expect(usesOverlayEditor('date')).toBe(true)
-    expect(resolveColumnCommitOn({ key: 'k', title: 'K', valueType: 'select' }, false)).toBe(
-      'change',
-    )
-    expect(resolveColumnCommitOn({ key: 'k', title: 'K', valueType: 'date' }, false)).toBe('enter')
-    expect(resolveColumnCommitOn({ key: 'k', title: 'K', valueType: 'datetime' }, false)).toBe(
-      'enter',
-    )
-    expect(resolveColumnEditTrigger({ key: 'k', title: 'K', valueType: 'select' }, 'dblclick')).toBe(
-      'click',
-    )
-  })
-
-  it('parses boolean edit text', () => {
-    expect(coerceBoolean(true)).toBe(true)
-    expect(coerceBoolean('YES')).toBe(true)
-    expect(booleanToEditText(false)).toBe('false')
-    expect(
-      parseCellEditInput('true', { a: false }, { key: 'a', title: 'A', valueType: 'boolean' }, 0),
-    ).toBe(true)
-  })
-
-  it('parses explicit NULL draft and emptyAsNull', () => {
-    expect(isNullDraft(RS_TABLE_NULL_DRAFT)).toBe(true)
-    expect(
-      parseCellEditInput(RS_TABLE_NULL_DRAFT, { a: 'x' }, { key: 'a', title: 'A' }, 0),
-    ).toBeNull()
-    expect(
-      parseCellEditInput('', { a: 'x' }, { key: 'a', title: 'A', emptyAsNull: true, nullable: true }, 0),
-    ).toBeNull()
-  })
-
-  it('supports async validators', async () => {
-    const { validateCellValueAsync, listBatchColumnTargets } = await import(
-      '../components/table/table-edit-utils'
-    )
-    await expect(
-      validateCellValueAsync(
-        -1,
-        { n: 0 },
-        {
-          key: 'n',
-          title: 'N',
-          validator: async (value) => (Number(value) >= 0 ? null : '异步不能为负'),
-        },
-        0,
-      ),
-    ).resolves.toBe('异步不能为负')
-
-    const targets = listBatchColumnTargets({
-      rows: [
-        { row: { id: '1' }, rowIndex: 0, rowKey: '1' },
-        { row: { id: '2' }, rowIndex: 1, rowKey: '2' },
-        { row: { id: '3' }, rowIndex: 2, rowKey: '3' },
-      ],
-      column: { key: 'name', title: '名称', editable: true },
-      tableEditable: true,
-      selectedKeys: ['1', '3'],
-      anchorRowKey: '1',
-    })
-    expect(targets.map((item) => item.rowKey)).toEqual(['1', '3'])
-  })
-
-  it('strips number decorations and validates', () => {
-    expect(stripNumberDecorations('1,234.5')).toBe('1234.5')
-    expect(
-      parseCellEditInput('1,200', { n: 0 }, { key: 'n', title: 'N', valueType: 'number' }, 0),
-    ).toBe(1200)
-    expect(
-      validateCellValue(-1, { n: 0 }, {
-        key: 'n',
-        title: 'N',
-        validator: (value) => (Number(value) >= 0 ? null : '不能为负'),
-      }, 0),
-    ).toBe('不能为负')
-  })
-
-  it('parses clipboard TSV grid', () => {
-    expect(parseClipboardGrid('a\tb\nc\td')).toEqual([
-      ['a', 'b'],
-      ['c', 'd'],
-    ])
-  })
-
-  it('navigates editable cells', () => {
-    const cells = [
-      { rowKey: '1', colKey: 'a', rowIndex: 0 },
-      { rowKey: '1', colKey: 'b', rowIndex: 0 },
-      { rowKey: '2', colKey: 'a', rowIndex: 1 },
-      { rowKey: '2', colKey: 'b', rowIndex: 1 },
-    ]
-    expect(navigateEditableCell(cells, '1', 'a', 'next', 2)?.colKey).toBe('b')
-    expect(navigateEditableCell(cells, '1', 'b', 'next', 2)?.rowKey).toBe('2')
-    expect(navigateEditableCell(cells, '1', 'a', 'down', 2)?.rowKey).toBe('2')
-    expect(navigateEditableCell(cells, '2', 'b', 'prev', 2)?.colKey).toBe('a')
-  })
-
-  it('keeps raw value separate from render display (incl. VNode)', () => {
-    const row = { time: 42 }
-    const column = {
-      key: 'time',
-      title: 'Time',
-      render: (r: { time: number }) => h('span', { class: 'x' }, String(r.time)),
-    }
-    expect(resolveColumnRawValue(row, column, 0)).toBe(42)
-    const display = resolveColumnDisplayContent(row, column, 0)
-    expect(plainTextFromCellDisplay(display)).toBe('42')
-    expect(isVNode(display)).toBe(true)
-  })
-})

package/src/__tests__/table-summary-utils.spec.ts

@@ -1,62 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import {
-  aggregateColumnSummary,
-  buildTableSummaryCells,
-  hasTableSummaryConfig,
-} from '../components/table/table-summary-utils'
-import type { RsTableColumn } from '../components/table-utils'
-
-type Row = { id: number; name: string; amount: number }
-
-const columns: Array<RsTableColumn<Row> & { summary?: any }> = [
-  { key: 'name', title: '名称' },
-  {
-    key: 'amount',
-    title: '金额',
-    summary: { type: 'sum', formatter: (v: number | string) => `¥${v}` },
-  },
-]
-
-const rows: Row[] = [
-  { id: 1, name: 'A', amount: 10 },
-  { id: 2, name: 'B', amount: 20 },
-]
-
-describe('table-summary-utils', () => {
-  it('aggregates sum with formatter', () => {
-    const cell = aggregateColumnSummary(columns[1]!, rows)
-    expect(cell?.value).toBe(30)
-    expect(cell?.text).toBe('¥30')
-  })
-
-  it('builds client summary cells', () => {
-    const cells = buildTableSummaryCells({
-      columns,
-      rows,
-      mode: 'client',
-    })
-    expect(cells.find((c) => c.key === 'amount')?.text).toBe('¥30')
-    expect(cells.find((c) => c.key === 'name')?.text).toBe('')
-  })
-
-  it('uses server summaryData without local reduce', () => {
-    const cells = buildTableSummaryCells({
-      columns,
-      rows,
-      mode: 'server',
-      summaryData: { amount: 999 },
-    })
-    expect(cells.find((c) => c.key === 'amount')?.text).toBe('¥999')
-  })
-
-  it('detects summary config', () => {
-    expect(hasTableSummaryConfig({ columns, mode: 'client' })).toBe(true)
-    expect(
-      hasTableSummaryConfig({
-        columns: [{ key: 'name', title: '名称' }],
-        mode: 'server',
-        summaryData: { name: 'x' },
-      }),
-    ).toBe(true)
-  })
-})

package/src/__tests__/table-utils.spec.ts

@@ -1,410 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import {
-  buildTableEntries,
-  buildTableTreeEntries,
-  buildTableTreeNodeIndex,
-  clampColumnWidth,
-  collectTableTreeExpandableKeys,
-  filterTableRows,
-  filterTableRowsByColumnFilters,
-  filterTableTreeRows,
-  flattenVisibleTableTreeEntries,
-  isColumnFilterActive,
-  fixedCellStyle,
-  groupTableRows,
-  injectExpandRows,
-  isNearScrollBottom,
-  resolveFixedColumnStyles,
-  resolveSelectableRowKeys,
-  resolveSelectAllState,
-  resolveTableTreeCheckState,
-  resolveTableVirtualEnabled,
-  selectRowKeys,
-  selectRowKeysByClick,
-  sliceVirtualColumns,
-  sliceVirtualTableEntries,
-  sortTableRows,
-  toggleMultiSortState,
-  toggleRowSelection,
-  toggleSelectAll,
-  toggleSortState,
-  toggleTableTreeCheck,
-  reorderColumnKeys,
-  reorderTableRows,
-  resolveColumnOrder,
-  resolveOrderedColumns,
-  sortTableRowsMulti,
-} from '../components/table-utils'
-
-describe('table-utils', () => {
-  const columns = [
-    { key: 'name', title: '名称', sortable: true },
-    { key: 'status', title: '状态' },
-    { key: 'count', title: '数量', sortable: true },
-  ]
-
-  const rows = [
-    { id: '1', name: 'Alpha', status: 'running', count: 12 },
-    { id: '2', name: 'Beta', status: 'stopped', count: 7 },
-    { id: '3', name: 'Gamma', status: 'running', count: 23 },
-  ]
-
-  it('filters rows by query across columns', () => {
-    expect(filterTableRows(rows, 'alp', columns).map((row) => row.name)).toEqual(['Alpha'])
-    expect(filterTableRows(rows, 'running', columns, ['status'])).toHaveLength(2)
-    expect(filterTableRows(rows, '  ', columns)).toHaveLength(3)
-  })
-
-  it('filters rows by per-column filters', () => {
-    expect(
-      filterTableRowsByColumnFilters(rows, columns, { name: 'beta' }).map((row) => row.name),
-    ).toEqual(['Beta'])
-    expect(filterTableRowsByColumnFilters(rows, columns, { status: 'running' })).toHaveLength(2)
-    expect(
-      filterTableRowsByColumnFilters(rows, columns, { name: 'alp', status: 'running' }).map((row) => row.name),
-    ).toEqual(['Alpha'])
-    expect(isColumnFilterActive({ name: 'x' }, 'name')).toBe(true)
-    expect(isColumnFilterActive({ name: '  ' }, 'name')).toBe(false)
-  })
-
-  it('applies column filters in buildTableEntries', () => {
-    const entries = buildTableEntries(rows, columns, { columnFilters: { name: 'gamma' } })
-    expect(entries).toHaveLength(1)
-    expect(entries[0]?.type).toBe('row')
-    if (entries[0]?.type === 'row') expect(entries[0].row.name).toBe('Gamma')
-  })
-
-  it('toggles sort state', () => {
-    expect(toggleSortState(null, 'name')).toEqual({ key: 'name', order: 'asc' })
-    expect(toggleSortState({ key: 'name', order: 'asc' }, 'name')).toEqual({ key: 'name', order: 'desc' })
-    expect(toggleSortState({ key: 'name', order: 'desc' }, 'name')).toBeNull()
-  })
-
-  it('sorts rows by numeric and string columns', () => {
-    expect(sortTableRows(rows, columns, { key: 'name', order: 'asc' }).map((row) => row.name)).toEqual([
-      'Alpha',
-      'Beta',
-      'Gamma',
-    ])
-    expect(sortTableRows(rows, columns, { key: 'count', order: 'desc' }).map((row) => row.count)).toEqual([23, 12, 7])
-  })
-
-  it('groups rows and inserts group headers', () => {
-    const sorted = [...rows].sort((left, right) => left.status.localeCompare(right.status))
-    const grouped = groupTableRows(sorted, 'status', (key) => `状态：${key}`)
-    expect(grouped.filter((entry) => entry.type === 'group').map((entry) => entry.label)).toEqual([
-      '状态：running',
-      '状态：stopped',
-    ])
-    expect(grouped.filter((entry) => entry.type === 'row')).toHaveLength(3)
-  })
-
-  it('builds entries with filter, sort and group pipeline', () => {
-    const entries = buildTableEntries(rows, columns, {
-      filterText: 'running',
-      filterKeys: ['status'],
-      sort: { key: 'count', order: 'desc' },
-      groupBy: 'status',
-      groupLabel: (key) => key,
-    })
-    expect(entries.some((entry) => entry.type === 'group' && entry.key === 'running')).toBe(true)
-    const dataRows = entries.filter((entry) => entry.type === 'row')
-    expect(dataRows).toHaveLength(2)
-    expect(dataRows[0].type === 'row' && dataRows[0].row.name).toBe('Gamma')
-  })
-
-  it('slices virtual entries with padding', () => {
-    const entries = buildTableEntries(
-      Array.from({ length: 100 }, (_, index) => ({
-        id: String(index),
-        name: `Row ${index}`,
-        status: 'running',
-        count: index,
-      })),
-      columns,
-    )
-    const slice = sliceVirtualTableEntries(entries, 400, 200, 40, 36, 2)
-    expect(slice.entries.length).toBeLessThan(entries.length)
-    expect(slice.paddingTop).toBeGreaterThan(0)
-    expect(slice.paddingBottom).toBeGreaterThan(0)
-  })
-
-  it('clamps column width', () => {
-    expect(clampColumnWidth(10)).toBe(48)
-    expect(clampColumnWidth(900)).toBe(640)
-    expect(clampColumnWidth(120)).toBe(120)
-  })
-
-  it('resolves virtual scroll for infinite mode', () => {
-    expect(resolveTableVirtualEnabled({ infinite: true })).toBe(true)
-    expect(resolveTableVirtualEnabled({ infinite: true, virtualOnInfinite: false })).toBe(false)
-    expect(resolveTableVirtualEnabled({ virtual: true })).toBe(true)
-  })
-
-  it('detects near scroll bottom', () => {
-    expect(isNearScrollBottom(300, 400, 120, 80)).toBe(true)
-    expect(isNearScrollBottom(100, 400, 120, 80)).toBe(false)
-  })
-
-  it('resolves row selection helpers', () => {
-    const rows = [
-      { id: '1', name: 'A' },
-      { id: '2', name: 'B', disabled: true },
-      { id: '3', name: 'C' },
-    ]
-    const keys = resolveSelectableRowKeys(rows, 'id')
-    expect(keys).toEqual(['1', '3'])
-    expect(resolveSelectAllState(['1'], keys)).toBe('indeterminate')
-    expect(toggleSelectAll([], keys, true)).toEqual(['1', '3'])
-    expect(toggleRowSelection(['1', '3'], '1')).toEqual(['3'])
-    expect(
-      selectRowKeysByClick(['1'], '3', {
-        toggle: false,
-        range: false,
-        orderedKeys: keys,
-        anchorKey: '1',
-      }),
-    ).toEqual(['3'])
-    expect(
-      selectRowKeysByClick(['1'], '3', {
-        toggle: true,
-        range: false,
-        orderedKeys: keys,
-        anchorKey: '1',
-      }),
-    ).toEqual(['1', '3'])
-    expect(
-      selectRowKeysByClick(['1'], '3', {
-        toggle: false,
-        range: true,
-        orderedKeys: ['1', '2', '3'],
-        anchorKey: '1',
-      }),
-    ).toEqual(['1', '2', '3'])
-  })
-
-  it('injects expand rows after expanded keys', () => {
-    const entries = buildTableEntries(
-      [{ id: '1', name: 'A' }],
-      [{ key: 'name', title: '名称' }],
-    )
-    const expanded = injectExpandRows(entries, new Set(['1']), 'id')
-    expect(expanded).toHaveLength(2)
-    expect(expanded[1]?.type).toBe('expand')
-  })
-
-  it('resolves fixed column offsets', () => {
-    const styles = resolveFixedColumnStyles(
-      [
-        { key: 'name', title: '名称', fixed: 'left', width: 100 },
-        { key: 'action', title: '操作', fixed: 'right', width: 80 },
-      ],
-      {},
-      { expandable: true },
-    )
-    expect(styles.get('name')?.left).toBe(40)
-    expect(styles.get('action')?.right).toBe(0)
-  })
-
-  it('applies header top sticky for fixed cells', () => {
-    expect(fixedCellStyle({ fixed: 'left', left: 0 }, { header: true })).toEqual({
-      position: 'sticky',
-      zIndex: '4',
-      top: '0',
-      left: '0px',
-    })
-    expect(fixedCellStyle({ fixed: 'right', right: 12 })).toEqual({
-      position: 'sticky',
-      zIndex: '2',
-      right: '12px',
-    })
-  })
-
-  it('slices visible columns for horizontal virtualization', () => {
-    const cols = Array.from({ length: 20 }, (_, i) => ({
-      key: `c${i}`,
-      title: `C${i}`,
-      width: 100,
-    }))
-    const sliced = sliceVirtualColumns(cols, {
-      scrollLeft: 500,
-      viewportWidth: 300,
-      getWidth: (c) => (typeof c.width === 'number' ? c.width : 100),
-      overscan: 1,
-    })
-    // 500→Start near col 5; viewport 300px ≈ 3 cols + overscan
-    expect(sliced.startIndex).toBeGreaterThanOrEqual(3)
-    expect(sliced.endIndex).toBeLessThanOrEqual(12)
-    expect(sliced.paddingLeft).toBe(sliced.startIndex * 100)
-    expect(sliced.paddingLeft + sliced.columns.reduce((n, c) => n + 100, 0) + sliced.paddingRight).toBe(
-      2000,
-    )
-  })
-
-  it('selects single row in radio mode', () => {
-    expect(selectRowKeys([], 'a', 'radio')).toEqual(['a'])
-    expect(selectRowKeys(['a'], 'b', 'radio')).toEqual(['b'])
-  })
-
-  it('toggles multi-column sort state', () => {
-    expect(toggleMultiSortState([], 'name')).toEqual([{ key: 'name', order: 'asc' }])
-    expect(toggleMultiSortState([{ key: 'name', order: 'asc' }], 'count')).toEqual([
-      { key: 'name', order: 'asc' },
-      { key: 'count', order: 'asc' },
-    ])
-    expect(toggleMultiSortState([{ key: 'name', order: 'desc' }], 'name')).toEqual([])
-  })
-
-  it('sorts rows by multiple columns', () => {
-    const mixed = [
-      { id: '1', name: 'A', status: 'running', count: 10 },
-      { id: '2', name: 'A', status: 'stopped', count: 5 },
-      { id: '3', name: 'B', status: 'running', count: 8 },
-    ]
-    const sorted = sortTableRowsMulti(mixed, columns, [
-      { key: 'name', order: 'asc' },
-      { key: 'count', order: 'desc' },
-    ])
-    expect(sorted.map((row) => row.id)).toEqual(['1', '2', '3'])
-  })
-
-  it('reorders columns and rows', () => {
-    expect(reorderColumnKeys(['a', 'b', 'c'], 'c', 'a')).toEqual(['c', 'a', 'b'])
-    expect(resolveOrderedColumns(columns, ['count', 'name']).map((column) => column.key)).toEqual([
-      'count',
-      'name',
-      'status',
-    ])
-    expect(resolveColumnOrder(columns, ['status', 'name'])).toEqual(['status', 'name', 'count'])
-    expect(reorderTableRows(['a', 'b', 'c'], 2, 0, 'before')).toEqual(['c', 'a', 'b'])
-  })
-
-  it('builds entries with multi sort', () => {
-    const entries = buildTableEntries(rows, columns, {
-      multiSort: true,
-      sorts: [
-        { key: 'status', order: 'asc' },
-        { key: 'count', order: 'desc' },
-      ],
-    })
-    const dataRows = entries.filter((entry) => entry.type === 'row')
-    expect(dataRows[0].type === 'row' && dataRows[0].row.name).toBe('Gamma')
-  })
-
-  it('flattens tree rows by expanded keys with depth', () => {
-    const treeRows = [
-      {
-        id: 'p',
-        name: 'Parent',
-        status: 'running',
-        count: 1,
-        children: [
-          { id: 'c1', name: 'Child1', status: 'running', count: 2 },
-          {
-            id: 'c2',
-            name: 'Child2',
-            status: 'stopped',
-            count: 3,
-            children: [{ id: 'g1', name: 'Grand', status: 'running', count: 4 }],
-          },
-        ],
-      },
-    ]
-    const collapsed = flattenVisibleTableTreeEntries(treeRows, new Set(), { rowKey: 'id' })
-    expect(collapsed.map((e) => e.row.id)).toEqual(['p'])
-    expect(collapsed[0]?.depth).toBe(0)
-    expect(collapsed[0]?.hasChildren).toBe(true)
-
-    const expanded = flattenVisibleTableTreeEntries(treeRows, new Set(['p', 'c2']), { rowKey: 'id' })
-    expect(expanded.map((e) => e.row.id)).toEqual(['p', 'c1', 'c2', 'g1'])
-    expect(expanded.map((e) => e.depth)).toEqual([0, 1, 1, 2])
-  })
-
-  it('collects expandable keys and filters tree keeping ancestors', () => {
-    const treeRows = [
-      {
-        id: 'p',
-        name: 'Parent',
-        status: 'running',
-        count: 1,
-        children: [
-          { id: 'c1', name: 'AlphaChild', status: 'running', count: 2 },
-          { id: 'c2', name: 'BetaChild', status: 'stopped', count: 3 },
-        ],
-      },
-    ]
-    expect(collectTableTreeExpandableKeys(treeRows, { rowKey: 'id' })).toEqual(['p'])
-
-    const filtered = filterTableTreeRows(treeRows, 'Alpha', columns, { childrenField: 'children' })
-    expect(filtered).toHaveLength(1)
-    expect(filtered[0]?.id).toBe('p')
-    expect((filtered[0] as { children: typeof treeRows }).children.map((c) => c.id)).toEqual(['c1'])
-  })
-
-  it('builds tree entries with sibling sort', () => {
-    const treeRows = [
-      {
-        id: 'p',
-        name: 'Parent',
-        status: 'running',
-        count: 1,
-        children: [
-          { id: 'c2', name: 'Beta', status: 'stopped', count: 3 },
-          { id: 'c1', name: 'Alpha', status: 'running', count: 2 },
-        ],
-      },
-    ]
-    const entries = buildTableTreeEntries(treeRows, columns, new Set(['p']), {
-      tree: { childrenField: 'children', expandColumnKey: 'name' },
-      rowKey: 'id',
-      sort: { key: 'name', order: 'asc' },
-    })
-    expect(entries.filter((e) => e.type === 'row').map((e) => (e.type === 'row' ? e.row.id : ''))).toEqual([
-      'p',
-      'c1',
-      'c2',
-    ])
-  })
-
-  it('uses path fallback keys when rowKey missing to avoid sibling collisions', () => {
-    const treeRows = [
-      {
-        name: 'A',
-        status: 'running',
-        count: 1,
-        children: [{ name: 'A1', status: 'running', count: 2 }],
-      },
-      {
-        name: 'B',
-        status: 'stopped',
-        count: 3,
-        children: [{ name: 'B1', status: 'stopped', count: 4 }],
-      },
-    ]
-    const expanded = flattenVisibleTableTreeEntries(treeRows, new Set(['tree:0', 'tree:1']))
-    const keys = expanded.map((e) => e.treeKey)
-    expect(keys).toEqual(['tree:0', 'tree:0/0', 'tree:1', 'tree:1/0'])
-  })
-
-  it('cascades tree check when checkStrictly is false', () => {
-    const treeRows = [
-      {
-        id: 'p',
-        name: 'Parent',
-        status: 'running',
-        count: 1,
-        children: [
-          { id: 'c1', name: 'C1', status: 'running', count: 2 },
-          { id: 'c2', name: 'C2', status: 'stopped', count: 3 },
-        ],
-      },
-    ]
-    const index = buildTableTreeNodeIndex(treeRows, { rowKey: 'id' })
-    const checked = toggleTableTreeCheck('c1', new Set(), index, false)
-    expect(checked.sort()).toEqual(['c1'])
-    expect(resolveTableTreeCheckState('p', new Set(checked), index, false)).toBe('indeterminate')
-
-    const all = toggleTableTreeCheck('p', new Set(), index, false)
-    expect(all.sort()).toEqual(['c1', 'c2', 'p'])
-  })
-})