Function runAsync

src/effected.ts:2610–2701

(
  effected: E extends Effected<infer F extends Effect, unknown> ?
    [ExtractUnhandled<F>] extends [never] ?
      E
    : UnhandledEffect<ExtractUnhandled<F>>
  : never,
)

 * @throws {UnhandledEffectError} If an unhandled effect is encountered.
 */
export function runAsync<E extends Effected<Effect, unknown>>(
  effected: E extends Effected<infer F extends Effect, unknown> ?
    [ExtractUnhandled<F>] extends [never] ?
      E
    : UnhandledEffect<ExtractUnhandled<F>>
  : never,
): Promise<E extends Effected<infer F, infer R> ? ExtractDefaultTerminateType<F> | R : never> {
  const iterator = (effected as Iterable<any>)[Symbol.iterator]();
  const context = {
    interceptIterator: null as typeof iterator | null,
    terminated: false as false | "with-value" | "without-value",
    terminatedValue: undefined as unknown,
  };

  return new Promise((resolve, reject) => {
    const iterate = (...args: [] | [unknown]) => {
      if (context.terminated) return context.terminatedValue;

      let done: boolean | undefined;
      let value: any;
      try {
        ({ done, value } = (context.interceptIterator || iterator).next(...args));
      } catch (e) {
        // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
        reject(e);
        return;
      }

      // We use a while loop to avoid stack overflow when there are many synchronous effects
      while (!done) {
        if (!value) {
          reject(
            new Error(
              `Invalid effected program: an effected program should yield only effects (received ${stringify(value)})`,
            ),
          );
          return;
        }
        if (value instanceof Effect) {
          while (value instanceof Effect && typeof (value as any).defaultHandler === "function") {
            value = handleEffect(context, effect.name, value, (value as any).defaultHandler).value;
            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
            if (context.terminated) return context.terminatedValue;
          }
          if (value instanceof Effect) {
            reject(new UnhandledEffectError(value, `Unhandled effect: ${stringifyEffect(value)}`));
            return;
          }
        }
        if (value._effectSync) {
          try {
            ({ done, value } = (context.interceptIterator || iterator).next(
              ...("value" in value ? [value.value] : []),
            ));
          } catch (e) {
            // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
            reject(e);
            return;