137 lines
3.4 KiB
TypeScript
137 lines
3.4 KiB
TypeScript
import { reactive, readonly, toRaw } from './reactive'
|
|
import { OperationTypes } from './operations'
|
|
import { track, trigger } from './effect'
|
|
import { LOCKED } from './lock'
|
|
import { isObject, hasOwn } from '@vue/shared'
|
|
import { isRef } from './ref'
|
|
|
|
const builtInSymbols = new Set(
|
|
Object.getOwnPropertyNames(Symbol)
|
|
.map(key => (Symbol as any)[key])
|
|
.filter(value => typeof value === 'symbol')
|
|
)
|
|
|
|
function createGetter(isReadonly: boolean) {
|
|
return function get(target: any, key: string | symbol, receiver: any) {
|
|
const res = Reflect.get(target, key, receiver)
|
|
if (typeof key === 'symbol' && builtInSymbols.has(key)) {
|
|
return res
|
|
}
|
|
if (isRef(res)) {
|
|
return res.value
|
|
}
|
|
track(target, OperationTypes.GET, key)
|
|
return isObject(res)
|
|
? isReadonly
|
|
? // need to lazy access readonly and reactive here to avoid
|
|
// circular dependency
|
|
readonly(res)
|
|
: reactive(res)
|
|
: res
|
|
}
|
|
}
|
|
|
|
function set(
|
|
target: any,
|
|
key: string | symbol,
|
|
value: any,
|
|
receiver: any
|
|
): boolean {
|
|
value = toRaw(value)
|
|
const hadKey = hasOwn(target, key)
|
|
const oldValue = target[key]
|
|
if (isRef(oldValue) && !isRef(value)) {
|
|
oldValue.value = value
|
|
return true
|
|
}
|
|
const result = Reflect.set(target, key, value, receiver)
|
|
// don't trigger if target is something up in the prototype chain of original
|
|
if (target === toRaw(receiver)) {
|
|
/* istanbul ignore else */
|
|
if (__DEV__) {
|
|
const extraInfo = { oldValue, newValue: value }
|
|
if (!hadKey) {
|
|
trigger(target, OperationTypes.ADD, key, extraInfo)
|
|
} else if (value !== oldValue) {
|
|
trigger(target, OperationTypes.SET, key, extraInfo)
|
|
}
|
|
} else {
|
|
if (!hadKey) {
|
|
trigger(target, OperationTypes.ADD, key)
|
|
} else if (value !== oldValue) {
|
|
trigger(target, OperationTypes.SET, key)
|
|
}
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
function deleteProperty(target: any, key: string | symbol): boolean {
|
|
const hadKey = hasOwn(target, key)
|
|
const oldValue = target[key]
|
|
const result = Reflect.deleteProperty(target, key)
|
|
if (hadKey) {
|
|
/* istanbul ignore else */
|
|
if (__DEV__) {
|
|
trigger(target, OperationTypes.DELETE, key, { oldValue })
|
|
} else {
|
|
trigger(target, OperationTypes.DELETE, key)
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
function has(target: any, key: string | symbol): boolean {
|
|
const result = Reflect.has(target, key)
|
|
track(target, OperationTypes.HAS, key)
|
|
return result
|
|
}
|
|
|
|
function ownKeys(target: any): (string | number | symbol)[] {
|
|
track(target, OperationTypes.ITERATE)
|
|
return Reflect.ownKeys(target)
|
|
}
|
|
|
|
export const mutableHandlers: ProxyHandler<any> = {
|
|
get: createGetter(false),
|
|
set,
|
|
deleteProperty,
|
|
has,
|
|
ownKeys
|
|
}
|
|
|
|
export const readonlyHandlers: ProxyHandler<any> = {
|
|
get: createGetter(true),
|
|
|
|
set(target: any, key: string | symbol, value: any, receiver: any): boolean {
|
|
if (LOCKED) {
|
|
if (__DEV__) {
|
|
console.warn(
|
|
`Set operation on key "${key as any}" failed: target is readonly.`,
|
|
target
|
|
)
|
|
}
|
|
return true
|
|
} else {
|
|
return set(target, key, value, receiver)
|
|
}
|
|
},
|
|
|
|
deleteProperty(target: any, key: string | symbol): boolean {
|
|
if (LOCKED) {
|
|
if (__DEV__) {
|
|
console.warn(
|
|
`Delete operation on key "${key as any}" failed: target is readonly.`,
|
|
target
|
|
)
|
|
}
|
|
return true
|
|
} else {
|
|
return deleteProperty(target, key)
|
|
}
|
|
},
|
|
|
|
has,
|
|
ownKeys
|
|
}
|