niuma-ui 1.0.0

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

@@ -0,0 +1,136 @@
+import { describe, expect, it } from 'vitest'
+import {
+  applySplitResize,
+  collapseSplitPane,
+  expandSplitPane,
+  isSplitPaneCollapsed,
+  normalizeSplitSizes,
+  resolveSplitConstraints,
+  splitSizesEqual,
+  type RsSplitPaneItem,
+} from '../components/split-pane-utils'
+
+const sum = (values: number[]) => values.reduce((acc, value) => acc + value, 0)
+
+describe('resolveSplitConstraints', () => {
+  it('applies defaults and clamps ranges', () => {
+    const result = resolveSplitConstraints([{ key: 'a' }])
+    expect(result[0]).toEqual({ min: 0, max: 100, collapsible: false, collapsedSize: 0 })
+  })
+
+  it('orders swapped min/max and caps collapsedSize at min', () => {
+    const result = resolveSplitConstraints([
+      { key: 'a', min: 60, max: 20, collapsible: true, collapsedSize: 40 },
+    ])
+    expect(result[0]).toEqual({ min: 20, max: 60, collapsible: true, collapsedSize: 20 })
+  })
+})
+
+describe('normalizeSplitSizes', () => {
+  it('distributes remaining space to unspecified panes', () => {
+    const panes: RsSplitPaneItem[] = [{ key: 'a', size: 40 }, { key: 'b' }, { key: 'c' }]
+    const sizes = normalizeSplitSizes(panes)
+    expect(sum(sizes)).toBeCloseTo(100)
+    expect(sizes[0]).toBeCloseTo(40)
+    expect(sizes[1]).toBeCloseTo(30)
+    expect(sizes[2]).toBeCloseTo(30)
+  })
+
+  it('rescales values that do not sum to 100', () => {
+    const sizes = normalizeSplitSizes([{ key: 'a', size: 1 }, { key: 'b', size: 3 }])
+    expect(sizes).toEqual([25, 75])
+  })
+
+  it('prefers provided (controlled) sizes over pane defaults', () => {
+    const panes: RsSplitPaneItem[] = [{ key: 'a', size: 20 }, { key: 'b', size: 80 }]
+    const sizes = normalizeSplitSizes(panes, [50, 50])
+    expect(sizes).toEqual([50, 50])
+  })
+
+  it('falls back to equal split when all sizes are zero', () => {
+    const sizes = normalizeSplitSizes([{ key: 'a', size: 0 }, { key: 'b', size: 0 }])
+    expect(sizes).toEqual([50, 50])
+  })
+})
+
+describe('applySplitResize', () => {
+  const constraints = resolveSplitConstraints([{ key: 'a' }, { key: 'b' }])
+
+  it('moves space between adjacent panes and preserves total', () => {
+    const next = applySplitResize([50, 50], constraints, 0, 10)
+    expect(next).toEqual([60, 40])
+    expect(sum(next)).toBe(100)
+  })
+
+  it('is immutable', () => {
+    const input = [50, 50]
+    const next = applySplitResize(input, constraints, 0, 10)
+    expect(input).toEqual([50, 50])
+    expect(next).not.toBe(input)
+  })
+
+  it('respects min/max of both neighbors', () => {
+    const bounded = resolveSplitConstraints([
+      { key: 'a', min: 30 },
+      { key: 'b', min: 30 },
+    ])
+    expect(applySplitResize([50, 50], bounded, 0, -40)).toEqual([30, 70])
+    expect(applySplitResize([50, 50], bounded, 0, 40)).toEqual([70, 30])
+  })
+
+  it('ignores dividers that are out of range', () => {
+    expect(applySplitResize([50, 50], constraints, 1, 10)).toEqual([50, 50])
+    expect(applySplitResize([50, 50], constraints, -1, 10)).toEqual([50, 50])
+  })
+
+  it('snaps a collapsible pane to collapsedSize past the halfway threshold', () => {
+    const collapsible = resolveSplitConstraints([
+      { key: 'a', min: 20, collapsible: true, collapsedSize: 0 },
+      { key: 'b' },
+    ])
+    // 50 - 45 = 5 < (20+0)/2 = 10 → 折叠到 0
+    expect(applySplitResize([50, 50], collapsible, 0, -45)).toEqual([0, 100])
+    // 50 - 38 = 12 > 10 → 夹到 min 20
+    expect(applySplitResize([50, 50], collapsible, 0, -38)).toEqual([20, 80])
+  })
+})
+
+describe('collapseSplitPane / expandSplitPane', () => {
+  const constraints = resolveSplitConstraints([
+    { key: 'a', min: 20, collapsible: true, collapsedSize: 0 },
+    { key: 'b' },
+  ])
+
+  it('collapses to collapsedSize and gives space to the neighbor', () => {
+    expect(collapseSplitPane([40, 60], constraints, 0)).toEqual([0, 100])
+  })
+
+  it('expands back to min by default', () => {
+    expect(expandSplitPane([0, 100], constraints, 0)).toEqual([20, 80])
+  })
+
+  it('expands to an explicit size clamped within bounds', () => {
+    expect(expandSplitPane([0, 100], constraints, 0, 35)).toEqual([35, 65])
+  })
+})
+
+describe('isSplitPaneCollapsed', () => {
+  const [collapsible, plain] = resolveSplitConstraints([
+    { key: 'a', collapsible: true, collapsedSize: 0 },
+    { key: 'b' },
+  ])
+
+  it('is true only for collapsible panes at collapsedSize', () => {
+    expect(isSplitPaneCollapsed(0, collapsible)).toBe(true)
+    expect(isSplitPaneCollapsed(10, collapsible)).toBe(false)
+    expect(isSplitPaneCollapsed(0, plain)).toBe(false)
+  })
+})
+
+describe('splitSizesEqual', () => {
+  it('compares with tolerance', () => {
+    expect(splitSizesEqual([50, 50], [50.005, 49.995])).toBe(true)
+    expect(splitSizesEqual([50, 50], [60, 40])).toBe(false)
+    expect(splitSizesEqual([50], [50, 50])).toBe(false)
+  })
+})

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

@@ -0,0 +1,35 @@
+import { describe, expect, it } from 'vitest'
+import {
+  resolveDragRowKeys,
+  resolveTableRowDropPosition,
+} from '../components/table-drag'
+
+describe('table-drag', () => {
+  it('resolves reorder drop position from pointer', () => {
+    const element = {
+      getBoundingClientRect: () => ({ top: 0, height: 100 }),
+    } as HTMLElement
+
+    expect(
+      resolveTableRowDropPosition({ clientY: 20 } as MouseEvent, element, 'reorder'),
+    ).toBe('before')
+    expect(
+      resolveTableRowDropPosition({ clientY: 80 } as MouseEvent, element, 'reorder'),
+    ).toBe('after')
+  })
+
+  it('uses into position for folder drop mode', () => {
+    const element = {
+      getBoundingClientRect: () => ({ top: 0, height: 100 }),
+    } as HTMLElement
+
+    expect(
+      resolveTableRowDropPosition({ clientY: 20 } as MouseEvent, element, 'into'),
+    ).toBe('into')
+  })
+
+  it('drags all selected rows when dragging a selected row', () => {
+    expect(resolveDragRowKeys('b', ['a', 'b', 'c'])).toEqual(['a', 'b', 'c'])
+    expect(resolveDragRowKeys('d', ['a', 'b', 'c'])).toEqual(['d'])
+  })
+})

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

@@ -0,0 +1,194 @@
+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-utils.spec.ts

@@ -0,0 +1,286 @@
+import { describe, expect, it } from 'vitest'
+import {
+  buildTableEntries,
+  clampColumnWidth,
+  filterTableRows,
+  filterTableRowsByColumnFilters,
+  isColumnFilterActive,
+  fixedCellStyle,
+  groupTableRows,
+  injectExpandRows,
+  isNearScrollBottom,
+  resolveFixedColumnStyles,
+  resolveSelectableRowKeys,
+  resolveSelectAllState,
+  resolveTableVirtualEnabled,
+  selectRowKeys,
+  selectRowKeysByClick,
+  sliceVirtualColumns,
+  sliceVirtualTableEntries,
+  sortTableRows,
+  toggleMultiSortState,
+  toggleRowSelection,
+  toggleSelectAll,
+  toggleSortState,
+  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')
+  })
+})

package/src/__tests__/theme.spec.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'vitest'
+import { createRsConfigState } from '../composables/useRsConfig'
+import { applyTheme } from '../theme/apply'
+
+describe('useRsConfig / theme', () => {
+  it('translates by locale', () => {
+    const zh = createRsConfigState('dark', 'zh-CN')
+    const en = createRsConfigState('dark', 'en-US')
+    expect(zh.t('select.placeholder')).toBe('请选择')
+    expect(en.t('select.placeholder')).toBe('Select')
+    expect(zh.t('input.required')).toBe('此项为必填')
+    expect(en.t('input.required')).toBe('This field is required')
+    expect(en.t('breadcrumb.label')).toBe('Breadcrumb')
+  })
+
+  it('applyTheme sets data-rs-theme on element', () => {
+    applyTheme('light')
+    expect(document.documentElement.dataset.rsTheme).toBe('light')
+    applyTheme('dark')
+    expect(document.documentElement.dataset.rsTheme).toBe('dark')
+  })
+})