Function runSync

src/effected.ts:2554–2601

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

 * @throws {Error} If an asynchronous effect is encountered.
 */
export function runSync<E extends Effected<Effect, unknown>>(
  effected: E extends Effected<infer F extends Effect, unknown> ?
    [ExtractUnhandled<F>] extends [never] ?
      E
    : UnhandledEffect<ExtractUnhandled<F>>
  : never,
): 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,
  };

  let { done, value } = (context.interceptIterator || iterator).next();
  while (!done) {
    if (context.terminated) return context.terminatedValue as never;

    if (!value)
      throw new Error(
        `Invalid effected program: an effected program should yield only effects (received ${stringify(value)})`,
      );
    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 as never;
      }
      if (value instanceof Effect)
        throw new UnhandledEffectError(value, `Unhandled effect: ${stringifyEffect(value)}`);
    }
    if (value._effectSync) {
      ({ done, value } = (context.interceptIterator || iterator).next(
        ...("value" in value ? [value.value] : []),
      ));
      continue;
    }
    if (value._effectAsync)
      throw new Error(
        "Cannot run an asynchronous effected program with `runSync`, use `runAsync` instead",
      );

    throw new Error(
      `Invalid effected program: an effected program should yield only effects (received ${stringify(value)})`,
    );
  }
  return value;
}

/**
 * Run a (possibly) asynchronous effected program and return its result as a {@link Promise}.