niuma-ui 1.0.0 → 1.0.2

package/src/__tests__/rs-table-echarts-adapter.spec.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'vitest'
+import { mapRsTableSeriesToEChartsOption } from '../components/table/rs-table-echarts-adapter'
+import type { RsTableChartSeries } from '../components/table/table-chart-utils'
+
+const bar: RsTableChartSeries = {
+  id: 'by-status',
+  kind: 'bar',
+  points: [
+    { key: 'ok', name: 'ok', value: 2, count: 2 },
+    { key: 'wait', name: 'wait', value: 1, count: 1 },
+  ],
+  categories: ['ok', 'wait'],
+  values: [2, 1],
+}
+
+const pie: RsTableChartSeries = {
+  ...bar,
+  id: 'pie',
+  kind: 'pie',
+}
+
+describe('mapRsTableSeriesToEChartsOption', () => {
+  it('柱状图产出类目轴 + values', () => {
+    const option = mapRsTableSeriesToEChartsOption([bar])
+    expect(option.tooltip?.trigger).toBe('axis')
+    expect(option.xAxis).toEqual({ type: 'category', data: ['ok', 'wait'] })
+    expect(option.series[0]).toMatchObject({
+      id: 'by-status',
+      type: 'bar',
+      data: [2, 1],
+    })
+  })
+
+  it('饼图产出 item tooltip 与 name/value 点', () => {
+    const option = mapRsTableSeriesToEChartsOption([pie])
+    expect(option.tooltip?.trigger).toBe('item')
+    expect(option.series[0]?.type).toBe('pie')
+    expect(option.series[0]?.data).toEqual([
+      { name: 'ok', value: 2 },
+      { name: 'wait', value: 1 },
+    ])
+  })
+})

package/src/__tests__/rs-table-grid-nav.spec.ts

@@ -0,0 +1,63 @@
+import { describe, expect, it } from 'vitest'
+import {
+  navigateGridCell,
+  resolveGridNavDirection,
+} from '../components/table/rs-table-grid-nav'
+
+const rows = [
+  { rowKey: '1', rowIndex: 0 },
+  { rowKey: '2', rowIndex: 1 },
+  { rowKey: '3', rowIndex: 2 },
+]
+const cols = ['a', 'b', 'c']
+
+describe('navigateGridCell', () => {
+  it('无焦点时以左上角为种子', () => {
+    expect(navigateGridCell(rows, cols, null, 'right')).toEqual({
+      rowKey: '1',
+      colKey: 'b',
+      rowIndex: 0,
+    })
+  })
+
+  it('箭头在边界钳制', () => {
+    const at = { rowKey: '1', colKey: 'a', rowIndex: 0 }
+    expect(navigateGridCell(rows, cols, at, 'left')?.colKey).toBe('a')
+    expect(navigateGridCell(rows, cols, at, 'up')?.rowKey).toBe('1')
+    const br = { rowKey: '3', colKey: 'c', rowIndex: 2 }
+    expect(navigateGridCell(rows, cols, br, 'right')?.colKey).toBe('c')
+    expect(navigateGridCell(rows, cols, br, 'down')?.rowKey).toBe('3')
+  })
+
+  it('Home/End 与 Ctrl 角点', () => {
+    const mid = { rowKey: '2', colKey: 'b', rowIndex: 1 }
+    expect(navigateGridCell(rows, cols, mid, 'home')?.colKey).toBe('a')
+    expect(navigateGridCell(rows, cols, mid, 'end')?.colKey).toBe('c')
+    expect(navigateGridCell(rows, cols, mid, 'first')).toEqual({
+      rowKey: '1',
+      colKey: 'a',
+      rowIndex: 0,
+    })
+    expect(navigateGridCell(rows, cols, mid, 'last')).toEqual({
+      rowKey: '3',
+      colKey: 'c',
+      rowIndex: 2,
+    })
+  })
+
+  it('PageDown 按 pageSize 跳行', () => {
+    const at = { rowKey: '1', colKey: 'a', rowIndex: 0 }
+    expect(navigateGridCell(rows, cols, at, 'pageDown', 2)?.rowKey).toBe('3')
+  })
+})
+
+describe('resolveGridNavDirection', () => {
+  it('映射常用键', () => {
+    expect(resolveGridNavDirection({ key: 'ArrowRight' } as KeyboardEvent)).toBe('right')
+    expect(resolveGridNavDirection({ key: 'Home' } as KeyboardEvent)).toBe('home')
+    expect(resolveGridNavDirection({ key: 'Home', ctrlKey: true } as KeyboardEvent)).toBe(
+      'first',
+    )
+    expect(resolveGridNavDirection({ key: 'a' } as KeyboardEvent)).toBeNull()
+  })
+})

package/src/__tests__/rs-table-isolation.spec.ts

@@ -0,0 +1,158 @@
+import { mount } from '@vue/test-utils'
+import { defineComponent, h, nextTick } from 'vue'
+import { describe, expect, it, beforeEach } from 'vitest'
+import RsTable from '../components/RsTable.vue'
+import { createRsTableFeatureHost } from '../components/table/rs-table-feature-host'
+import {
+  resolveInstanceFeatures,
+  RsTableModuleRegistry,
+} from '../components/table/rs-table-module-registry'
+import {
+  createOverlayTableFeature,
+  createToolbarTableFeature,
+} from '../components/table/table-features'
+import { useRsTableHeadless } from '../composables/useRsTableHeadless'
+import type { RsTableRowData } from '../components/table-utils'
+
+type Row = RsTableRowData & { id: string; name: string }
+
+const columns = [{ key: 'name', title: 'Name' }]
+
+function analyticsStub() {
+  return {
+    getViewRows: () => [] as Row[],
+    getSelectedRows: () => [] as Row[],
+    getAnalyticsSnapshot: () => ({
+      sourceRows: [] as Row[],
+      viewRows: [] as Row[],
+      selectedRows: [] as Row[],
+      sourceMode: 'view' as const,
+      selectedCount: 0,
+      viewCount: 0,
+    }),
+    subscribeAnalytics: () => () => undefined,
+  }
+}
+
+describe('RsTable 多表隔离', () => {
+  beforeEach(() => {
+    RsTableModuleRegistry.clear()
+  })
+
+  it('两个 FeatureHost 贡献袋互不污染', () => {
+    const a = createRsTableFeatureHost<Row>()
+    const b = createRsTableFeatureHost<Row>()
+    const stub = analyticsStub()
+    a.setup(
+      [createToolbarTableFeature({ items: [{ key: 'a-only', label: 'A' }] })],
+      a.createContext(stub),
+    )
+    b.setup(
+      [createToolbarTableFeature({ items: [{ key: 'b-only', label: 'B' }] })],
+      b.createContext(stub),
+    )
+    expect(a.getToolbarItems().map((i) => i.key)).toEqual(['a-only'])
+    expect(b.getToolbarItems().map((i) => i.key)).toEqual(['b-only'])
+  })
+
+  it('同页两表选中与 viewRows 互不影响', async () => {
+    const t1 = mount(RsTable, {
+      props: {
+        columns,
+        data: [{ id: '1', name: 'a' }] as Row[],
+        rowKey: 'id',
+        selectable: true,
+        selectedRowKeys: ['1'],
+      },
+    })
+    const t2 = mount(RsTable, {
+      props: {
+        columns,
+        data: [{ id: '2', name: 'b' }] as Row[],
+        rowKey: 'id',
+        selectable: true,
+        selectedRowKeys: [],
+      },
+    })
+    await nextTick()
+
+    const api1 = t1.vm as unknown as {
+      getSelectedRowKeys: () => string[]
+      getViewRows: () => Row[]
+      getToolbarItems: () => Array<{ key: string }>
+    }
+    const api2 = t2.vm as unknown as {
+      getSelectedRowKeys: () => string[]
+      getViewRows: () => Row[]
+    }
+    expect(api1.getSelectedRowKeys()).toEqual(['1'])
+    expect(api2.getSelectedRowKeys()).toEqual([])
+    expect(api1.getViewRows()[0]?.id).toBe('1')
+    expect(api2.getViewRows()[0]?.id).toBe('2')
+
+    t1.unmount()
+    t2.unmount()
+  })
+
+  it('ModuleRegistry 全局生效；实例同 id 可覆盖', () => {
+    RsTableModuleRegistry.register(
+      createOverlayTableFeature({
+        items: [{ key: 'global-chart', slot: 'chart' }],
+      }),
+    )
+    const hostA = createRsTableFeatureHost<Row>()
+    const hostB = createRsTableFeatureHost<Row>()
+    const stub = analyticsStub()
+    const featuresA = resolveInstanceFeatures<Row>([
+      createOverlayTableFeature({
+        id: 'overlayExtra',
+        items: [{ key: 'a-chart', slot: 'chart-a' }],
+      }),
+    ])
+    const featuresB = resolveInstanceFeatures<Row>([])
+    hostA.setup(featuresA, hostA.createContext(stub))
+    hostB.setup(featuresB, hostB.createContext(stub))
+    expect(hostA.getOverlayContributions().map((i) => i.key)).toEqual(['a-chart'])
+    expect(hostB.getOverlayContributions().map((i) => i.key)).toEqual(['global-chart'])
+  })
+
+  it('useRsTableHeadless 两实例状态与 toolbar 隔离', async () => {
+    const Host = defineComponent({
+      setup() {
+        const h1 = useRsTableHeadless<Row>({
+          columns: () => columns,
+          data: () => [{ id: '1', name: 'a' }],
+          rowKey: 'id',
+          features: () => [
+            createToolbarTableFeature({ items: [{ key: 't1', label: 'T1' }] }),
+          ],
+        })
+        const h2 = useRsTableHeadless<Row>({
+          columns: () => columns,
+          data: () => [
+            { id: '2', name: 'b' },
+            { id: '3', name: 'c' },
+          ],
+          rowKey: 'id',
+          features: () => [
+            createToolbarTableFeature({ items: [{ key: 't2', label: 'T2' }] }),
+          ],
+        })
+        return () =>
+          h('div', {
+            'data-v1': String(h1.api.getViewRows().length),
+            'data-v2': String(h2.api.getViewRows().length),
+            'data-t1': h1.getToolbarItems()[0]?.key ?? '',
+            'data-t2': h2.getToolbarItems()[0]?.key ?? '',
+          })
+      },
+    })
+    const wrapper = mount(Host)
+    await nextTick()
+    expect(wrapper.attributes('data-v1')).toBe('1')
+    expect(wrapper.attributes('data-v2')).toBe('2')
+    expect(wrapper.attributes('data-t1')).toBe('t1')
+    expect(wrapper.attributes('data-t2')).toBe('t2')
+    wrapper.unmount()
+  })
+})

package/src/__tests__/split-pane-utils.spec.ts

@@ -51,6 +51,27 @@ describe('normalizeSplitSizes', () => {
     const sizes = normalizeSplitSizes([{ key: 'a', size: 0 }, { key: 'b', size: 0 }])
     expect(sizes).toEqual([50, 50])
   })
+
+  it('keeps auto panes out of percentage pool', () => {
+    const sizes = normalizeSplitSizes([
+      { key: 'search', size: 'auto' },
+      { key: 'table' },
+    ])
+    expect(sizes[0]).toBe(0)
+    expect(sizes[1]).toBeCloseTo(100)
+  })
+
+  it('distributes remaining percent among non-auto panes only', () => {
+    const sizes = normalizeSplitSizes([
+      { key: 'a', size: 'auto' },
+      { key: 'b', size: 40 },
+      { key: 'c' },
+    ])
+    expect(sizes[0]).toBe(0)
+    expect(sizes[1]).toBeCloseTo(40)
+    expect(sizes[2]).toBeCloseTo(60)
+    expect(sizes[1]! + sizes[2]!).toBeCloseTo(100)
+  })
 })
 
 describe('applySplitResize', () => {

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

@@ -0,0 +1,88 @@
+import { describe, expect, it } from 'vitest'
+import { ref } from 'vue'
+import { buildTableChartSeries } from '../components/table/table-chart-utils'
+import { useRsTableChartBridge } from '../composables/useRsTableChartBridge'
+import { useRsTableSelectionSource } from '../composables/useRsTableSelectionSource'
+
+const rows = [
+  { id: '1', status: 'ok', amount: 10 },
+  { id: '2', status: 'ok', amount: 20 },
+  { id: '3', status: 'wait', amount: 5 },
+  { id: '4', status: 'wait', amount: 15 },
+  { id: '5', status: 'fail', amount: 3 },
+]
+
+describe('buildTableChartSeries', () => {
+  it('groups by category with count', () => {
+    const series = buildTableChartSeries(rows, {
+      id: 'by-status',
+      kind: 'pie',
+      categoryField: 'status',
+      valueAgg: 'count',
+    })
+    expect(series.kind).toBe('pie')
+    expect(series.categories).toEqual(['ok', 'wait', 'fail'])
+    expect(series.values).toEqual([2, 2, 1])
+  })
+
+  it('sums valueField for bar', () => {
+    const series = buildTableChartSeries(rows, {
+      id: 'amount',
+      kind: 'bar',
+      categoryField: 'status',
+      valueField: 'amount',
+      valueAgg: 'sum',
+    })
+    const byName = Object.fromEntries(series.points.map((p) => [p.name, p.value]))
+    expect(byName.ok).toBe(30)
+    expect(byName.wait).toBe(20)
+    expect(byName.fail).toBe(3)
+  })
+
+  it('merges tail into other when topN set', () => {
+    const series = buildTableChartSeries(rows, {
+      id: 'top1',
+      kind: 'pie',
+      categoryField: 'status',
+      valueAgg: 'count',
+      topN: 1,
+      otherLabel: '其余',
+    })
+    expect(series.points).toHaveLength(2)
+    expect(series.points[0]?.name).toBe('ok')
+    expect(series.points[1]?.name).toBe('其余')
+    expect(series.points[1]?.value).toBe(3)
+  })
+})
+
+describe('useRsTableSelectionSource', () => {
+  it('prefers selected rows as source', () => {
+    const viewRows = ref(rows)
+    const selectedRows = ref([rows[2]!])
+    const src = useRsTableSelectionSource({ viewRows, selectedRows })
+    expect(src.sourceMode.value).toBe('selected')
+    expect(src.sourceRows.value).toEqual([rows[2]])
+    selectedRows.value = []
+    expect(src.sourceMode.value).toBe('view')
+    expect(src.sourceRows.value).toHaveLength(5)
+  })
+})
+
+describe('useRsTableChartBridge', () => {
+  it('rebuilds pie series when selection changes', () => {
+    const viewRows = ref(rows)
+    const selectedRows = ref<typeof rows>([])
+    const bridge = useRsTableChartBridge({
+      viewRows,
+      selectedRows,
+      seriesDefs: [
+        { id: 'status-pie', kind: 'pie', categoryField: 'status', valueAgg: 'count' },
+      ],
+    })
+    expect(bridge.series.value[0]?.values).toEqual([2, 2, 1])
+    selectedRows.value = [rows[0]!, rows[1]!]
+    expect(bridge.sourceMode.value).toBe('selected')
+    expect(bridge.series.value[0]?.categories).toEqual(['ok'])
+    expect(bridge.series.value[0]?.values).toEqual([2])
+  })
+})

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

@@ -0,0 +1,62 @@
+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,9 +1,14 @@
 import { describe, expect, it } from 'vitest'
 import {
   buildTableEntries,
+  buildTableTreeEntries,
+  buildTableTreeNodeIndex,
   clampColumnWidth,
+  collectTableTreeExpandableKeys,
   filterTableRows,
   filterTableRowsByColumnFilters,
+  filterTableTreeRows,
+  flattenVisibleTableTreeEntries,
   isColumnFilterActive,
   fixedCellStyle,
   groupTableRows,
@@ -12,6 +17,7 @@ import {
   resolveFixedColumnStyles,
   resolveSelectableRowKeys,
   resolveSelectAllState,
+  resolveTableTreeCheckState,
   resolveTableVirtualEnabled,
   selectRowKeys,
   selectRowKeysByClick,
@@ -22,6 +28,7 @@ import {
   toggleRowSelection,
   toggleSelectAll,
   toggleSortState,
+  toggleTableTreeCheck,
   reorderColumnKeys,
   reorderTableRows,
   resolveColumnOrder,
@@ -283,4 +290,121 @@ describe('table-utils', () => {
     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'])
+  })
 })

package/src/__tests__/theme.spec.ts

@@ -1,6 +1,13 @@
 import { describe, expect, it } from 'vitest'
 import { createRsConfigState } from '../composables/useRsConfig'
 import { applyTheme } from '../theme/apply'
+import { themePresets } from '../theme/presets'
+import {
+  RS_FONT_SIZES,
+  RS_FONT_SIZE_CSS,
+  RS_FONT_WEIGHTS,
+  RS_FONT_WEIGHT_CSS,
+} from '../theme/types'
 
 describe('useRsConfig / theme', () => {
   it('translates by locale', () => {
@@ -19,4 +26,22 @@ describe('useRsConfig / theme', () => {
     applyTheme('dark')
     expect(document.documentElement.dataset.rsTheme).toBe('dark')
   })
+
+  it('exposes typography token ladders', () => {
+    expect(RS_FONT_SIZES).toEqual(['xs', 'sm', 'base', 'lg', 'xl', '2xl', '3xl'])
+    expect(RS_FONT_SIZE_CSS['3xl']).toBe('var(--rs-font-size-3xl)')
+    expect(RS_FONT_WEIGHTS).toEqual(['regular', 'medium', 'semibold', 'bold'])
+    expect(RS_FONT_WEIGHT_CSS.semibold).toBe('var(--rs-font-weight-semibold)')
+  })
+
+  it('theme presets include text semantic fields', () => {
+    for (const mode of ['light', 'dark'] as const) {
+      const p = themePresets[mode]
+      expect(p.text).toBeTruthy()
+      expect(p.muted).toBeTruthy()
+      expect(p.placeholder).toBeTruthy()
+      expect(p.textDisabled).toBeTruthy()
+      expect(p.textInverse).toBe('#ffffff')
+    }
+  })
 })

package/src/__tests__/useRsTableColumnResize.spec.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from 'vitest'
+import { measureRsTablePrefixWidth } from '../composables/useRsTableColumnVirtual'
+
+describe('measureRsTablePrefixWidth', () => {
+  it('sums visible prefix columns only', () => {
+    expect(
+      measureRsTablePrefixWidth({
+        showRowDragHandle: true,
+        detailExpandable: true,
+        showSelectColumn: true,
+        showIndexColumn: true,
+        indexWidth: 48,
+      }),
+    ).toBe(40 + 40 + 40 + 48)
+
+    expect(
+      measureRsTablePrefixWidth({
+        showEditGutterColumn: true,
+        gutterWidth: 32,
+        showIndexColumn: true,
+        indexWidth: 48,
+      }),
+    ).toBe(32)
+  })
+})