niuma-ui 1.0.0 → 1.0.2

package/src/__tests__/RsUpload.spec.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from 'vitest'
+import { describe, expect, it, vi } from 'vitest'
 import { h } from 'vue'
 import { mount } from '@vue/test-utils'
 import RsConfigProvider from '../components/RsConfigProvider.vue'
@@ -8,6 +8,7 @@ import {
   isFileAccepted,
   mergeUploadFiles,
   removeUploadFileAt,
+  resolveUploadFileIcon,
   validateUploadFiles,
 } from '../components/upload-utils'
 
@@ -63,6 +64,17 @@ describe('upload-utils', () => {
     const files = [createFile('a.txt', 'a'), createFile('b.txt', 'b')]
     expect(removeUploadFileAt(files, 0).map((file) => file.name)).toEqual(['b.txt'])
   })
+
+  it('resolves list icons by extension and mime', () => {
+    expect(resolveUploadFileIcon('localhost.pem')).toBe('file-key')
+    expect(resolveUploadFileIcon('localhost.key')).toBe('key-round')
+    expect(resolveUploadFileIcon('photo.png')).toBe('file-image')
+    expect(resolveUploadFileIcon('app.ts')).toBe('file-code')
+    expect(resolveUploadFileIcon('data.xlsx')).toBe('file-spreadsheet')
+    expect(resolveUploadFileIcon('pack.zip')).toBe('file-archive')
+    expect(resolveUploadFileIcon(createFile('blob.bin', 'x', 'image/png'))).toBe('file-image')
+    expect(resolveUploadFileIcon('unknown.xyz')).toBe('file')
+  })
 })
 
 describe('RsUpload', () => {
@@ -149,12 +161,56 @@ describe('RsUpload', () => {
     expect(wrapper.find('.rs-upload__dropzone').classes()).toContain('rs-upload__dropzone--disabled')
   })
 
-  it('binds accept and multiple attributes', () => {
+  it('hides file list when showFileList is false', () => {
     const wrapper = mount(RsUpload, {
-      props: { accept: 'image/*', multiple: true },
+      props: {
+        modelValue: [createFile('a.txt', 'a')],
+        showFileList: false,
+      },
+    })
+    expect(wrapper.find('.rs-upload__list').exists()).toBe(false)
+  })
+
+  it('shows download action and emits download', async () => {
+    const createObjectURL = vi.fn(() => 'blob:mock')
+    const revokeObjectURL = vi.fn()
+    vi.stubGlobal('URL', { createObjectURL, revokeObjectURL })
+
+    const file = createFile('a.txt', 'hello')
+    const wrapper = mount(RsUpload, {
+      props: {
+        modelValue: [file],
+        showDownload: true,
+      },
+    })
+    expect(wrapper.find('.rs-upload__file-action').exists()).toBe(true)
+    await wrapper.find('.rs-upload__file-action').trigger('click')
+    expect(wrapper.emitted('download')?.[0]?.[0]).toBe(file)
+    expect(createObjectURL).toHaveBeenCalled()
+
+    vi.unstubAllGlobals()
+  })
+
+  it('accepts dropped files', async () => {
+    const wrapper = mount(RsUpload, {
+      props: { modelValue: [] },
+    })
+    const file = createFile('drop.txt', 'x')
+    await wrapper.find('.rs-upload__dropzone').trigger('drop', {
+      dataTransfer: { files: [file] },
+    })
+    expect(wrapper.emitted('update:modelValue')?.[0]?.[0]).toEqual([file])
+  })
+
+  it('hides dropzone when full and hideDropzoneWhenFull', () => {
+    const wrapper = mount(RsUpload, {
+      props: {
+        modelValue: [createFile('a.txt', 'a')],
+        maxCount: 1,
+        hideDropzoneWhenFull: true,
+      },
     })
-    const input = wrapper.find('input')
-    expect(input.attributes('accept')).toBe('image/*')
-    expect(input.attributes('multiple')).toBeDefined()
+    expect(wrapper.find('.rs-upload__dropzone').exists()).toBe(false)
+    expect(wrapper.find('.rs-upload__file-name').text()).toBe('a.txt')
   })
 })

package/src/__tests__/createRsDialog.spec.ts

@@ -0,0 +1,145 @@
+import { h } from 'vue'
+import { afterEach, describe, expect, it } from 'vitest'
+import { flushPromises } from '@vue/test-utils'
+import { openRsDialog, rsConfirm } from '../composables/createRsDialog'
+
+describe('createRsDialog', () => {
+  afterEach(() => {
+    document.body.querySelectorAll('.rs-dialog__content, .rs-confirm-dialog__content').forEach((el) => {
+      el.closest('body > div')?.remove()
+    })
+  })
+
+  it('rsConfirm resolves true when confirm clicked', async () => {
+    const promise = rsConfirm({
+      title: '删除？',
+      description: '不可撤销',
+      showOverlay: false,
+    })
+    await flushPromises()
+    const confirmBtn = Array.from(document.body.querySelectorAll('.rs-confirm-dialog__footer button')).at(
+      -1,
+    ) as HTMLButtonElement
+    expect(confirmBtn).toBeTruthy()
+    confirmBtn.click()
+    await flushPromises()
+    await expect(promise).resolves.toBe(true)
+  })
+
+  it('rsConfirm resolves false when cancel clicked', async () => {
+    const promise = rsConfirm({
+      title: '取消测试',
+      showOverlay: false,
+    })
+    await flushPromises()
+    const cancelBtn = document.body.querySelector(
+      '.rs-confirm-dialog__footer button',
+    ) as HTMLButtonElement
+    cancelBtn.click()
+    await flushPromises()
+    await expect(promise).resolves.toBe(false)
+  })
+
+  it('rsConfirm passes subtitle and width', async () => {
+    const promise = rsConfirm({
+      title: '删除？',
+      subtitle: '不可恢复',
+      description: '确定删除吗？',
+      width: 500,
+      showOverlay: false,
+    })
+    await flushPromises()
+    const content = document.body.querySelector('.rs-confirm-dialog__content') as HTMLElement
+    expect(content?.textContent).toContain('不可恢复')
+    expect(content?.textContent).toContain('确定删除吗？')
+    expect(content.style.maxWidth).toBe('500px')
+    const cancelBtn = document.body.querySelector(
+      '.rs-confirm-dialog__footer button',
+    ) as HTMLButtonElement
+    cancelBtn.click()
+    await flushPromises()
+    await expect(promise).resolves.toBe(false)
+  })
+
+  it('rsConfirm waits for async onConfirm before resolving', async () => {
+    let release!: () => void
+    const gate = new Promise<void>((resolve) => {
+      release = resolve
+    })
+    const promise = rsConfirm({
+      title: '异步',
+      showOverlay: false,
+      onConfirm: () => gate,
+    })
+    await flushPromises()
+    const confirmBtn = Array.from(document.body.querySelectorAll('.rs-confirm-dialog__footer button')).at(
+      -1,
+    ) as HTMLButtonElement
+    confirmBtn.click()
+    await flushPromises()
+    expect(confirmBtn.getAttribute('disabled')).not.toBeNull()
+    release()
+    await flushPromises()
+    await expect(promise).resolves.toBe(true)
+  })
+
+  it('openRsDialog mounts builtin footer and can destroy', async () => {
+    const handle = openRsDialog({
+      title: '命令式',
+      showOverlay: false,
+      body: () => '临时内容',
+    })
+    await flushPromises()
+    const content = document.body.querySelector('.rs-dialog__content')
+    expect(content?.textContent).toContain('命令式')
+    expect(content?.classList.contains('rs-dialog__content--window')).toBe(true)
+    expect(document.body.querySelector('.rs-dialog__footer')).not.toBeNull()
+    handle.destroy()
+    await flushPromises()
+    expect(document.body.querySelector('.rs-dialog__content')).toBeNull()
+  })
+
+  it('rsConfirm.info uses single confirm button', async () => {
+    const promise = rsConfirm.info({
+      title: '提示',
+      description: '仅确认',
+      showOverlay: false,
+    })
+    await flushPromises()
+    const buttons = document.body.querySelectorAll('.rs-confirm-dialog__footer button')
+    expect(buttons).toHaveLength(1)
+    ;(buttons[0] as HTMLButtonElement).click()
+    await flushPromises()
+    await expect(promise).resolves.toBe(true)
+  })
+
+  it('rsConfirm.warning accepts string shorthand', async () => {
+    const promise = rsConfirm.warning('确定删除吗？')
+    await flushPromises()
+    const content = document.body.querySelector('.rs-confirm-dialog__content')
+    expect(content?.textContent).toContain('确定删除吗？')
+    const cancelBtn = document.body.querySelector(
+      '.rs-confirm-dialog__footer button',
+    ) as HTMLButtonElement
+    cancelBtn.click()
+    await flushPromises()
+    await expect(promise).resolves.toBe(false)
+  })
+
+  it('rsConfirm supports extra render content', async () => {
+    const promise = rsConfirm({
+      title: '带额外',
+      description: '正文',
+      showOverlay: false,
+      extra: () => h('div', { class: 'extra-probe' }, 'list-item'),
+    })
+    await flushPromises()
+    expect(document.body.querySelector('.extra-probe')?.textContent).toContain('list-item')
+    const cancelBtn = document.body.querySelector(
+      '.rs-confirm-dialog__footer button',
+    ) as HTMLButtonElement
+    cancelBtn.click()
+    await flushPromises()
+    await expect(promise).resolves.toBe(false)
+  })
+})

package/src/__tests__/form-rules.spec.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it } from 'vitest'
+import {
+  buildLocalInputRules,
+  matchFormRuleTrigger,
+  normalizeFormRules,
+  runFormFieldRules,
+} from '../components/form-rules'
+
+describe('form-rules', () => {
+  it('normalizes single rule and arrays', () => {
+    expect(normalizeFormRules({ required: true })).toHaveLength(1)
+    expect(normalizeFormRules([{ required: true }, { min: 2 }])).toHaveLength(2)
+    expect(normalizeFormRules()).toEqual([])
+  })
+
+  it('matches trigger filters', () => {
+    expect(matchFormRuleTrigger({ required: true }, 'blur')).toBe(true)
+    expect(matchFormRuleTrigger({ required: true, trigger: 'blur' }, 'change')).toBe(false)
+    expect(matchFormRuleTrigger({ required: true, trigger: ['blur', 'change'] }, 'change')).toBe(
+      true,
+    )
+  })
+
+  it('validates required / min / pattern / email type', async () => {
+    const required = await runFormFieldRules('', [{ required: true, message: '必填' }])
+    expect(required).toEqual({ valid: false, message: '必填' })
+
+    const min = await runFormFieldRules('ab', [{ min: 3, message: '短' }])
+    expect(min.valid).toBe(false)
+
+    const email = await runFormFieldRules('bad', [{ type: 'email', message: '邮箱错' }])
+    expect(email.message).toBe('邮箱错')
+
+    const ok = await runFormFieldRules('a@b.com', [{ type: 'email' }])
+    expect(ok.valid).toBe(true)
+
+    const pattern = await runFormFieldRules('x', [
+      { pattern: /^\d+$/, message: '数字' },
+    ])
+    expect(pattern.message).toBe('数字')
+  })
+
+  it('supports async validator', async () => {
+    const result = await runFormFieldRules('admin', [
+      {
+        async validator(value) {
+          if (String(value) === 'admin') return '占用'
+          return true
+        },
+      },
+    ])
+    expect(result).toEqual({ valid: false, message: '占用' })
+  })
+
+  it('builds local input rules', () => {
+    const rules = buildLocalInputRules({
+      required: true,
+      rule: 'email',
+      validator: () => true,
+    })
+    expect(rules).toHaveLength(3)
+    expect(rules[0]?.required).toBe(true)
+    expect(rules[1]?.type).toBe('email')
+  })
+
+  it('supports message as function', async () => {
+    const result = await runFormFieldRules('x', [
+      {
+        min: 3,
+        message: ({ value }) => `当前「${String(value)}」太短`,
+      },
+    ])
+    expect(result.valid).toBe(false)
+    expect(result.message).toBe('当前「x」太短')
+  })
+})

package/src/__tests__/perf-budgets.ts

@@ -0,0 +1,32 @@
+/**
+ * RsTable / Core 性能门槛（CI 与本地共用）。
+ *
+ * CI（process.env.CI）用更紧预算，防止 jsdom 抖动掩盖回归；
+ * 本地默认略松，避免开发机噪音误杀。
+ */
+
+const isCi = Boolean(process.env.CI)
+
+function budget(localMs: number, ciMs: number): number {
+  return isCi ? ciMs : localMs
+}
+
+/** mount 类门槛（ms） */
+export const RS_TABLE_PERF_BUDGETS = {
+  /** 3000 行只读虚拟表 mount */
+  mountReadonly3k: budget(8000, 5000),
+  /** 双表各 1500 行 mount */
+  mountDual1k5: budget(12000, 8000),
+  /**
+   * 可编辑相对只读的倍率上限（另加 slackMs）。
+   * editableElapsed < readonlyElapsed * ratio + slackMs
+   */
+  editableVsReadonlyRatio: 3,
+  editableVsReadonlySlackMs: budget(2000, 1500),
+} as const
+
+export function assertWithinBudget(elapsedMs: number, limitMs: number, label: string): void {
+  if (elapsedMs >= limitMs) {
+    throw new Error(`[perf] ${label}: ${elapsedMs.toFixed(1)}ms >= budget ${limitMs}ms`)
+  }
+}

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",
+      ]
+    `)
+  })
+})