feat(reactivity): support converting getter to ref with toRef()

packages/dts-test/ref.test-d.ts

@@ -203,6 +203,13 @@ expectType<Ref<string>>(p2.obj.k)
   // Should not distribute Refs over union
   expectType<Ref<number | string>>(toRef(obj, 'c'))
 
+  expectType<Ref<number>>(toRef(() => 123))
+  expectType<Ref<number | string>>(toRef(() => obj.c))
+
+  const r = toRef(() => 123)
+  // @ts-expect-error
+  r.value = 234
+
   // toRefs
   expectType<{
     a: Ref<number>

packages/reactivity/__tests__/ref.spec.ts

@@ -287,6 +287,15 @@ describe('reactivity/ref', () => {
     expect(x.value).toBe(1)
   })
 
+  test('toRef getter', () => {
+    const x = toRef(() => 1)
+    expect(x.value).toBe(1)
+    expect(isRef(x)).toBe(true)
+    expect(unref(x)).toBe(1)
+    //@ts-expect-error
+    expect(() => (x.value = 123)).toThrow()
+  })
+
   test('toRefs', () => {
     const a = reactive({
       x: 1,

packages/reactivity/src/ref.ts

@@ -6,7 +6,7 @@ import {
   triggerEffects
 } from './effect'
 import { TrackOpTypes, TriggerOpTypes } from './operations'
-import { isArray, hasChanged, IfAny } from '@vue/shared'
+import { isArray, hasChanged, IfAny, isFunction } from '@vue/shared'
 import {
   isProxy,
   toRaw,
@@ -333,6 +333,14 @@ class ObjectRefImpl<T extends object, K extends keyof T> {
   }
 }
 
+class GetterRefImpl<T> {
+  public readonly __v_isRef = true
+  constructor(private readonly _getter: () => T) {}
+  get value() {
+    return this._getter()
+  }
+}
+
 export type ToRef<T> = IfAny<T, Ref<T>, [T] extends [Ref] ? T : Ref<T>>
 
 /**
@@ -362,6 +370,9 @@ export type ToRef<T> = IfAny<T, Ref<T>, [T] extends [Ref] ? T : Ref<T>>
  * @param key - Name of the property in the reactive object.
  * @see {@link https://vuejs.org/api/reactivity-utilities.html#toref}
  */
+export function toRef<T extends () => any>(
+  getter: T
+): T extends () => infer R ? Readonly<ShallowRef<R>> : never
 export function toRef<T extends object, K extends keyof T>(
   object: T,
   key: K
@@ -371,15 +382,19 @@ export function toRef<T extends object, K extends keyof T>(
   key: K,
   defaultValue: T[K]
 ): ToRef<Exclude<T[K], undefined>>
-export function toRef<T extends object, K extends keyof T>(
-  object: T,
-  key: K,
-  defaultValue?: T[K]
-): ToRef<T[K]> {
-  const val = object[key]
-  return isRef(val)
-    ? val
-    : (new ObjectRefImpl(object, key, defaultValue) as any)
+export function toRef(
+  objectOrGetter: Record<string, any> | (() => unknown),
+  key?: string,
+  defaultValue?: unknown
+): Ref {
+  if (isFunction(objectOrGetter)) {
+    return new GetterRefImpl(objectOrGetter as () => unknown) as any
+  } else {
+    const val = objectOrGetter[key!]
+    return isRef(val)
+      ? val
+      : (new ObjectRefImpl(objectOrGetter, key!, defaultValue) as any)
+  }
 }
 
 // corner case when use narrows type