@expressive/mvc 0.0.3 → 0.1.1

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;
-    };
-    const compute = () => {
-        try {
-            const output = fn();
-            return output instanceof Promise
-                ? output.catch(retry)
-                : output;
-        }
-        catch (err) {
-            return retry(err);
-        }
+            throw Oops$b.BadEffectCallback();
     };
-    return compute();
 }
 
 const UPDATE = new WeakMap();
@@ -107,9 +156,18 @@ const LOCAL = Symbol("LOCAL");
 const STATE = Symbol("STATE");
 class Model {
     constructor() {
-        define(this, CONTROL, new Controller(this));
+        const control = new Controller(this);
+        define(this, CONTROL, control);
         define(this, "get", this);
-        define(this, "set", this);
+        defineLazy(this, "set", () => {
+            const assign = (key, value) => {
+                control.update(key, value);
+            };
+            ready(control);
+            for (const key of getOwnPropertyNames(control.proxy))
+                define(assign, key, control.ref(key));
+            return assign;
+        });
     }
     get [STATE]() {
         return this[CONTROL].state;
@@ -150,18 +208,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);
@@ -239,10 +304,7 @@ class Model {
         return (typeof maybe == "function" &&
             maybe.prototype instanceof this);
     }
-}
-defineLazy(Model, CONTROL, function () {
-    return new Controller(this);
-});
+}
 
 class Subscriber {
     constructor(target, onUpdate) {
@@ -290,30 +352,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.`,
@@ -468,26 +506,28 @@ class Controller {
         this.proxy = Object.create(subject);
     }
     start() {
-        for (const key in this.subject)
-            this.manage(key);
+        READY.add(this);
+        for (const key in this.subject) {
+            const { value: entry } = getOwnPropertyDescriptor(this.subject, key);
+            if (typeof entry == "function")
+                continue;
+            if (typeof entry == "symbol") {
+                const instruction = PENDING.get(entry);
+                if (instruction)
+                    instruction.call(this, key, this);
+                continue;
+            }
+            this.manage(key, entry);
+        }
         this.emit([]);
     }
     stop() {
         this.followers.clear();
         this.onDestroy.forEach(x => x());
     }
-    manage(key) {
+    manage(key, value) {
         const { proxy, state, subject } = this;
-        const { value: entry } = getOwnPropertyDescriptor(subject, key);
-        if (typeof entry == "function")
-            return;
-        if (typeof entry == "symbol") {
-            const instruction = PENDING.get(entry);
-            if (instruction)
-                instruction.call(this, key, this);
-            return;
-        }
-        state[key] = entry;
+        state[key] = value;
         const set = this.ref(key);
         defineProperty(subject, key, {
             enumerable: false,
@@ -579,26 +619,23 @@ class Controller {
 }
 function control(subject, cb) {
     let control = subject[CONTROL];
-    const ready = READY.has(control);
     if (!control) {
         control = new Controller(subject);
         define(subject, CONTROL, control);
     }
-    if (!cb) {
-        if (!ready) {
-            READY.add(control);
-            control.start();
-        }
-        return control;
-    }
+    return ready(control, cb);
+}
+function ready(control, cb) {
+    const ready = READY.has(control);
     if (!ready) {
-        let done;
-        control.requestUpdate(() => {
-            done = cb(control);
-        });
-        return () => done && done();
+        if (cb) {
+            let done;
+            control.requestUpdate(() => done = cb(control));
+            return () => done && done();
+        }
+        control.start();
     }
-    return cb(control);
+    return cb ? cb(control) : control;
 }
 
 function apply(fn, label) {
@@ -691,18 +728,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 +870,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) {
@@ -1001,7 +1039,7 @@ const useLookup = () => React__default["default"].useContext(LookupContext);
 const Oops$4 = issues({
     NothingInContext: (name) => `Couldn't find ${name} in context; did you forget to use a Provider?`
 });
-function useInContext(Type, arg) {
+function useLocal(Type, arg) {
     const instance = useLookup().get(Type);
     if (!instance && arg !== false)
         throw Oops$4.NothingInContext(Type.name);
@@ -1169,7 +1207,7 @@ function useTap(source, path, expect) {
         if ("get" in source)
             return () => source.get();
         if ("prototype" in source)
-            return () => useInContext(source);
+            return () => useLocal(source);
         else
             return source;
     }, [])();
@@ -1204,7 +1242,7 @@ class MVC extends Model {
         return useModel(this, arg, callback);
     }
     static get(required) {
-        return useInContext(this, required);
+        return useLocal(this, required);
     }
     static tap(key, expect) {
         return useTap(this, key, expect);
@@ -1258,7 +1296,7 @@ function Consumer(props) {
         return children(useTap(Control));
     const callback = has || get;
     if (typeof callback == "function")
-        callback(useInContext(Control, !!has));
+        callback(useLocal(Control, !!has));
     else
         throw Oops$2.BadConsumerProps();
     return null;
@@ -1377,7 +1415,7 @@ exports.set = set;
 exports.tap = tap;
 exports.use = use$1;
 exports.useFrom = useFrom;
-exports.useInContext = useInContext;
+exports.useLocal = useLocal;
 exports.useModel = useModel;
 exports.useTap = useTap;
 //# sourceMappingURL=index.js.map