A hook that takes a promise and throws it according to the Suspense API

awaitPromise.ts

interface PromiseCachePending {
  promise: Promise<void>;
}
interface PromiseCacheResolved<T> {
  promise: Promise<void>;
  result: T;
}
interface PromiseCacheError {
  promise: Promise<void>;
  error: any;
}

type PromiseCache<T> =
  | PromiseCachePending
  | PromiseCacheResolved<T>
  | PromiseCacheError;

const PROMISE_CACHE = new WeakMap<Promise<any>, PromiseCache<any>>();

/**
 * This is a hook that takes a promise and throws it according to the Suspense API
 *
 * @note This is a bit of a hack since this API is really low level and the full version of Suspense isn't released yet
 */
export default function awaitPromise<T>(promise: Promise<T>): T {
  let promiseCache: PromiseCache<T> | undefined = PROMISE_CACHE.get(promise);

  if (promiseCache) {
    if ('error' in promiseCache) {
      throw promiseCache.error;
    }
    if ('result' in promiseCache) {
      return promiseCache.result;
    }

    throw promiseCache.promise;
  }

  promiseCache = {
    promise: promise
      .then((result) => {
        Object.assign(promiseCache, {
          result,
        });
      })
      .catch((error) => {
        Object.assign(promiseCache, {
          error,
        });
      }),
  };

  PROMISE_CACHE.set(promise, promiseCache);
  throw promiseCache.promise;
}