@expressive/mvc 1.0.0-beta.22 → 1.0.0-beta.23

package/lib/index.js

@@ -1080,51 +1080,76 @@ function from(source, 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));
+}
 /**
- * Create suspense promise also interpretable as an error.
- * React will handle it but other contexts probably won't.
+ * Get value, suspend instead if undefined.
+ *
+ * Throws suspense promise also interpretable as an error.
+ * React could handle it but other contexts probably not.
  */
-function suspense(model, key) {
-    const { message, stack } = Oops$1.ValueNotReady(model, key);
+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 = model.on(key, (value) => {
-            if (value !== undefined)
-                release(), resolve();
+        const release = via.addListener({
+            [key](value) {
+                if (value !== undefined) {
+                    release();
+                    resolve();
+                }
+            }
         });
     });
-    return Object.assign(promise, { message, stack });
+    throw Object.assign(promise, {
+        toString: () => String(error),
+        message: error.message,
+        stack: error.stack
+    });
 }
-function pending(source, compute) {
-    if (typeof source == "function" && !source.prototype)
-        return suspendForAsync(source);
-    else
-        return from(source, compute, function getter(value, key) {
-            if (value === undefined)
-                throw suspense(this, key);
-            return value;
-        });
+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 output;
+        let value;
         let error;
         return () => {
-            if (waiting) {
-                const issue = Oops$1.ValueNotReady(this.subject, key);
-                const promise = source
-                    .call(this.subject, key)
-                    .catch(err => error = err)
-                    .then((value) => output = value)
-                    .finally(() => waiting = false);
-                throw Object.assign(promise, {
-                    message: issue.message,
-                    stack: issue.stack
-                });
-            }
             if (error)
                 throw error;
-            return output;
+            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
+            });
         };
     });
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@expressive/mvc",
+  "version": "1.0.0-beta.23",
   "description": "Use classes to define state in React!",
-  "version": "1.0.0-beta.22",
   "author": {
     "name": "Gabe Klein",
     "email": "gabe@termtm.com",
@@ -50,7 +50,10 @@
   },
   "release": {
     "branches": [
-      { "name": "beta", "prerelease": true }
+      {
+        "name": "beta",
+        "prerelease": true
+      }
     ]
   }
 }

package/types/context.d.ts

@@ -1,9 +1,7 @@
-import { Consumer, ReactElement, ReactNode, Component, ComponentType } from "react";
+import { Consumer, ReactElement, ReactNode } from "react";
 import { Model } from "./model"
 import { Class } from "./types";
 
-type Output = ReactElement<any, any> | null;
-
 export namespace Provider {
     type Item = Model | typeof Model;
     type Collection<T extends Item> = T[] | { [key: string]: T };
@@ -21,7 +19,7 @@ export namespace Provider {
     type Props<T extends Item> = MultipleProps<T> | NormalProps<T>;
 }
 
-export function Provider<T extends Provider.Item>(props: Provider.Props<T>): Output;
+export function Provider<T extends Provider.Item>(props: Provider.Props<T>): ReactElement<typeof props>;
 
 export namespace Consumer {
     type HasProps<E extends Class> = {
@@ -50,10 +48,10 @@ export namespace Consumer {
          * Similar to `tap()`, updates to properties accessed in
          * this function will cause a refresh when they change.
          */
-        children: (value: InstanceType<E>) => Output;
+        children: (value: InstanceType<E>) => ReactElement<any, any> | null;
     }
 
     type Props<T extends Class> = HasProps<T> | GetProps<T> | RenderProps<T>
 }
 
-export function Consumer<T extends Class>(props: Consumer.Props<T>): Output;
+export function Consumer<T extends Class>(props: Consumer.Props<T>): null;

package/types/instructions.d.ts

@@ -194,6 +194,12 @@ export function memo <T> (compute: () => T, lazy?: boolean): T;
  */
 export function lazy <T> (value?: T): T;
 
+/**
+ * Pending value. Will suspend unless value is defined,
+ * suspense resolves when a value is aquired. 
+ */
+export function pending <T = boolean> (): Exclude<T, undefined>;
+
 /**
  * Suspend during the execution of given function to obtain value.
  *