@expressive/mvc 1.0.0-beta.33 → 1.0.0-beta.34

package/lib/index.js

@@ -96,58 +96,51 @@ class Subscriber {
     constructor(parent, onUpdate) {
         this.onUpdate = onUpdate;
         this.active = false;
-        this.handle = {};
+        this.using = {};
         this.dependant = new Set();
-        this.debug = () => {
-            const update = [];
-            this.notify = keys => {
-                update.splice(0, update.length, ...keys.filter(k => k in this.handle));
-            };
-            return update;
-        };
-        this.listen = (key, from) => {
-            const handler = this.handle[key];
-            if (!handler)
-                return;
-            if (typeof handler == "function")
-                handler();
-            const notify = this.onUpdate(key, from);
-            if (notify)
-                from.waiting.add(notify);
-            if (this.notify)
-                from.waiting.add(this.notify);
-        };
         if (!(parent instanceof Controller))
             parent = manage(parent);
         this.parent = parent;
         this.source = parent.subject;
         this.proxy = create(parent.subject);
         define(this.proxy, LOCAL, this);
-        defineLazy(this.proxy, UPDATE, this.debug);
+        defineLazy(this.proxy, UPDATE, () => {
+            const update = [];
+            this.notify = keys => {
+                update.splice(0, update.length, ...keys.filter(k => k in this.using));
+            };
+            return update;
+        });
         for (const key in parent.state)
             this.spy(key);
     }
     spy(key) {
-        const { proxy, source } = this;
-        const { set } = getOwnPropertyDescriptor(source, key);
-        const intercept = () => {
-            this.follow(key);
+        const { proxy } = this;
+        const existing = getOwnPropertyDescriptor(this.source, key);
+        const isUsing = () => {
+            this.using[key] = true;
             delete proxy[key];
             return proxy[key];
         };
-        setAlias(intercept, `tap ${key}`);
+        setAlias(isUsing, `tap ${key}`);
         defineProperty(proxy, key, {
-            get: intercept,
-            set,
+            set: existing.set,
+            get: isUsing,
             configurable: true,
             enumerable: true
         });
     }
-    follow(key, callback) {
-        this.handle[key] = callback || true;
-    }
     commit() {
-        const onDone = this.parent.addListener(this.listen);
+        const onDone = this.parent.addListener((key, source) => {
+            const handler = this.using[key];
+            if (!handler)
+                return;
+            if (typeof handler == "function")
+                handler();
+            const notify = this.onUpdate(key, source);
+            source.onUpdate(notify);
+            source.onUpdate(this.notify);
+        });
         this.active = true;
         this.dependant.forEach(x => x.commit());
         return this.release = () => {
@@ -234,7 +227,7 @@ function prepare(parent, key, source, setter, getter) {
         }
         finally {
             sub.commit();
-            for (const key in sub.handle) {
+            for (const key in sub.using) {
                 const peer = register.get(key);
                 if (peer && peer.priority >= info.priority)
                     info.priority = peer.priority + 1;
@@ -371,6 +364,10 @@ class Controller {
     get pending() {
         return this.frame.size > 0;
     }
+    onUpdate(cb) {
+        if (typeof cb == "function")
+            this.waiting.add(cb);
+    }
     start() {
         const { subject } = this;
         for (const key in subject) {
@@ -435,11 +432,8 @@ class Controller {
         if (!this.frame.size)
             setTimeout(() => this.emit(), 0);
         this.frame.add(key);
-        for (const subscription of this.followers) {
-            const notify = subscription(key, this);
-            if (notify)
-                this.waiting.add(notify);
-        }
+        for (const callback of this.followers)
+            this.onUpdate(callback(key, this));
     }
     emit() {
         flush(this);
@@ -498,7 +492,7 @@ function child(source, name) {
                 start();
             }
             start();
-            sub.follow(key, restart);
+            sub.using[key] = restart;
         }
         return (local) => {
             if (!local)
@@ -669,9 +663,9 @@ function act(task) {
 }
 function from(source, setter, argument) {
     return apply(function from(key) {
-        const { subject } = this;
         let getSource;
-        let getter = argument === true
+        const { subject } = this;
+        const getter = argument === true
             ? pendingValue
             : argument || undefined;
         // Easy mistake, using a peer, will always be unresolved.
@@ -812,13 +806,11 @@ function useWatcher(target, focus, expected) {
 function useComputed(target, compute, expected) {
     const hook = use$1(refresh => {
         const sub = new Subscriber(target, () => update);
-        const { proxy } = sub;
-        let value;
+        const spy = sub.proxy;
+        let value = compute.call(spy, spy);
+        let update;
         let retry;
-        const update = () => {
-            const next = compute.call(proxy, proxy);
-            if (value == next)
-                return;
+        const set = (next) => {
             value = next;
             if (retry) {
                 retry();
@@ -827,16 +819,26 @@ function useComputed(target, compute, expected) {
             else
                 refresh();
         };
-        const access = () => {
-            if (value === undefined && expected)
-                throw new Promise(res => {
-                    retry = res;
-                });
-            return value;
-        };
-        value = compute.call(proxy, proxy);
-        sub.commit();
-        defineProperty(sub, "proxy", { get: access });
+        if (value instanceof Promise) {
+            value.then(set);
+            value = undefined;
+        }
+        else {
+            sub.commit();
+            update = () => {
+                const next = compute.call(spy, spy);
+                if (value != next)
+                    set(next);
+            };
+        }
+        const get = expected
+            ? () => {
+                if (value === undefined)
+                    throw new Promise(res => retry = res);
+                return value;
+            }
+            : () => value;
+        defineProperty(sub, "proxy", { get });
         return sub;
     });
     react.useLayoutEffect(() => hook.release, []);
@@ -999,7 +1001,7 @@ class Model {
         define(this, "set", this);
         defer(control, "on");
         defer(control, "effect");
-        control.waiting.add(() => {
+        control.onUpdate(() => {
             delete this.on;
             delete this.effect;
         });
@@ -1046,10 +1048,9 @@ class Model {
     once(select, callback, squash) {
         if (callback)
             return this.on(select, callback, squash, true);
-        else
-            return new Promise(resolve => {
-                this.on(select, resolve, true, true);
-            });
+        return new Promise(resolve => {
+            this.on(select, resolve, true, true);
+        });
     }
     effect(callback, select) {
         const control = manage(this);