Function effect

src/effected.ts:112–157

(...args: unknown[])

  <Payloads extends unknown[], R>(...payloads: Payloads) => Effected<Effect<Name, Payloads, R>, R>
: (...payloads: Payloads) => Effected<Default<Effect<Name, Payloads, R>, T, F>, R>;
export function effect(...args: unknown[]): any {
  if (args.length === 0) return effect;
  const [name, options = {}] = args as [
    name: string | symbol,
    options?: {
      resumable?: boolean;
      defaultHandler?: (context: any, ...args: unknown[]) => unknown;
    },
  ];
  const result = (...payloads: unknown[]) => {
    const defaultHandler =
      options.defaultHandler &&
      ((context: any, ...payloads: unknown[]) => options.defaultHandler!(context, ...payloads));
    return effected(() => {
      let state = 0;
      return {
        next: (...args) => {
          switch (state) {
            case 0:
              state++;
              return {
                done: false,
                value: Object.assign(new Effect(name, payloads), {
                  ...(options.resumable === false ? { resumable: false } : {}),
                  ...(defaultHandler ? { defaultHandler } : {}),
                }),
              };
            case 1:
              state++;
              return {
                done: true,
                ...(args.length > 0 ? { value: args[0] } : {}),
              } as IteratorReturnResult<unknown>;
            default:
              return { done: true } as IteratorReturnResult<unknown>;
          }
        },
      };
    });
  };
  if ((options as any)._overrideFunctionName === false) return result as never;
  return renameFunction(
    result,
    typeof name === "string" ? name : name.toString().slice(7, -1) || "",
  ) as never;
}

/**
 * Create a function that returns an {@link Effected} instance (an effected program) which yields a