@expressive/mvc 1.0.0-beta.32 → 1.0.0-beta.33

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) {
@@ -94,6 +94,13 @@ class Subscriber {
         this.active = false;
         this.handle = {};
         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)
@@ -103,28 +110,16 @@ class Subscriber {
             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);
-        const subject = this.source =
-            parent.subject;
-        const proxy = this.proxy =
-            create(subject);
         this.parent = parent;
+        this.source = parent.subject;
+        this.proxy = create(parent.subject);
         define(this.proxy, LOCAL, this);
-        defineProperty(this.proxy, UPDATE, {
-            get: () => (this.parent.handled.filter(key => key in this.handle))
-        });
-        if ("update" in subject) {
-            define(proxy, "update", (...args) => {
-                if (!args.length) {
-                    const refresh = this.onUpdate("", parent);
-                    if (refresh)
-                        refresh([]);
-                }
-                return subject.update(...args);
-            });
-        }
+        defineLazy(this.proxy, UPDATE, this.debug);
         for (const key in parent.state)
             this.spy(key);
     }
@@ -158,7 +153,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.`
 });
@@ -177,14 +172,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;
         }
     }
@@ -230,7 +225,7 @@ function prepare(parent, key, source, setter, getter) {
         }
         catch (e) {
             if (early)
-                Oops$7.ComputedEarly(key).warn();
+                Oops$8.ComputedEarly(key).warn();
             throw e;
         }
         finally {
@@ -356,30 +351,16 @@ class Controller {
         this.state = {};
         this.frame = new Set();
         this.waiting = new Set();
-        this.handled = [];
         this.followers = new Set();
     }
     static setup(onto) {
         const control = new this(onto);
-        defineProperty(onto, CONTROL, {
-            configurable: true,
-            get() {
-                defineProperty(onto, CONTROL, {
-                    value: control
-                });
-                defineProperty(onto, STATE, {
-                    get: () => (Object.assign({}, control.state)),
-                    configurable: true
-                });
-                defineProperty(onto, UPDATE, {
-                    get: () => [...control.handled],
-                    configurable: true
-                });
-                control.start();
-                if (onto.didCreate)
-                    onto.didCreate();
-                return control;
-            }
+        defineLazy(onto, CONTROL, () => {
+            onto[STATE] = control.state;
+            control.start();
+            if (onto.didCreate)
+                onto.didCreate();
+            return control;
         });
         return control;
     }
@@ -458,14 +439,17 @@ class Controller {
     }
     emit() {
         flush(this);
+        const keys = Object.freeze([...this.frame]);
         const handle = new Set(this.waiting);
-        const handled = this.handled =
-            Object.freeze([...this.frame]);
         this.waiting.clear();
         this.frame.clear();
+        defineProperty(this.subject, UPDATE, {
+            configurable: true,
+            value: keys
+        });
         handle.forEach(callback => {
             try {
-                callback(handled);
+                callback(keys);
             }
             catch (e) { }
         });
@@ -522,6 +506,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.`
@@ -624,10 +663,13 @@ function act(task) {
         };
     });
 }
-function from(source, setter, getter) {
+function from(source, setter, argument) {
     return apply(function from(key) {
         const { subject } = this;
         let getSource;
+        let 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);
@@ -642,7 +684,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);
@@ -652,12 +694,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.
@@ -671,6 +715,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 => {
@@ -690,45 +768,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) {
@@ -969,9 +1008,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;
     }
@@ -1019,12 +1056,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))
@@ -1220,31 +1255,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.`
@@ -1286,5 +1296,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