@expressive/mvc 0.9.3 → 0.9.5

package/lib/index.js

@@ -8,6 +8,8 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 
 var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
 
+const { assign, create, defineProperties, defineProperty, entries, getPrototypeOf, getOwnPropertyNames, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
+
 class Issue extends Error {
     constructor() {
         super(...arguments);
@@ -25,13 +27,11 @@ function issues(register) {
     return Library;
 }
 
-const { assign, create, defineProperties, defineProperty, entries, getPrototypeOf, getOwnPropertyNames, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
-
-const Oops$d = issues({
+const Oops$e = issues({
     NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
 });
 function suspend(source, key) {
-    const error = Oops$d.NotReady(source.subject, key);
+    const error = Oops$e.NotReady(source.subject, key);
     const promise = new Promise(resolve => {
         const release = source.addListener(forKey => {
             if (forKey == key)
@@ -71,7 +71,7 @@ function mayRetry(fn) {
     return compute();
 }
 
-const Oops$c = issues({
+const Oops$d = issues({
     Failed: (parent, property, initial) => `An exception was thrown while ${initial ? "initializing" : "refreshing"} [${parent}.${property}].`
 });
 const INFO = new WeakMap();
@@ -91,7 +91,7 @@ function computeMode(self, source, setter, key, required) {
             return setter.call(sub.proxy, sub.proxy);
         }
         catch (err) {
-            Oops$c.Failed(subject, key, initial).warn();
+            Oops$d.Failed(subject, key, initial).warn();
             throw err;
         }
     };
@@ -466,7 +466,7 @@ function __awaiter(thisArg, _arguments, P, generator) {
     });
 }
 
-const Oops$b = issues({
+const Oops$c = issues({
     DuplicatePending: (key) => `Invoked action ${key} but one is already active.`
 });
 function run(task) {
@@ -474,7 +474,7 @@ function run(task) {
         let pending = false;
         const invoke = (...args) => __awaiter(this, void 0, void 0, function* () {
             if (pending)
-                return Promise.reject(Oops$b.DuplicatePending(key));
+                return Promise.reject(Oops$c.DuplicatePending(key));
             pending = true;
             this.update(key);
             try {
@@ -496,7 +496,7 @@ function run(task) {
     });
 }
 
-const Oops$a = issues({
+const Oops$b = issues({
     NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`
 });
 function factoryMode(self, output, key, required) {
@@ -520,7 +520,7 @@ function factoryMode(self, output, key, required) {
     const suspend = () => {
         if (required === false)
             return undefined;
-        const issue = Oops$a.NotReady(subject, key);
+        const issue = Oops$b.NotReady(subject, key);
         assign(pending, {
             message: issue.message,
             stack: issue.stack
@@ -537,7 +537,7 @@ function factoryMode(self, output, key, required) {
     };
 }
 
-const Oops$9 = issues({
+const Oops$a = 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}].`
@@ -550,7 +550,7 @@ function get(arg0, arg1, arg2) {
         let getter;
         // Easy mistake, using a peer, will always be unresolved.
         if (typeof arg0 == "symbol")
-            throw Oops$9.PeerNotAllowed(subject, key);
+            throw Oops$a.PeerNotAllowed(subject, key);
         // if(typeof arg0 == "function" && /^[A-Z]/.test(arg0.name))
         //   throw Oops.BadSource(subject, key, arg0);
         this.state.set(key, undefined);
@@ -584,7 +584,7 @@ function get(arg0, arg1, arg2) {
                 init();
             }
             catch (err) {
-                Oops$9.ComputeFailed(subject, key).warn();
+                Oops$a.ComputeFailed(subject, key).warn();
                 throw err;
             }
         return () => {
@@ -595,7 +595,7 @@ function get(arg0, arg1, arg2) {
     });
 }
 
-const Oops$8 = issues({
+const Oops$9 = issues({
     BadCallback: () => `Callback for effect-callback may only return a function.`
 });
 function createEffect(model, callback, keys) {
@@ -609,7 +609,7 @@ function createEffect(model, callback, keys) {
             if (unSet instanceof Promise)
                 unSet = undefined;
             if (unSet && typeof unSet !== "function")
-                throw Oops$8.BadCallback();
+                throw Oops$9.BadCallback();
         }
         function invoke() {
             if (busy)
@@ -652,7 +652,7 @@ function createValueEffect(callback) {
         if (typeof out == "function")
             unSet = out;
         else
-            throw Oops$8.BadCallback();
+            throw Oops$9.BadCallback();
     };
 }
 
@@ -850,7 +850,7 @@ function createProxy(emit, watch) {
 }
 
 const Parent = new WeakMap();
-const Oops$7 = issues({
+const Oops$8 = issues({
     BadArgument: (type) => `Instruction \`use\` cannot accept argument type of ${type}.`,
     NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`
 });
@@ -867,7 +867,7 @@ function use$1(input, argument) {
                 input = new input();
         }
         else if (input && typeof input !== "object")
-            throw Oops$7.BadArgument(typeof input);
+            throw Oops$8.BadArgument(typeof input);
         if (input instanceof Map || input instanceof Set)
             return keyed(this, key, input);
         const onUpdate = (next) => {
@@ -884,7 +884,7 @@ function use$1(input, argument) {
         const suspend = () => {
             if (required === false)
                 return;
-            const issue = Oops$7.NotReady(subject, key);
+            const issue = Oops$8.NotReady(subject, key);
             assign(pending, {
                 message: issue.message,
                 stack: issue.stack
@@ -929,7 +929,7 @@ function use$1(input, argument) {
     });
 }
 
-const Oops$6 = issues({
+const Oops$7 = issues({
     Required: (expects, child) => `New ${child} created standalone but requires parent of type ${expects}. Did you remember to create via use(${child})?`,
     Unexpected: (expects, child, got) => `New ${child} created as child of ${got}, but must be instanceof ${expects}.`,
 });
@@ -940,19 +940,100 @@ function has(Type, required) {
         const expected = Type.name;
         if (!value) {
             if (required !== false)
-                throw Oops$6.Required(expected, child);
+                throw Oops$7.Required(expected, child);
         }
         else if (!(value instanceof Type))
-            throw Oops$6.Unexpected(expected, child, value);
+            throw Oops$7.Unexpected(expected, child, value);
         return { value };
     });
 }
 
-const Oops$5 = issues({
+const Oops$6 = issues({
     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!`,
+    StrictNoUpdate: () => `Update is not expected but one is in progress!`
+});
+function addEventListener(source, arg1, arg2, arg3) {
+    const single = typeof arg1 == "string";
+    const keys = typeof arg1 == "string" ? [arg1] :
+        typeof arg1 == "object" ? arg1 :
+            undefined;
+    if (typeof arg2 == "function" && keys)
+        return Control.for(source, control => {
+            for (const key of keys)
+                try {
+                    void source[key];
+                }
+                catch (e) { }
+            const invoke = single
+                ? () => arg2.call(source, control.state.get(arg1), arg1)
+                : (frame) => arg2.call(source, frame);
+            const removeListener = control.addListener(key => {
+                if (!key && !keys.length)
+                    invoke([]);
+                if (keys.includes(key)) {
+                    if (arg3)
+                        removeListener();
+                    return invoke;
+                }
+            });
+            return removeListener;
+        });
+    return new Promise((resolve, reject) => {
+        const timeout = (message) => {
+            const k = keys ? keys.join(", ") : "any";
+            removeListener();
+            reject(Oops$6.Timeout(k, message));
+        };
+        const removeListener = Control.for(source, control => {
+            const pending = control.frame;
+            if (keys === null) {
+                if (pending.size)
+                    reject(Oops$6.StrictNoUpdate());
+                else
+                    resolve(null);
+                return;
+            }
+            if (keys) {
+                if (keys.length) {
+                    if (arg2 === 0 && single && !pending.has(keys[0])) {
+                        reject(Oops$6.KeysExpected(keys[0]));
+                        return;
+                    }
+                    else
+                        for (const key of keys)
+                            try {
+                                void source[key];
+                            }
+                            catch (e) { }
+                }
+            }
+            else if (!pending.size && arg1 === true || arg2 === 0) {
+                reject(Oops$6.StrictUpdate());
+                return;
+            }
+            else
+                control.waiting.add(resolve);
+            return control.addListener(key => {
+                if (!key) {
+                    if (keys && !keys.length)
+                        resolve([]);
+                    else
+                        timeout(`lifetime of ${source}`);
+                }
+                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);
+    });
+}
+
+const Oops$5 = issues({
     NoChaining: () => `Then called with undefined; update promise will never catch nor supports chaining.`
 });
 class Model {
@@ -963,82 +1044,7 @@ class Model {
     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 invoke;
-                    }
-                });
-                return removeListener;
-            });
-        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;
-                }
-                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) { }
-                    }
-                }
-                else if (!pending.size && arg1 === true || arg2 === 0) {
-                    reject(Oops$5.StrictUpdate());
-                    return;
-                }
-                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);
-        });
+        return addEventListener(this.is, arg1, arg2, arg3);
     }
     export(subset) {
         const { state } = Control.for(this);
@@ -1291,6 +1297,19 @@ function useValue(source, compute, suspend) {
             else
                 refresh();
         };
+        if (value === null) {
+            sub.watch.clear();
+            return {
+                proxy: null,
+                release: () => { }
+            };
+        }
+        if (typeof value == "function") {
+            const get = value;
+            sub.watch.clear();
+            compute = () => get();
+            value = get();
+        }
         if (value instanceof Promise) {
             value.then(set);
             value = undefined;
@@ -1353,43 +1372,6 @@ class MVC extends Model {
     }
 }
 
-const LOCAL = "$debug local";
-const STATE = "$debug state";
-const UPDATE = "$debug update";
-const CONTROL = "$debug controller";
-defineProperties(Model.prototype, {
-    [CONTROL]: {
-        get() {
-            return Control.get(this);
-        }
-    },
-    [LOCAL]: {
-        get() {
-            return Subscriber.get(this);
-        }
-    },
-    [STATE]: {
-        get() {
-            const { state } = Control.get(this);
-            const output = {};
-            state.forEach((value, key) => output[key] = value);
-            return output;
-        }
-    },
-    [UPDATE]: {
-        get() {
-            const source = Subscriber.get(this) || Control.get(this);
-            return source && source.latest;
-        }
-    }
-});
-const Debug = {
-    CONTROL,
-    LOCAL,
-    STATE,
-    UPDATE
-};
-
 const Oops$2 = issues({
     BadProps: () => `Provider expects either a render function, 'get' or 'has' props.`
 });
@@ -1519,6 +1501,43 @@ class Global extends MVC {
 }
 Global.keepAlive = true;
 
+const LOCAL = "$debug local";
+const STATE = "$debug state";
+const UPDATE = "$debug update";
+const CONTROL = "$debug controller";
+defineProperties(Model.prototype, {
+    [CONTROL]: {
+        get() {
+            return Control.get(this);
+        }
+    },
+    [LOCAL]: {
+        get() {
+            return Subscriber.get(this);
+        }
+    },
+    [STATE]: {
+        get() {
+            const { state } = Control.get(this);
+            const output = {};
+            state.forEach((value, key) => output[key] = value);
+            return output;
+        }
+    },
+    [UPDATE]: {
+        get() {
+            const source = Subscriber.get(this) || Control.get(this);
+            return source && source.latest;
+        }
+    }
+});
+const Debug = {
+    CONTROL,
+    LOCAL,
+    STATE,
+    UPDATE
+};
+
 exports.Consumer = Consumer;
 exports.Debug = Debug;
 exports.Global = Global;