@expressive/mvc 1.0.0-beta.27 → 1.0.0-beta.30

package/lib/index.esm.js

@@ -20,7 +20,7 @@ function issues(register) {
     return Library;
 }
 
-const Oops$9 = issues({
+const Oops$8 = 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$9.BadEffectCallback();
+            throw Oops$8.BadEffectCallback();
     };
 }
 function createValueEffect(callback) {
@@ -65,7 +65,7 @@ function createValueEffect(callback) {
         if (typeof out == "function")
             unSet = out;
         else
-            throw Oops$9.BadEffectCallback();
+            throw Oops$8.BadEffectCallback();
     };
 }
 function select(source, select) {
@@ -153,7 +153,7 @@ class Subscriber {
     }
 }
 
-const Oops$8 = issues({
+const Oops$7 = 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.`
 });
@@ -179,7 +179,7 @@ function prepare(parent, key, source, setter, getter) {
             return setter.call(sub.proxy, sub.proxy);
         }
         catch (err) {
-            Oops$8.ComputeFailed(subject, key, !!initial).warn();
+            Oops$7.ComputeFailed(subject, key, !!initial).warn();
             throw err;
         }
     }
@@ -225,7 +225,7 @@ function prepare(parent, key, source, setter, getter) {
         }
         catch (e) {
             if (early)
-                Oops$8.ComputedEarly(key).warn();
+                Oops$7.ComputedEarly(key).warn();
             throw e;
         }
         finally {
@@ -506,9 +506,215 @@ function child(source, name) {
     }, name || source.name);
 }
 
-const Oops$7 = issues({
-    HasPropertyUndefined: (control, property) => `${control}.${property} is marked as required for this render.`
+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.`
+});
+const PendingContext = new WeakMap();
+const ContextWasUsed = new WeakMap();
+function tap(type, argument) {
+    return child(function tap(key) {
+        return pendingAccess(this.subject, type, key, argument);
+    });
+}
+function pendingAccess(from, type, key, argument) {
+    if ("current" in type)
+        return () => type.current;
+    if ("current" in from.constructor)
+        throw Oops$6.CantAttachGlobal(from, type.name);
+    let instance;
+    getPending(from).push(context => {
+        instance = context.get(type);
+        if (typeof argument == "function") {
+            if (argument(instance) === false)
+                instance = undefined;
+        }
+        else if (!instance && argument)
+            throw Oops$6.AmbientRequired(type.name, from, key);
+    });
+    return () => instance;
+}
+function usePeerContext(subject) {
+    if (ContextWasUsed.has(subject)) {
+        if (ContextWasUsed.get(subject))
+            useLookup();
+        return;
+    }
+    const pending = PendingContext.get(subject);
+    if (pending) {
+        const local = useLookup();
+        for (const init of pending)
+            init(local);
+        PendingContext.delete(subject);
+    }
+    ContextWasUsed.set(subject, !!pending);
+}
+function getPending(subject) {
+    let pending = PendingContext.get(subject);
+    if (!pending)
+        PendingContext.set(subject, pending = []);
+    return pending;
+}
+
+const Oops$5 = issues({
+    DuplicateAction: (key) => `Invoked action ${key} but one is already active.`,
+    BadComputedSource: (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.`
+});
+function createRef(key, cb) {
+    const refObjectFunction = this.setter(key, cb && createValueEffect(cb));
+    defineProperty(refObjectFunction, "current", {
+        set: refObjectFunction,
+        get: () => this.state[key]
+    });
+    return refObjectFunction;
+}
+function ref(arg) {
+    return apply(function ref(key) {
+        let value = {};
+        if (typeof arg == "object") {
+            const source = manage(arg);
+            for (const key in source.state)
+                defineLazy(value, key, createRef.bind(source, key));
+        }
+        else
+            value = createRef.call(this, key, arg);
+        return { value };
+    });
+}
+function act(task) {
+    return apply(function act(key) {
+        let pending = false;
+        const invoke = (...args) => {
+            if (pending)
+                return Promise.reject(Oops$5.DuplicateAction(key));
+            pending = true;
+            this.update(key);
+            return new Promise(res => {
+                res(task.apply(this.subject, args));
+            }).finally(() => {
+                pending = false;
+                this.update(key);
+            });
+        };
+        this.state[key] = undefined;
+        setAlias(invoke, `run ${key}`);
+        defineProperty(invoke, "active", {
+            get: () => pending
+        });
+        return {
+            value: invoke,
+            writable: false
+        };
+    });
+}
+function from(source, setter, getter) {
+    return apply(function from(key) {
+        const { subject } = this;
+        let getSource;
+        // Easy mistake, using a peer, will always be unresolved.
+        if (typeof source == "symbol")
+            throw Oops$5.PeerNotAllowed(subject, key);
+        // replace source controller in-case different
+        if (typeof source == "object")
+            getSource = () => manage(source);
+        // specifically an arrow function (getter factory)
+        else if (!source.prototype) {
+            setter = source.call(subject, key);
+            getSource = () => this;
+        }
+        // is a peer Model (constructor)
+        else if (Model.isTypeof(source))
+            getSource = pendingAccess(subject, source, key, true);
+        // Regular function is to ambiguous so not allowed.
+        else
+            throw Oops$5.BadComputedSource(subject, key, source);
+        prepare(this, key, getSource, setter, getter);
+    });
+}
+
+const Oops$4 = issues({
+    ValueNotReady: (model, key) => `Value ${model}.${key} value is not yet available.`
 });
+function pending(source, compute) {
+    return (source === undefined ?
+        suspendForValue() :
+        typeof source == "function" && !source.prototype ?
+            suspendForAsync(source) :
+            suspendForComputed(source, compute));
+}
+/**
+ * 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 suspend(source, key) {
+    const error = Oops$4.ValueNotReady(source.subject, key);
+    const promise = new Promise(resolve => {
+        const release = source.addListener(forKey => {
+            if (forKey == key)
+                return () => {
+                    if (source.state[key] !== undefined) {
+                        release();
+                        resolve();
+                    }
+                };
+        });
+    });
+    return Object.assign(promise, {
+        toString: () => String(error),
+        name: "Suspense",
+        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) {
     const [state, update] = useState(() => [
         init(() => update(state.concat()))
@@ -529,13 +735,14 @@ function useWatcher(target, focus, expected) {
     const hook = use$1(refresh => {
         const sub = new Subscriber(target, () => refresh);
         if (focus) {
-            const src = sub.proxy;
+            const source = sub.proxy;
             const key = keys(sub.parent, focus)[0];
             defineProperty(sub, "proxy", {
                 get() {
-                    if (src[key] === undefined && expected)
-                        throw Oops$7.HasPropertyUndefined(target, key);
-                    return src[key];
+                    const value = source[key];
+                    if (value === undefined && expected)
+                        throw suspend(sub.parent, key);
+                    return value;
                 }
             });
         }
@@ -563,56 +770,6 @@ function useModel(Type, callback) {
     return hook.proxy;
 }
 
-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.`
-});
-const PendingContext = new WeakMap();
-const ContextWasUsed = new WeakMap();
-function tap(type, argument) {
-    return child(function tap(key) {
-        return pendingAccess(this.subject, type, key, argument);
-    });
-}
-function pendingAccess(from, type, key, argument) {
-    if ("current" in type)
-        return () => type.current;
-    if ("current" in from.constructor)
-        throw Oops$6.CantAttachGlobal(from, type.name);
-    let instance;
-    getPending(from).push(context => {
-        instance = context.get(type);
-        if (typeof argument == "function") {
-            if (argument(instance) === false)
-                instance = undefined;
-        }
-        else if (!instance && argument)
-            throw Oops$6.AmbientRequired(type.name, from, key);
-    });
-    return () => instance;
-}
-function usePeerContext(subject) {
-    if (ContextWasUsed.has(subject)) {
-        if (ContextWasUsed.get(subject))
-            useLookup();
-        return;
-    }
-    const pending = PendingContext.get(subject);
-    if (pending) {
-        const local = useLookup();
-        for (const init of pending)
-            init(local);
-        PendingContext.delete(subject);
-    }
-    ContextWasUsed.set(subject, !!pending);
-}
-function getPending(subject) {
-    let pending = PendingContext.get(subject);
-    if (!pending)
-        PendingContext.set(subject, pending = []);
-    return pending;
-}
-
 class Lookup {
     constructor() {
         this.table = new Map();
@@ -668,7 +825,7 @@ class Lookup {
     }
 }
 
-const Oops$5 = issues({
+const Oops$3 = issues({
     NoProviderType: () => `Provider 'of' prop must be Model, typeof Model or a collection of them.`,
     NothingInContext: (name) => `Couldn't find ${name} in context; did you forget to use a Provider?`,
     BadConsumerProps: () => `Provider expects either a render function, 'get' or 'has' props.`
@@ -678,7 +835,7 @@ const useLookup = () => useContext(LookupContext);
 function useFromContext(Type, strict) {
     const instance = useLookup().get(Type);
     if (!instance && strict)
-        throw Oops$5.NothingInContext(Type.name);
+        throw Oops$3.NothingInContext(Type.name);
     return instance;
 }
 function Consumer(props) {
@@ -689,13 +846,13 @@ function Consumer(props) {
     if (typeof callback == "function")
         callback(Control.get(!!has));
     else
-        throw Oops$5.BadConsumerProps();
+        throw Oops$3.BadConsumerProps();
     return null;
 }
 function useNewContext(from, inject) {
     return useMemo(() => {
         if (!inject)
-            throw Oops$5.NoProviderType();
+            throw Oops$3.NoProviderType();
         const context = from.push(inject);
         for (const instance of context.local)
             for (const apply of getPending(instance))
@@ -738,7 +895,7 @@ function Provider(props) {
         : render);
 }
 
-const Oops$4 = issues({
+const Oops$2 = issues({
     StrictUpdate: (expected) => `Strict update() did ${expected ? "not " : ""}find pending updates.`,
     NoChaining: () => `Then called with undefined; update promise will never catch nor supports chaining.`
 });
@@ -837,7 +994,7 @@ class Model {
             arg = select(this, arg);
         if (typeof arg == "boolean") {
             if (!control.pending === arg)
-                return Promise.reject(Oops$4.StrictUpdate(arg));
+                return Promise.reject(Oops$2.StrictUpdate(arg));
         }
         else if (arg) {
             control.update(arg);
@@ -858,7 +1015,7 @@ class Model {
                     else
                         callback(false);
                 else
-                    throw Oops$4.NoChaining();
+                    throw Oops$2.NoChaining();
             }
         };
     }
@@ -939,7 +1096,7 @@ function defer(on, method) {
 }
 
 const Parent = new WeakMap();
-const Oops$3 = issues({
+const Oops$1 = issues({
     ParentRequired: (expects, child) => `New ${child} created standalone but requires parent of type ${expects}. Did you remember to create via use(${child})?`,
     UnexpectedParent: (expects, child, got) => `New ${child} created as child of ${got}, but must be instanceof ${expects}.`,
     UndefinedNotAllowed: (key) => `Child property ${key} may not be undefined.`,
@@ -964,7 +1121,7 @@ function use(input, argument) {
         let current;
         const onUpdate = (next, initial) => {
             if (mode === true && !initial)
-                throw Oops$3.IsReadOnly(subject, key);
+                throw Oops$1.IsReadOnly(subject, key);
             if (next) {
                 current = next instanceof Model
                     ? next : bootstrap(next);
@@ -972,7 +1129,7 @@ function use(input, argument) {
                 manage(current);
             }
             else if (mode === undefined)
-                throw Oops$3.UndefinedNotAllowed(key);
+                throw Oops$1.UndefinedNotAllowed(key);
             else
                 current = undefined;
             if (typeof argument == "function")
@@ -984,11 +1141,11 @@ function use(input, argument) {
                     input instanceof Model ? input :
                         typeof input === "function" ? input() :
                             typeof input === "object" ? bootstrap(input) :
-                                Oops$3.BadArgument(typeof input).throw();
+                                Oops$1.BadArgument(typeof input).throw();
             if (current)
                 mode = onUpdate(current, true) || mode;
             else if (mode == true)
-                throw Oops$3.MustBeDefined(subject, key);
+                throw Oops$1.MustBeDefined(subject, key);
         }
         else
             mode = false;
@@ -1003,10 +1160,10 @@ function parent(Expects, required) {
         const value = Parent.get(this.subject);
         if (!value) {
             if (required)
-                throw Oops$3.ParentRequired(expected, child);
+                throw Oops$1.ParentRequired(expected, child);
         }
         else if (!(value instanceof Expects))
-            throw Oops$3.UnexpectedParent(expected, child, value);
+            throw Oops$1.UnexpectedParent(expected, child, value);
         return { value };
     });
 }
@@ -1036,160 +1193,6 @@ function lazy(value) {
     });
 }
 
-const Oops$2 = issues({
-    DuplicateAction: (key) => `Invoked action ${key} but one is already active.`,
-    BadComputedSource: (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.`
-});
-function createRef(key, cb) {
-    const refObjectFunction = this.setter(key, cb && createValueEffect(cb));
-    defineProperty(refObjectFunction, "current", {
-        set: refObjectFunction,
-        get: () => this.state[key]
-    });
-    return refObjectFunction;
-}
-function ref(arg) {
-    return apply(function ref(key) {
-        let value = {};
-        if (typeof arg == "object") {
-            const source = manage(arg);
-            for (const key in source.state)
-                defineLazy(value, key, createRef.bind(source, key));
-        }
-        else
-            value = createRef.call(this, key, arg);
-        return { value };
-    });
-}
-function act(task) {
-    return apply(function act(key) {
-        let pending = false;
-        const invoke = (...args) => {
-            if (pending)
-                return Promise.reject(Oops$2.DuplicateAction(key));
-            pending = true;
-            this.update(key);
-            return new Promise(res => {
-                res(task.apply(this.subject, args));
-            }).finally(() => {
-                pending = false;
-                this.update(key);
-            });
-        };
-        setAlias(invoke, `run ${key}`);
-        defineProperty(invoke, "active", {
-            get: () => pending
-        });
-        return {
-            value: invoke,
-            writable: false
-        };
-    });
-}
-function from(source, setter, getter) {
-    return apply(function from(key) {
-        const { subject } = this;
-        let getSource;
-        // Easy mistake, using a peer, will always be unresolved.
-        if (typeof source == "symbol")
-            throw Oops$2.PeerNotAllowed(subject, key);
-        // replace source controller in-case different
-        if (typeof source == "object")
-            getSource = () => manage(source);
-        // specifically an arrow function (getter factory)
-        else if (!source.prototype) {
-            setter = source.call(subject, key);
-            getSource = () => this;
-        }
-        // is a peer Model (constructor)
-        else if (Model.isTypeof(source))
-            getSource = pendingAccess(subject, source, key, true);
-        // Regular function is to ambiguous so not allowed.
-        else
-            throw Oops$2.BadComputedSource(subject, key, source);
-        prepare(this, key, getSource, setter, getter);
-    });
-}
-
-const Oops$1 = issues({
-    ValueNotReady: (model, key) => `Value ${model}.${key} value is not yet available.`
-});
-function pending(source, compute) {
-    return (source === undefined ?
-        suspendForValue() :
-        typeof source == "function" && !source.prototype ?
-            suspendForAsync(source) :
-            suspendForComputed(source, compute));
-}
-/**
- * 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)
-        return value;
-    const error = Oops$1.ValueNotReady(via.subject, key);
-    const promise = new Promise(resolve => {
-        const release = via.addListener(forKey => {
-            if (forKey == key)
-                return () => {
-                    if (via.state[key] !== undefined) {
-                        release();
-                        resolve();
-                    }
-                };
-        });
-    });
-    throw Object.assign(promise, {
-        toString: () => String(error),
-        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$1.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
-            });
-        };
-    });
-}
-
 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.`