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

package/lib/index.js

@@ -42,9 +42,6 @@ function defineLazy(object, property, init) {
         }
     });
 }
-function setAlias(func, displayName) {
-    assign(func, { displayName });
-}
 function createEffect(callback) {
     let unSet;
     return function (value) {
@@ -152,66 +149,7 @@ class Subscriber {
 
 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 => {
@@ -248,9 +186,7 @@ function from(source, arg1, arg2) {
         const parent = this;
         const { subject, state } = this;
         let getSource;
-        let getter;
-        if (arg2 === true || arg1 === true)
-            getter = pendingValue;
+        let required = arg2 === true || arg1 === true;
         if (typeof arg1 == "boolean")
             arg1 = undefined;
         // Easy mistake, using a peer, will always be unresolved.
@@ -334,9 +270,6 @@ function from(source, arg1, arg2) {
                 }
             }
         }
-        setAlias(update, `try ${key}`);
-        setAlias(create, `new ${key}`);
-        setAlias(setter, `run ${key}`);
         INIT.add(create);
         INFO.set(update, info);
         defineProperty(state, key, {
@@ -344,8 +277,12 @@ function from(source, arg1, arg2) {
             configurable: true,
             enumerable: true
         });
-        if (getter)
-            return () => getter(parent, key);
+        return () => {
+            const value = parent.state[key];
+            if (value === undefined && required)
+                throw suspend(this, key);
+            return value;
+        };
     });
 }
 function ensure(on, keys) {
@@ -372,7 +309,7 @@ function flush(on) {
 }
 
 const Oops$9 = issues({
-    StrictUpdate: (expected) => `Strict update() did ${expected ? "not " : ""}find pending updates.`,
+    StrictUpdate: () => `Strict update() did not find pending updates.`,
     NoChaining: () => `Then called with undefined; update promise will never catch nor supports chaining.`
 });
 const READY = new WeakSet();
@@ -402,7 +339,9 @@ class Controller {
             return;
         let onGet;
         let onSet;
+        let set;
         let enumerable;
+        let suspense;
         const instruction = Pending.get(entry);
         if (instruction) {
             Pending.delete(entry);
@@ -415,31 +354,35 @@ class Controller {
                     state[key] = desc.value;
                 onSet = desc.set;
                 onGet = desc.get;
+                suspense = desc.suspense;
                 enumerable = desc.enumerable;
             }
         }
         else
             state[key] = entry;
-        const set = onSet !== false
-            ? this.ref(key, onSet)
-            : undefined;
-        function get() {
-            const local = this[LOCAL];
+        if (onSet !== false)
+            set = this.ref(key, onSet);
+        const get = (local) => {
+            if (!(key in state) && suspense)
+                throw suspend(this, key);
             const value = state[key];
-            if (local && !local.watch[key])
-                local.watch[key] = true;
-            return onGet ? onGet(value, local) : value;
-        }
-        setAlias(get, `tap ${key}`);
+            if (onGet)
+                return local
+                    ? onGet(value, local)
+                    : onGet(value);
+            return value;
+        };
         defineProperty(subject, key, {
-            enumerable,
-            set,
-            get: onGet
-                ? () => onGet(state[key])
-                : () => state[key]
+            enumerable, set, get
         });
         defineProperty(proxy, key, {
-            enumerable, get, set
+            enumerable, set,
+            get() {
+                const local = this[LOCAL];
+                if (local && !local.watch[key])
+                    local.watch[key] = true;
+                return get(local);
+            }
         });
     }
     ref(key, handler) {
@@ -499,12 +442,12 @@ class Controller {
             this.waiting.add(arg);
             return;
         }
-        if (typeof arg == "boolean" && arg !== this.frame.size > 0)
-            return Promise.reject(Oops$9.StrictUpdate(arg));
+        if (arg === true && this.frame.size < 1)
+            return Promise.reject(Oops$9.StrictUpdate());
         return {
             then: (callback) => {
                 if (callback)
-                    if (this.frame.size)
+                    if (this.frame.size || arg !== false)
                         this.waiting.add(callback);
                     else
                         callback(false);
@@ -687,17 +630,21 @@ function apply(fn, label) {
     const placeholder = Symbol(`${name} instruction`);
     function setup(key) {
         let output = fn.call(this, key, this);
-        if (typeof output == "function")
-            return { get: output };
-        if (typeof output !== "object")
-            return output || undefined;
-        if ("explicit" in output && output.explicit) {
-            defineProperty(this.subject, key, output);
-            return false;
+        switch (typeof output) {
+            case "function":
+                return { get: output };
+            case "object": {
+                if ("explicit" in output && output.explicit) {
+                    defineProperty(this.subject, key, output);
+                    return false;
+                }
+                if ("recursive" in output && output.recursive)
+                    return Object.assign(Object.assign({}, output), { get: recursive(this, key) });
+            }
+            case "boolean":
+                return output;
         }
-        if ("recursive" in output)
-            output = Object.assign(Object.assign({}, output), { get: recursive(this, key) });
-        return output;
+        return;
     }
     Pending.set(placeholder, setup);
     return placeholder;
@@ -753,7 +700,6 @@ function act(task) {
             });
         };
         this.state[key] = undefined;
-        setAlias(invoke, `run ${key}`);
         defineProperty(invoke, "active", {
             get: () => pending
         });
@@ -788,20 +734,22 @@ 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.`
+    BadFactory: () => `Set instruction can only accept a factory or undefined.`,
+    ValueNotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
+    FactoryFailed: (model, key) => `Generating initial value for ${model}.${key} failed.`
 });
 function set(factory, argument) {
     return apply(function set(key) {
         let set;
         let get;
+        let suspense;
         const required = argument === true || argument === undefined;
         if (factory === undefined)
-            get = () => pendingValue(this, key);
-        else if (typeof factory !== "function")
-            throw Oops$7.BadFactory();
-        else {
+            suspense = true;
+        else if (typeof factory === "function")
             get = pendingFactory(this, key, factory, required);
-        }
+        else
+            throw Oops$7.BadFactory();
         if (typeof argument == "function")
             set = createValueEffect(argument);
         else
@@ -809,8 +757,63 @@ function set(factory, argument) {
                 if (value === undefined && required)
                     throw Oops$7.NonOptional(this.subject, key);
             };
-        return { set, get };
+        return {
+            set,
+            get,
+            suspense
+        };
     });
+}
+function pendingFactory(parent, key, fn, required) {
+    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);
+            });
+            return;
+        }
+        return state[key] = output;
+    };
+    const suspend = () => {
+        if (required === false)
+            return undefined;
+        const issue = Oops$7.ValueNotReady(subject, key);
+        Object.assign(pending, {
+            message: issue.message,
+            stack: issue.stack
+        });
+        throw pending;
+    };
+    if (required)
+        try {
+            init();
+        }
+        catch (err) {
+            Oops$7.FactoryFailed(subject, key).warn();
+            throw err;
+        }
+    return () => {
+        if (pending)
+            return suspend();
+        if (error)
+            throw error;
+        if (key in state)
+            return state[key];
+        let output = init();
+        return pending
+            ? suspend()
+            : output;
+    };
 }
 
 const Parent = new WeakMap();
@@ -953,24 +956,26 @@ const ContextWasUsed = new WeakMap();
 function tap(type, argument) {
     return apply(function tap(key) {
         if ("set" in type)
-            this.state[key] = type.get();
-        else {
-            const { subject } = this;
-            if ("set" in subject.constructor)
-                throw Oops$3.CantAttachGlobal(subject, type.name);
-            getPending(subject).push(context => {
-                let instance = context.get(type);
-                if (typeof argument == "function") {
-                    if (argument(instance) === false)
-                        instance = undefined;
-                }
-                else if (!instance && argument)
-                    throw Oops$3.AmbientRequired(type.name, subject, key);
-                this.update(key, instance);
-            });
-        }
+            return {
+                recursive: true,
+                value: type.get()
+            };
+        const { subject } = this;
+        if ("set" in subject.constructor)
+            throw Oops$3.CantAttachGlobal(subject, type.name);
+        getPending(subject).push(context => {
+            let instance = context.get(type);
+            if (typeof argument == "function") {
+                if (argument(instance) === false)
+                    instance = undefined;
+            }
+            else if (!instance && argument)
+                throw Oops$3.AmbientRequired(type.name, subject, key);
+            this.update(key, instance);
+        });
         return {
-            recursive: true
+            recursive: true,
+            suspense: true
         };
     });
 }
@@ -1268,7 +1273,7 @@ class Global extends MVC {
     static set(updates) {
         const instance = Active.get(this) || this.create();
         instance.import(updates);
-        return instance.update();
+        return instance.update(false);
     }
     static get(arg) {
         const instance = Active.get(this);