All files liob.js

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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/*
 * @Author: lijianzhang
 * @Date: 2018-03-31 20:33:58
 * @Last Modified by: lijianzhang
 * @Last Modified time: 2018-08-01 15:15:28
 * @flow
 */
import event from './event';
import useLog from './log';
import type Observer from './observer';
 
/**
 * 全局的数据源管理
 */
 
type observersType = Set<Observer>;
class Liob {
  /**
     * key: 原始值 value 原始值的proxy;
     */
  dataToProxy: WeakMap<{}, {}> = new WeakMap(); // 弱引用
  proxys: WeakSet<{}> = new WeakSet();
 
  useLog = useLog;
 
  /**
     * 当前需要触发的观察者函数会在栈至0的时候执行
     */
  queue: Set<Observer> = new Set();
 
 
  collectObservers = [];
 
  onError(error) {
      throw error;
  }
 
  /**
     * action栈
     */
  stack = 0;
 
  readyRunQueue: boolean;
 
  /**
     * 当前的Observer
     */
  get currentObserver(): Observer {
      return this.collectObservers[this.collectObservers.length - 1];
  }
 
  set currentObserver(observer: Observer) {
      if (observer === null) {
          this.collectObservers.pop();
          return;
      }
      const index = this.collectObservers.indexOf(observer);
      if (index > -1) {
          this.collectObservers.splice(index, 1);
      }
      this.collectObservers.push(observer);
  }
 
  isObservable(raw: any) {
      return this.dataToProxy.has(raw);
  }
 
  isProxy(proxy: any) {
      return this.proxys.has(proxy);
  }
 
  dataKeyToObservers: WeakMap<{}, Map<string, observersType>> = new WeakMap();
 
  /**
     *
     * @param {object} raw 可观察对象的原始值
     * @param {string} key 可以观察对象的属性
     */
  getObservers(raw: {}, key: string) {
      let keyToObservers = this.dataKeyToObservers.get(raw);
      if (!keyToObservers) {
          keyToObservers = new Map();
          this.dataKeyToObservers.set(raw, keyToObservers);
      }
 
      let observers = keyToObservers.get(key);
 
      if (!observers) {
          // $flow-disable-line
          observers = new Set();
          keyToObservers.set(key, observers);
      }
 
      if (Array.isArray(Reflect.get(raw, key))) {
        const subObservers = this.getObservers(Reflect.get(raw, key), 'length'); //eslint-disable-line
          observers.forEach(observer => subObservers.add(observer));
      }
 
      return observers;
  }
 
  /**
     *
     * @param {object} raw 可观察对象的原始值
     * @param {string} key 可以观察对象的属性
     */
  hasObservers(raw: {}, key: string) {
      const map = this.dataKeyToObservers.get(raw);
      if (map && map.get(key)) {
          return true;
      }
      return false;
  }
 
  /**
     *
     * @param {Array<Observer>} observers 可观察对象数组
     * 修改可观察对象属性的时候触发将对应的观察者push到队列中如果不在action中特殊处理
     */
  pushQueue(observers: observersType) {
      observers.forEach((observer) => {
          this.queue.delete(observer);
          this.queue.add(observer);
      });
      if (!this.inAction && !this.readyRunQueue) {
          Promise.resolve().then(this.runQueue);
          this.readyRunQueue = true;
      }
  }
 
  runQueue = () => {
      this.readyRunQueue = false;
      if (this.queue.size === 0) return;
      this.queue.forEach((observer) => {
          event.emit('Observer', observer.name);
          observer.run();
      });
 
      this.queue.clear();
  };
 
  get inAction(): boolean {
      return this.stack > 0;
  }
}
 
const liob = new Liob();
 
if (window) {
    window.liob = liob;
}

if (global) {
    global.liob = liob;
}
 

export default liob;