@expressive/mvc 0.0.1 → 0.0.4

package/lib/index.js

@@ -8,6 +8,31 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 
 var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
 
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
 class Issue extends Error {
     constructor() {
         super(...arguments);
@@ -26,6 +51,50 @@ function issues(register) {
 }
 
 const Oops$c = issues({
+    ValueNotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
+});
+function suspend(source, key) {
+    const error = Oops$c.ValueNotReady(source.subject, key);
+    const promise = new Promise(resolve => {
+        const release = source.addListener(forKey => {
+            if (forKey == key)
+                return () => {
+                    if (source.state[key] !== undefined) {
+                        release();
+                        resolve();
+                    }
+                };
+        });
+    });
+    return Object.assign(promise, {
+        toString: () => String(error),
+        name: "Suspense",
+        message: error.message,
+        stack: error.stack
+    });
+}
+function mayRetry(fn) {
+    const retry = (err) => {
+        if (err instanceof Promise)
+            return err.then(compute);
+        else
+            throw err;
+    };
+    const compute = () => {
+        try {
+            const output = fn();
+            return output instanceof Promise
+                ? output.catch(retry)
+                : output;
+        }
+        catch (err) {
+            return retry(err);
+        }
+    };
+    return compute();
+}
+
+const Oops$b = issues({
     BadEffectCallback: () => `Callback for effect-callback may only return a function.`
 });
 const { assign, create, defineProperty, entries, getPrototypeOf, getOwnPropertyNames, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
@@ -51,7 +120,7 @@ function createEffect(callback) {
         if (unSet instanceof Promise)
             unSet = undefined;
         if (unSet && typeof unSet !== "function")
-            throw Oops$c.BadEffectCallback();
+            throw Oops$b.BadEffectCallback();
     };
 }
 function createValueEffect(callback) {
@@ -67,28 +136,8 @@ function createValueEffect(callback) {
         if (typeof out == "function")
             unSet = out;
         else
-            throw Oops$c.BadEffectCallback();
-    };
-}
-function suspenseBoundary(fn) {
-    const retry = (err) => {
-        if (err instanceof Promise)
-            return err.then(compute);
-        else
-            throw err;
+            throw Oops$b.BadEffectCallback();
     };
-    const compute = () => {
-        try {
-            const output = fn();
-            return output instanceof Promise
-                ? output.catch(retry)
-                : output;
-        }
-        catch (err) {
-            return retry(err);
-        }
-    };
-    return compute();
 }
 
 const UPDATE = new WeakMap();
@@ -150,18 +199,25 @@ class Model {
     effect(callback, select) {
         const effect = createEffect(callback);
         return control(this, control => {
+            let busy = false;
+            let inject = this.get;
+            const invoke = () => {
+                if (busy)
+                    return;
+                const output = mayRetry(() => {
+                    effect.call(inject, inject);
+                });
+                if (output instanceof Promise) {
+                    output.finally(() => busy = false);
+                    busy = true;
+                }
+            };
             if (!select) {
                 const sub = new Subscriber(control, () => invoke);
-                const invoke = () => {
-                    const x = sub.proxy;
-                    effect.call(x, x);
-                };
+                inject = sub.proxy;
                 invoke();
                 return sub.commit();
             }
-            const invoke = () => {
-                effect.call(this.get, this.get);
-            };
             invoke();
             if (!select.length) {
                 control.onDestroy.add(invoke);
@@ -290,30 +346,6 @@ class Subscriber {
     }
 }
 
-const Oops$b = issues({
-    ValueNotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
-});
-function suspend(source, key) {
-    const error = Oops$b.ValueNotReady(source.subject, key);
-    const promise = new Promise(resolve => {
-        const release = source.addListener(forKey => {
-            if (forKey == key)
-                return () => {
-                    if (source.state[key] !== undefined) {
-                        release();
-                        resolve();
-                    }
-                };
-        });
-    });
-    return Object.assign(promise, {
-        toString: () => String(error),
-        name: "Suspense",
-        message: error.message,
-        stack: error.stack
-    });
-}
-
 const Oops$a = issues({
     BadComputedSource: (model, property, got) => `Bad from-instruction provided to ${model}.${property}. Expects an arrow-function or a Model as source. Got ${got}.`,
     PeerNotAllowed: (model, property) => `Attempted to use an instruction result (probably use or tap) as computed source for ${model}.${property}. This is not possible.`,
@@ -691,18 +723,19 @@ const Oops$8 = issues({
 function act(task) {
     return apply(function act(key) {
         let pending = false;
-        const invoke = (...args) => {
+        const invoke = (...args) => __awaiter(this, void 0, void 0, function* () {
             if (pending)
                 return Promise.reject(Oops$8.DuplicateAction(key));
             pending = true;
             this.update(key);
-            return new Promise(res => {
-                res(task.apply(this.subject, args));
-            }).finally(() => {
+            try {
+                return yield mayRetry(() => (task.apply(this.subject, args)));
+            }
+            finally {
                 pending = false;
                 this.update(key);
-            });
-        };
+            }
+        });
         this.state[key] = undefined;
         defineProperty(invoke, "active", {
             get: () => pending
@@ -832,7 +865,7 @@ function pendingFactory(parent, key, fn, required) {
     let pending;
     let error;
     const init = () => {
-        const output = suspenseBoundary(() => {
+        const output = mayRetry(() => {
             return fn.call(subject, key, subject);
         });
         if (output instanceof Promise) {