feat(reactivity): toValue

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

@@ -7,12 +7,13 @@ import {
   reactive,
   proxyRefs,
   toRef,
+  toValue,
   toRefs,
   ToRefs,
   shallowReactive,
   readonly,
   MaybeRef,
-  MaybeReadonlyRef
+  MaybeWritableRef
 } from 'vue'
 import { expectType, describe } from './utils'
 
@@ -28,7 +29,8 @@ function plainType(arg: number | Ref<number>) {
 
   // ref unwrapping
   expectType<number>(unref(arg))
-  expectType<number>(unref(() => 123))
+  expectType<number>(toValue(arg))
+  expectType<number>(toValue(() => 123))
 
   // ref inner type should be unwrapped
   const nestedRef = ref({
@@ -330,11 +332,11 @@ describe('reactive in shallow ref', () => {
   expectType<number>(x.value.a.b)
 })
 
-describe('toRef <-> unref', () => {
+describe('toRef <-> toValue', () => {
   function foo(
-    a: MaybeRef<string>,
+    a: MaybeWritableRef<string>,
     b: () => string,
-    c: MaybeReadonlyRef<string>
+    c: MaybeRef<string>
   ) {
     const r = toRef(a)
     expectType<Ref<string>>(r)
@@ -352,9 +354,9 @@ describe('toRef <-> unref', () => {
     rc.value = 'foo'
 
     return {
-      r: unref(r),
-      rb: unref(rb),
-      rc: unref(rc)
+      r: toValue(r),
+      rb: toValue(rb),
+      rc: toValue(rc)
     }
   }
 

packages/reactivity/src/index.ts

@@ -3,14 +3,15 @@ export {
   shallowRef,
   isRef,
   toRef,
+  toValue,
   toRefs,
   unref,
   proxyRefs,
   customRef,
   triggerRef,
   type Ref,
   type MaybeRef,
-  type MaybeReadonlyRef,
+  type MaybeWritableRef,
   type ToRef,
   type ToRefs,
   type UnwrapRef,

packages/reactivity/src/ref.ts

@@ -194,8 +194,8 @@ export function triggerRef(ref: Ref) {
   triggerRefValue(ref, __DEV__ ? ref.value : void 0)
 }
 
-export type MaybeRef<T = any> = T | Ref<T>
-export type MaybeReadonlyRef<T = any> = MaybeRef<T> | (() => T)
+export type MaybeWritableRef<T = any> = T | Ref<T>
+export type MaybeRef<T = any> = MaybeWritableRef<T> | (() => T)
 
 /**
  * Returns the inner value if the argument is a ref, otherwise return the
@@ -213,8 +213,12 @@ export type MaybeReadonlyRef<T = any> = MaybeRef<T> | (() => T)
  * @param ref - Ref or plain value to be converted into the plain value.
  * @see {@link https://vuejs.org/api/reactivity-utilities.html#unref}
  */
-export function unref<T>(ref: MaybeReadonlyRef<T>): T {
-  return isRef(ref) ? (ref.value as any) : isFunction(ref) ? ref() : ref
+export function unref<T>(ref: MaybeWritableRef<T>): T {
+  return isRef(ref) ? (ref.value as any) : ref
+}
+
+export function toValue<T>(ref: MaybeRef<T>): T {
+  return isFunction(ref) ? ref() : unref(ref)
 }
 
 const shallowUnwrapHandlers: ProxyHandler<any> = {

packages/runtime-core/src/index.ts

@@ -11,6 +11,7 @@ export {
   proxyRefs,
   isRef,
   toRef,
+  toValue,
   toRefs,
   isProxy,
   isReactive,
@@ -153,7 +154,7 @@ export { TrackOpTypes, TriggerOpTypes } from '@vue/reactivity'
 export type {
   Ref,
   MaybeRef,
-  MaybeReadonlyRef,
+  MaybeWritableRef,
   ToRef,
   ToRefs,
   UnwrapRef,