@expressive/mvc 1.0.0-beta.30 → 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) {
@@ -153,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.`
 });
@@ -172,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;
         }
     }
@@ -225,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 {
@@ -506,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.`
@@ -608,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);
@@ -626,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);
@@ -636,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.
@@ -655,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 => {
@@ -674,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) {
@@ -736,12 +791,11 @@ function useWatcher(target, focus, expected) {
         const sub = new Subscriber(target, () => refresh);
         if (focus) {
             const source = sub.proxy;
-            const key = keys(sub.parent, focus)[0];
             defineProperty(sub, "proxy", {
                 get() {
-                    const value = source[key];
+                    const value = source[focus];
                     if (value === undefined && expected)
-                        throw suspend(sub.parent, key);
+                        throw suspend(sub.parent, focus);
                     return value;
                 }
             });
@@ -751,6 +805,39 @@ function useWatcher(target, focus, expected) {
     useLayoutEffect(() => hook.commit(), []);
     return hook.proxy;
 }
+function useComputed(target, compute, expected) {
+    const hook = use$1(refresh => {
+        const sub = new Subscriber(target, () => update);
+        const { proxy } = sub;
+        let value;
+        let retry;
+        const update = () => {
+            const next = compute.call(proxy, proxy);
+            if (value == next)
+                return;
+            value = next;
+            if (retry) {
+                retry();
+                retry = undefined;
+            }
+            else
+                refresh();
+        };
+        const access = () => {
+            if (value === undefined && expected)
+                throw new Promise(res => {
+                    retry = res;
+                });
+            return value;
+        };
+        value = compute.call(proxy, proxy);
+        sub.commit();
+        defineProperty(sub, "proxy", { get: access });
+        return sub;
+    });
+    useLayoutEffect(() => hook.release, []);
+    return hook.proxy;
+}
 function useModel(Type, callback) {
     const hook = use$1(refresh => {
         const instance = new Type();
@@ -914,14 +1001,14 @@ class Model {
         });
     }
     tap(path, expect) {
+        if (typeof path == "function")
+            return useComputed(this, path, expect);
         const proxy = useWatcher(this, path, expect);
         this.update("willRender", true);
         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;
     }
@@ -969,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))
@@ -1069,7 +1154,9 @@ class Model {
         return instance;
     }
     static meta(path) {
-        return useWatcher(this, path);
+        return typeof path == "function"
+            ? useComputed(this, path)
+            : useWatcher(this, path);
     }
     static isTypeof(maybe) {
         return (typeof maybe == "function" &&
@@ -1168,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.`
@@ -1234,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