@expressive/mvc 0.5.0 → 0.6.0

package/lib/index.js

@@ -25,11 +25,11 @@ function issues(register) {
     return Library;
 }
 
-const Oops$c = issues({
+const Oops$b = issues({
     NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
 });
 function suspend(source, key) {
-    const error = Oops$c.NotReady(source.subject, key);
+    const error = Oops$b.NotReady(source.subject, key);
     const promise = new Promise(resolve => {
         const release = source.addListener(forKey => {
             if (forKey == key)
@@ -69,101 +69,170 @@ function mayRetry(fn) {
     return compute();
 }
 
-const Oops$b = issues({
+const Oops$a = issues({
     BadSource: (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.`,
-    Failed: (parent, property, initial) => `An exception was thrown while ${initial ? "initializing" : "refreshing"} [${parent}.${property}].`
+    Failed: (parent, property, initial) => `An exception was thrown while ${initial ? "initializing" : "refreshing"} [${parent}.${property}].`,
+    FactoryFailed: (model, key) => `Generating initial value for ${model}.${key} failed.`,
+    NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
+    ComputeFailed: (model, key) => `Generating initial value for ${model}.${key} failed.`
 });
 const INFO = new WeakMap();
 const KEYS = new WeakMap();
 const ORDER = new WeakMap();
-function get(source, arg1, arg2) {
+function get(arg0, arg1, arg2) {
     return apply(function get(key) {
-        const { subject, state } = this;
-        const required = arg2 === true || arg1 === true;
-        let getSource;
-        if (typeof arg1 == "boolean")
-            arg1 = undefined;
+        const { subject } = this;
+        const computeRequired = arg1 === true || arg2 === true;
+        const factoryRequired = arg1 !== false && arg2 !== false;
+        let getter;
         // Easy mistake, using a peer, will always be unresolved.
-        if (typeof source == "symbol")
-            throw Oops$b.PeerNotAllowed(subject, key);
-        // replace source controller in-case it is different
-        if (typeof source == "object")
-            getSource = () => ensure(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$b.BadSource(subject, key, source);
-        const setter = arg1;
-        const info = { key, parent: this };
-        let sub;
-        let order = ORDER.get(this);
-        if (!order)
-            ORDER.set(this, order = []);
-        const compute = (initial) => {
-            try {
-                return setter.call(sub.proxy, sub.proxy);
-            }
-            catch (err) {
-                Oops$b.Failed(subject, key, initial).warn();
-                throw err;
-            }
-        };
-        const refresh = () => {
-            let value;
-            try {
-                value = compute(false);
-            }
-            catch (e) {
-                console.error(e);
-            }
-            finally {
-                if (state.get(key) !== value) {
-                    state.set(key, value);
-                    this.update(key);
-                    return value;
+        if (typeof arg0 == "symbol")
+            throw Oops$a.PeerNotAllowed(subject, key);
+        if (typeof arg0 == "function" && /^[A-Z]/.test(arg0.name))
+            throw Oops$a.BadSource(subject, key, arg0);
+        this.state.set(key, undefined);
+        const init = () => {
+            let source = this;
+            let setter;
+            if (typeof arg0 == "function") {
+                const result = mayRetry(() => arg0.call(subject, key, subject));
+                if (typeof result == "function")
+                    setter = result;
+                else {
+                    getter = factoryMode(this, result, key, factoryRequired);
+                    return;
                 }
             }
-        };
-        const update = (_key, source) => {
-            if (source !== this) {
-                refresh();
+            else if (arg0 instanceof Promise) {
+                getter = factoryMode(this, arg0, key, factoryRequired);
                 return;
             }
-            let pending = KEYS.get(this);
-            if (!pending)
-                KEYS.set(this, pending = []);
-            pending.push(refresh);
+            else if (typeof arg1 == "function") {
+                // replace source controller in-case it is different
+                source = ensure(arg0);
+                setter = arg1;
+            }
+            else
+                throw new Error(`Factory argument cannot be ${arg1}`);
+            getter = computeMode(this, source, setter, key, computeRequired);
         };
-        const create = () => {
-            sub = getSource().subscribe(update);
+        if (typeof arg0 == "function" && factoryRequired)
             try {
-                const value = compute(true);
-                state.set(key, value);
-                return value;
-            }
-            catch (e) {
-                throw e;
+                init();
             }
-            finally {
-                sub.commit();
-                order.push(refresh);
+            catch (err) {
+                Oops$a.ComputeFailed(subject, key).warn();
+                throw err;
             }
-        };
-        state.set(key, undefined);
-        INFO.set(refresh, info);
         return () => {
-            const value = sub ? state.get(key) : create();
-            if (value === undefined && required)
-                throw suspend(this, key);
-            return value;
+            if (!getter)
+                init();
+            return getter();
         };
     });
 }
+function factoryMode(self, output, key, required) {
+    const { subject, state } = self;
+    let pending;
+    let error;
+    if (output instanceof Promise) {
+        state.set(key, undefined);
+        pending = output
+            .catch(err => error = err)
+            .then(val => {
+            state.set(key, val);
+            return val;
+        })
+            .finally(() => {
+            pending = undefined;
+            self.update(key);
+        });
+    }
+    state.set(key, output);
+    const suspend = () => {
+        if (required === false)
+            return undefined;
+        const issue = Oops$a.NotReady(subject, key);
+        Object.assign(pending, {
+            message: issue.message,
+            stack: issue.stack
+        });
+        throw pending;
+    };
+    return () => {
+        if (error)
+            throw error;
+        if (pending)
+            return suspend();
+        if (state.has(key))
+            return state.get(key);
+    };
+}
+function computeMode(self, source, setter, key, required) {
+    const { subject, state } = self;
+    let sub;
+    let order = ORDER.get(self);
+    if (!order)
+        ORDER.set(self, order = []);
+    const compute = (initial) => {
+        try {
+            return setter.call(sub.proxy, sub.proxy);
+        }
+        catch (err) {
+            Oops$a.Failed(subject, key, initial).warn();
+            throw err;
+        }
+    };
+    const refresh = () => {
+        let value;
+        try {
+            value = compute(false);
+        }
+        catch (e) {
+            console.error(e);
+        }
+        finally {
+            if (state.get(key) !== value) {
+                state.set(key, value);
+                self.update(key);
+                return value;
+            }
+        }
+    };
+    const update = (_key, source) => {
+        if (source !== self) {
+            refresh();
+            return;
+        }
+        let pending = KEYS.get(self);
+        if (!pending)
+            KEYS.set(self, pending = []);
+        pending.push(refresh);
+    };
+    const create = () => {
+        sub = source.subscribe(update);
+        try {
+            const value = compute(true);
+            state.set(key, value);
+            return value;
+        }
+        catch (e) {
+            throw e;
+        }
+        finally {
+            sub.commit();
+            order.push(refresh);
+        }
+    };
+    INFO.set(refresh, key);
+    return () => {
+        const value = sub ? state.get(key) : create();
+        if (value === undefined && required)
+            throw suspend(self, key);
+        return value;
+    };
+}
 function flush(control) {
     const pending = KEYS.get(control);
     if (!pending)
@@ -173,14 +242,14 @@ function flush(control) {
         const compute = pending
             .sort((a, b) => list.indexOf(b) - list.indexOf(a))
             .pop();
-        const { key } = INFO.get(compute);
+        const key = INFO.get(compute);
         if (!control.frame.has(key))
             compute();
     }
     KEYS.delete(control);
 }
 
-const Oops$a = issues({
+const Oops$9 = issues({
     BadCallback: () => `Callback for effect-callback may only return a function.`
 });
 const { assign, create, defineProperty, entries, getPrototypeOf, getOwnPropertyNames, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
@@ -193,7 +262,7 @@ function createEffect(callback) {
         if (unSet instanceof Promise)
             unSet = undefined;
         if (unSet && typeof unSet !== "function")
-            throw Oops$a.BadCallback();
+            throw Oops$9.BadCallback();
     };
 }
 function createValueEffect(callback) {
@@ -209,65 +278,11 @@ function createValueEffect(callback) {
         if (typeof out == "function")
             unSet = out;
         else
-            throw Oops$a.BadCallback();
+            throw Oops$9.BadCallback();
     };
 }
 
-class Subscriber {
-    constructor(parent, onUpdate) {
-        this.onUpdate = onUpdate;
-        this.active = false;
-        this.dependant = new Set();
-        const proxy = create(parent.subject);
-        const using = new Map();
-        defineProperty(proxy, LOCAL, { value: this });
-        defineProperty(this, "proxy", {
-            configurable: true,
-            get() {
-                if (UPDATE.has(proxy))
-                    setTimeout(() => UPDATE.delete(proxy), 0);
-                return proxy;
-            }
-        });
-        const release = parent.addListener(key => {
-            if (!this.active)
-                return;
-            const handler = using.get(key);
-            let notify;
-            if (typeof handler == "function") {
-                const callback = handler();
-                if (callback === true)
-                    notify = this.onUpdate(key, parent);
-            }
-            else if (handler === true)
-                notify = this.onUpdate(key, parent);
-            if (!notify)
-                return;
-            const notate = () => {
-                UPDATE.set(proxy, getUpdate(parent.subject).filter(k => using.has(k)));
-            };
-            parent.waiting.add(notate);
-            parent.waiting.add(notify);
-        });
-        this.commit = () => {
-            this.active = true;
-            this.dependant.forEach(x => x.commit());
-            return this.release;
-        };
-        this.release = () => {
-            this.dependant.forEach(x => x.release());
-            release();
-        };
-        this.add = (key, value) => {
-            if (value !== undefined)
-                using.set(key, value);
-            else if (!using.has(key))
-                using.set(key, true);
-        };
-    }
-}
-
-const Oops$9 = issues({
+const Oops$8 = issues({
     Timeout: (keys, timeout) => `No update for [${keys}] within ${timeout}.`,
     StrictUpdate: () => `Strict update() did not find pending updates.`,
     NoChaining: () => `Then called with undefined; update promise will never catch nor supports chaining.`
@@ -350,7 +365,7 @@ class Model {
             const invoke = (key) => {
                 if (!key) {
                     clear();
-                    reject(Oops$9.Timeout(select, typeof argument == "number"
+                    reject(Oops$8.Timeout(select, typeof argument == "number"
                         ? `${argument}ms`
                         : `lifetime of ${this}`));
                 }
@@ -437,11 +452,11 @@ class Model {
             arg = undefined;
         }
         if (!frame.size && arg === true)
-            return Promise.reject(Oops$9.StrictUpdate());
+            return Promise.reject(Oops$8.StrictUpdate());
         return {
             then: (callback) => {
                 if (!callback)
-                    throw Oops$9.NoChaining();
+                    throw Oops$8.NoChaining();
                 if (frame.size || arg !== false)
                     waiting.add(() => {
                         callback(getUpdate(this));
@@ -483,7 +498,63 @@ class Model {
     }
 }
 
+class Subscriber {
+    constructor(parent, onUpdate) {
+        this.onUpdate = onUpdate;
+        this.active = false;
+        this.dependant = new Set();
+        const proxy = create(parent.subject);
+        const using = new Map();
+        const listen = this.add = (key, value) => {
+            if (value !== undefined)
+                using.set(key, value);
+            else if (!using.has(key))
+                using.set(key, true);
+        };
+        LISTEN.set(proxy, listen);
+        defineProperty(proxy, LOCAL, { value: this });
+        defineProperty(this, "proxy", {
+            configurable: true,
+            get() {
+                if (UPDATE.has(proxy))
+                    setTimeout(() => UPDATE.delete(proxy), 0);
+                return proxy;
+            }
+        });
+        const release = parent.addListener(key => {
+            if (!this.active)
+                return;
+            const handler = using.get(key);
+            let notify;
+            if (typeof handler == "function") {
+                const callback = handler();
+                if (callback === true)
+                    notify = this.onUpdate(key, parent);
+            }
+            else if (handler === true)
+                notify = this.onUpdate(key, parent);
+            if (!notify)
+                return;
+            const notate = () => {
+                UPDATE.set(proxy, getUpdate(parent.subject).filter(k => using.has(k)));
+            };
+            parent.waiting.add(notate);
+            parent.waiting.add(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 UPDATE = new WeakMap();
+const LISTEN = new WeakMap();
 const CONTROL = Symbol("CONTROL");
 function getUpdate(subject) {
     return UPDATE.get(subject);
@@ -514,9 +585,9 @@ class Controller {
             enumerable: false,
             set: this.ref(key),
             get() {
-                const local = this[LOCAL];
-                if (local)
-                    local.add(key);
+                const listen = LISTEN.get(this);
+                if (listen)
+                    listen(key);
                 return state.get(key);
             }
         });
@@ -643,9 +714,10 @@ function apply(fn, label) {
             get() {
                 if (!state.has(key) && suspense)
                     throw suspend(control, key);
+                const listen = LISTEN.get(this);
                 const local = this[LOCAL];
-                if (local)
-                    local.add(key);
+                if (listen)
+                    listen(key);
                 return onGet
                     ? onGet(local)
                     : state.get(key);
@@ -713,7 +785,7 @@ function __awaiter(thisArg, _arguments, P, generator) {
     });
 }
 
-const Oops$8 = issues({
+const Oops$7 = issues({
     DuplicatePending: (key) => `Invoked action ${key} but one is already active.`
 });
 function act(task) {
@@ -721,7 +793,7 @@ function act(task) {
         let pending = false;
         const invoke = (...args) => __awaiter(this, void 0, void 0, function* () {
             if (pending)
-                return Promise.reject(Oops$8.DuplicatePending(key));
+                return Promise.reject(Oops$7.DuplicatePending(key));
             pending = true;
             this.update(key);
             try {
@@ -757,81 +829,6 @@ function ref(callback) {
     });
 }
 
-const Oops$7 = issues({
-    NonOptional: (Parent, key) => `Property ${Parent}.${key} is marked as required.`,
-    NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
-    Failed: (model, key) => `Generating initial value for ${model}.${key} failed.`
-});
-function put(factory, argument) {
-    return apply(function set(key) {
-        const { subject, state } = this;
-        const required = argument === true ||
-            argument === undefined;
-        let pending;
-        let error;
-        const init = () => {
-            const output = typeof factory == "function" ?
-                mayRetry(() => factory.call(subject, key, subject)) :
-                factory;
-            if (output instanceof Promise) {
-                pending = output
-                    .catch(err => error = err)
-                    .then(val => {
-                    state.set(key, val);
-                    return val;
-                })
-                    .finally(() => {
-                    pending = undefined;
-                    this.update(key);
-                });
-                return;
-            }
-            state.set(key, output);
-            return output;
-        };
-        if (required)
-            try {
-                init();
-            }
-            catch (err) {
-                Oops$7.Failed(subject, key).warn();
-                throw err;
-            }
-        const suspend = () => {
-            if (required === false)
-                return undefined;
-            const issue = Oops$7.NotReady(subject, key);
-            Object.assign(pending, {
-                message: issue.message,
-                stack: issue.stack
-            });
-            throw pending;
-        };
-        const get = () => {
-            if (pending)
-                return suspend();
-            if (error)
-                throw error;
-            if (state.has(key))
-                return state.get(key);
-            const output = init();
-            return pending
-                ? suspend()
-                : output;
-        };
-        const set = typeof argument == "function"
-            ? createValueEffect(argument)
-            : (value) => {
-                if (value === undefined && required)
-                    throw Oops$7.NonOptional(subject, key);
-            };
-        return {
-            set,
-            get
-        };
-    });
-}
-
 function set(value, argument) {
     if (!(1 in arguments)) {
         argument = value;
@@ -995,31 +992,77 @@ function createProxy(emit, watch) {
 const Parent = new WeakMap();
 const Oops$6 = issues({
     BadArgument: (type) => `Instruction \`use\` cannot accept argument type of ${type}.`,
+    NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`
 });
 function use$1(input, argument) {
     return apply(function use(key) {
         const { state, subject } = this;
+        const required = argument !== false;
+        let pending;
+        let error;
+        let get = (_local) => state.get(key);
         if (typeof input === "function")
-            input = "prototype" in input ? new input() : input();
+            input = /^[A-Z]/.test(input.name)
+                ? new input() : input;
         else if (input && typeof input !== "object")
             throw Oops$6.BadArgument(typeof input);
         if (input instanceof Map || input instanceof Set)
             return keyed(this, key, input);
-        function onUpdate(next) {
+        const onUpdate = (next) => {
             state.set(key, next);
             if (next) {
+                get = getRecursive(key, this);
                 Parent.set(next, subject);
                 ensure(next);
             }
             if (typeof argument == "function")
                 argument(next);
             return true;
-        }
-        if (input)
-            onUpdate(input);
+        };
+        const suspend = () => {
+            if (required === false)
+                return;
+            const issue = Oops$6.NotReady(subject, key);
+            Object.assign(pending, {
+                message: issue.message,
+                stack: issue.stack
+            });
+            throw pending;
+        };
+        const initialize = () => {
+            const output = typeof input == "function" ?
+                mayRetry(() => input.call(subject, subject)) :
+                input;
+            if (output instanceof Promise) {
+                pending = output
+                    .catch(err => error = err)
+                    .then(val => {
+                    onUpdate(val);
+                    return val;
+                })
+                    .finally(() => {
+                    pending = undefined;
+                    this.update(key);
+                });
+                return;
+            }
+            onUpdate(output);
+        };
+        if (input !== undefined && required)
+            initialize();
         return {
             set: onUpdate,
-            recursive: true
+            get(local) {
+                if (pending)
+                    return suspend();
+                if (error)
+                    throw error;
+                if (!state.has(key))
+                    initialize();
+                if (pending)
+                    return suspend();
+                return get(local);
+            }
         };
     });
 }
@@ -1479,7 +1522,6 @@ exports.apply = apply;
 exports["default"] = MVC;
 exports.get = get;
 exports.has = has;
-exports.put = put;
 exports.ref = ref;
 exports.set = set;
 exports.tap = tap;