@expressive/mvc 0.0.3 → 0.1.1

package/lib/index.d.ts

@@ -75,6 +75,11 @@ declare namespace Model {
     export type Methods<T> = {
         [K in keyof T]: T[K] extends Ref ? never : T[K] extends Function ? K : never;
     }[keyof T];
+    export type Refs<T extends Model> = {
+        <K extends Field<T>>(key: K, value: T[K]): void;
+    } & {
+        [P in Field<T>]: (next: any) => void;
+    };
     /**
      * Subset of `keyof T` which are not methods or defined by base Model U.
      *
@@ -110,11 +115,12 @@ interface Model extends Stateful {
      */
     get: this;
     /**
-    * Circular reference to `this` controller.
+    * Setter utility
     *
-    * Shortcut is mainly to update values, while having destructured already.
+    * Can be used to set (and force-update) values.
+    * Shortcut to update values, contains refs for all controlled values.
     */
-    set: this;
+    set: Model.Refs<this>;
 }
 declare class Model {
     static [CONTROL]: Controller;
@@ -186,7 +192,7 @@ declare class Controller<T extends Stateful = any> {
     constructor(subject: T);
     start(): void;
     stop(): void;
-    private manage;
+    manage(key: Model.Field<T>, value: any): void;
     ref(key: Model.Field<T>, handler?: Controller.OnValue<T>): (value: any) => void;
     addListener(listener: Controller.OnEvent<T>): () => void;
     emit(keys: readonly Model.Event<T>[]): void;
@@ -575,7 +581,7 @@ declare function tap<T extends Class>(Type: T, required?: boolean): InstanceOf<T
 declare function useFrom<T extends Stateful, R>(source: (() => T) | T, compute: (this: T, from: T) => R, expect: true): Exclude<R, undefined>;
 declare function useFrom<T extends Stateful, R>(source: (() => T) | T, compute: (this: T, from: T) => R, expect?: boolean): R;
 
-declare function useInContext<T extends typeof Model>(Type: T, arg?: boolean | string): any;
+declare function useLocal<T extends typeof Model>(Type: T, arg?: boolean | string): any;
 
 declare function useModel<T extends Class, I extends InstanceOf<T>>(source: T, watch: Model.Field<I>[], callback?: (instance: I) => void): I;
 declare function useModel<T extends Class, I extends InstanceOf<T>>(source: T, callback?: (instance: I) => void): I;
@@ -597,4 +603,4 @@ declare function useTap<T extends Stateful, K extends Model.Field<T>>(source: T
 declare function useTap<T extends Stateful, R>(source: T | (() => T) | useTap.Tappable, compute: (this: T, from: T) => R, expect: true): Exclude<R, undefined>;
 declare function useTap<T extends Stateful, R>(source: T | (() => T) | useTap.Tappable, compute: (this: T, from: T) => R, expect?: boolean): R;
 
-export { CONTROL, Consumer, Global, LOCAL, MVC as Model, Provider, STATE, Stateful, WHY, act, apply, array, MVC as default, from, parent, ref, set, tap, use, useFrom, useInContext, useModel, useTap };
+export { CONTROL, Consumer, Global, LOCAL, MVC as Model, Provider, STATE, Stateful, WHY, act, apply, array, MVC as default, from, parent, ref, set, tap, use, useFrom, useLocal, useModel, useTap };

package/lib/index.esm.js

@@ -1,5 +1,30 @@
 import React, { useState, useMemo } from '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);
@@ -18,6 +43,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;
@@ -43,7 +112,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) {
@@ -59,28 +128,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();
@@ -99,9 +148,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;
@@ -142,18 +200,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);
@@ -231,10 +296,7 @@ class Model {
         return (typeof maybe == "function" &&
             maybe.prototype instanceof this);
     }
-}
-defineLazy(Model, CONTROL, function () {
-    return new Controller(this);
-});
+}
 
 class Subscriber {
     constructor(target, onUpdate) {
@@ -282,30 +344,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.`,
@@ -460,26 +498,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,
@@ -571,26 +611,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) {
@@ -683,18 +720,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
@@ -824,7 +862,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) {
@@ -993,7 +1031,7 @@ const useLookup = () => React.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);
@@ -1161,7 +1199,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;
     }, [])();
@@ -1196,7 +1234,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);
@@ -1250,7 +1288,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;
@@ -1350,5 +1388,5 @@ class Global extends MVC {
     }
 }
 
-export { CONTROL, Consumer, Global, LOCAL, MVC as Model, Provider, STATE, WHY, act, apply, array, MVC as default, from, parent, ref, set, tap, use$1 as use, useFrom, useInContext, useModel, useTap };
+export { CONTROL, Consumer, Global, LOCAL, MVC as Model, Provider, STATE, WHY, act, apply, array, MVC as default, from, parent, ref, set, tap, use$1 as use, useFrom, useLocal, useModel, useTap };
 //# sourceMappingURL=index.esm.js.map