[REF] owl: reorganize src code in sub files

src/core/event_bus.ts

@@ -0,0 +1,79 @@
+/**
+ * We define here a simple event bus: it can
+ * - emit events
+ * - add/remove listeners.
+ *
+ * This is a useful pattern of communication in many cases.  For OWL, each
+ * components and stores are event buses.
+ */
+
+//------------------------------------------------------------------------------
+// Types
+//------------------------------------------------------------------------------
+
+export type Callback = (...args: any[]) => void;
+
+export interface Subscription {
+  owner: any;
+  callback: Callback;
+}
+
+//------------------------------------------------------------------------------
+// EventBus
+//------------------------------------------------------------------------------
+
+export class EventBus {
+  subscriptions: { [eventType: string]: Subscription[] } = {};
+
+  /**
+   * Add a listener for the 'eventType' events.
+   *
+   * Note that the 'owner' of this event can be anything, but will more likely
+   * be a component or a class. The idea is that the callback will be called with
+   * the proper owner bound.
+   *
+   * Also, the owner should be kind of unique. This will be used to remove the
+   * listener.
+   */
+  on(eventType: string, owner: any, callback: Callback) {
+    if (!callback) {
+      throw new Error("Missing callback");
+    }
+    if (!this.subscriptions[eventType]) {
+      this.subscriptions[eventType] = [];
+    }
+    this.subscriptions[eventType].push({
+      owner,
+      callback
+    });
+  }
+
+  /**
+   * Remove a listener
+   */
+  off(eventType: string, owner: any) {
+    const subs = this.subscriptions[eventType];
+    if (subs) {
+      this.subscriptions[eventType] = subs.filter(s => s.owner !== owner);
+    }
+  }
+
+  /**
+   * Emit an event of type 'eventType'.  Any extra arguments will be passed to
+   * the listeners callback.
+   */
+  trigger(eventType: string, ...args: any[]) {
+    const subs = this.subscriptions[eventType] || [];
+    for (let i = 0, iLen = subs.length; i < iLen; i++) {
+      const sub = subs[i];
+      sub.callback.call(sub.owner, ...args);
+    }
+  }
+
+  /**
+   * Remove all subscriptions.
+   */
+  clear() {
+    this.subscriptions = {};
+  }
+}

src/core/observer.ts

@@ -0,0 +1,194 @@
+/**
+ * Owl Observer
+ *
+ * This code contains the logic that allows Owl to observe and react to state
+ * changes.
+ *
+ * This is a Observer class that can observe any JS values.  The way it works
+ * can be summarized thusly:
+ * - primitive values are not observed at all
+ * - Objects are observed by replacing all their keys with getters/setters
+ *   (recursively)
+ * - Arrays are observed by replacing their prototype with a customized version,
+ *   which wrap some methods to allow the tracking of each state change.
+ *
+ * Note that this code is inspired by Vue.
+ */
+
+//------------------------------------------------------------------------------
+// Modified Array prototype
+//------------------------------------------------------------------------------
+
+// we define here a new modified Array prototype, which basically override all
+// Array methods that change some state to be able to track their changes
+const methodsToPatch = ["push", "pop", "shift", "unshift", "splice", "sort", "reverse"];
+const methodLen = methodsToPatch.length;
+
+const ArrayProto = Array.prototype;
+const ModifiedArrayProto = Object.create(ArrayProto);
+
+for (let i = 0; i < methodLen; i++) {
+  const method = methodsToPatch[i];
+  const initialMethod = ArrayProto[method];
+  ModifiedArrayProto[method] = function(...args) {
+    if (!this.__observer__.allowMutations) {
+      throw new Error(`Array cannot be changed here")`);
+    }
+    this.__observer__.rev++;
+    this.__observer__.notifyChange();
+    this.__owl__.rev++;
+    let parent = this;
+    do {
+      parent.__owl__.deepRev++;
+    } while ((parent = parent.__owl__.parent));
+    let inserted;
+    switch (method) {
+      case "push":
+      case "unshift":
+        inserted = args;
+        break;
+      case "splice":
+        inserted = args.slice(2);
+        break;
+    }
+    if (inserted) {
+      for (let i = 0, iLen = inserted.length; i < iLen; i++) {
+        this.__observer__.observe(inserted[i], this);
+      }
+    }
+    return initialMethod.call(this, ...args);
+  };
+}
+
+//------------------------------------------------------------------------------
+// Observer
+//------------------------------------------------------------------------------
+export class Observer {
+  rev: number = 1;
+  allowMutations: boolean = true;
+  dirty: boolean = false;
+
+  static set(target: any, key: number | string, value: any) {
+    if (!target.__owl__) {
+      throw Error("`Observer.set()` can only be called with observed Objects or Arrays");
+    }
+    target.__owl__.observer.set(target, key, value);
+  }
+
+  static delete(target: any, key: number | string) {
+    if (!target.__owl__) {
+      throw Error("`Observer.delete()` can only be called with observed Objects");
+    }
+    target.__owl__.observer.delete(target, key);
+  }
+
+  notifyCB() {}
+  notifyChange() {
+    this.dirty = true;
+    Promise.resolve().then(() => {
+      if (this.dirty) {
+        this.dirty = false;
+        this.notifyCB();
+      }
+    });
+  }
+
+  observe(value: any, parent?: any) {
+    if (value === null) {
+      // fun fact: typeof null === 'object'
+      return;
+    }
+    if (typeof value !== "object") {
+      return;
+    }
+    if ("__owl__" in value) {
+      // already observed
+      value.__owl__.parent = parent;
+      return;
+    }
+    if (Array.isArray(value)) {
+      this._observeArr(value, parent);
+    } else {
+      this._observeObj(value, parent);
+    }
+  }
+
+  set(target: any, key: number | string, value: any) {
+    let alreadyDefined =
+      key in target && Object.getOwnPropertyDescriptor(target, key)!.configurable === false;
+    if (alreadyDefined) {
+      target[key] = value;
+    } else {
+      this._addProp(target, key, value);
+      this._updateRevNumber(target);
+    }
+    this.notifyChange();
+  }
+
+  delete(target: any, key: number | string) {
+    delete target[key];
+    this._updateRevNumber(target);
+    this.notifyChange();
+  }
+
+  _observeObj<T extends { __owl__?: any }>(obj: T, parent?: any) {
+    obj.__owl__ = {
+      rev: this.rev,
+      deepRev: this.rev,
+      parent,
+      observer: this
+    };
+    Object.defineProperty(obj, "__owl__", { enumerable: false });
+    for (let key in obj) {
+      this._addProp(obj, key, obj[key]);
+    }
+  }
+
+  _observeArr(arr: Array<any>, parent?: any) {
+    (<any>arr).__owl__ = {
+      rev: this.rev,
+      deepRev: this.rev,
+      parent,
+      observer: this
+    };
+    Object.defineProperty(arr, "__owl__", { enumerable: false });
+    (<any>arr).__proto__ = Object.create(ModifiedArrayProto);
+    (<any>arr).__proto__.__observer__ = this;
+    for (let i = 0, iLen = arr.length; i < iLen; i++) {
+      this.observe(arr[i], arr);
+    }
+  }
+
+  _addProp<T extends { __owl__?: any }>(obj: T, key: string | number, value: any) {
+    var self = this;
+    Object.defineProperty(obj, key, {
+      configurable: true,
+      enumerable: true,
+      get() {
+        return value;
+      },
+      set(newVal) {
+        if (newVal !== value) {
+          if (!self.allowMutations) {
+            throw new Error(
+              `Observed state cannot be changed here! (key: "${key}", val: "${newVal}")`
+            );
+          }
+          self._updateRevNumber(obj);
+          value = newVal;
+          self.observe(newVal, obj);
+          self.notifyChange();
+        }
+      }
+    });
+    this.observe(value, obj);
+  }
+  _updateRevNumber(target: any) {
+    this.rev++;
+    target.__owl__.rev!++;
+    let parent = target;
+    do {
+      parent.__owl__.deepRev++;
+    } while ((parent = parent.__owl__.parent) && parent !== target);
+  }
+}