From e2c19c20cfee9788519a80c0e53e216b78505994 Mon Sep 17 00:00:00 2001
From: Tycho <jh.leong@outlook.com>
Date: Fri, 27 Sep 2024 10:23:01 +0800
Subject: [PATCH] fix(types/ref): handle nested refs in UnwrapRef (#12049)

close #12044
---
 packages-private/dts-test/ref.test-d.ts | 18 ++++++++++++++++++
 packages/reactivity/src/ref.ts          |  8 +++++---
 2 files changed, 23 insertions(+), 3 deletions(-)

diff --git a/packages-private/dts-test/ref.test-d.ts b/packages-private/dts-test/ref.test-d.ts
index 929e3d1a1ab..89b80a70fb5 100644
--- a/packages-private/dts-test/ref.test-d.ts
+++ b/packages-private/dts-test/ref.test-d.ts
@@ -189,6 +189,24 @@ describe('allow getter and setter types to be unrelated', <T>() => {
   f.value = ref(1)
 })
 
+describe('correctly unwraps nested refs', () => {
+  const obj = {
+    n: 24,
+    ref: ref(24),
+    nestedRef: ref({ n: ref(0) }),
+  }
+
+  const a = ref(obj)
+  expectType<number>(a.value.n)
+  expectType<number>(a.value.ref)
+  expectType<number>(a.value.nestedRef.n)
+
+  const b = reactive({ a })
+  expectType<number>(b.a.n)
+  expectType<number>(b.a.ref)
+  expectType<number>(b.a.nestedRef.n)
+})
+
 // computed
 describe('allow computed getter and setter types to be unrelated', () => {
   const obj = ref({
diff --git a/packages/reactivity/src/ref.ts b/packages/reactivity/src/ref.ts
index 1de8b9e3317..43b26b78f9d 100644
--- a/packages/reactivity/src/ref.ts
+++ b/packages/reactivity/src/ref.ts
@@ -62,7 +62,9 @@ export function ref(value?: unknown) {
 
 declare const ShallowRefMarker: unique symbol
 
-export type ShallowRef<T = any> = Ref<T> & { [ShallowRefMarker]?: true }
+export type ShallowRef<T = any, S = T> = Ref<T, S> & {
+  [ShallowRefMarker]?: true
+}
 
 /**
  * Shallow version of {@link ref()}.
@@ -490,9 +492,9 @@ export type ShallowUnwrapRef<T> = {
 type DistributeRef<T> = T extends Ref<infer V> ? V : T
 
 export type UnwrapRef<T> =
-  T extends ShallowRef<infer V>
+  T extends ShallowRef<infer V, infer _>
     ? V
-    : T extends Ref<infer V>
+    : T extends Ref<infer V, infer _>
       ? UnwrapRefSimple<V>
       : UnwrapRefSimple<T>