fix (types): do not unwrap refs in toRefs (#4966)

packages/reactivity/src/ref.ts

@@ -190,9 +190,7 @@ export function customRef<T>(factory: CustomRefFactory<T>): Ref<T> {
 }
 
 export type ToRefs<T = any> = {
-  // #2687: somehow using ToRef<T[K]> here turns the resulting type into
+  [K in keyof T]: ToRef<T[K]>
-  // a union of multiple Ref<*> types instead of a single Ref<* | *> type.
-  [K in keyof T]: T[K] extends Ref ? T[K] : Ref<UnwrapRef<T[K]>>
 }
 export function toRefs<T extends object>(object: T): ToRefs<T> {
   if (__DEV__ && !isProxy(object)) {

test-dts/ref.test-d.ts

@@ -10,8 +10,7 @@ import {
   toRef,
   toRefs,
   ToRefs,
-  shallowReactive,
+  shallowReactive
-  watch
 } from './index'
 
 function plainType(arg: number | Ref<number>) {
@@ -185,28 +184,45 @@ const p2 = proxyRefs(r2)
 expectType<number>(p2.a)
 expectType<Ref<string>>(p2.obj.k)
 
-// toRef
+// toRef and toRefs
-const obj = {
+{
+  const obj: {
+    a: number
+    b: Ref<number>
+    c: number | string
+  } = {
     a: 1,
-  b: ref(1)
+    b: ref(1),
+    c: 1
   }
+
+  // toRef
   expectType<Ref<number>>(toRef(obj, 'a'))
   expectType<Ref<number>>(toRef(obj, 'b'))
-
+  // Should not distribute Refs over union
-const objWithUnionProp: { a: string | number } = {
+  expectType<Ref<number | string>>(toRef(obj, 'c'))
-  a: 1
-}
-
-watch(toRef(objWithUnionProp, 'a'), value => {
-  expectType<string | number>(value)
-})
 
   // toRefs
-const objRefs = toRefs(obj)
   expectType<{
     a: Ref<number>
     b: Ref<number>
-}>(objRefs)
+    // Should not distribute Refs over union
+    c: Ref<number | string>
+  }>(toRefs(obj))
+
+  // Both should not do any unwrapping
+  const someReactive = shallowReactive({
+    a: {
+      b: ref(42)
+    }
+  })
+
+  const toRefResult = toRef(someReactive, 'a')
+  const toRefsResult = toRefs(someReactive)
+
+  expectType<Ref<number>>(toRefResult.value.b)
+  expectType<Ref<number>>(toRefsResult.a.value.b)
+}
 
 // #2687
 interface AppData {
@@ -238,20 +254,6 @@ function testUnrefGenerics<T>(p: T | Ref<T>) {
 
 testUnrefGenerics(1)
 
-// #4732
-describe('ref in shallow reactive', () => {
-  const baz = shallowReactive({
-    foo: {
-      bar: ref(42)
-    }
-  })
-
-  const foo = toRef(baz, 'foo')
-
-  expectType<Ref<number>>(foo.value.bar)
-  expectType<number>(foo.value.bar.value)
-})
-
 // #4771
 describe('shallow reactive in reactive', () => {
   const baz = reactive({