Method handle

src/effected.ts:702–753

(
    name: string | symbol | ((name: string | symbol) => boolean),
    handler: (...args: any[]) => unknown,
  )

    : never,
  ): Effected<ExcludeEffect<E, Effect<Name>> | F, R | T>;
  handle(
    name: string | symbol | ((name: string | symbol) => boolean),
    handler: (...args: any[]) => unknown,
  ): Effected<any, unknown> {
    const matchEffect = (value: unknown) =>
      value instanceof Effect &&
      (typeof name === "function" ? name(value.name) : value.name === name);

    return effected(() => {
      const iterator = this[Symbol.iterator]();
      const context = {
        interceptIterator: null as typeof iterator | null,

        terminated: false as false | "with-value" | "without-value",
        terminatedValue: undefined as unknown,
      };

      return {
        next: (...args: [] | [unknown]) => {
          if (context.terminated)
            return {
              done: true,
              ...(context.terminated === "with-value" ? { value: context.terminatedValue } : {}),
            } as IteratorReturnResult<unknown>;

          const result = (context.interceptIterator || iterator).next(...args);

          const { done, value } = result;
          if (done) return result;

          if (matchEffect(value)) return handleEffect(context, name, value, handler as never);

          if (value instanceof Effect && typeof (value as any).defaultHandler === "function") {
            const originalDefaultHandler = (value as any).defaultHandler;
            (value as any).defaultHandler = (context: any, ...payloads: unknown[]) => {
              const result = originalDefaultHandler(context, ...payloads);
              if (result instanceof Effected) return result.handle(name as never, handler as never);
              if (isGenerator(result)) {
                return effected(() => result as Generator<Effect, unknown, unknown>).handle(
                  name as never,
                  handler as never,
                );
              }
              return result;
            };
          }

          return result;
        },
      };
    });
  }

  /**
   * Resume an effect with the return value of the handler.