@expressive/mvc 0.6.0 → 0.6.3

package/lib/index.js

@@ -25,11 +25,11 @@ function issues(register) {
     return Library;
 }
 
-const Oops$b = issues({
+const Oops$c = issues({
     NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
 });
 function suspend(source, key) {
-    const error = Oops$b.NotReady(source.subject, key);
+    const error = Oops$c.NotReady(source.subject, key);
     const promise = new Promise(resolve => {
         const release = source.addListener(forKey => {
             if (forKey == key)
@@ -69,106 +69,12 @@ function mayRetry(fn) {
     return compute();
 }
 
-const Oops$a = 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}].`,
-    FactoryFailed: (model, key) => `Generating initial value for ${model}.${key} failed.`,
-    NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
-    ComputeFailed: (model, key) => `Generating initial value for ${model}.${key} failed.`
+const Oops$b = issues({
+    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(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$a.PeerNotAllowed(subject, key);
-        if (typeof arg0 == "function" && /^[A-Z]/.test(arg0.name))
-            throw Oops$a.BadSource(subject, key, arg0);
-        this.state.set(key, undefined);
-        const init = () => {
-            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;
-            }
-            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 (typeof arg0 == "function" && factoryRequired)
-            try {
-                init();
-            }
-            catch (err) {
-                Oops$a.ComputeFailed(subject, key).warn();
-                throw err;
-            }
-        return () => {
-            if (!getter)
-                init();
-            return getter();
-        };
-    });
-}
-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);
-        });
-    }
-    state.set(key, output);
-    const suspend = () => {
-        if (required === false)
-            return undefined;
-        const issue = Oops$a.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);
-    };
-}
 function computeMode(self, source, setter, key, required) {
     const { subject, state } = self;
     let sub;
@@ -180,7 +86,7 @@ function computeMode(self, source, setter, key, required) {
             return setter.call(sub.proxy, sub.proxy);
         }
         catch (err) {
-            Oops$a.Failed(subject, key, initial).warn();
+            Oops$b.Failed(subject, key, initial).warn();
             throw err;
         }
     };
@@ -249,7 +155,7 @@ function flush(control) {
     KEYS.delete(control);
 }
 
-const Oops$9 = issues({
+const Oops$a = issues({
     BadCallback: () => `Callback for effect-callback may only return a function.`
 });
 const { assign, create, defineProperty, entries, getPrototypeOf, getOwnPropertyNames, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
@@ -262,7 +168,7 @@ function createEffect(callback) {
         if (unSet instanceof Promise)
             unSet = undefined;
         if (unSet && typeof unSet !== "function")
-            throw Oops$9.BadCallback();
+            throw Oops$a.BadCallback();
     };
 }
 function createValueEffect(callback) {
@@ -278,11 +184,11 @@ function createValueEffect(callback) {
         if (typeof out == "function")
             unSet = out;
         else
-            throw Oops$9.BadCallback();
+            throw Oops$a.BadCallback();
     };
 }
 
-const Oops$8 = issues({
+const Oops$9 = issues({
     Timeout: (keys, timeout) => `No update for [${keys}] within ${timeout}.`,
     StrictUpdate: () => `Strict update() did not find pending updates.`,
     NoChaining: () => `Then called with undefined; update promise will never catch nor supports chaining.`
@@ -365,7 +271,7 @@ class Model {
             const invoke = (key) => {
                 if (!key) {
                     clear();
-                    reject(Oops$8.Timeout(select, typeof argument == "number"
+                    reject(Oops$9.Timeout(select, typeof argument == "number"
                         ? `${argument}ms`
                         : `lifetime of ${this}`));
                 }
@@ -452,11 +358,11 @@ class Model {
             arg = undefined;
         }
         if (!frame.size && arg === true)
-            return Promise.reject(Oops$8.StrictUpdate());
+            return Promise.reject(Oops$9.StrictUpdate());
         return {
             then: (callback) => {
                 if (!callback)
-                    throw Oops$8.NoChaining();
+                    throw Oops$9.NoChaining();
                 if (frame.size || arg !== false)
                     waiting.add(() => {
                         callback(getUpdate(this));
@@ -785,7 +691,7 @@ function __awaiter(thisArg, _arguments, P, generator) {
     });
 }
 
-const Oops$7 = issues({
+const Oops$8 = issues({
     DuplicatePending: (key) => `Invoked action ${key} but one is already active.`
 });
 function act(task) {
@@ -793,7 +699,7 @@ function act(task) {
         let pending = false;
         const invoke = (...args) => __awaiter(this, void 0, void 0, function* () {
             if (pending)
-                return Promise.reject(Oops$7.DuplicatePending(key));
+                return Promise.reject(Oops$8.DuplicatePending(key));
             pending = true;
             this.update(key);
             try {
@@ -815,6 +721,106 @@ function act(task) {
     });
 }
 
+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);
+        });
+    }
+    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({
+    // 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.`,
+    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 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 = () => {
+            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;
+            }
+            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 (typeof arg0 == "function" && factoryRequired)
+            try {
+                init();
+            }
+            catch (err) {
+                Oops$7.ComputeFailed(subject, key).warn();
+                throw err;
+            }
+        return () => {
+            if (!getter)
+                init();
+            return getter();
+        };
+    });
+}
+
 function ref(callback) {
     return apply(function ref(key) {
         const value = this.ref(key, callback && createValueEffect(callback));
@@ -1001,9 +1007,11 @@ function use$1(input, argument) {
         let pending;
         let error;
         let get = (_local) => state.get(key);
-        if (typeof input === "function")
-            input = /^[A-Z]/.test(input.name)
-                ? new input() : input;
+        if (typeof input === "function") {
+            if ("prototype" in input &&
+                input === input.prototype.constructor)
+                input = new input();
+        }
         else if (input && typeof input !== "object")
             throw Oops$6.BadArgument(typeof input);
         if (input instanceof Map || input instanceof Set)