niuma-ui 1.0.1 → 1.1.0

package/src/__tests__/RsTooltip.spec.ts

@@ -54,6 +54,49 @@ describe('RsTooltip', () => {
     wrapper.unmount()
   })
 
+  it('does not open on non-keyboard focus when ignoreNonKeyboardFocus is on', async () => {
+    const wrapper = mountTooltip(
+      '<button type="button" class="trigger">Hover</button>',
+      { content: 'Focus tip' },
+    )
+    try {
+      const trigger = wrapper.find('.trigger').element as HTMLButtonElement
+      // 模拟 Dialog 关闭回焦：有 focus 但无 :focus-visible（jsdom 对 :focus-visible 不稳定）
+      const matchesSpy = vi
+        .spyOn(trigger, 'matches')
+        .mockImplementation((selectors: string) => !selectors.includes(':focus-visible'))
+      trigger.dispatchEvent(new FocusEvent('focus', { bubbles: true }))
+      await vi.runAllTimersAsync()
+      await flushPromises()
+      expect(document.body.querySelector('.rs-tooltip__content')).toBeNull()
+      matchesSpy.mockRestore()
+    } finally {
+      wrapper.unmount()
+    }
+  })
+
+  it('opens on keyboard-style focus-visible', async () => {
+    const wrapper = mountTooltip(
+      '<button type="button" class="trigger">Hover</button>',
+      { content: 'Keyboard tip' },
+    )
+    try {
+      const trigger = wrapper.find('.trigger').element as HTMLButtonElement
+      const matchesSpy = vi
+        .spyOn(trigger, 'matches')
+        .mockImplementation((selectors: string) => selectors.includes(':focus-visible'))
+      trigger.dispatchEvent(new FocusEvent('focus', { bubbles: true }))
+      await vi.runAllTimersAsync()
+      await flushPromises()
+      expect(document.body.querySelector('.rs-tooltip__content')).not.toBeNull()
+      expect(document.body.textContent).toContain('Keyboard tip')
+      matchesSpy.mockRestore()
+    } finally {
+      wrapper.unmount()
+    }
+  })
+
+
   it('renders custom content slot', async () => {
     const wrapper = mount(
       {

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__/css-token.spec.ts

@@ -0,0 +1,51 @@
+import { afterEach, describe, expect, it } from 'vitest'
+import {
+  parseCssLengthToPx,
+  readCodeFontFamily,
+  readCodeFontSizePx,
+  readCssLengthPx,
+  readCssVar,
+  readTerminalFontFamily,
+  readTerminalFontSizePx,
+  readTerminalFontWeight,
+  readTerminalFontWeightBold,
+} from '../theme/css-token'
+
+describe('css-token', () => {
+  afterEach(() => {
+    document.documentElement.style.cssText = ''
+  })
+
+  it('parses px / rem / unitless lengths', () => {
+    expect(parseCssLengthToPx('12px', 16)).toBe(12)
+    expect(parseCssLengthToPx('0.875rem', 16)).toBe(14)
+    expect(parseCssLengthToPx('1.5em', 16)).toBe(24)
+    expect(parseCssLengthToPx('14', 16)).toBe(14)
+    expect(parseCssLengthToPx('var(--x)', 16)).toBeNull()
+  })
+
+  it('reads and unwraps nested custom properties', () => {
+    const root = document.documentElement
+    root.style.setProperty('--rs-font-size-sm', '0.875rem')
+    root.style.setProperty('--rs-code-font-size', 'var(--rs-font-size-sm)')
+    root.style.setProperty('--rs-font-mono', 'JetBrains Mono, monospace')
+    root.style.setProperty('--rs-code-font-family', 'var(--rs-font-mono)')
+    root.style.setProperty('--rs-font-weight-regular', '400')
+    root.style.setProperty('--rs-terminal-font-weight', 'var(--rs-font-weight-regular)')
+
+    expect(readCssVar('--rs-code-font-size')).toBe('0.875rem')
+    expect(readCssLengthPx('--rs-code-font-size', 99)).toBe(14)
+    expect(readCodeFontSizePx()).toBe(14)
+    expect(readCodeFontFamily()).toBe('JetBrains Mono, monospace')
+    expect(readTerminalFontWeight()).toBe('400')
+  })
+
+  it('falls back when tokens are missing', () => {
+    expect(readCodeFontSizePx()).toBe(14)
+    expect(readTerminalFontSizePx()).toBe(14)
+    expect(readCodeFontFamily()).toContain('monospace')
+    expect(readTerminalFontFamily()).toContain('monospace')
+    expect(readTerminalFontWeight()).toBe('400')
+    expect(readTerminalFontWeightBold()).toBe('500')
+  })
+})

package/src/__tests__/date-picker-utils.spec.ts

@@ -4,8 +4,10 @@ import {
   formatDateTimeDisplay,
   formatDateTimeValue,
   formatDateValue,
+  fromInternalPickerValue,
   parseDateTimeValue,
   parseDateValue,
+  toInternalPickerValue,
 } from '../components/date-picker-utils'
 import { RS_DATE_FORMAT, RS_DATETIME_FORMAT } from '../lib/rs-dayjs'
 
@@ -68,3 +70,50 @@ describe('date-picker-utils (dayjs)', () => {
     expect(formatDateTimeValue('not-a-date')).toBe('not-a-date')
   })
 })
+
+describe('date-picker valueFormat conversion', () => {
+  const datetimeOpts = { valueFormat: 'iso', withTime: true }
+  const dateOpts = { valueFormat: 'iso', withTime: false }
+
+  it('converts internal datetime to local-offset RFC3339', () => {
+    const iso = fromInternalPickerValue('2025-06-16 14:30:00', datetimeOpts)
+    expect(iso).toMatch(/^2025-06-16T14:30:00[+-]\d{2}:\d{2}$/)
+  })
+
+  it('converts internal date to RFC3339 at midnight local offset', () => {
+    const iso = fromInternalPickerValue('2025-06-16', dateOpts)
+    expect(iso).toMatch(/^2025-06-16T00:00:00[+-]\d{2}:\d{2}$/)
+  })
+
+  it('round-trips iso datetime as wall clock', () => {
+    const iso = fromInternalPickerValue('2025-06-16 14:30:00', datetimeOpts)
+    expect(toInternalPickerValue(iso, datetimeOpts)).toBe('2025-06-16 14:30:00')
+    expect(toInternalPickerValue('2026-07-01T14:49:43Z', datetimeOpts)).toBe('2026-07-01 14:49:43')
+    expect(toInternalPickerValue('2026-08-14T14:38:42+08:00', datetimeOpts)).toBe('2026-08-14 14:38:42')
+  })
+
+  it('keeps string format as internal wall clock', () => {
+    expect(fromInternalPickerValue('2025-06-16 14:30:00', { valueFormat: 'string', withTime: true }))
+      .toBe('2025-06-16 14:30:00')
+    expect(toInternalPickerValue('2025-06-16 14:30:00', { valueFormat: 'string', withTime: true }))
+      .toBe('2025-06-16 14:30:00')
+  })
+
+  it('converts timestamp format', () => {
+    const ms = fromInternalPickerValue('2025-06-16 14:30:00', { valueFormat: 'timestamp', withTime: true })
+    expect(typeof ms).toBe('number')
+    expect(toInternalPickerValue(ms, { valueFormat: 'timestamp', withTime: true })).toBe('2025-06-16 14:30:00')
+  })
+
+  it('supports custom dayjs value-format templates', () => {
+    const custom = { valueFormat: 'YYYY-MM-DDTHH:mm:ss', withTime: true }
+    expect(fromInternalPickerValue('2025-06-16 14:30:00', custom)).toBe('2025-06-16T14:30:00')
+    expect(toInternalPickerValue('2025-06-16T14:30:00', custom)).toBe('2025-06-16 14:30:00')
+  })
+
+  it('emits null for empty iso and timestamp', () => {
+    expect(fromInternalPickerValue('', datetimeOpts)).toBeNull()
+    expect(fromInternalPickerValue('', { valueFormat: 'timestamp', withTime: true })).toBeNull()
+    expect(fromInternalPickerValue('', { valueFormat: 'string', withTime: true })).toBe('')
+  })
+})

package/src/__tests__/dialog-utils.spec.ts

@@ -0,0 +1,43 @@
+import { afterEach, describe, expect, it } from 'vitest'
+import { resolveRsDialogCssWidth, resolveRsDialogWidthPx } from '../components/dialog-utils'
+
+describe('resolveRsDialogWidthPx', () => {
+  afterEach(() => {
+    document.documentElement.style.removeProperty('font-size')
+  })
+
+  it('returns undefined for presets', () => {
+    expect(resolveRsDialogWidthPx('sm')).toBeUndefined()
+    expect(resolveRsDialogWidthPx('md')).toBeUndefined()
+    expect(resolveRsDialogWidthPx('lg')).toBeUndefined()
+  })
+
+  it('keeps numeric and px widths', () => {
+    expect(resolveRsDialogWidthPx(1200)).toBe(1200)
+    expect(resolveRsDialogWidthPx('960px')).toBe(960)
+  })
+
+  it('converts rem using root font size', () => {
+    document.documentElement.style.fontSize = '16px'
+    expect(resolveRsDialogWidthPx('40rem')).toBe(640)
+  })
+
+  it('converts percent against the given viewport width', () => {
+    expect(resolveRsDialogWidthPx('90%', 1000)).toBe(900)
+    expect(resolveRsDialogWidthPx('80%', 800)).toBe(640)
+  })
+
+  it('returns undefined for empty or unknown units', () => {
+    expect(resolveRsDialogWidthPx('')).toBeUndefined()
+    expect(resolveRsDialogWidthPx('min(90vw, 1200px)')).toBeUndefined()
+    expect(resolveRsDialogWidthPx(0)).toBeUndefined()
+  })
+})
+
+describe('resolveRsDialogCssWidth', () => {
+  it('maps number to px and keeps custom CSS strings', () => {
+    expect(resolveRsDialogCssWidth('md')).toBeUndefined()
+    expect(resolveRsDialogCssWidth(520)).toBe('520px')
+    expect(resolveRsDialogCssWidth('90%')).toBe('90%')
+  })
+})

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

@@ -0,0 +1,46 @@
+import { describe, expect, it } from 'vitest'
+import {
+  concatNamePath,
+  getByNamePath,
+  hasByNamePath,
+  namePathKey,
+  normalizeNamePath,
+  setByNamePath,
+} from '../components/form-path'
+
+describe('form-path', () => {
+  it('normalizes string and array name paths', () => {
+    expect(normalizeNamePath('user.email')).toEqual(['user', 'email'])
+    expect(normalizeNamePath(['user', 'email'])).toEqual(['user', 'email'])
+    expect(namePathKey(['a', 0, 'b'])).toBe('a.0.b')
+  })
+
+  it('gets and sets nested values', () => {
+    const model: Record<string, unknown> = {}
+    setByNamePath(model, 'user.email', 'a@b.com')
+    expect(model).toEqual({ user: { email: 'a@b.com' } })
+    expect(getByNamePath(model, ['user', 'email'])).toBe('a@b.com')
+    expect(hasByNamePath(model, 'user.email')).toBe(true)
+  })
+
+  it('walks multi-level JSON paths', () => {
+    const model: Record<string, unknown> = {}
+    setByNamePath(model, 'config.headerConfig.isRequestHeader', true)
+    expect(model).toEqual({
+      config: { headerConfig: { isRequestHeader: true } },
+    })
+    expect(getByNamePath(model, 'config.headerConfig.isRequestHeader')).toBe(true)
+    expect(hasByNamePath(model, 'config.headerConfig.headerName')).toBe(false)
+  })
+
+  it('preserves arrays when setting nested list fields', () => {
+    const model: Record<string, unknown> = { users: [{ name: 'A' }] }
+    setByNamePath(model, ['users', 0, 'name'], 'B')
+    expect(model.users).toEqual([{ name: 'B' }])
+    expect(Array.isArray(model.users)).toBe(true)
+  })
+
+  it('concatenates list prefix and item name', () => {
+    expect(concatNamePath('users', [0, 'name'])).toEqual(['users', 0, 'name'])
+  })
+})

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

@@ -0,0 +1,139 @@
+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('interpolates required message with label', async () => {
+    const labeled = await runFormFieldRules('', [{ required: true }], { label: '邮箱' })
+    expect(labeled.message).toBe('请填写邮箱')
+  })
+
+  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」太短')
+  })
+
+  it('validator can read other fields via context', async () => {
+    const result = await runFormFieldRules('two', [
+      {
+        validator(value, ctx) {
+          if (String(value) !== String(ctx.getFieldValue('a'))) return '不一致'
+          return true
+        },
+      },
+    ], {
+      getFieldValue: (name) => (String(name) === 'a' ? 'one' : undefined),
+    })
+    expect(result).toEqual({ valid: false, message: '不一致' })
+
+    const ok = await runFormFieldRules('one', [
+      {
+        validator(value, ctx) {
+          if (String(value) !== String(ctx.getFieldValue('a'))) return '不一致'
+          return true
+        },
+      },
+    ], {
+      getFieldValue: (name) => (String(name) === 'a' ? 'one' : undefined),
+    })
+    expect(ok.valid).toBe(true)
+  })
+
+  it('runs custom validator on empty value for cross-field required', async () => {
+    const result = await runFormFieldRules(
+      '',
+      [
+        {
+          validator(_value, ctx) {
+            if (ctx.getFieldValue('kind') === 'email') return '邮箱必填'
+            return true
+          },
+        },
+      ],
+      { getFieldValue: (name) => (String(name) === 'kind' ? 'email' : undefined) },
+    )
+    expect(result).toEqual({ valid: false, message: '邮箱必填' })
+  })
+
+  it('treats Error return and thrown errors as failure', async () => {
+    const returned = await runFormFieldRules('x', [
+      { validator: () => new Error('返回错误') as unknown as string },
+    ])
+    expect(returned).toEqual({ valid: false, message: '返回错误' })
+
+    const thrown = await runFormFieldRules('x', [
+      {
+        validator() {
+          throw new Error('抛出错误')
+        },
+      },
+    ])
+    expect(thrown).toEqual({ valid: false, message: '抛出错误' })
+  })
+})

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