@expressive/mvc 1.0.0-beta.40 → 1.0.0-beta.43

package/lib/index.esm.js

@@ -17,7 +17,7 @@ function issues(register) {
     return Library;
 }
 
-const Oops$d = issues({
+const Oops$c = issues({
     BadEffectCallback: () => `Callback for effect-callback may only return a function.`
 });
 const { assign, create, defineProperty, entries, getPrototypeOf, getOwnPropertyNames, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
@@ -46,7 +46,7 @@ function createEffect(callback) {
         if (unSet instanceof Promise)
             unSet = undefined;
         if (unSet && typeof unSet !== "function")
-            throw Oops$d.BadEffectCallback();
+            throw Oops$c.BadEffectCallback();
     };
 }
 function createValueEffect(callback) {
@@ -62,8 +62,28 @@ function createValueEffect(callback) {
         if (typeof out == "function")
             unSet = out;
         else
-            throw Oops$d.BadEffectCallback();
+            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);
+        }
+    };
+    return compute();
 }
 
 const UPDATE = new WeakMap();
@@ -76,7 +96,274 @@ function applyUpdate(subject, keys) {
     };
 }
 
-const Oops$c = issues({
+class Subscriber {
+    constructor(target, onUpdate) {
+        this.onUpdate = onUpdate;
+        this.active = false;
+        this.dependant = new Set();
+        this.watch = {};
+        const parent = target instanceof Controller
+            ? target : control(target);
+        const proxy = create(parent.proxy);
+        let reset;
+        define(proxy, LOCAL, this);
+        defineProperty(this, "proxy", {
+            configurable: true,
+            get() {
+                if (reset)
+                    setTimeout(reset, 0);
+                return proxy;
+            }
+        });
+        const release = parent.addListener(key => {
+            const handler = this.watch[key];
+            if (!handler || !this.active)
+                return;
+            if (typeof handler == "function")
+                handler();
+            const notify = this.onUpdate(key, parent);
+            const getWhy = (keys) => {
+                reset = applyUpdate(proxy, keys.filter(k => k in this.watch));
+            };
+            if (notify) {
+                parent.requestUpdate(getWhy);
+                parent.requestUpdate(notify);
+            }
+        });
+        this.commit = () => {
+            this.active = true;
+            this.dependant.forEach(x => x.commit());
+            return this.release;
+        };
+        this.release = () => {
+            this.dependant.forEach(x => x.release());
+            release();
+        };
+    }
+}
+
+const Oops$b = issues({
+    ValueNotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
+    FactoryFailed: (model, key) => `Generating initial value for ${model}.${key} failed.`
+});
+/**
+ * Get value, suspend instead if undefined.
+ *
+ * Throws suspense promise also interpretable as an error.
+ * React could handle it but other contexts probably not.
+ */
+function pendingValue(via, key) {
+    const value = via.state[key];
+    if (value === undefined)
+        throw suspend(via, key);
+    return value;
+}
+function pendingFactory(parent, key, fn, immediate) {
+    const { subject, state } = parent;
+    let pending;
+    let error;
+    const init = () => {
+        const output = suspenseBoundary(() => {
+            return fn.call(subject, key, subject);
+        });
+        if (output instanceof Promise) {
+            pending = output
+                .catch(err => error = err)
+                .then(val => state[key] = val)
+                .finally(() => {
+                pending = undefined;
+                parent.update(key);
+            });
+            const issue = Oops$b.ValueNotReady(subject, key);
+            Object.assign(pending, {
+                message: issue.message,
+                stack: issue.stack
+            });
+        }
+        return state[key] = output;
+    };
+    if (immediate)
+        try {
+            init();
+        }
+        catch (err) {
+            Oops$b.FactoryFailed(subject, key).warn();
+            throw err;
+        }
+    return () => {
+        if (pending)
+            throw pending;
+        if (error)
+            throw error;
+        if (key in state)
+            return state[key];
+        let output = init();
+        if (pending)
+            throw pending;
+        else
+            return output;
+    };
+}
+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.`,
+    ComputeFailed: (parent, property, initial) => `An exception was thrown while ${initial ? "initializing" : "refreshing"} [${parent}.${property}].`,
+    ComputedEarly: (property) => `Note: Computed values don't run until accessed, except when subscribed to. '${property}' getter may have run earlier than intended.`
+});
+const INIT = new WeakSet();
+const INFO = new WeakMap();
+const USED = new WeakMap();
+const KEYS = new WeakMap();
+function from(source, arg1, arg2) {
+    return apply(function from(key) {
+        const parent = this;
+        const { subject, state } = this;
+        let getSource;
+        let getter;
+        if (arg2 === true || arg1 === true)
+            getter = pendingValue;
+        if (typeof arg1 == "boolean")
+            arg1 = undefined;
+        // Easy mistake, using a peer, will always be unresolved.
+        if (typeof source == "symbol")
+            throw Oops$a.PeerNotAllowed(subject, key);
+        // replace source controller in-case it is different
+        if (typeof source == "object")
+            getSource = () => control(source);
+        // specifically an arrow function (getter factory)
+        else if (!source.prototype) {
+            arg1 = source.call(subject, key);
+            getSource = () => this;
+        }
+        // Regular function is too ambiguous so not allowed.
+        else
+            throw Oops$a.BadComputedSource(subject, key, source);
+        let sub;
+        const setter = arg1;
+        const info = { key, parent, priority: 1 };
+        let register = USED.get(parent);
+        if (!register) {
+            register = new Map();
+            USED.set(parent, register);
+        }
+        register.set(key, info);
+        function compute(initial) {
+            try {
+                return setter.call(sub.proxy, sub.proxy);
+            }
+            catch (err) {
+                Oops$a.ComputeFailed(subject, key, !!initial).warn();
+                throw err;
+            }
+        }
+        function update() {
+            let value;
+            try {
+                value = compute(false);
+            }
+            catch (e) {
+                console.error(e);
+            }
+            finally {
+                if (state[key] !== value) {
+                    parent.update(key, value);
+                    return value;
+                }
+            }
+        }
+        function defer(_key, from) {
+            let pending = KEYS.get(from);
+            if (!pending)
+                KEYS.set(from, pending = []);
+            if (info.parent !== from)
+                update();
+            else {
+                const after = pending.findIndex(peer => (info.priority > INFO.get(peer).priority));
+                pending.splice(after + 1, 0, update);
+            }
+        }
+        function create(early) {
+            sub = new Subscriber(getSource(), defer);
+            defineProperty(state, key, {
+                value: undefined,
+                writable: true
+            });
+            try {
+                return state[key] = compute(true);
+            }
+            catch (e) {
+                if (early)
+                    Oops$a.ComputedEarly(key).warn();
+                throw e;
+            }
+            finally {
+                sub.commit();
+                for (const key in sub.watch) {
+                    const peer = register.get(key);
+                    if (peer && peer.priority >= info.priority)
+                        info.priority = peer.priority + 1;
+                }
+            }
+        }
+        setAlias(update, `try ${key}`);
+        setAlias(create, `new ${key}`);
+        setAlias(setter, `run ${key}`);
+        INIT.add(create);
+        INFO.set(update, info);
+        defineProperty(state, key, {
+            get: create,
+            configurable: true,
+            enumerable: true
+        });
+        if (getter)
+            return () => getter(parent, key);
+    });
+}
+function ensure(on, keys) {
+    for (const key of keys) {
+        const desc = getOwnPropertyDescriptor(on.state, key);
+        const getter = desc && desc.get;
+        if (INIT.has(getter))
+            getter(true);
+    }
+}
+function flush(on) {
+    const handled = on.frame;
+    const pending = KEYS.get(on);
+    if (!pending)
+        return;
+    while (pending.length) {
+        const why = [...handled];
+        const compute = pending.shift();
+        const { key } = INFO.get(compute);
+        if (!handled.has(key))
+            compute(why);
+    }
+    KEYS.delete(on);
+}
+
+const Oops$9 = issues({
     StrictUpdate: (expected) => `Strict update() did ${expected ? "not " : ""}find pending updates.`,
     NoChaining: () => `Then called with undefined; update promise will never catch nor supports chaining.`
 });
@@ -144,9 +431,7 @@ class Controller {
                 : () => state[key]
         });
         defineProperty(proxy, key, {
-            enumerable,
-            set,
-            get
+            enumerable, get, set
         });
     }
     ref(key, handler) {
@@ -207,7 +492,7 @@ class Controller {
             return;
         }
         if (typeof arg == "boolean" && arg !== this.frame.size > 0)
-            return Promise.reject(Oops$c.StrictUpdate(arg));
+            return Promise.reject(Oops$9.StrictUpdate(arg));
         return {
             then: (callback) => {
                 if (callback)
@@ -216,7 +501,7 @@ class Controller {
                     else
                         callback(false);
                 else
-                    throw Oops$c.NoChaining();
+                    throw Oops$9.NoChaining();
             }
         };
     }
@@ -245,164 +530,6 @@ function control(subject, cb) {
     return cb(control);
 }
 
-class Subscriber {
-    constructor(target, onUpdate) {
-        this.onUpdate = onUpdate;
-        this.active = false;
-        this.dependant = new Set();
-        this.watch = {};
-        const parent = target instanceof Controller
-            ? target : control(target);
-        const proxy = create(parent.proxy);
-        let reset;
-        define(proxy, LOCAL, this);
-        defineProperty(this, "proxy", {
-            configurable: true,
-            get() {
-                if (reset)
-                    setTimeout(reset, 0);
-                return proxy;
-            }
-        });
-        const release = parent.addListener(key => {
-            const handler = this.watch[key];
-            if (!handler || !this.active)
-                return;
-            if (typeof handler == "function")
-                handler();
-            const notify = this.onUpdate(key, parent);
-            const getWhy = (keys) => {
-                reset = applyUpdate(proxy, keys.filter(k => k in this.watch));
-            };
-            if (notify) {
-                parent.requestUpdate(getWhy);
-                parent.requestUpdate(notify);
-            }
-        });
-        this.commit = () => {
-            this.active = true;
-            this.dependant.forEach(x => x.commit());
-            return this.release;
-        };
-        this.release = () => {
-            this.dependant.forEach(x => x.release());
-            release();
-        };
-    }
-}
-
-const Oops$b = issues({
-    ComputeFailed: (parent, property, initial) => `An exception was thrown while ${initial ? "initializing" : "refreshing"} [${parent}.${property}].`,
-    ComputedEarly: (property) => `Note: Computed values don't run until accessed, except when subscribed to. '${property}' getter may have run earlier than intended.`
-});
-const INIT = new WeakSet();
-const INFO = new WeakMap();
-const USED = new WeakMap();
-const KEYS = new WeakMap();
-function prepare(parent, key, source, setter, getter) {
-    let sub;
-    const { state, subject } = parent;
-    const info = { key, parent, priority: 1 };
-    let register = USED.get(parent);
-    if (!register) {
-        register = new Map();
-        USED.set(parent, register);
-    }
-    register.set(key, info);
-    function compute(initial) {
-        try {
-            return setter.call(sub.proxy, sub.proxy);
-        }
-        catch (err) {
-            Oops$b.ComputeFailed(subject, key, !!initial).warn();
-            throw err;
-        }
-    }
-    function update() {
-        let value;
-        try {
-            value = compute(false);
-        }
-        catch (e) {
-            console.error(e);
-        }
-        finally {
-            if (state[key] !== value) {
-                parent.update(key, value);
-                return value;
-            }
-        }
-    }
-    function defer(_key, from) {
-        let pending = KEYS.get(from);
-        if (!pending)
-            KEYS.set(from, pending = []);
-        if (info.parent !== from)
-            update();
-        else {
-            const after = pending.findIndex(peer => (info.priority > INFO.get(peer).priority));
-            pending.splice(after + 1, 0, update);
-        }
-    }
-    function create(early) {
-        sub = new Subscriber(source(), defer);
-        defineProperty(state, key, {
-            value: undefined,
-            writable: true
-        });
-        try {
-            return state[key] = compute(true);
-        }
-        catch (e) {
-            if (early)
-                Oops$b.ComputedEarly(key).warn();
-            throw e;
-        }
-        finally {
-            sub.commit();
-            for (const key in sub.watch) {
-                const peer = register.get(key);
-                if (peer && peer.priority >= info.priority)
-                    info.priority = peer.priority + 1;
-            }
-        }
-    }
-    setAlias(update, `try ${key}`);
-    setAlias(create, `new ${key}`);
-    setAlias(setter, `run ${key}`);
-    INIT.add(create);
-    INFO.set(update, info);
-    defineProperty(state, key, {
-        get: create,
-        configurable: true,
-        enumerable: true
-    });
-    if (getter)
-        return () => getter(parent, key);
-}
-function ensure(on, keys) {
-    for (const key of keys) {
-        const desc = getOwnPropertyDescriptor(on.state, key);
-        const getter = desc && desc.get;
-        if (INIT.has(getter))
-            getter(true);
-    }
-}
-function flush(on) {
-    const handled = on.frame;
-    const pending = KEYS.get(on);
-    if (!pending)
-        return;
-    while (pending.length) {
-        const why = [...handled];
-        const compute = pending.shift();
-        const { key } = INFO.get(compute);
-        if (!handled.has(key))
-            compute(why);
-    }
-    KEYS.delete(on);
-}
-
 const CONTROL = Symbol("CONTROL");
 const WHY = Symbol("UPDATE");
 const LOCAL = Symbol("LOCAL");
@@ -599,7 +726,7 @@ function recursive(source, key) {
     };
 }
 
-const Oops$a = issues({
+const Oops$8 = issues({
     DuplicateAction: (key) => `Invoked action ${key} but one is already active.`
 });
 function act(task) {
@@ -607,7 +734,7 @@ function act(task) {
         let pending = false;
         const invoke = (...args) => {
             if (pending)
-                return Promise.reject(Oops$a.DuplicateAction(key));
+                return Promise.reject(Oops$8.DuplicateAction(key));
             pending = true;
             this.update(key);
             return new Promise(res => {
@@ -629,107 +756,6 @@ function act(task) {
     });
 }
 
-const Oops$9 = issues({
-    ValueNotReady: (model, key) => `Value ${model}.${key} value is not yet available.`
-});
-/**
- * Get value, suspend instead if undefined.
- *
- * Throws suspense promise also interpretable as an error.
- * React could handle it but other contexts probably not.
- */
-function pendingValue(via, key) {
-    const value = via.state[key];
-    if (value === undefined)
-        throw suspend(via, key);
-    return value;
-}
-function pendingFactory(via, key, fn) {
-    const { subject, state } = via;
-    let waiting;
-    let error;
-    return () => {
-        if (waiting)
-            throw waiting;
-        if (error)
-            throw error;
-        if (key in state)
-            return state[key];
-        let output;
-        try {
-            output = fn.call(subject, key, subject);
-        }
-        catch (err) {
-            throw error = err;
-        }
-        if (output instanceof Promise) {
-            const issue = Oops$9.ValueNotReady(subject, key);
-            output
-                .catch(err => error = err)
-                .then(out => state[key] = out)
-                .finally(() => waiting = undefined);
-            throw waiting = Object.assign(output, {
-                message: issue.message,
-                stack: issue.stack
-            });
-        }
-        else {
-            return state[key] = output;
-        }
-    };
-}
-function suspend(source, key) {
-    const error = Oops$9.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$8 = 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.`
-});
-function from(source, setter, arg) {
-    return apply(function from(key) {
-        const { subject } = this;
-        let getSource;
-        let getter;
-        if (arg === true || setter === true)
-            getter = pendingValue;
-        if (typeof setter == "boolean")
-            setter = undefined;
-        // Easy mistake, using a peer, will always be unresolved.
-        if (typeof source == "symbol")
-            throw Oops$8.PeerNotAllowed(subject, key);
-        // replace source controller in-case it is different
-        if (typeof source == "object")
-            getSource = () => control(source);
-        // specifically an arrow function (getter factory)
-        else if (!source.prototype) {
-            setter = source.call(subject, key);
-            getSource = () => this;
-        }
-        // Regular function is too ambiguous so not allowed.
-        else
-            throw Oops$8.BadComputedSource(subject, key, source);
-        return prepare(this, key, getSource, setter, getter);
-    });
-}
-
 function ref(arg) {
     return apply(function ref(key) {
         let value = {};
@@ -754,8 +780,7 @@ function createRef(key, cb) {
 
 const Oops$7 = issues({
     NonOptional: (Parent, key) => `Property ${Parent}.${key} is marked as required.`,
-    BadFactory: () => `Set instruction can only accept a factory or undefined.`,
-    FactoryFailed: (model, key) => `Generating initial value for ${model}.${key} failed.`
+    BadFactory: () => `Set instruction can only accept a factory or undefined.`
 });
 function set(factory, argument) {
     return apply(function set(key) {
@@ -767,19 +792,7 @@ function set(factory, argument) {
         else if (typeof factory !== "function")
             throw Oops$7.BadFactory();
         else {
-            get = pendingFactory(this, key, factory);
-            if (required)
-                try {
-                    get();
-                }
-                catch (err) {
-                    if (err instanceof Promise)
-                        ;
-                    else {
-                        Oops$7.FactoryFailed(this.subject, key).warn();
-                        throw err;
-                    }
-                }
+            get = pendingFactory(this, key, factory, required);
         }
         if (typeof argument == "function")
             set = createValueEffect(argument);
@@ -1120,15 +1133,21 @@ class MVC extends Model {
     static tap(key, expect) {
         return useTap(this, key, expect);
     }
-    /**
-     * **React Hook** - Spawn and maintain a controller from within a component.
-     *
-     * More efficient than `use()` if you don't need hook-based features.
-     *
-     * @param callback - Run after creation of instance.
-     */
-    static new(callback) {
-        return useModel(this, [], callback);
+    static new(arg) {
+        const instance = React.useMemo(() => {
+            const instance = new this();
+            control(instance);
+            if (typeof arg == "function")
+                arg(instance);
+            else if (arg)
+                getOwnPropertyNames(instance).forEach(key => {
+                    if (key in arg)
+                        instance[key] = arg[key];
+                });
+            return instance;
+        }, []);
+        usePeerContext(instance.get);
+        return instance;
     }
     static use(a, b) {
         const instance = useModel(this, a, b);