@expressive/mvc 0.5.0 → 0.6.2

package/lib/index.esm.js

@@ -62,99 +62,74 @@ function mayRetry(fn) {
 }
 
 const Oops$b = 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}].`
 });
 const INFO = new WeakMap();
 const KEYS = new WeakMap();
 const ORDER = new WeakMap();
-function get(source, 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;
-        // 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;
+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);
         }
-        // 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;
-                }
-            }
-        };
-        const update = (_key, source) => {
-            if (source !== this) {
-                refresh();
-                return;
-            }
-            let pending = KEYS.get(this);
-            if (!pending)
-                KEYS.set(this, pending = []);
-            pending.push(refresh);
-        };
-        const create = () => {
-            sub = getSource().subscribe(update);
-            try {
-                const value = compute(true);
+        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);
+                self.update(key);
                 return value;
             }
-            catch (e) {
-                throw e;
-            }
-            finally {
-                sub.commit();
-                order.push(refresh);
-            }
-        };
-        state.set(key, undefined);
-        INFO.set(refresh, info);
-        return () => {
-            const value = sub ? state.get(key) : create();
-            if (value === undefined && required)
-                throw suspend(this, key);
+        }
+    };
+    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);
@@ -165,7 +140,7 @@ 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();
     }
@@ -205,60 +180,6 @@ function createValueEffect(callback) {
     };
 }
 
-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({
     Timeout: (keys, timeout) => `No update for [${keys}] within ${timeout}.`,
     StrictUpdate: () => `Strict update() did not find pending updates.`,
@@ -475,7 +396,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);
@@ -506,9 +483,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);
             }
         });
@@ -635,9 +612,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);
@@ -735,91 +713,116 @@ function act(task) {
     });
 }
 
-function ref(callback) {
-    return apply(function ref(key) {
-        const value = this.ref(key, callback && createValueEffect(callback));
-        defineProperty(value, "current", {
-            set: value,
-            get: () => this.state.get(key)
+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);
         });
-        return {
-            value,
-            explicit: true
-        };
-    });
+    }
+    state.set(key, output);
+    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;
+    };
+    return () => {
+        if (error)
+            throw error;
+        if (pending)
+            return suspend();
+        if (state.has(key))
+            return state.get(key);
+    };
 }
 
 const Oops$7 = issues({
-    NonOptional: (Parent, key) => `Property ${Parent}.${key} is marked as required.`,
+    // 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.`,
+    ComputeFailed: (model, key) => `Generating initial value for ${model}.${key} failed.`,
     NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
-    Failed: (model, key) => `Generating initial value for ${model}.${key} failed.`
+    FactoryFailed: (model, key) => `Generating initial value for ${model}.${key} failed.`,
+    Failed: (parent, property, initial) => `An exception was thrown while ${initial ? "initializing" : "refreshing"} [${parent}.${property}].`
 });
-function put(factory, argument) {
-    return apply(function set(key) {
-        const { subject, state } = this;
-        const required = argument === true ||
-            argument === undefined;
-        let pending;
-        let error;
+function get(arg0, arg1, arg2) {
+    return apply(function get(key) {
+        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 arg0 == "symbol")
+            throw Oops$7.PeerNotAllowed(subject, key);
+        // if(typeof arg0 == "function" && /^[A-Z]/.test(arg0.name))
+        //   throw Oops.BadSource(subject, key, arg0);
+        this.state.set(key, undefined);
         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);
-                });
+            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;
+                }
+            }
+            else if (arg0 instanceof Promise) {
+                getter = factoryMode(this, arg0, key, factoryRequired);
                 return;
             }
-            state.set(key, output);
-            return output;
+            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);
         };
-        if (required)
+        if (typeof arg0 == "function" && factoryRequired)
             try {
                 init();
             }
             catch (err) {
-                Oops$7.Failed(subject, key).warn();
+                Oops$7.ComputeFailed(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;
+        return () => {
+            if (!getter)
+                init();
+            return getter();
         };
-        const set = typeof argument == "function"
-            ? createValueEffect(argument)
-            : (value) => {
-                if (value === undefined && required)
-                    throw Oops$7.NonOptional(subject, key);
-            };
+    });
+}
+
+function ref(callback) {
+    return apply(function ref(key) {
+        const value = this.ref(key, callback && createValueEffect(callback));
+        defineProperty(value, "current", {
+            set: value,
+            get: () => this.state.get(key)
+        });
         return {
-            set,
-            get
+            value,
+            explicit: true
         };
     });
 }
@@ -987,31 +990,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);
+            }
         };
     });
 }
@@ -1458,5 +1507,5 @@ class Global extends MVC {
     }
 }
 
-export { CONTROL, Consumer, Global, LOCAL, MVC as Model, Provider, STATE, WHY, act, apply, MVC as default, get, has, put, ref, set, tap, use$1 as use, useFrom, useLocal, useModel, useTap };
+export { CONTROL, Consumer, Global, LOCAL, MVC as Model, Provider, STATE, WHY, act, apply, MVC as default, get, has, ref, set, tap, use$1 as use, useFrom, useLocal, useModel, useTap };
 //# sourceMappingURL=index.esm.js.map