JavaScript/TypeScript `withInterval`

withInterval.js

export class IntervalCancelledError extends Error {
  constructor(intervalCount, ...args) {
    super(...args);
    if (Error.captureStackTrace) {
      Error.captureStackTrace(this, IntervalCancelledError);
    }
    this.name = "IntervalCancelledError";
    this.intervalCount = intervalCount;
  }
}

export function withInterval(promiseFunc, delay) {
  let nextIntervalQueue = [];
  const nextInterval = function () {
    return new Promise(function (resolve, reject) {
      nextIntervalQueue.push([resolve, reject]);
    });
  };
  let intervalCount = 0;
  const intervalCallback = function () {
    for (const [resolve, _reject] of nextIntervalQueue) {
      resolve(intervalCount);
    }
    nextIntervalQueue.length = 0;
    ++intervalCount;
  };
  const intervalId = setInterval(intervalCallback, delay);
  const promise = promiseFunc(nextInterval);
  const resolvedPromise = Promise.resolve(promise);
  const onPromiseFufilled = function (_value) {
    clearInterval(intervalId);
    const intervalCancelledError = new IntervalCancelledError(
      intervalCount,
      "Promise fufilled"
    );
    intervalCancelledError.promise = resolvedPromise;
    for (const [_resolve, reject] of nextIntervalQueue) {
      reject(intervalCancelledError);
    }
    nextIntervalQueue.length = 0;
  };
  const onPromiseRejected = function (reason) {
    clearInterval(intervalId);
    const intervalCancelledError = new IntervalCancelledError(
      intervalCount,
      "Promise rejected",
      { cause: reason }
    );
    intervalCancelledError.promise = resolvedPromise;
    for (const [_resolve, reject] of nextIntervalQueue) {
      reject(intervalCancelledError);
    }
    nextIntervalQueue.length = 0;
  };
  resolvedPromise.then(onPromiseFufilled, onPromiseRejected);
  return promise;
}

withInterval.ts

export class IntervalCancelledError extends Error {
  public intervalCount: number;
  public promise?: Promise<unknown>;
  constructor(
    intervalCount: number,
    ...args: ConstructorParameters<typeof Error>
  ) {
    super(...args);
    if (Error.captureStackTrace) {
      Error.captureStackTrace(this, IntervalCancelledError);
    }
    this.name = "IntervalCancelledError";
    this.intervalCount = intervalCount;
  }
}

export function withInterval<
  TResult,
  TPromise extends TResult | PromiseLike<TResult>
>(
  promiseFunc: (nextInterval: () => Promise<number>) => TPromise,
  delay: number
): TPromise {
  let nextIntervalQueue: [
    (value: number | PromiseLike<number>) => void,
    (reason?: unknown) => void
  ][] = [];
  const nextInterval = function (): Promise<number> {
    return new Promise(function (resolve, reject): void {
      nextIntervalQueue.push([resolve, reject]);
    });
  };
  let intervalCount: number = 0;
  const intervalCallback = function (): void {
    for (const [resolve, _reject] of nextIntervalQueue) {
      resolve(intervalCount);
    }
    nextIntervalQueue.length = 0;
    ++intervalCount;
  };
  const intervalId = setInterval(intervalCallback, delay);
  const promise: TPromise = promiseFunc(nextInterval);
  const resolvedPromise: Promise<TResult> = Promise.resolve<TResult>(promise);
  const onPromiseFufilled = function (_value: TResult): void {
    clearInterval(intervalId);
    const intervalCancelledError = new IntervalCancelledError(
      intervalCount,
      "Promise fufilled"
    );
    intervalCancelledError.promise = resolvedPromise;
    for (const [_resolve, reject] of nextIntervalQueue) {
      reject(intervalCancelledError);
    }
    nextIntervalQueue.length = 0;
  };
  const onPromiseRejected = function (reason: unknown): void {
    clearInterval(intervalId);
    const intervalCancelledError = new IntervalCancelledError(
      intervalCount,
      "Promise rejected",
      { cause: reason }
    );
    intervalCancelledError.promise = resolvedPromise;
    for (const [_resolve, reject] of nextIntervalQueue) {
      reject(intervalCancelledError);
    }
    nextIntervalQueue.length = 0;
  };
  resolvedPromise.then(onPromiseFufilled, onPromiseRejected);
  return promise;
}