cancelable.ts

/**
 * Something that can be yielded
 */
interface Yieldable<T> {
  (signal: AbortSignal): Promise<T>;
}

/**
 * Executes a generator function that yields promises, allowing for cancellation via an AbortSignal.
 */
export async function co<B, C>(
  signal: AbortSignal,
  fn: () => Generator<Yieldable<any>, B, C>
): Promise<B> {
  const gen = fn();
  let current = gen.next();
  while (!signal.aborted && !current.done) {
    const v = await current.value(signal);
    if (signal.aborted) {
      current = gen.throw(signal.reason);
    } else {
      current = gen.next(v);
    }
  }

  signal.throwIfAborted();
  if (!current.done) {
    throw new UnfinishedGeneratorError();
  }

  return current.value;
}

class UnfinishedGeneratorError extends Error {
  name = 'UnfinishedGeneratorError';
  constructor() {
    super('unfinished generator');
  }
}

export function* cancelable<T>(fn: Yieldable<T>): Generator<typeof fn, T, T> {
  return yield fn;
}

export function* from<T>(promise: Promise<T>) {
  return yield* cancelable(() => promise);
}