@expressive/mvc 0.8.2 → 0.9.1

package/lib/index.esm.js

@@ -17,44 +17,13 @@ function issues(register) {
     return Library;
 }
 
-const Oops$d = issues({
-    BadCallback: () => `Callback for effect-callback may only return a function.`
-});
-const { assign, create, defineProperty, entries, getPrototypeOf, getOwnPropertyNames, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
-function createEffect(callback) {
-    let unSet;
-    return function (value) {
-        if (typeof unSet == "function")
-            unSet();
-        unSet = callback.call(this, value);
-        if (unSet instanceof Promise)
-            unSet = undefined;
-        if (unSet && typeof unSet !== "function")
-            throw Oops$d.BadCallback();
-    };
-}
-function createValueEffect(callback) {
-    let unSet;
-    return function (value) {
-        if (typeof unSet == "function")
-            unSet(value);
-        const out = callback.call(this, value, this);
-        if (typeof out == "boolean")
-            return out;
-        if (!out || out instanceof Promise)
-            return;
-        if (typeof out == "function")
-            unSet = out;
-        else
-            throw Oops$d.BadCallback();
-    };
-}
+const { assign, create, defineProperties, defineProperty, entries, getPrototypeOf, getOwnPropertyNames, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
 
-const Oops$c = issues({
+const Oops$d = issues({
     NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
 });
 function suspend(source, key) {
-    const error = Oops$c.NotReady(source.subject, key);
+    const error = Oops$d.NotReady(source.subject, key);
     const promise = new Promise(resolve => {
         const release = source.addListener(forKey => {
             if (forKey == key)
@@ -94,7 +63,7 @@ function mayRetry(fn) {
     return compute();
 }
 
-const Oops$b = issues({
+const Oops$c = issues({
     Failed: (parent, property, initial) => `An exception was thrown while ${initial ? "initializing" : "refreshing"} [${parent}.${property}].`
 });
 const INFO = new WeakMap();
@@ -104,14 +73,17 @@ function computeMode(self, source, setter, key, required) {
     const { subject, state } = self;
     let sub;
     let order = ORDER.get(self);
+    let pending = KEYS.get(self);
     if (!order)
-        ORDER.set(self, order = []);
+        ORDER.set(self, order = new Map());
+    if (!pending)
+        KEYS.set(self, pending = new Set());
     const compute = (initial) => {
         try {
             return setter.call(sub.proxy, sub.proxy);
         }
         catch (err) {
-            Oops$b.Failed(subject, key, initial).warn();
+            Oops$c.Failed(subject, key, initial).warn();
             throw err;
         }
     };
@@ -131,18 +103,13 @@ function computeMode(self, source, setter, key, required) {
             }
         }
     };
-    const update = (_key, source) => {
-        if (source !== self) {
-            refresh();
-            return;
-        }
-        let pending = KEYS.get(self);
-        if (!pending)
-            KEYS.set(self, pending = []);
-        pending.push(refresh);
-    };
     const create = () => {
-        sub = source.subscribe(update);
+        sub = source.subscribe((_, source) => {
+            if (source !== self)
+                refresh();
+            else
+                pending.add(refresh);
+        });
         try {
             const value = compute(true);
             state.set(key, value);
@@ -153,11 +120,15 @@ function computeMode(self, source, setter, key, required) {
         }
         finally {
             sub.commit();
-            order.push(refresh);
+            order.set(refresh, order.size);
         }
     };
     INFO.set(refresh, key);
     return () => {
+        if (pending.has(refresh)) {
+            pending.delete(refresh);
+            refresh();
+        }
         const value = sub ? state.get(key) : create();
         if (value === undefined && required)
             throw suspend(self, key);
@@ -166,18 +137,20 @@ function computeMode(self, source, setter, key, required) {
 }
 function flush(control) {
     const pending = KEYS.get(control);
-    if (!pending)
+    if (!pending || !pending.size)
         return;
-    const list = ORDER.get(control);
-    while (pending.length) {
-        const compute = pending
-            .sort((a, b) => list.indexOf(b) - list.indexOf(a))
-            .pop();
+    const priority = ORDER.get(control);
+    while (pending.size) {
+        let compute;
+        for (const item of pending)
+            if (!compute || priority.get(item) < priority.get(compute))
+                compute = item;
+        pending.delete(compute);
         const key = INFO.get(compute);
         if (!control.frame.has(key))
             compute();
     }
-    KEYS.delete(control);
+    pending.clear();
 }
 
 const REGISTER$1 = new WeakMap();
@@ -212,8 +185,8 @@ class Subscriber {
                 notify = this.onUpdate(key, parent);
             if (!notify)
                 return;
-            parent.waiting.add(() => {
-                this.latest = parent.latest.filter(k => watch.has(k));
+            parent.waiting.add(update => {
+                this.latest = update.filter(k => watch.has(k));
             });
             parent.waiting.add(notify);
         };
@@ -320,13 +293,13 @@ class Control {
         else if (!frame.size)
             setTimeout(() => {
                 flush(this);
-                this.latest = Array.from(frame);
+                const keys = this.latest = Array.from(frame);
                 setTimeout(() => this.latest = undefined, 0);
                 frame.clear();
                 for (const notify of waiting)
                     try {
                         waiting.delete(notify);
-                        notify();
+                        notify(keys);
                     }
                     catch (err) {
                         console.error(err);
@@ -354,18 +327,21 @@ class Control {
         if (!control.state) {
             const { waiting } = control;
             if (cb) {
-                let done;
+                let callback;
                 waiting.add(() => {
-                    done = cb(control);
+                    callback = cb(control);
                 });
-                return () => done && done();
+                return () => {
+                    if (callback)
+                        callback();
+                };
             }
             control.state = new Map();
             for (const key in subject)
                 control.watch(key);
             control.waiting = new Set();
             for (const cb of waiting)
-                cb();
+                cb([]);
         }
         return cb ? cb(control) : control;
     }
@@ -481,15 +457,15 @@ function __awaiter(thisArg, _arguments, P, generator) {
     });
 }
 
-const Oops$a = issues({
+const Oops$b = issues({
     DuplicatePending: (key) => `Invoked action ${key} but one is already active.`
 });
-function act(task) {
-    return add(function act(key) {
+function run(task) {
+    return add(function run(key) {
         let pending = false;
         const invoke = (...args) => __awaiter(this, void 0, void 0, function* () {
             if (pending)
-                return Promise.reject(Oops$a.DuplicatePending(key));
+                return Promise.reject(Oops$b.DuplicatePending(key));
             pending = true;
             this.update(key);
             try {
@@ -511,7 +487,7 @@ function act(task) {
     });
 }
 
-const Oops$9 = issues({
+const Oops$a = issues({
     NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`
 });
 function factoryMode(self, output, key, required) {
@@ -535,7 +511,7 @@ function factoryMode(self, output, key, required) {
     const suspend = () => {
         if (required === false)
             return undefined;
-        const issue = Oops$9.NotReady(subject, key);
+        const issue = Oops$a.NotReady(subject, key);
         assign(pending, {
             message: issue.message,
             stack: issue.stack
@@ -552,7 +528,7 @@ function factoryMode(self, output, key, required) {
     };
 }
 
-const Oops$8 = issues({
+const Oops$9 = issues({
     PeerNotAllowed: (model, property) => `Attempted to use an instruction result (probably use or tap) as computed source for ${model}.${property}. This is not possible.`,
     ComputeFailed: (model, key) => `Generating initial value for ${model}.${key} failed.`,
     Failed: (parent, property, initial) => `An exception was thrown while ${initial ? "initializing" : "refreshing"} [${parent}.${property}].`
@@ -565,7 +541,7 @@ function get(arg0, arg1, arg2) {
         let getter;
         // Easy mistake, using a peer, will always be unresolved.
         if (typeof arg0 == "symbol")
-            throw Oops$8.PeerNotAllowed(subject, key);
+            throw Oops$9.PeerNotAllowed(subject, key);
         // if(typeof arg0 == "function" && /^[A-Z]/.test(arg0.name))
         //   throw Oops.BadSource(subject, key, arg0);
         this.state.set(key, undefined);
@@ -599,7 +575,7 @@ function get(arg0, arg1, arg2) {
                 init();
             }
             catch (err) {
-                Oops$8.ComputeFailed(subject, key).warn();
+                Oops$9.ComputeFailed(subject, key).warn();
                 throw err;
             }
         return () => {
@@ -610,6 +586,67 @@ function get(arg0, arg1, arg2) {
     });
 }
 
+const Oops$8 = issues({
+    BadCallback: () => `Callback for effect-callback may only return a function.`
+});
+function createEffect(model, callback, keys) {
+    return Control.for(model, control => {
+        let unSet;
+        let busy = false;
+        function effect(value) {
+            if (typeof unSet == "function")
+                unSet();
+            unSet = callback.call(this, value);
+            if (unSet instanceof Promise)
+                unSet = undefined;
+            if (unSet && typeof unSet !== "function")
+                throw Oops$8.BadCallback();
+        }
+        function invoke() {
+            if (busy)
+                return;
+            const output = mayRetry(() => {
+                effect.call(model, model);
+            });
+            if (output instanceof Promise) {
+                output.finally(() => busy = false);
+                busy = true;
+            }
+        }
+        if (Array.isArray(keys)) {
+            invoke();
+            return control.addListener(key => {
+                if (key === null) {
+                    if (!keys.length)
+                        invoke();
+                }
+                else if (keys.includes(key))
+                    return invoke;
+            });
+        }
+        const sub = control.subscribe(() => invoke);
+        model = sub.proxy;
+        invoke();
+        return sub.commit();
+    });
+}
+function createValueEffect(callback) {
+    let unSet;
+    return function (value) {
+        if (typeof unSet == "function")
+            unSet(value);
+        const out = callback.call(this, value, this);
+        if (typeof out == "boolean")
+            return out;
+        if (!out || out instanceof Promise)
+            return;
+        if (typeof out == "function")
+            unSet = out;
+        else
+            throw Oops$8.BadCallback();
+    };
+}
+
 function ref(arg, mapper) {
     return add(function ref(key) {
         let value = {};
@@ -903,8 +940,10 @@ function has(Type, required) {
 }
 
 const Oops$5 = issues({
-    Timeout: (keys, timeout) => `No update for [${keys}] within ${timeout}.`,
-    StrictUpdate: () => `Strict update() did not find pending updates.`,
+    Timeout: (keys, timeout) => `No update seen for [${keys}] within ${timeout}.`,
+    KeysExpected: (key) => `Key "${key}" was expected in current update.`,
+    StrictUpdate: () => `Expected update but none in progress.`,
+    StrictNoUpdate: () => `Update is not expected but one is in progress!`,
     NoChaining: () => `Then called with undefined; update promise will never catch nor supports chaining.`
 });
 class Model {
@@ -912,91 +951,84 @@ class Model {
         new Control(this);
         defineProperty(this, "is", { value: this });
     }
-    on(select, argument, once) {
-        if (typeof select == "function")
-            return Control.for(this, x => x.addListener(select));
-        const single = typeof select == "string";
-        let keys = single ? [select] : select;
-        if (typeof argument !== "function")
-            return new Promise((resolve, reject) => {
-                const removeListener = Control.for(this, control => {
-                    for (const key of keys)
-                        try {
-                            void this[key];
-                        }
-                        catch (e) { }
-                    return control.addListener(key => {
-                        if (!key) {
-                            removeListener();
-                            reject(Oops$5.Timeout(select, `lifetime of ${this}`));
-                        }
-                        else if (keys.includes(key)) {
+    on(arg1, arg2, arg3) {
+        if (typeof arg1 == "function")
+            return createEffect(this.is, arg1, arg2);
+        const single = typeof arg1 == "string";
+        const keys = typeof arg1 == "string" ? [arg1] :
+            typeof arg1 == "object" ? arg1 :
+                undefined;
+        if (typeof arg2 == "function" && keys)
+            return Control.for(this, control => {
+                for (const key of keys)
+                    try {
+                        void this[key];
+                    }
+                    catch (e) { }
+                const invoke = single
+                    ? () => arg2.call(this, control.state.get(arg1), arg1)
+                    : (frame) => arg2.call(this, frame);
+                const removeListener = control.addListener(key => {
+                    if (!key && !keys.length)
+                        invoke([]);
+                    if (keys.includes(key)) {
+                        if (arg3)
                             removeListener();
-                            return () => resolve(single ? control.state.get(key) : control.latest);
-                        }
-                    });
+                        return invoke;
+                    }
                 });
-                if (typeof argument == "number")
-                    setTimeout(() => {
-                        removeListener();
-                        reject(Oops$5.Timeout(select, `${argument}ms`));
-                    }, argument);
+                return removeListener;
             });
-        return Control.for(this, control => {
-            if (!keys.length)
-                keys = [...control.state.keys()];
-            for (const key of keys)
-                try {
-                    void this[key];
+        return new Promise((resolve, reject) => {
+            const timeout = (message) => {
+                const k = keys ? keys.join(", ") : "any";
+                removeListener();
+                reject(Oops$5.Timeout(k, message));
+            };
+            const removeListener = Control.for(this, control => {
+                const pending = control.frame;
+                if (keys === null) {
+                    if (pending.size)
+                        reject(Oops$5.StrictNoUpdate());
+                    else
+                        resolve(null);
+                    return;
                 }
-                catch (e) { }
-            const callback = single
-                ? () => { argument.call(this, control.state.get(select), select); }
-                : () => { argument.call(this, control.latest); };
-            const onEvent = once
-                ? () => {
-                    removeListener();
-                    callback();
+                if (keys) {
+                    if (keys.length) {
+                        if (arg2 === 0 && single && !pending.has(keys[0])) {
+                            reject(Oops$5.KeysExpected(keys[0]));
+                            return;
+                        }
+                        else
+                            for (const key of keys)
+                                try {
+                                    void this[key];
+                                }
+                                catch (e) { }
+                    }
                 }
-                : callback;
-            const removeListener = control.addListener(key => {
-                if (keys.includes(key))
-                    return onEvent;
-            });
-            return removeListener;
-        });
-    }
-    effect(callback, select) {
-        const effect = createEffect(callback);
-        return Control.for(this, control => {
-            let busy = false;
-            let inject = this.is;
-            const invoke = () => {
-                if (busy)
+                else if (!pending.size && arg1 === true || arg2 === 0) {
+                    reject(Oops$5.StrictUpdate());
                     return;
-                const output = mayRetry(() => {
-                    effect.call(inject, inject);
-                });
-                if (output instanceof Promise) {
-                    output.finally(() => busy = false);
-                    busy = true;
-                }
-            };
-            if (!select) {
-                const sub = control.subscribe(() => invoke);
-                inject = sub.proxy;
-                invoke();
-                return sub.commit();
-            }
-            invoke();
-            return control.addListener(key => {
-                if (key === null) {
-                    if (!select.length)
-                        invoke();
                 }
-                else if (select.includes(key))
-                    return invoke;
+                else
+                    control.waiting.add(resolve);
+                return control.addListener(key => {
+                    if (!key) {
+                        if (keys && !keys.length)
+                            resolve([]);
+                        else
+                            timeout(`lifetime of ${this}`);
+                    }
+                    else if (!keys || keys.includes(key)) {
+                        removeListener();
+                        return keys => resolve(single ? control.state.get(key) : keys);
+                    }
+                });
             });
+            if (arg2 && typeof arg2 == "number")
+                setTimeout(() => timeout(`${arg2}ms`), arg2);
         });
     }
     export(subset) {
@@ -1009,13 +1041,10 @@ class Model {
     }
     update(arg1, arg2) {
         const control = Control.for(this);
-        const { frame, state, waiting } = control;
-        if (arg1 === true && !frame.size)
-            return Promise.reject(Oops$5.StrictUpdate());
         if (typeof arg1 == "object") {
             for (const key in arg1)
-                if (arg2 === true || (arg2 ? arg2.includes(key) : state.has(key))) {
-                    state.set(key, arg1[key]);
+                if (arg2 === true || (arg2 ? arg2.includes(key) : control.state.has(key))) {
+                    control.state.set(key, arg1[key]);
                     control.update(key);
                 }
         }
@@ -1029,25 +1058,19 @@ class Model {
                     else if (arg2)
                         method.call(this);
             }
-            arg1 = undefined;
         }
         return {
             then: (callback) => {
                 if (!callback)
                     throw Oops$5.NoChaining();
-                if (frame.size || arg1 !== false)
-                    waiting.add(() => {
-                        callback(control.latest);
-                    });
-                else
-                    callback(false);
+                control.waiting.add(callback);
             }
         };
     }
     /**
-     * Mark this instance for garbage-collection and send `willDestroy` event to all listeners.
+     * Clean up side effects and mark this instance for garbage-collection.
      */
-    kill() {
+    destroy() {
         Control.for(this).clear();
     }
     /**
@@ -1124,7 +1147,7 @@ class Lookup {
                 items.add(entry.value);
         }
         for (const model of items)
-            model.kill();
+            model.destroy();
     }
 }
 const LookupContext = React.createContext(new Lookup());
@@ -1224,7 +1247,7 @@ function useModel(source, arg, arg2) {
                 instance.on(arg, () => update(x => x + 1));
             return () => {
                 if (Model.isTypeof(source))
-                    instance.kill();
+                    instance.destroy();
             };
         }, []);
         return instance;
@@ -1237,15 +1260,15 @@ function useModel(source, arg, arg2) {
         return () => {
             local.release();
             if (Model.isTypeof(source))
-                instance.kill();
+                instance.destroy();
         };
     }, []);
     return local.proxy;
 }
 
-function useFrom(target, compute, suspend) {
+function useValue(source, compute, suspend) {
     const local = use(refresh => {
-        const sub = Control.for(target).subscribe(() => update);
+        const sub = Control.for(source).subscribe(() => update);
         const spy = sub.proxy;
         let value = compute.call(spy, spy);
         let update;
@@ -1295,7 +1318,7 @@ function useTap(source, arg1, arg2) {
         return source;
     }, [])();
     if (typeof arg1 == "function")
-        return useFrom(instance, arg1, arg2);
+        return useValue(instance, arg1, arg2);
     const local = use(refresh => (Control.for(instance).subscribe(() => refresh)));
     React.useLayoutEffect(local.commit, []);
     if (arg1 === undefined)
@@ -1325,7 +1348,7 @@ const LOCAL = "$debug local";
 const STATE = "$debug state";
 const UPDATE = "$debug update";
 const CONTROL = "$debug controller";
-Object.defineProperties(Model.prototype, {
+defineProperties(Model.prototype, {
     [CONTROL]: {
         get() {
             return Control.get(this);
@@ -1444,11 +1467,11 @@ class Global extends MVC {
         super();
         Active.set(this.constructor, this);
     }
-    kill(force) {
+    destroy(force) {
         const type = this.constructor;
         if (type.keepAlive && !force)
             return false;
-        super.kill();
+        Control.for(this).clear();
         Active.delete(type);
         return true;
     }
@@ -1482,10 +1505,10 @@ class Global extends MVC {
     static reset() {
         const current = Active.get(this);
         if (current)
-            current.kill(true);
+            current.destroy(true);
     }
 }
 Global.keepAlive = true;
 
-export { Consumer, Debug, Global, MVC, MVC as Model, Provider, act, add, MVC as default, get, has, ref, set, tap, use$1 as use, useContext, useFrom, useModel, useTap };
+export { Consumer, Debug, Global, MVC, MVC as Model, Provider, add, MVC as default, get, has, ref, run, set, tap, use$1 as use, useContext, useModel, useTap, useValue };
 //# sourceMappingURL=index.esm.js.map