Press n or j to go to the next uncovered block, b, p or k for the previous block.
| 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 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 | 6x 6x 6x 6x 6x 6x 91x 91x 53x 53x 53x 17x 53x 53x 24x 24x 53x 53x 91x 25x 25x 25x 25x 25x 21x 21x 19x 25x 1x 1x 1x 1x 1x 1x 20x 20x 20x 6x 14x 14x 5x 5x 5x 6x 6x 6x 5x 9x 6x | /*
* @Author: lijianzhang
* @Date: 2018-03-31 21:04:00
* @Last Modified by: lijianzhang
* @Last Modified time: 2018-09-02 02:10:08
* @flow
*/
import "reflect-metadata";
import store from './store';
import event from './event';
import { OBSERVER_KEY, RAW_KEY, DO_NOT_TRUN_INTO_A_PRXOY } from './constant';
import { isFunction, isObservableObject } from './utils';
import { IProxyData, IClass } from './type';
/**
* 设计流程:
* observable 函数传入一个待观察的对象, 对改对象进行Proxy的封装
* 主要在get, set, delete该对象的时候出来
* get: 当处于observer执行的时候对
*
*/
function onGet(target: IProxyData, key: string | number | symbol, receiver) {
let value = Reflect.get(target, key, receiver);
I
if (store.currentObserver) {
if (isFunction(value) || key === RAW_KEY) {
I return value;
}
if (isObservableObject(value) && !Reflect.get(value, DO_NOT_TRUN_INTO_A_PRXOY) && !value[RAW_KEY]) {
const descriptor = Object.getOwnPropertyDescriptor(target, key);
if (descriptor && !descriptor.get) {
value = toObservable(value);
}
}
if (!target[OBSERVER_KEY]) {
Object.defineProperty(target, OBSERVER_KEY, {
value: new Map(),
writable: false,
enumerable: false,
configurable: false,
});
}
let observers = target[OBSERVER_KEY]!.get(key);
if (!observers) {
observers = new Set();
target[OBSERVER_KEY]!.set(key as string, observers);
}
I observers.add(store.currentObserver.id);
store.currentObserver.bindObservers.add(observers);
}
return value;
}
function onSet(target: IProxyData, key, value, receiver) {
const oldValue = Reflect.get(target, key, receiver);
if (oldValue === value && key !== 'length') return true;
event.emit('set', { target, key, oldValue, value });
Reflect.set(target, key, value, receiver);
if (target[OBSERVER_KEY]) {
E const observers = target[OBSERVER_KEY]!.get(key);
Eif (observers) {
store.pushQueue(observers);
}
}
return true;
}
function onDelete(target, key) {
const result = Reflect.deleteProperty(target, key);
if (target[OBSERVER_KEY]) {
const observers = target[OBSERVER_KEY]!.get(key);
if (observers) {
store.pushQueue(observers);
}
}
return result;
}
expoIrt function toObservable<T>(store: T) {
const proxy = new Proxy(store, {
get: onGet,
set: onSet,
deleteProperty: onDelete,
});
Object.defineProperty(store, RAW_KEY, {
value: store,
writable: false,
enumerable: false,
});
return proxy;
}
I
export default function observable<T>(target: T | (T & IClass) | object, key?: string): any {
if (key) {
const observableKey = Symbol('liob_' + key);
(observableKey as any).type == 'attr';
Object.defineProperty(target as object, key, {
get: function() {
const value = onGet(this, observableKey, undefined);
return value;
},
set: function(value) {
onSet(this, observableKey, value, this);
},
enumerable: true,
});
return undefined;
} else if (typeof target === 'function') {
target[RAW_KEY] = target; // fix extends class error
if (target.__proto__[RAW_KEY]) {
target.__proto__ = target.__proto__[RAW_KEY];
}
const proxy = new Proxy(target, {
construct(Cls, argumentsList) {
const ob = new Cls(...argumentsList);
const proxy = toObservable(ob);
return proxy;
},
});
return proxy;
}
return toObservable(target);
} |