Add status attribute to deferred

packages/suspense/src/types.ts

@@ -92,6 +92,7 @@ export interface Deferred<Type> {
   promise: Promise<Type>;
   reject(error: any): void;
   resolve(value?: Type): void;
+  status: StatusPending | StatusRejected | StatusResolved;
 }
 
 // Cache types

packages/suspense/src/utils/createDeferred.test.ts

@@ -1,20 +1,25 @@
+import { STATUS_PENDING, STATUS_REJECTED, STATUS_RESOLVED } from "..";
 import { createDeferred } from "./createDeferred";
 
 describe("createDeferred", () => {
   it("should resolve with a value", async () => {
     const deferred = createDeferred<string>();
+    expect(deferred.status).toBe(STATUS_PENDING);
 
     setTimeout(() => {
       deferred.resolve("Resolved value");
+      expect(deferred.status).toBe(STATUS_RESOLVED);
     }, 0);
 
     await expect(await deferred.promise).toBe("Resolved value");
   });
 
   it("should reject with a value", async () => {
     const deferred = createDeferred<string>();
+    expect(deferred.status).toBe(STATUS_PENDING);
 
     deferred.reject("Expected error");
+    expect(deferred.status).toBe(STATUS_REJECTED);
 
     let caught = null;
 

packages/suspense/src/utils/createDeferred.ts

@@ -1,12 +1,18 @@
-import { Deferred, Status } from "../types";
+import { STATUS_PENDING, STATUS_REJECTED, STATUS_RESOLVED } from "..";
+import {
+  Deferred,
+  StatusPending,
+  StatusRejected,
+  StatusResolved,
+} from "../types";
 
 // A "thenable" is a subset of the Promise API.
 // We could use a Promise as thenable, but Promises have a downside: they use the microtask queue.
 // An advantage to creating a custom thenable is synchronous resolution (or rejection).
 //
 // A "deferred" is a "thenable" that has convenience resolve/reject methods.
 export function createDeferred<Type>(debugLabel?: string): Deferred<Type> {
-  let status: Status = "pending";
+  let status: StatusPending | StatusRejected | StatusResolved = STATUS_PENDING;
 
   let rejectPromise: (error: Error) => void;
   let resolvePromise: (value: Type | PromiseLike<Type>) => void;
@@ -20,7 +26,7 @@ export function createDeferred<Type>(debugLabel?: string): Deferred<Type> {
   });
 
   function assertPending() {
-    if (status !== "pending") {
+    if (status !== STATUS_PENDING) {
       throw Error(`Deferred has already been ${status}`);
     }
   }
@@ -34,18 +40,22 @@ export function createDeferred<Type>(debugLabel?: string): Deferred<Type> {
     reject(error: Error) {
       assertPending();
 
-      status = "rejected";
+      status = STATUS_REJECTED;
 
       rejectPromise(error);
     },
 
     resolve(value: Type) {
       assertPending();
 
-      status = "resolved";
+      status = STATUS_RESOLVED;
 
       resolvePromise(value);
     },
+
+    get status() {
+      return status;
+    },
   };
 
   return deferred;