niuma-ui 1.0.0

package/src/__tests__/RsUpload.spec.ts

@@ -0,0 +1,160 @@
+import { describe, expect, it } from 'vitest'
+import { h } from 'vue'
+import { mount } from '@vue/test-utils'
+import RsConfigProvider from '../components/RsConfigProvider.vue'
+import RsUpload from '../components/RsUpload.vue'
+import {
+  formatFileSize,
+  isFileAccepted,
+  mergeUploadFiles,
+  removeUploadFileAt,
+  validateUploadFiles,
+} from '../components/upload-utils'
+
+function createFile(name: string, content: string, type = 'text/plain'): File {
+  return new File([content], name, { type })
+}
+
+async function selectFiles(wrapper: ReturnType<typeof mount>, files: File[]): Promise<void> {
+  const input = wrapper.find('input[type="file"]')
+  Object.defineProperty(input.element, 'files', {
+    value: files,
+    configurable: true,
+  })
+  await input.trigger('change')
+}
+
+describe('upload-utils', () => {
+  it('formats file sizes', () => {
+    expect(formatFileSize(512)).toBe('512 B')
+    expect(formatFileSize(1024)).toBe('1.0 KB')
+    expect(formatFileSize(1024 * 1024)).toBe('1.0 MB')
+  })
+
+  it('matches accept rules by extension, mime type, and wildcard', () => {
+    const txt = createFile('a.txt', 'x')
+    const png = createFile('b.png', 'x', 'image/png')
+    expect(isFileAccepted(txt, '.txt')).toBe(true)
+    expect(isFileAccepted(txt, 'image/*')).toBe(false)
+    expect(isFileAccepted(png, 'image/*')).toBe(true)
+    expect(isFileAccepted(png, 'text/plain')).toBe(false)
+  })
+
+  it('validates accept, maxSize, and maxCount', () => {
+    const small = createFile('small.txt', 'hi')
+    const large = createFile('large.txt', 'x'.repeat(200))
+    const invalidType = createFile('bad.pdf', 'x', 'application/pdf')
+
+    expect(validateUploadFiles([invalidType], { accept: '.txt' }).rejected[0]?.reason).toBe('accept')
+    expect(validateUploadFiles([large], { maxSize: 100 }).rejected[0]?.reason).toBe('maxSize')
+    expect(
+      validateUploadFiles([small, createFile('extra.txt', 'y')], { maxCount: 1 }).rejected[0]?.reason,
+    ).toBe('maxCount')
+  })
+
+  it('merges and trims files by maxCount', () => {
+    const first = createFile('a.txt', 'a')
+    const second = createFile('b.txt', 'b')
+    expect(mergeUploadFiles([first], [second], 1)).toHaveLength(1)
+    expect(mergeUploadFiles([first], [second])).toHaveLength(2)
+  })
+
+  it('removes file at index', () => {
+    const files = [createFile('a.txt', 'a'), createFile('b.txt', 'b')]
+    expect(removeUploadFileAt(files, 0).map((file) => file.name)).toEqual(['b.txt'])
+  })
+})
+
+describe('RsUpload', () => {
+  it('renders default zh-CN label', () => {
+    const wrapper = mount(RsUpload)
+    expect(wrapper.find('.rs-upload__label').text()).toBe('点击或拖拽文件到此处上传')
+  })
+
+  it('renders custom label and hint', () => {
+    const wrapper = mount(RsUpload, {
+      props: { label: '上传附件', hint: '仅 PDF' },
+    })
+    expect(wrapper.find('.rs-upload__label').text()).toBe('上传附件')
+    expect(wrapper.find('.rs-upload__hint').text()).toBe('仅 PDF')
+  })
+
+  it('renders default browse hint when hint is omitted', () => {
+    const wrapper = mount(RsUpload)
+    expect(wrapper.find('.rs-upload__hint').text()).toBe('或点击浏览本地文件')
+  })
+
+  it('uses en-US label inside RsConfigProvider', () => {
+    const wrapper = mount(RsConfigProvider, {
+      props: { locale: 'en-US' },
+      slots: {
+        default: () => h(RsUpload),
+      },
+    })
+    expect(wrapper.find('.rs-upload__label').text()).toBe('Click or drag files here to upload')
+  })
+
+  it('accepts files and updates model', async () => {
+    const wrapper = mount(RsUpload, {
+      props: { modelValue: [] },
+    })
+    const file = createFile('demo.txt', 'hello')
+    await selectFiles(wrapper, [file])
+    expect(wrapper.emitted('update:modelValue')?.[0]?.[0]).toEqual([file])
+  })
+
+  it('shows file list with formatted size', async () => {
+    const file = createFile('demo.txt', 'hello')
+    const wrapper = mount(RsUpload, {
+      props: { modelValue: [file] },
+    })
+    expect(wrapper.find('.rs-upload__file-name').text()).toBe('demo.txt')
+    expect(wrapper.find('.rs-upload__file-size').text()).toBe(formatFileSize(file.size))
+  })
+
+  it('removes file from list', async () => {
+    const first = createFile('a.txt', 'a')
+    const second = createFile('b.txt', 'b')
+    const wrapper = mount(RsUpload, {
+      props: { modelValue: [first, second] },
+    })
+    await wrapper.find('.rs-upload__file-remove').trigger('click')
+    expect(wrapper.emitted('update:modelValue')?.[0]?.[0]).toEqual([second])
+  })
+
+  it('emits reject for invalid files', async () => {
+    const wrapper = mount(RsUpload, {
+      props: { modelValue: [], accept: '.txt' },
+    })
+    const invalid = createFile('image.png', 'x', 'image/png')
+    await selectFiles(wrapper, [invalid])
+    const reject = wrapper.emitted('reject')?.[0]?.[0] as Array<{ reason: string }>
+    expect(reject?.[0]?.reason).toBe('accept')
+  })
+
+  it('disables input when disabled', () => {
+    const wrapper = mount(RsUpload, { props: { disabled: true } })
+    expect(wrapper.find('input').attributes('disabled')).toBeDefined()
+    expect(wrapper.find('.rs-upload__dropzone').classes()).toContain('rs-upload__dropzone--disabled')
+  })
+
+  it('disables input when maxCount is reached', () => {
+    const wrapper = mount(RsUpload, {
+      props: {
+        modelValue: [createFile('a.txt', 'a'), createFile('b.txt', 'b')],
+        maxCount: 2,
+      },
+    })
+    expect(wrapper.find('input').attributes('disabled')).toBeDefined()
+    expect(wrapper.find('.rs-upload__dropzone').classes()).toContain('rs-upload__dropzone--disabled')
+  })
+
+  it('binds accept and multiple attributes', () => {
+    const wrapper = mount(RsUpload, {
+      props: { accept: 'image/*', multiple: true },
+    })
+    const input = wrapper.find('input')
+    expect(input.attributes('accept')).toBe('image/*')
+    expect(input.attributes('multiple')).toBeDefined()
+  })
+})

package/src/__tests__/RsVirtualList.spec.ts

@@ -0,0 +1,77 @@
+import { describe, expect, it } from 'vitest'
+import { mount } from '@vue/test-utils'
+import RsVirtualList from '../components/RsVirtualList.vue'
+import { resolveItemSize, resolveVirtualListHeight } from '../components/virtual-list-utils'
+
+describe('virtual-list-utils', () => {
+  it('resolves item size from number or function', () => {
+    expect(resolveItemSize(32)).toBe(32)
+    expect(resolveItemSize((index) => index * 10 + 20, 2)).toBe(40)
+  })
+
+  it('resolves list height', () => {
+    expect(resolveVirtualListHeight(240)).toBe('240px')
+    expect(resolveVirtualListHeight('50%')).toBe('50%')
+    expect(resolveVirtualListHeight(0)).toBeUndefined()
+  })
+})
+
+describe('RsVirtualList', () => {
+  const items = Array.from({ length: 500 }, (_, index) => `Row ${index}`)
+
+  it('renders subset of items for large lists', () => {
+    const wrapper = mount(RsVirtualList, {
+      props: { items, height: 200, itemSize: 32 },
+      slots: {
+        default: `<div class="item">{{ item }}</div>`,
+      },
+    })
+    expect(wrapper.findAll('.item').length).toBeLessThan(items.length)
+  })
+
+  it('passes index to default slot', () => {
+    const wrapper = mount(RsVirtualList, {
+      props: { items: ['A', 'B', 'C'], height: 96, itemSize: 32 },
+      slots: {
+        default: `<div class="cell">{{ index }}-{{ item }}</div>`,
+      },
+    })
+    expect(wrapper.text()).toContain('0-A')
+  })
+
+  it('marks active row with activeIndex', () => {
+    const wrapper = mount(RsVirtualList, {
+      props: { items: ['A', 'B', 'C', 'D'], height: 128, itemSize: 32, activeIndex: 2 },
+      slots: {
+        default: `<div class="cell">{{ index }}</div>`,
+      },
+    })
+    expect(wrapper.find('.rs-virtual-list__item--active').exists()).toBe(true)
+    expect(wrapper.find('.rs-virtual-list__item--active').text()).toBe('2')
+  })
+
+  it('scrolls active row into view on mount', async () => {
+    const items = Array.from({ length: 100 }, (_, index) => `Row ${index}`)
+    const wrapper = mount(RsVirtualList, {
+      props: { items, height: 200, itemSize: 40, activeIndex: 50 },
+      slots: {
+        default: `<div class="cell">{{ index }}</div>`,
+      },
+      attachTo: document.body,
+    })
+    const listEl = wrapper.find('.rs-virtual-list').element as HTMLElement
+    Object.defineProperty(listEl, 'clientHeight', { configurable: true, value: 200 })
+    await wrapper.vm.$nextTick()
+    await new Promise((resolve) => requestAnimationFrame(resolve))
+    expect(listEl.scrollTop).toBeGreaterThan(0)
+    wrapper.unmount()
+  })
+
+  it('applies radius none as CSS variable', () => {
+    const wrapper = mount(RsVirtualList, {
+      props: { items: ['A'], height: 64, itemSize: 32, radius: 'none' },
+    })
+    const el = wrapper.find('.rs-virtual-list').element as HTMLElement
+    expect(el.style.getPropertyValue('--rs-virtual-list-radius')).toBe('0')
+  })
+})

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

@@ -0,0 +1,70 @@
+import { describe, expect, it } from 'vitest'
+import {
+  formatDateDisplay,
+  formatDateTimeDisplay,
+  formatDateTimeValue,
+  formatDateValue,
+  parseDateTimeValue,
+  parseDateValue,
+} from '../components/date-picker-utils'
+import { RS_DATE_FORMAT, RS_DATETIME_FORMAT } from '../lib/rs-dayjs'
+
+describe('date-picker-utils (dayjs)', () => {
+  it('uses fixed date format constant', () => {
+    expect(RS_DATE_FORMAT).toBe('YYYY-MM-DD')
+    expect(RS_DATETIME_FORMAT).toBe('YYYY-MM-DD HH:mm:ss')
+  })
+
+  it('formats and parses date values', () => {
+    expect(formatDateValue('2025-06-16')).toBe('2025-06-16')
+    expect(formatDateDisplay('2025-06-16')).toBe('2025-06-16')
+    expect(parseDateValue('2025-06-16')).toEqual({ year: 2025, month: 6, day: 16 })
+  })
+
+  it('formats and parses datetime values', () => {
+    expect(formatDateTimeValue('2025-06-16 14:30:00')).toBe('2025-06-16 14:30:00')
+    expect(formatDateTimeDisplay('2025-06-16 14:30:00')).toBe('2025-06-16 14:30:00')
+    expect(parseDateTimeValue('2025-06-16 14:30:00')).toEqual({
+      year: 2025,
+      month: 6,
+      day: 16,
+      hour: 14,
+      minute: 30,
+      second: 0,
+    })
+  })
+
+  it('parses ISO-like datetime and normalizes to canonical form', () => {
+    expect(parseDateTimeValue('2025-06-16T14:30:00')).toEqual({
+      year: 2025,
+      month: 6,
+      day: 16,
+      hour: 14,
+      minute: 30,
+      second: 0,
+    })
+    expect(parseDateTimeValue('2025-06-16T14:30')).toEqual({
+      year: 2025,
+      month: 6,
+      day: 16,
+      hour: 14,
+      minute: 30,
+      second: 0,
+    })
+    expect(parseDateTimeValue('2025-06-16 14:30')).toEqual({
+      year: 2025,
+      month: 6,
+      day: 16,
+      hour: 14,
+      minute: 30,
+      second: 0,
+    })
+    expect(formatDateTimeValue('2025-06-16T14:30:00')).toBe('2025-06-16 14:30:00')
+    expect(formatDateTimeValue('2026-07-01T14:49:43Z')).toBe('2026-07-01 14:49:43')
+  })
+
+  it('rejects unrecognizable datetime strings', () => {
+    expect(parseDateTimeValue('not-a-date')).toBeNull()
+    expect(formatDateTimeValue('not-a-date')).toBe('not-a-date')
+  })
+})

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

@@ -0,0 +1,38 @@
+import { afterEach, describe, expect, it } from 'vitest'
+import { dialogViewportSize, readDialogViewportInsets } from '../components/dialog-viewport'
+
+describe('dialog-viewport', () => {
+  afterEach(() => {
+    document.documentElement.style.removeProperty('--rs-dialog-inset-top')
+    document.documentElement.style.removeProperty('--rs-dialog-inset-bottom')
+    document.documentElement.style.removeProperty('--rs-dialog-inset-x')
+  })
+
+  it('falls back to viewport gap when insets are unset', () => {
+    const insets = readDialogViewportInsets()
+    expect(insets.top).toBe(16)
+    expect(insets.bottom).toBe(16)
+    expect(insets.left).toBe(16)
+    expect(insets.right).toBe(16)
+  })
+
+  it('reads inset tokens from document root', () => {
+    document.documentElement.style.setProperty('--rs-dialog-inset-top', '40px')
+    document.documentElement.style.setProperty('--rs-dialog-inset-bottom', '26px')
+    document.documentElement.style.setProperty('--rs-dialog-inset-x', '12px')
+    const insets = readDialogViewportInsets()
+    expect(insets.top).toBe(40)
+    expect(insets.bottom).toBe(26)
+    expect(insets.left).toBe(12)
+    expect(insets.right).toBe(12)
+  })
+
+  it('subtracts insets from viewport size', () => {
+    document.documentElement.style.setProperty('--rs-dialog-inset-top', '40px')
+    document.documentElement.style.setProperty('--rs-dialog-inset-bottom', '26px')
+    document.documentElement.style.setProperty('--rs-dialog-inset-x', '10px')
+    const size = dialogViewportSize()
+    expect(size.width).toBe(window.innerWidth - 20)
+    expect(size.height).toBe(window.innerHeight - 66)
+  })
+})

package/src/__tests__/iso-local-datetime.spec.ts

@@ -0,0 +1,58 @@
+import { describe, expect, it } from 'vitest'
+import {
+  formatIsoUtcToLocal,
+  looksLikeIsoDateTimeWithTz,
+  parseLocalDateTimeToUtcIso,
+} from '../lib/iso-local-datetime'
+
+function localParts(isoForDate: string): { date: string; time: string; ms: string } {
+  const d = new Date(isoForDate)
+  const pad = (n: number, w = 2) => String(n).padStart(w, '0')
+  return {
+    date: `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`,
+    time: `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`,
+    ms: pad(d.getMilliseconds(), 3),
+  }
+}
+
+describe('iso-local-datetime', () => {
+  it('formats Z to local with second / millisecond precision', () => {
+    const sec = '2026-06-25T08:06:36Z'
+    const { date, time } = localParts(sec)
+    expect(formatIsoUtcToLocal(sec)).toBe(`${date} ${time}`)
+
+    const ms = '2026-06-25T08:06:36.2263624Z'
+    const p = localParts('2026-06-25T08:06:36.226Z')
+    expect(formatIsoUtcToLocal(ms)).toBe(`${p.date} ${p.time}.${p.ms}`)
+  })
+
+  it('preserves original ISO when local second unchanged (picker strips ms)', () => {
+    const prev = '2026-06-25T08:06:36.2263624Z'
+    const local = formatIsoUtcToLocal(prev)!
+    const withoutMs = local.replace(/\.\d+$/, '')
+    expect(parseLocalDateTimeToUtcIso(withoutMs, prev)).toBe(prev)
+  })
+
+  it('writes new UTC ISO when local time changes', () => {
+    const prev = '2026-06-25T08:06:36.226Z'
+    const prevLocal = formatIsoUtcToLocal(prev)!
+    // +1 second on local wall clock（无毫秒 → 写回秒精度）
+    const d = new Date(prev)
+    d.setSeconds(d.getSeconds() + 1)
+    d.setMilliseconds(0)
+    const pad = (n: number) => String(n).padStart(2, '0')
+    const nextLocal =
+      `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ` +
+      `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`
+    expect(nextLocal).not.toBe(prevLocal.replace(/\.\d+$/, ''))
+    const written = parseLocalDateTimeToUtcIso(nextLocal, prev)
+    expect(written).toMatch(/Z$/i)
+    expect(written).not.toBe(prev)
+    expect(new Date(written!).getTime()).toBe(d.getTime())
+  })
+
+  it('rejects naive datetime for looksLike / format', () => {
+    expect(looksLikeIsoDateTimeWithTz('2026-06-25T08:06:36')).toBe(false)
+    expect(formatIsoUtcToLocal('2026-06-25T08:06:36')).toBeNull()
+  })
+})

package/src/__tests__/rs-clipboard.spec.ts

@@ -0,0 +1,142 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import {
+  __resetClipboardStateForTests,
+  beginClipboardPrefetch,
+  copyTextToClipboard,
+  copyTextWithExecCommand,
+  readClipboardText,
+  writeClipboardText,
+} from '../utils/rs-clipboard'
+
+function stubNavigator(clipboard: Record<string, unknown>): void {
+  vi.stubGlobal('navigator', {
+    clipboard,
+    permissions: {
+      query: vi.fn().mockResolvedValue({ state: 'granted', onchange: null }),
+    },
+  })
+}
+
+describe('rs-clipboard', () => {
+  afterEach(() => {
+    __resetClipboardStateForTests()
+    vi.restoreAllMocks()
+  })
+
+  it('uses prefetched text when menu opens before paste', async () => {
+    const readText = vi.fn().mockResolvedValue('from-windows')
+    vi.stubGlobal('navigator', {
+      clipboard: { readText, writeText: vi.fn() },
+    })
+    await beginClipboardPrefetch()
+    expect(readText).toHaveBeenCalledTimes(1)
+    await expect(readClipboardText()).resolves.toBe('from-windows')
+    expect(readText).toHaveBeenCalledTimes(1)
+  })
+
+  it('waits for in-flight prefetch before paste', async () => {
+    let resolveRead: (value: string) => void = () => undefined
+    const readText = vi.fn(
+      () =>
+        new Promise<string>((resolve) => {
+          resolveRead = resolve
+        }),
+    )
+    vi.stubGlobal('navigator', {
+      clipboard: { readText, writeText: vi.fn() },
+    })
+    const pending = beginClipboardPrefetch()
+    await Promise.resolve()
+    const readPromise = readClipboardText()
+    resolveRead('late-text')
+    await pending
+    await expect(readPromise).resolves.toBe('late-text')
+  })
+
+  it('writes clipboard text via API', async () => {
+    const writeText = vi.fn().mockResolvedValue(undefined)
+    vi.stubGlobal('navigator', { clipboard: { readText: vi.fn(), writeText } })
+    await expect(writeClipboardText('hello')).resolves.toBe(true)
+    expect(writeText).toHaveBeenCalledWith('hello')
+  })
+
+  it('falls back to execCommand when writeText fails', async () => {
+    const writeText = vi.fn().mockRejectedValue(new Error('denied'))
+    const execCommand = vi.fn().mockReturnValue(true)
+    vi.stubGlobal('navigator', { clipboard: { readText: vi.fn(), writeText } })
+    vi.stubGlobal('document', {
+      body: { appendChild: vi.fn(), removeChild: vi.fn() },
+      createElement: () => ({
+        value: '',
+        style: {},
+        setAttribute: vi.fn(),
+        select: vi.fn(),
+        remove: vi.fn(),
+      }),
+      execCommand,
+    })
+    await expect(copyTextToClipboard('fallback')).resolves.toBe(true)
+    expect(execCommand).toHaveBeenCalledWith('copy')
+  })
+
+  it('falls back to shell bridge when clipboard read fails', async () => {
+    const readText = vi.fn().mockRejectedValue(new DOMException('denied', 'NotAllowedError'))
+    const cefQuery = vi.fn(({ onSuccess }: { onSuccess: (r: string) => void }) => {
+      onSuccess(JSON.stringify({ text: 'from-shell' }))
+    })
+    vi.stubGlobal('cefQuery', cefQuery)
+    vi.stubGlobal('navigator', {
+      clipboard: { readText, writeText: vi.fn() },
+    })
+    await beginClipboardPrefetch()
+    await expect(readClipboardText()).resolves.toBe('from-shell')
+    expect(cefQuery).toHaveBeenCalled()
+    expect(readText).toHaveBeenCalledTimes(1)
+    await expect(readClipboardText()).resolves.toBe('from-shell')
+    expect(readText).toHaveBeenCalledTimes(1)
+  })
+
+  it('writes via shell bridge only when API and execCommand fail', async () => {
+    const writeText = vi.fn().mockRejectedValue(new Error('denied'))
+    const execCommand = vi.fn().mockReturnValue(false)
+    const cefQuery = vi.fn(({ request, onSuccess }: { request: string; onSuccess: (r: string) => void }) => {
+      const payload = JSON.parse(request) as { method: string }
+      expect(payload.method).toBe('shell.clipboard.writeText')
+      onSuccess(JSON.stringify({ written: true }))
+    })
+    vi.stubGlobal('cefQuery', cefQuery)
+    vi.stubGlobal('navigator', { clipboard: { readText: vi.fn(), writeText } })
+    vi.stubGlobal('document', {
+      body: { appendChild: vi.fn(), removeChild: vi.fn() },
+      createElement: () => ({
+        value: '',
+        style: {},
+        setAttribute: vi.fn(),
+        select: vi.fn(),
+        remove: vi.fn(),
+      }),
+      execCommand,
+    })
+    await expect(copyTextToClipboard('cef-copy')).resolves.toBe(true)
+    expect(writeText).toHaveBeenCalled()
+    expect(execCommand).toHaveBeenCalledWith('copy')
+    expect(cefQuery).toHaveBeenCalled()
+  })
+
+  it('copyTextWithExecCommand uses textarea trick', () => {
+    const execCommand = vi.fn().mockReturnValue(true)
+    vi.stubGlobal('document', {
+      body: { appendChild: vi.fn(), removeChild: vi.fn() },
+      createElement: () => ({
+        value: '',
+        style: {},
+        setAttribute: vi.fn(),
+        select: vi.fn(),
+        remove: vi.fn(),
+      }),
+      execCommand,
+    })
+    expect(copyTextWithExecCommand('line')).toBe(true)
+    expect(execCommand).toHaveBeenCalledWith('copy')
+  })
+})

package/src/__tests__/setup.ts

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