niuma-ui 1.1.11 → 1.2.0

package/src/__tests__/rs-table-compat-matrix.spec.ts

@@ -1,108 +0,0 @@
-import { mount } from '@vue/test-utils'
-import { describe, expect, it } from 'vitest'
-import RsTable from '../components/RsTable.vue'
-import {
-  RS_TABLE_API_VERSION,
-  isRsTableApi,
-} from '../components/table/rs-table-api'
-import {
-  RS_TABLE_API_OPTIONAL_METHODS,
-  RS_TABLE_API_REQUIRED_METHODS,
-  RS_TABLE_COMPAT_API_VERSION,
-  RS_TABLE_DEFAULTED_PROP_KEYS,
-  RS_TABLE_STABLE_EMITS,
-} from '../components/table/rs-table-compat-matrix'
-import { RS_TABLE_PROP_DEFAULTS } from '../components/table/rs-table-props'
-
-describe('RsTable 兼容矩阵（自动化）', () => {
-  it('契约版本与 Api 常量一致', () => {
-    expect(RS_TABLE_COMPAT_API_VERSION).toBe(RS_TABLE_API_VERSION)
-    expect(RS_TABLE_API_VERSION).toBe('1.0.0')
-  })
-
-  it('PROP_DEFAULTS 键与矩阵锁定列表一致', () => {
-    expect(Object.keys(RS_TABLE_PROP_DEFAULTS).sort()).toEqual(RS_TABLE_DEFAULTED_PROP_KEYS)
-  })
-
-  it('expose 满足必选 Api 方法且可选方法为函数或 undefined', async () => {
-    const wrapper = mount(RsTable, {
-      props: {
-        columns: [{ key: 'name', title: 'Name' }],
-        data: [{ id: '1', name: 'a' }],
-        rowKey: 'id',
-        selectable: true,
-      },
-    })
-    await wrapper.vm.$nextTick()
-    const api = wrapper.vm as unknown as Record<string, unknown>
-    expect(isRsTableApi(api)).toBe(true)
-    expect(api.apiVersion).toBe(RS_TABLE_API_VERSION)
-
-    for (const method of RS_TABLE_API_REQUIRED_METHODS) {
-      expect(typeof api[method], `required ${method}`).toBe('function')
-    }
-    for (const method of RS_TABLE_API_OPTIONAL_METHODS) {
-      const value = api[method]
-      expect(
-        value === undefined || typeof value === 'function',
-        `optional ${method}`,
-      ).toBe(true)
-    }
-
-    // 冒烟：查询路径可调用
-    expect((api.getViewRows as () => unknown[])()).toHaveLength(1)
-    expect((api.getSelectedRowKeys as () => string[])()).toEqual([])
-    wrapper.unmount()
-  })
-
-  it('稳定 emit 名仍可被组件声明（defineEmits 面）', () => {
-    // 通过挂载监听稳定事件，确保名称未从运行时面消失
-    const wrapper = mount(RsTable, {
-      props: {
-        columns: [{ key: 'name', title: 'Name' }],
-        data: [{ id: '1', name: 'a' }],
-        rowKey: 'id',
-      },
-    })
-    for (const name of RS_TABLE_STABLE_EMITS) {
-      expect(wrapper.emitted(name) === undefined || Array.isArray(wrapper.emitted(name))).toBe(
-        true,
-      )
-    }
-    // 触发一次 rowClick 验证核心 emit 通路
-    const row = wrapper.find('.rs-table__row')
-    if (row.exists()) {
-      void row.trigger('click')
-    }
-    wrapper.unmount()
-  })
-
-  it('必选 Api 方法列表快照（防静默删减）', () => {
-    expect([...RS_TABLE_API_REQUIRED_METHODS]).toMatchInlineSnapshot(`
-      [
-        "getRowByKey",
-        "getRowByIndex",
-        "getColumnValues",
-        "getCellValue",
-        "getViewRows",
-        "getSelectedRows",
-        "getSelectedRowKeys",
-        "getAnalyticsSnapshot",
-        "subscribeAnalytics",
-        "getHighlightedRowKey",
-        "setHighlightedRowKey",
-        "cancelCellEdit",
-        "cancelAllEdits",
-        "getDirtyCellKeys",
-        "getCellError",
-        "setCellError",
-        "stageCell",
-        "rejectRowEdit",
-        "undoEdit",
-        "redoEdit",
-        "commitRowEdits",
-        "rollbackRowEdits",
-      ]
-    `)
-  })
-})

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

@@ -1,43 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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

@@ -1,158 +0,0 @@
-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__/rs-table-slots.types.spec.ts

@@ -1,20 +0,0 @@
-import { describe, expectTypeOf, it } from 'vitest'
-import type {
-  RsTableColumnSlotProps,
-  RsTableSlots,
-} from '../components/table/rs-table-props'
-
-describe('RsTable slot types', () => {
-  it('column slot row is the table generic', () => {
-    type Row = { id: string; name: string }
-    expectTypeOf<RsTableColumnSlotProps<Row>['row']>().toEqualTypeOf<Row>()
-    expectTypeOf<RsTableColumnSlotProps<Row>['index']>().toEqualTypeOf<number>()
-  })
-
-  it('named column slots stay callable with the row generic', () => {
-    type Row = { id: string; name: string }
-    type NameSlot = NonNullable<RsTableSlots<Row>['name']>
-    expectTypeOf<NameSlot>().toBeFunction()
-    expectTypeOf<NameSlot>().parameter(0).toMatchTypeOf<{ row: Row; index: number }>()
-  })
-})

package/src/__tests__/setup.ts

@@ -1,12 +0,0 @@
-/** jsdom 不实现 ResizeObserver，此处提供最小 mock 供组件初始化使用。 */
-class ResizeObserverMock {
-  observe() {}
-  unobserve() {}
-  disconnect() {}
-}
-
-Object.defineProperty(globalThis, 'ResizeObserver', {
-  writable: true,
-  configurable: true,
-  value: ResizeObserverMock,
-})

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

@@ -1,157 +0,0 @@
-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])
-  })
-
-  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', () => {
-  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-chart-utils.spec.ts

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

@@ -1,35 +0,0 @@
-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'])
-  })
-})