@expressive/mvc 0.2.4 → 0.3.0

package/lib/index.js

@@ -148,6 +148,9 @@ function applyUpdate(subject, keys) {
             UPDATE.delete(subject);
         }, 0);
     };
+}
+function getUpdate(subject) {
+    return UPDATE.get(subject);
 }
 
 const CONTROL = Symbol("CONTROL");
@@ -179,21 +182,30 @@ class Model {
         return control(this, control => {
             if (typeof select == "function")
                 return control.addListener(select);
-            const keys = typeof select == "string" ? [select] :
+            const selection = typeof select == "string" ? [select] :
                 !select.length ? getOwnPropertyNames(control.state) :
                     select;
-            ensure(control, keys);
+            ensure(control, selection);
             const callback = squash
-                ? handler.bind(this)
-                : frame => frame
-                    .filter(k => keys.includes(k))
-                    .forEach(k => handler.call(this, control.state[k], k));
-            const trigger = once
-                ? frame => { remove(); callback(frame); }
+                ? () => {
+                    handler.call(this, getUpdate(this));
+                }
+                : () => {
+                    getUpdate(this)
+                        .filter(k => selection.includes(k))
+                        .forEach(k => {
+                        handler.call(this, control.state[k], k);
+                    });
+                };
+            const onEvent = once
+                ? () => {
+                    remove();
+                    callback();
+                }
                 : callback;
             const remove = control.addListener(key => {
-                if (keys.includes(key))
-                    return trigger;
+                if (selection.includes(key))
+                    return onEvent;
             });
             return remove;
         });
@@ -209,7 +221,7 @@ class Model {
         const effect = createEffect(callback);
         return control(this, control => {
             let busy = false;
-            let inject = this.get;
+            let inject = this.is;
             const invoke = () => {
                 if (busy)
                     return;
@@ -314,6 +326,7 @@ class Subscriber {
         this.watch = {};
         const parent = target instanceof Controller
             ? target : control(target);
+        const subject = parent.subject;
         const proxy = create(parent.proxy);
         let reset;
         define(proxy, LOCAL, this);
@@ -332,8 +345,10 @@ class Subscriber {
             if (typeof handler == "function")
                 handler();
             const notify = this.onUpdate(key, parent);
-            const getWhy = (keys) => {
-                reset = applyUpdate(proxy, keys.filter(k => k in this.watch));
+            const getWhy = () => {
+                const update = getUpdate(subject);
+                const applicable = update.filter(k => k in this.watch);
+                reset = applyUpdate(proxy, applicable);
             };
             if (notify) {
                 parent.requestUpdate(getWhy);
@@ -418,9 +433,9 @@ function from(source, arg1, arg2) {
             }
         }
         function defer(_key, from) {
-            let pending = KEYS.get(from);
+            let pending = KEYS.get(from.frame);
             if (!pending)
-                KEYS.set(from, pending = []);
+                KEYS.set(from.frame, pending = []);
             if (info.parent !== from)
                 update();
             else {
@@ -474,19 +489,17 @@ function ensure(on, keys) {
             getter(true);
     }
 }
-function flush(on) {
-    const handled = on.frame;
-    const pending = KEYS.get(on);
+function flush(frame) {
+    const pending = KEYS.get(frame);
     if (!pending)
         return;
     while (pending.length) {
-        const why = [...handled];
         const compute = pending.shift();
         const { key } = INFO.get(compute);
-        if (!handled.has(key))
-            compute(why);
+        if (!frame.has(key))
+            compute();
     }
-    KEYS.delete(on);
+    KEYS.delete(frame);
 }
 
 const Oops$9 = issues({
@@ -500,41 +513,41 @@ class Controller {
         this.subject = subject;
         this.state = {};
         this.frame = new Set();
-        this.waiting = new Set();
         this.onDestroy = new Set();
+        this.waiting = new Set();
         this.followers = new Set();
         this.proxy = Object.create(subject);
     }
     start() {
         READY.add(this);
         for (const key in this.subject) {
-            const { value: entry } = getOwnPropertyDescriptor(this.subject, key);
-            if (typeof entry == "function")
+            const { value } = getOwnPropertyDescriptor(this.subject, key);
+            if (typeof value == "function")
                 continue;
-            if (typeof entry == "symbol") {
-                const instruction = PENDING.get(entry);
+            if (typeof value == "symbol") {
+                const instruction = PENDING.get(value);
                 if (instruction)
                     instruction.call(this, key, this);
                 continue;
             }
-            this.manage(key, entry);
+            this.manage(key, value);
         }
-        this.emit([]);
+        this.flush();
     }
     stop() {
         this.followers.clear();
         this.onDestroy.forEach(x => x());
     }
     manage(key, value) {
-        const { proxy, state, subject } = this;
-        state[key] = value;
+        const { state } = this;
         const set = this.ref(key);
-        defineProperty(subject, key, {
+        state[key] = value;
+        defineProperty(this.subject, key, {
             enumerable: false,
             get: () => state[key],
             set
         });
-        defineProperty(proxy, key, {
+        defineProperty(this.proxy, key, {
             enumerable: false,
             get() {
                 const local = this[LOCAL];
@@ -566,53 +579,56 @@ class Controller {
             this.followers.delete(listener);
         };
     }
-    emit(keys) {
-        const waiting = [...this.waiting];
-        this.waiting.clear();
-        applyUpdate(this.subject, keys)();
-        for (const callback of waiting)
-            try {
-                callback(keys);
-            }
-            catch (err) {
-                console.error(err);
-            }
-    }
     update(key, value) {
+        const { frame } = this;
         if (1 in arguments)
             this.state[key] = value;
-        if (this.frame.has(key))
-            return;
-        if (!this.frame.size)
+        if (!frame.size)
             setTimeout(() => {
-                flush(this);
-                const keys = Object.freeze([...this.frame]);
-                this.frame.clear();
-                this.emit(keys);
+                flush(frame);
+                this.flush();
             }, 0);
-        this.frame.add(key);
+        else if (frame.has(key))
+            return;
+        frame.add(key);
         for (const callback of this.followers) {
             const event = callback(key, this);
             if (typeof event == "function")
                 this.waiting.add(event);
         }
     }
+    flush() {
+        const waiting = Array.from(this.waiting);
+        const keys = Array.from(this.frame);
+        this.frame.clear();
+        this.waiting.clear();
+        applyUpdate(this.subject, keys)();
+        for (const callback of waiting)
+            try {
+                callback();
+            }
+            catch (err) {
+                console.error(err);
+            }
+    }
     requestUpdate(arg) {
+        const { frame, subject, waiting } = this;
         if (typeof arg == "function") {
-            this.waiting.add(arg);
+            waiting.add(arg);
             return;
         }
-        if (arg === true && this.frame.size < 1)
+        if (!frame.size && arg === true)
             return Promise.reject(Oops$9.StrictUpdate());
         return {
             then: (callback) => {
-                if (callback)
-                    if (this.frame.size || arg !== false)
-                        this.waiting.add(callback);
-                    else
-                        callback(false);
-                else
+                if (!callback)
                     throw Oops$9.NoChaining();
+                if (frame.size || arg !== false)
+                    waiting.add(() => {
+                        callback(getUpdate(subject));
+                    });
+                else
+                    callback(false);
             }
         };
     }
@@ -835,65 +851,60 @@ const Oops$7 = issues({
     NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
     Failed: (model, key) => `Generating initial value for ${model}.${key} failed.`
 });
-function set(factory, argument) {
+function put(factory, argument) {
     return apply(function set(key) {
         const { subject, state } = this;
         const required = argument === true || argument === undefined;
         let set;
         let get;
-        let suspense;
-        if (factory === undefined)
-            suspense = true;
-        else {
-            let pending;
-            let error;
-            const init = () => {
-                const output = typeof factory == "function" ?
-                    mayRetry(() => factory.call(subject, key, subject)) :
-                    factory;
-                if (output instanceof Promise) {
-                    pending = output
-                        .catch(err => error = err)
-                        .then(val => state[key] = val)
-                        .finally(() => {
-                        pending = undefined;
-                        this.update(key);
-                    });
-                    return;
-                }
-                return state[key] = output;
-            };
-            const suspend = () => {
-                if (required === false)
-                    return undefined;
-                const issue = Oops$7.NotReady(subject, key);
-                Object.assign(pending, {
-                    message: issue.message,
-                    stack: issue.stack
+        let pending;
+        let error;
+        const init = () => {
+            const output = typeof factory == "function" ?
+                mayRetry(() => factory.call(subject, key, subject)) :
+                factory;
+            if (output instanceof Promise) {
+                pending = output
+                    .catch(err => error = err)
+                    .then(val => state[key] = val)
+                    .finally(() => {
+                    pending = undefined;
+                    this.update(key);
                 });
-                throw pending;
-            };
-            if (required)
-                try {
-                    init();
-                }
-                catch (err) {
-                    Oops$7.Failed(subject, key).warn();
-                    throw err;
-                }
-            get = () => {
-                if (pending)
-                    return suspend();
-                if (error)
-                    throw error;
-                if (key in state)
-                    return state[key];
-                let output = init();
-                return pending
-                    ? suspend()
-                    : output;
-            };
-        }
+                return;
+            }
+            return state[key] = output;
+        };
+        const suspend = () => {
+            if (required === false)
+                return undefined;
+            const issue = Oops$7.NotReady(subject, key);
+            Object.assign(pending, {
+                message: issue.message,
+                stack: issue.stack
+            });
+            throw pending;
+        };
+        if (required)
+            try {
+                init();
+            }
+            catch (err) {
+                Oops$7.Failed(subject, key).warn();
+                throw err;
+            }
+        get = () => {
+            if (pending)
+                return suspend();
+            if (error)
+                throw error;
+            if (key in state)
+                return state[key];
+            let output = init();
+            return pending
+                ? suspend()
+                : output;
+        };
         if (typeof argument == "function")
             set = createValueEffect(argument);
         else
@@ -903,8 +914,24 @@ function set(factory, argument) {
             };
         return {
             set,
-            get,
-            suspense
+            get
+        };
+    });
+}
+
+function set(value, argument) {
+    if (!(1 in arguments)) {
+        argument = value;
+        value = undefined;
+    }
+    return apply(function set(key) {
+        if (value !== undefined)
+            this.state[key] = value;
+        return {
+            suspense: true,
+            set: typeof argument == "function"
+                ? createValueEffect(argument)
+                : undefined
         };
     });
 }
@@ -1410,6 +1437,7 @@ exports.array = array;
 exports["default"] = MVC;
 exports.from = from;
 exports.parent = parent;
+exports.put = put;
 exports.ref = ref;
 exports.set = set;
 exports.tap = tap;