From 27f4678d9d631c009d2fc0388944f9d57edf9f59 Mon Sep 17 00:00:00 2001
From: pikax <carlos@hypermob.co.uk>
Date: Wed, 6 May 2020 08:31:18 +0100
Subject: [PATCH] types: allow using ref with unknown generic types

---
 packages/reactivity/src/ref.ts | 15 ++++++++++++++-
 test-dts/ref.test-d.ts         | 33 +++++++++++++++++++++++++++++++++
 2 files changed, 47 insertions(+), 1 deletion(-)

diff --git a/packages/reactivity/src/ref.ts b/packages/reactivity/src/ref.ts
index d22e6a0e969..e18274af6bd 100644
--- a/packages/reactivity/src/ref.ts
+++ b/packages/reactivity/src/ref.ts
@@ -27,10 +27,23 @@ export function isRef(r: any): r is Ref {
   return r ? r.__v_isRef === true : false
 }
 
+// explicit `boolean` otherwise it will return
+// `Ref<true> | Ref<false>` instead of `Ref<boolean>`
+export function ref(value: boolean): Ref<boolean>
+// handles normal object
 export function ref<T extends object>(
   value: T
 ): T extends Ref ? T : Ref<UnwrapRef<T>>
-export function ref<T>(value: T): Ref<UnwrapRef<T>>
+
+// handles ref object
+export function ref<T extends Ref>(value: T): T
+
+// handles unknown and some odd types
+export function ref<T extends unknown | object>(
+  value: T
+): T extends Ref ? T : Ref<UnwrapRef<T>>
+
+// export function ref<T>(value: T): Ref<UnwrapRef<T>>
 export function ref<T = any>(): Ref<T | undefined>
 export function ref(value?: unknown) {
   return createRef(value)
diff --git a/test-dts/ref.test-d.ts b/test-dts/ref.test-d.ts
index e2454e035c8..34064029d32 100644
--- a/test-dts/ref.test-d.ts
+++ b/test-dts/ref.test-d.ts
@@ -85,6 +85,39 @@ function withSymbol() {
 
 withSymbol()
 
+function generics<TGeneric extends { a: 1 }>() {
+  ;(function unknownGeneric<T>(v: T) {
+    const r = ref(v)
+    expectType<any>(r.value) // T in this case can be anything
+  })
+  ;(function stringGeneric<T extends string>(v: T) {
+    const r = ref(v)
+    expectType<string>(r.value)
+  })
+  ;(function assignedGeneric<T = TGeneric>(v: T) {
+    const r = ref(v)
+    expectType<any>(r.value) // T in this case can be anything
+  })
+  ;(function extendsGeneric<T extends TGeneric>(v: T) {
+    const r = ref(v)
+    expectType<{ a: 1 }>(r.value) // this will infer the actual type instead of being generic
+  })
+  ;(function functionGeneric<T extends (a: number, b: string) => number>(v: T) {
+    const r = ref(v)
+    expectType<(a: number, b: string) => number>(r.value) // this will infer the actual type instead of being generic
+  })
+  ;(function arrayGeneric<T extends Array<number>>(v: T) {
+    const r = ref(v)
+    expectType<Array<number>>(r.value)
+  })
+  ;(function tupleGeneric<T extends [number, string]>(v: T) {
+    const r = ref(v)
+    expectType<[number, string]>(r.value)
+  })
+}
+
+generics()
+
 const state = reactive({
   foo: {
     value: 1,