106 lines
3.0 KiB
TypeScript
106 lines
3.0 KiB
TypeScript
import { track, trigger } from './effect'
|
|
import { TrackOpTypes, TriggerOpTypes } from './operations'
|
|
import { isObject } from '@vue/shared'
|
|
import { reactive, isReactive } from './reactive'
|
|
import { ComputedRef } from './computed'
|
|
import { CollectionTypes } from './collectionHandlers'
|
|
|
|
const isRefSymbol = Symbol()
|
|
|
|
export interface Ref<T = any> {
|
|
// This field is necessary to allow TS to differentiate a Ref from a plain
|
|
// object that happens to have a "value" field.
|
|
// However, checking a symbol on an arbitrary object is much slower than
|
|
// checking a plain property, so we use a _isRef plain property for isRef()
|
|
// check in the actual implementation.
|
|
// The reason for not just declaring _isRef in the interface is because we
|
|
// don't want this internal field to leak into userland autocompletion -
|
|
// a private symbol, on the other hand, achieves just that.
|
|
[isRefSymbol]: true
|
|
value: UnwrapRef<T>
|
|
}
|
|
|
|
const convert = <T extends unknown>(val: T): T =>
|
|
isObject(val) ? reactive(val) : val
|
|
|
|
export function isRef<T>(r: Ref<T> | T): r is Ref<T>
|
|
export function isRef(r: any): r is Ref {
|
|
return r ? r._isRef === true : false
|
|
}
|
|
|
|
export function ref<T extends Ref>(value: T): T
|
|
export function ref<T>(value: T): Ref<T>
|
|
export function ref<T = any>(): Ref<T>
|
|
export function ref(value?: unknown) {
|
|
if (isRef(value)) {
|
|
return value
|
|
}
|
|
value = convert(value)
|
|
const r = {
|
|
_isRef: true,
|
|
get value() {
|
|
track(r, TrackOpTypes.GET, 'value')
|
|
return value
|
|
},
|
|
set value(newVal) {
|
|
value = convert(newVal)
|
|
trigger(
|
|
r,
|
|
TriggerOpTypes.SET,
|
|
'value',
|
|
__DEV__ ? { newValue: newVal } : void 0
|
|
)
|
|
}
|
|
}
|
|
return r
|
|
}
|
|
|
|
export function toRefs<T extends object>(
|
|
object: T
|
|
): { [K in keyof T]: Ref<T[K]> } {
|
|
if (__DEV__ && !isReactive(object)) {
|
|
console.warn(`toRefs() expects a reactive object but received a plain one.`)
|
|
}
|
|
const ret: any = {}
|
|
for (const key in object) {
|
|
ret[key] = toProxyRef(object, key)
|
|
}
|
|
return ret
|
|
}
|
|
|
|
function toProxyRef<T extends object, K extends keyof T>(
|
|
object: T,
|
|
key: K
|
|
): Ref<T[K]> {
|
|
return {
|
|
_isRef: true,
|
|
get value(): any {
|
|
return object[key]
|
|
},
|
|
set value(newVal) {
|
|
object[key] = newVal
|
|
}
|
|
} as any
|
|
}
|
|
|
|
type UnwrapArray<T> = { [P in keyof T]: UnwrapRef<T[P]> }
|
|
|
|
// corner case when use narrows type
|
|
// Ex. type RelativePath = string & { __brand: unknown }
|
|
// RelativePath extends object -> true
|
|
type BaseTypes = string | number | boolean
|
|
|
|
// Recursively unwraps nested value bindings.
|
|
export type UnwrapRef<T> = {
|
|
cRef: T extends ComputedRef<infer V> ? UnwrapRef<V> : T
|
|
ref: T extends Ref<infer V> ? UnwrapRef<V> : T
|
|
array: T extends Array<infer V> ? Array<UnwrapRef<V>> & UnwrapArray<T> : T
|
|
object: { [K in keyof T]: UnwrapRef<T[K]> }
|
|
}[T extends ComputedRef<any>
|
|
? 'cRef'
|
|
: T extends Array<any>
|
|
? 'array'
|
|
: T extends Ref | Function | CollectionTypes | BaseTypes
|
|
? 'ref' // bail out on types that shouldn't be unwrapped
|
|
: T extends object ? 'object' : 'ref']
|