✨ Feature(custom): optimize logic to get raw data from reactive object

tests/getraw.test.ts

@@ -0,0 +1,117 @@
+import { describe, expect, it } from 'vitest'
+import { isProxy, reactive, ref, shallowReactive } from 'vue'
+
+import { getRawData } from '../src/renderer/utils/common'
+
+describe('getRawData 深度扩展工具测试', () => {
+  it('应当能处理基本类型和 null', () => {
+    expect(getRawData(42)).toBe(42)
+    expect(getRawData('hello')).toBe('hello')
+    expect(getRawData(true)).toBe(true)
+    expect(getRawData(null)).toBeNull()
+    expect(getRawData(undefined)).toBeUndefined()
+  })
+
+  it('应当能处理简单的 Ref 和 Reactive 对象', () => {
+    const numRef = ref(100)
+    const strReactive = reactive({ text: 'vue' })
+
+    expect(getRawData(numRef)).toBe(100)
+    const result = getRawData(strReactive)
+    expect(result).toEqual({ text: 'vue' })
+    expect(isProxy(result)).toBe(false)
+  })
+
+  it('应当能处理嵌套的数组和对象', () => {
+    const nested = reactive({
+      list: [ref(1), reactive({ val: 2 }), 3],
+      info: {
+        name: ref('test'),
+        details: reactive({ age: 30 }),
+      },
+    })
+
+    const result = getRawData(nested)
+
+    expect(result).toEqual({
+      list: [1, { val: 2 }, 3],
+      info: {
+        name: 'test',
+        details: { age: 30 },
+      },
+    })
+    expect(isProxy(result)).toBe(false)
+    expect(isProxy(result.info)).toBe(false)
+    expect(isProxy(result.list[1])).toBe(false)
+  })
+
+  it('应当能处理深层嵌套的 Map', () => {
+    const map = reactive(new Map())
+    const keyRef = ref('info')
+    const valReactive = reactive({ id: 1, tags: ref(['vue', 'ts']) })
+
+    map.set(keyRef, valReactive)
+
+    const result = getRawData(map)
+
+    expect(result).toBeInstanceOf(Map)
+    expect(result.has('info')).toBe(true)
+    const info = result.get('info')
+    expect(info.id).toBe(1)
+    expect(info.tags).toEqual(['vue', 'ts'])
+    expect(isProxy(info)).toBe(false)
+  })
+
+  it('应当能处理深层嵌套的 Set', () => {
+    const set = reactive(new Set())
+    const item = reactive({ name: 'test' })
+    set.add(item)
+    set.add(ref(100))
+
+    const result = getRawData(set)
+
+    expect(result).toBeInstanceOf(Set)
+    const items = Array.from(result)
+    expect(items).toContainEqual({ name: 'test' })
+    expect(items).toContain(100)
+    expect(isProxy(items[0])).toBe(false)
+  })
+
+  it('应当处理混合嵌套结构 (Object + Array + Set)', () => {
+    const complex = reactive({
+      users: new Set([reactive({ id: 1, meta: ref('admin') }), { id: 2, meta: 'user' }]),
+      config: [ref(true), { active: ref(false) }],
+    })
+
+    const result = getRawData(complex)
+
+    expect(result.users).toBeInstanceOf(Set)
+    const userArr = Array.from(result.users) as any[]
+    expect(userArr[0].meta).toBe('admin')
+    expect(result.config[0]).toBe(true)
+    expect(result.config[1].active).toBe(false)
+  })
+
+  it('应当正确克隆 Date 和 RegExp', () => {
+    const date = new Date('2024-01-01')
+    const reg = /test/g
+    const data = reactive({ date, reg })
+
+    const result = getRawData(data)
+
+    expect(result.date).toBeInstanceOf(Date)
+    expect(result.date.getFullYear()).toBe(2024)
+    expect(result.date).not.toBe(date)
+    expect(result.reg).toBeInstanceOf(RegExp)
+    expect(result.reg.test('test')).toBe(true)
+  })
+
+  it('应当处理 shallowReactive', () => {
+    const shallow = shallowReactive({
+      nested: { a: 1 },
+    })
+    const result = getRawData(shallow)
+    expect(result.nested.a).toBe(1)
+    expect(result).not.toBe(shallow)
+  })
+})