Function iterate

src/effected.ts:2625–2697

(...args: [] | [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;
          }
          continue;
        }
        if (value._effectAsync) {
          if (value.interruptable) {
            let resolve!: (value: unknown) => void;
            const promise = new Promise((_resolve) => (resolve = _resolve));
            // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
            value.onComplete(resolve, (...args: unknown[]) => reject(...args.slice(0, 1)));
            ({ done, value } = (context.interceptIterator || iterator).next({
              _effectInterrupt: value.interruptable,
              with: promise,
            }));
            continue;
          } else {