@expressive/mvc 0.2.0 → 0.2.1

package/lib/index.d.ts

@@ -364,6 +364,18 @@ declare function set<T>(factory: set.Factory<T>, required?: boolean): T;
 declare function set<T, S>(factory: set.Factory<T, S>, required?: boolean): T;
 declare function set<T>(value: set.Factory<T>, onUpdate: set.Callback<T>): T;
 declare function set<T, S>(value: set.Factory<T, S>, onUpdate: set.Callback<T, S>): T;
+/**
+ * Assign a property with result of a promise.
+ */
+declare function set<T>(factory: Promise<T>, required: false): T | undefined;
+declare function set<T>(factory: Promise<T>, required?: boolean): T;
+declare function set<T>(value: Promise<T>, onUpdate: set.Callback<T>): T;
+/**
+ * Assign a property.
+ */
+declare function set<T>(factory: T, required: false): T | undefined;
+declare function set<T>(factory: T, required?: boolean): T;
+declare function set<T>(value: T, onUpdate: set.Callback<T>): T;
 
 /**
  * Create a placeholder for specified Model type.

package/lib/index.esm.js

@@ -824,28 +824,74 @@ 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.`,
     NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
     Failed: (model, key) => `Generating initial value for ${model}.${key} failed.`
 });
 function set(factory, argument) {
     return apply(function set(key) {
+        const { subject, state } = this;
+        const required = argument === true || argument === undefined;
         let set;
         let get;
         let suspense;
-        const required = argument === true || argument === undefined;
         if (factory === undefined)
             suspense = true;
-        else if (typeof factory === "function")
-            get = pendingFactory(this, key, factory, required);
-        else
-            throw Oops$7.BadFactory();
+        else {
+            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[key] = val)
+                        .finally(() => {
+                        pending = undefined;
+                        this.update(key);
+                    });
+                    return;
+                }
+                return state[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;
+            };
+            if (required)
+                try {
+                    init();
+                }
+                catch (err) {
+                    Oops$7.Failed(subject, key).warn();
+                    throw err;
+                }
+            get = () => {
+                if (pending)
+                    return suspend();
+                if (error)
+                    throw error;
+                if (key in state)
+                    return state[key];
+                let output = init();
+                return pending
+                    ? suspend()
+                    : output;
+            };
+        }
         if (typeof argument == "function")
             set = createValueEffect(argument);
         else
             set = (value) => {
                 if (value === undefined && required)
-                    throw Oops$7.NonOptional(this.subject, key);
+                    throw Oops$7.NonOptional(subject, key);
             };
         return {
             set,
@@ -853,57 +899,6 @@ function set(factory, argument) {
             suspense
         };
     });
-}
-function pendingFactory(parent, key, fn, required) {
-    const { subject, state } = parent;
-    let pending;
-    let error;
-    const init = () => {
-        const output = mayRetry(() => {
-            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.NotReady(subject, key);
-        Object.assign(pending, {
-            message: issue.message,
-            stack: issue.stack
-        });
-        throw pending;
-    };
-    if (required)
-        try {
-            init();
-        }
-        catch (err) {
-            Oops$7.Failed(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();