Spaces:
Paused
Paused
File size: 2,901 Bytes
9ada4bc |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 |
import { findPropertySource } from './findPropertySource'
export interface ProxyOptions<Target extends Record<string, any>> {
constructorCall?(args: Array<unknown>, next: NextFunction<Target>): Target
methodCall?<F extends keyof Target>(
this: Target,
data: [methodName: F, args: Array<unknown>],
next: NextFunction<void>
): void
setProperty?(
data: [propertyName: string | symbol, nextValue: unknown],
next: NextFunction<boolean>
): boolean
getProperty?(
data: [propertyName: string | symbol, receiver: Target],
next: NextFunction<void>
): void
}
export type NextFunction<ReturnType> = () => ReturnType
export function createProxy<Target extends object>(
target: Target,
options: ProxyOptions<Target>
): Target {
const proxy = new Proxy(target, optionsToProxyHandler(options))
return proxy
}
function optionsToProxyHandler<T extends Record<string, any>>(
options: ProxyOptions<T>
): ProxyHandler<T> {
const { constructorCall, methodCall, getProperty, setProperty } = options
const handler: ProxyHandler<T> = {}
if (typeof constructorCall !== 'undefined') {
handler.construct = function (target, args, newTarget) {
const next = Reflect.construct.bind(null, target as any, args, newTarget)
return constructorCall.call(newTarget, args, next)
}
}
handler.set = function (target, propertyName, nextValue) {
const next = () => {
const propertySource = findPropertySource(target, propertyName) || target
const ownDescriptors = Reflect.getOwnPropertyDescriptor(
propertySource,
propertyName
)
// Respect any custom setters present for this property.
if (typeof ownDescriptors?.set !== 'undefined') {
ownDescriptors.set.apply(target, [nextValue])
return true
}
// Otherwise, set the property on the source.
return Reflect.defineProperty(propertySource, propertyName, {
writable: true,
enumerable: true,
configurable: true,
value: nextValue,
})
}
if (typeof setProperty !== 'undefined') {
return setProperty.call(target, [propertyName, nextValue], next)
}
return next()
}
handler.get = function (target, propertyName, receiver) {
/**
* @note Using `Reflect.get()` here causes "TypeError: Illegal invocation".
*/
const next = () => target[propertyName as any]
const value =
typeof getProperty !== 'undefined'
? getProperty.call(target, [propertyName, receiver], next)
: next()
if (typeof value === 'function') {
return (...args: Array<any>) => {
const next = value.bind(target, ...args)
if (typeof methodCall !== 'undefined') {
return methodCall.call(target, [propertyName as any, args], next)
}
return next()
}
}
return value
}
return handler
}
|