@expressive/mvc 1.0.0-beta.31 → 1.0.0-beta.34

package/lib/index.esm.js

@@ -20,7 +20,7 @@ function issues(register) {
     return Library;
 }
 
-const Oops$8 = issues({
+const Oops$9 = issues({
     BadEffectCallback: () => `Callback for effect-callback may only return a function.`
 });
 const { assign, create, defineProperty, entries, getPrototypeOf, getOwnPropertyNames, getOwnPropertyDescriptor, getOwnPropertyDescriptors, getOwnPropertySymbols, keys: keys$1, values } = Object;
@@ -49,7 +49,7 @@ function createEffect(callback) {
         if (unSet instanceof Promise)
             unSet = undefined;
         if (unSet && typeof unSet !== "function")
-            throw Oops$8.BadEffectCallback();
+            throw Oops$9.BadEffectCallback();
     };
 }
 function createValueEffect(callback) {
@@ -65,7 +65,7 @@ function createValueEffect(callback) {
         if (typeof out == "function")
             unSet = out;
         else
-            throw Oops$8.BadEffectCallback();
+            throw Oops$9.BadEffectCallback();
     };
 }
 function select(source, select) {
@@ -92,58 +92,51 @@ class Subscriber {
     constructor(parent, onUpdate) {
         this.onUpdate = onUpdate;
         this.active = false;
-        this.handle = {};
+        this.using = {};
         this.dependant = new Set();
-        this.debug = () => {
-            const update = [];
-            this.notify = keys => {
-                update.splice(0, update.length, ...keys.filter(k => k in this.handle));
-            };
-            return update;
-        };
-        this.listen = (key, from) => {
-            const handler = this.handle[key];
-            if (!handler)
-                return;
-            if (typeof handler == "function")
-                handler();
-            const notify = this.onUpdate(key, from);
-            if (notify)
-                from.waiting.add(notify);
-            if (this.notify)
-                from.waiting.add(this.notify);
-        };
         if (!(parent instanceof Controller))
             parent = manage(parent);
         this.parent = parent;
         this.source = parent.subject;
         this.proxy = create(parent.subject);
         define(this.proxy, LOCAL, this);
-        defineLazy(this.proxy, UPDATE, this.debug);
+        defineLazy(this.proxy, UPDATE, () => {
+            const update = [];
+            this.notify = keys => {
+                update.splice(0, update.length, ...keys.filter(k => k in this.using));
+            };
+            return update;
+        });
         for (const key in parent.state)
             this.spy(key);
     }
     spy(key) {
-        const { proxy, source } = this;
-        const { set } = getOwnPropertyDescriptor(source, key);
-        const intercept = () => {
-            this.follow(key);
+        const { proxy } = this;
+        const existing = getOwnPropertyDescriptor(this.source, key);
+        const isUsing = () => {
+            this.using[key] = true;
             delete proxy[key];
             return proxy[key];
         };
-        setAlias(intercept, `tap ${key}`);
+        setAlias(isUsing, `tap ${key}`);
         defineProperty(proxy, key, {
-            get: intercept,
-            set,
+            set: existing.set,
+            get: isUsing,
             configurable: true,
             enumerable: true
         });
     }
-    follow(key, callback) {
-        this.handle[key] = callback || true;
-    }
     commit() {
-        const onDone = this.parent.addListener(this.listen);
+        const onDone = this.parent.addListener((key, source) => {
+            const handler = this.using[key];
+            if (!handler)
+                return;
+            if (typeof handler == "function")
+                handler();
+            const notify = this.onUpdate(key, source);
+            source.onUpdate(notify);
+            source.onUpdate(this.notify);
+        });
         this.active = true;
         this.dependant.forEach(x => x.commit());
         return this.release = () => {
@@ -153,7 +146,7 @@ class Subscriber {
     }
 }
 
-const Oops$7 = issues({
+const Oops$8 = 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.`
 });
@@ -172,14 +165,14 @@ function prepare(parent, key, source, setter, getter) {
     }
     register.set(key, info);
     const current = getter
-        ? () => getter.call(subject, state[key], key)
+        ? () => getter(parent, key)
         : () => state[key];
     function compute(initial) {
         try {
             return setter.call(sub.proxy, sub.proxy);
         }
         catch (err) {
-            Oops$7.ComputeFailed(subject, key, !!initial).warn();
+            Oops$8.ComputeFailed(subject, key, !!initial).warn();
             throw err;
         }
     }
@@ -225,12 +218,12 @@ function prepare(parent, key, source, setter, getter) {
         }
         catch (e) {
             if (early)
-                Oops$7.ComputedEarly(key).warn();
+                Oops$8.ComputedEarly(key).warn();
             throw e;
         }
         finally {
             sub.commit();
-            for (const key in sub.handle) {
+            for (const key in sub.using) {
                 const peer = register.get(key);
                 if (peer && peer.priority >= info.priority)
                     info.priority = peer.priority + 1;
@@ -367,6 +360,10 @@ class Controller {
     get pending() {
         return this.frame.size > 0;
     }
+    onUpdate(cb) {
+        if (typeof cb == "function")
+            this.waiting.add(cb);
+    }
     start() {
         const { subject } = this;
         for (const key in subject) {
@@ -431,11 +428,8 @@ class Controller {
         if (!this.frame.size)
             setTimeout(() => this.emit(), 0);
         this.frame.add(key);
-        for (const subscription of this.followers) {
-            const notify = subscription(key, this);
-            if (notify)
-                this.waiting.add(notify);
-        }
+        for (const callback of this.followers)
+            this.onUpdate(callback(key, this));
     }
     emit() {
         flush(this);
@@ -494,7 +488,7 @@ function child(source, name) {
                 start();
             }
             start();
-            sub.follow(key, restart);
+            sub.using[key] = restart;
         }
         return (local) => {
             if (!local)
@@ -506,6 +500,61 @@ function child(source, name) {
     }, name || source.name);
 }
 
+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.`
+});
+function lazy(value) {
+    return apply(function lazy(key) {
+        const source = this.subject;
+        source[key] = value;
+        defineProperty(this.state, key, {
+            get: () => source[key]
+        });
+    });
+}
+function set(factory, argument) {
+    return apply(function set(key) {
+        let onSet;
+        let onGet;
+        const required = argument === true || argument === undefined;
+        if (factory === undefined)
+            onGet = () => pendingValue(this, key);
+        else if (typeof factory !== "function")
+            throw Oops$7.BadFactory();
+        else {
+            onGet = pendingFactory(this, key, factory);
+            if (required)
+                try {
+                    onGet();
+                }
+                catch (err) {
+                    if (err instanceof Promise)
+                        ;
+                    else {
+                        Oops$7.FactoryFailed(this.subject, key).warn();
+                        throw err;
+                    }
+                }
+        }
+        if (typeof argument == "function")
+            onSet = createValueEffect(argument);
+        else if (required)
+            onSet = (value) => {
+                if (value === undefined)
+                    throw Oops$7.NonOptional(this.subject, key);
+            };
+        return {
+            set: this.setter(key, onSet),
+            get: onGet
+        };
+    });
+}
+function on(initial, onUpdate) {
+    return set(initial && (() => initial), onUpdate);
+}
+
 const Oops$6 = issues({
     CantAttachGlobal: (parent, child) => `Singleton '${parent}' attempted to attach '${child}' but it is not also a singleton.`,
     AmbientRequired: (requested, requester, key) => `Attempted to find an instance of ${requested} in context. It is required for [${requester}.${key}], but one could not be found.`
@@ -608,10 +657,13 @@ function act(task) {
         };
     });
 }
-function from(source, setter, getter) {
+function from(source, setter, argument) {
     return apply(function from(key) {
-        const { subject } = this;
         let getSource;
+        const { subject } = this;
+        const getter = argument === true
+            ? pendingValue
+            : argument || undefined;
         // Easy mistake, using a peer, will always be unresolved.
         if (typeof source == "symbol")
             throw Oops$5.PeerNotAllowed(subject, key);
@@ -626,7 +678,7 @@ function from(source, setter, getter) {
         // is a peer Model (constructor)
         else if (Model.isTypeof(source))
             getSource = pendingAccess(subject, source, key, true);
-        // Regular function is to ambiguous so not allowed.
+        // Regular function is too ambiguous so not allowed.
         else
             throw Oops$5.BadComputedSource(subject, key, source);
         prepare(this, key, getSource, setter, getter);
@@ -636,12 +688,14 @@ function from(source, setter, getter) {
 const Oops$4 = issues({
     ValueNotReady: (model, key) => `Value ${model}.${key} value is not yet available.`
 });
+/* deprecated - ignore coverage */
+/* istanbul ignore next */
 function pending(source, compute) {
-    return (source === undefined ?
-        suspendForValue() :
-        typeof source == "function" && !source.prototype ?
-            suspendForAsync(source) :
-            suspendForComputed(source, compute));
+    if (source === undefined)
+        return set();
+    if (typeof source == "function" && !source.prototype)
+        return set(source);
+    return from(source, compute, true);
 }
 /**
  * Get value, suspend instead if undefined.
@@ -655,6 +709,40 @@ function pendingValue(via, key) {
         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$4.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$4.ValueNotReady(source.subject, key);
     const promise = new Promise(resolve => {
@@ -674,45 +762,6 @@ function suspend(source, key) {
         message: error.message,
         stack: error.stack
     });
-}
-function suspendForComputed(source, compute) {
-    function getter(_value, key) {
-        return pendingValue(manage(this), key);
-    }
-    return from(source, compute, getter);
-}
-function suspendForValue() {
-    return apply(function pending(key) {
-        this.state[key] = undefined;
-        return {
-            set: this.setter(key),
-            get: () => pendingValue(this, key)
-        };
-    });
-}
-function suspendForAsync(source) {
-    return apply(function suspense(key) {
-        const subject = this.subject;
-        let waiting = true;
-        let value;
-        let error;
-        return () => {
-            if (error)
-                throw error;
-            if (!waiting)
-                return value;
-            const issue = Oops$4.ValueNotReady(subject, key);
-            let suspend = source
-                .call(subject, key)
-                .catch(err => error = err)
-                .then(out => value = out)
-                .finally(() => waiting = false);
-            throw Object.assign(suspend, {
-                message: issue.message,
-                stack: issue.stack
-            });
-        };
-    });
 }
 
 function use$1(init) {
@@ -753,13 +802,11 @@ function useWatcher(target, focus, expected) {
 function useComputed(target, compute, expected) {
     const hook = use$1(refresh => {
         const sub = new Subscriber(target, () => update);
-        const { proxy } = sub;
-        let value;
+        const spy = sub.proxy;
+        let value = compute.call(spy, spy);
+        let update;
         let retry;
-        const update = () => {
-            const next = compute.call(proxy, proxy);
-            if (value == next)
-                return;
+        const set = (next) => {
             value = next;
             if (retry) {
                 retry();
@@ -768,16 +815,26 @@ function useComputed(target, compute, expected) {
             else
                 refresh();
         };
-        const access = () => {
-            if (value === undefined && expected)
-                throw new Promise(res => {
-                    retry = res;
-                });
-            return value;
-        };
-        value = compute.call(proxy, proxy);
-        sub.commit();
-        defineProperty(sub, "proxy", { get: access });
+        if (value instanceof Promise) {
+            value.then(set);
+            value = undefined;
+        }
+        else {
+            sub.commit();
+            update = () => {
+                const next = compute.call(spy, spy);
+                if (value != next)
+                    set(next);
+            };
+        }
+        const get = expected
+            ? () => {
+                if (value === undefined)
+                    throw new Promise(res => retry = res);
+                return value;
+            }
+            : () => value;
+        defineProperty(sub, "proxy", { get });
         return sub;
     });
     useLayoutEffect(() => hook.release, []);
@@ -940,7 +997,7 @@ class Model {
         define(this, "set", this);
         defer(control, "on");
         defer(control, "effect");
-        control.waiting.add(() => {
+        control.onUpdate(() => {
             delete this.on;
             delete this.effect;
         });
@@ -953,9 +1010,7 @@ class Model {
         return proxy;
     }
     tag(id) {
-        const hook = use$1(refresh => {
-            return new Subscriber(this, () => refresh);
-        });
+        const hook = use$1(refresh => (new Subscriber(this, () => refresh)));
         useElementLifecycle(hook, id || 0);
         return hook.proxy;
     }
@@ -989,10 +1044,9 @@ class Model {
     once(select, callback, squash) {
         if (callback)
             return this.on(select, callback, squash, true);
-        else
-            return new Promise(resolve => {
-                this.on(select, resolve, true, true);
-            });
+        return new Promise(resolve => {
+            this.on(select, resolve, true, true);
+        });
     }
     effect(callback, select) {
         const control = manage(this);
@@ -1003,12 +1057,10 @@ class Model {
             invoke();
             return this.on(select, invoke, true);
         }
-        else {
-            const sub = new Subscriber(control, () => invoke);
-            target = sub.proxy;
-            invoke();
-            return sub.commit();
-        }
+        const sub = new Subscriber(control, () => invoke);
+        target = sub.proxy;
+        invoke();
+        return sub.commit();
     }
     import(from, subset) {
         for (const key of keys(manage(this), subset))
@@ -1204,31 +1256,6 @@ function parent(Expects, required) {
     });
 }
 
-function on(initial, cb) {
-    return apply(function on(key) {
-        this.manage(key, initial, cb && createValueEffect(cb));
-    });
-}
-function memo(factory, defer) {
-    return apply(function memo(key) {
-        const source = this.subject;
-        const get = () => factory.call(source);
-        if (defer)
-            defineLazy(source, key, get);
-        else
-            define(source, key, get());
-    });
-}
-function lazy(value) {
-    return apply(function lazy(key) {
-        const source = this.subject;
-        source[key] = value;
-        defineProperty(this.state, key, {
-            get: () => source[key]
-        });
-    });
-}
-
 const Oops = issues({
     GlobalDoesNotExist: (name) => `Tried to access singleton ${name}, but none exist! Did you forget to initialize?\nCall ${name}.create() before attempting to access, or consider using ${name}.use() instead.`,
     GlobalExists: (name) => `Shared instance of ${name} already exists! Consider unmounting existing, or use ${name}.reset() to force-delete it.`
@@ -1270,5 +1297,5 @@ class Singleton extends Model {
     }
 }
 
-export { Consumer, Model, Provider, Singleton, act, apply, child, Model as default, from, lazy, memo, on, parent, pending, ref, tap, use };
+export { Consumer, Model, Provider, Singleton, act, apply, child, Model as default, from, lazy, set as memo, on, parent, pending, ref, set, tap, use };
 //# sourceMappingURL=index.esm.js.map