niuma-ui 1.0.1 → 1.1.0

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

@@ -0,0 +1,206 @@
+import { mount } from '@vue/test-utils'
+import { describe, expect, it, beforeEach } from 'vitest'
+import RsTable from '../components/RsTable.vue'
+import { createRsTableApi, isRsTableApi, RS_TABLE_API_VERSION } from '../components/table/rs-table-api'
+import { createRsTableFeatureHost } from '../components/table/rs-table-feature-host'
+import { RsTableModuleRegistry, resolveInstanceFeatures } from '../components/table/rs-table-module-registry'
+import {
+  createAnalyticsTableFeature,
+  createChartSeriesTableFeature,
+  createContextMenuTableFeature,
+} from '../components/table/table-features'
+import type { RsTableRowData } from '../components/table-utils'
+import { useRsTable } from '../composables/useRsTable'
+
+type Row = RsTableRowData & { id: string; name: string }
+
+function stubAnalytics() {
+  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('RsTableApi / FeatureHost / ModuleRegistry', () => {
+  beforeEach(() => {
+    RsTableModuleRegistry.clear()
+  })
+
+  it('createRsTableApi 冻结 apiVersion 与查询方法', () => {
+    const api = createRsTableApi<Row>({
+      getRowByKey: () => undefined,
+      getRowByIndex: () => undefined,
+      getColumnValues: () => [],
+      getCellValue: () => undefined,
+      getViewRows: () => [],
+      getSelectedRows: () => [],
+      getSelectedRowKeys: () => [],
+      getAnalyticsSnapshot: stubAnalytics().getAnalyticsSnapshot,
+      subscribeAnalytics: stubAnalytics().subscribeAnalytics,
+      getHighlightedRowKey: () => undefined,
+      setHighlightedRowKey: () => undefined,
+      cancelCellEdit: () => undefined,
+      cancelAllEdits: () => undefined,
+      getDirtyCellKeys: () => [],
+      getCellError: () => undefined,
+      setCellError: () => undefined,
+      stageCell: () => undefined,
+      rejectRowEdit: () => undefined,
+      undoEdit: () => undefined,
+      redoEdit: () => undefined,
+      commitRowEdits: () => undefined,
+      rollbackRowEdits: () => undefined,
+    })
+    expect(api.apiVersion).toBe(RS_TABLE_API_VERSION)
+    expect(isRsTableApi(api)).toBe(true)
+    expect(isRsTableApi({})).toBe(false)
+  })
+
+  it('FeatureHost 收集 contextMenu 贡献并 merge', () => {
+    const host = createRsTableFeatureHost<Row>()
+    const ctx = host.createContext(stubAnalytics())
+    host.setup(
+      [
+        {
+          id: 'export-row',
+          setup(featureCtx) {
+            featureCtx.contributeContextMenuItems?.((items) => {
+              items.push({ key: 'export', label: '导出' })
+            })
+          },
+        },
+      ],
+      ctx,
+    )
+    const merged = host.mergeContextMenuItems(
+      [{ key: 'copy', label: '复制' }],
+      { row: null, selectedRows: [] },
+    )
+    expect(merged.map((i) => i.key)).toEqual(['copy', '__ctx-feature-sep', 'export'])
+    expect(host.getActiveFeatureIds()).toEqual(['export-row'])
+  })
+
+  it('ModuleRegistry 全局注册并被 resolveInstanceFeatures 合并', () => {
+    const analytics = createAnalyticsTableFeature<Row>({
+      onSnapshot: () => undefined,
+    })
+    RsTableModuleRegistry.register(analytics)
+    expect(RsTableModuleRegistry.listIds()).toContain('analytics')
+
+    const resolved = resolveInstanceFeatures<Row>([
+      { id: 'local', setup() {} },
+    ])
+    expect(resolved.map((f) => f.id).sort()).toEqual(['analytics', 'local'])
+
+    const override = resolveInstanceFeatures<Row>([
+      {
+        id: 'analytics',
+        setup() {},
+      },
+    ])
+    expect(override.find((f) => f.id === 'analytics')?.setup).not.toBe(analytics.setup)
+  })
+
+  it('useRsTable.bindFeatures 合并内置与全局模块', () => {
+    RsTableModuleRegistry.register({
+      id: 'plugin-a',
+      setup() {},
+    })
+    const surface = useRsTable<Row>()
+    const dispose = surface.bindFeatures({
+      builtinIds: ['selection'],
+      instanceFeatures: [{ id: 'local', setup() {} }],
+      ...stubAnalytics(),
+    })
+    expect(surface.getActiveFeatureIds()).toEqual(
+      expect.arrayContaining(['selection', 'plugin-a', 'local']),
+    )
+    dispose()
+    expect(surface.getActiveFeatureIds()).toEqual([])
+  })
+
+  it('createChartSeriesTableFeature 产出 series 并登记 overlay', () => {
+    const host = createRsTableFeatureHost<Row>()
+    const seriesSeen: string[] = []
+    const ctx = host.createContext({
+      ...stubAnalytics(),
+      getAnalyticsSnapshot: () => ({
+        sourceRows: [
+          { id: '1', name: 'a' },
+          { id: '2', name: 'a' },
+          { id: '3', name: 'b' },
+        ] as Row[],
+        viewRows: [],
+        selectedRows: [],
+        sourceMode: 'view',
+        selectedCount: 0,
+        viewCount: 0,
+      }),
+      subscribeAnalytics: (listener) => {
+        listener({
+          sourceRows: [
+            { id: '1', name: 'a' },
+            { id: '2', name: 'a' },
+            { id: '3', name: 'b' },
+          ] as Row[],
+          viewRows: [],
+          selectedRows: [],
+          sourceMode: 'view',
+          selectedCount: 0,
+          viewCount: 0,
+        })
+        return () => undefined
+      },
+    })
+    host.setup(
+      [
+        createChartSeriesTableFeature<Row>({
+          seriesDefs: [{ id: 'by-name', kind: 'pie', categoryField: 'name' }],
+          onSeries: (series) => {
+            seriesSeen.push(...series.map((s) => s.id))
+          },
+        }),
+      ],
+      ctx,
+    )
+    expect(seriesSeen).toEqual(['by-name'])
+    expect(host.getOverlayContributions().map((i) => i.key)).toEqual(['chart'])
+  })
+
+  it('RsTable expose 符合 RsTableApi 契约', async () => {
+    const wrapper = mount(RsTable, {
+      props: {
+        columns: [{ key: 'name', title: 'Name' }],
+        data: [{ id: '1', name: 'a' }],
+        rowKey: 'id',
+        selectable: true,
+        features: [
+          createContextMenuTableFeature({
+            items: [{ key: 'ping', label: 'Ping' }],
+          }),
+        ],
+      },
+    })
+    await wrapper.vm.$nextTick()
+    const api = wrapper.vm as unknown as {
+      apiVersion: string
+      getViewRows: () => Row[]
+      getSelectedRowKeys: () => string[]
+      getActiveFeatureIds: () => string[]
+    }
+    expect(api.apiVersion).toBe(RS_TABLE_API_VERSION)
+    expect(isRsTableApi(api)).toBe(true)
+    expect(api.getViewRows().length).toBe(1)
+    expect(api.getSelectedRowKeys()).toEqual([])
+    expect(api.getActiveFeatureIds()).toEqual(expect.arrayContaining(['contextMenuExtra']))
+  })
+})

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

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

@@ -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])
+  })
+})