browser/libs/common/src/platform/misc/throttle.ts

/**
 * Use as a Decorator on async functions, it will limit how many times the function can be
 * in-flight at a time.
 *
 * Calls beyond the limit will be queued, and run when one of the active calls finishes
 */
export function throttle(limit: number, throttleKey: (args: any[]) => string) {
  return <T>(
    target: any,
    propertyKey: string | symbol,
    descriptor: TypedPropertyDescriptor<(...args: any[]) => Promise<T>>,
  ) => {
    const originalMethod: () => Promise<T> = descriptor.value;
    const allThrottles = new Map<any, Map<string, (() => void)[]>>();

    const getThrottles = (obj: any) => {
      let throttles = allThrottles.get(obj);
      if (throttles != null) {
        return throttles;
      }
      throttles = new Map<string, (() => void)[]>();
      allThrottles.set(obj, throttles);
      return throttles;
    };

    return {
      value: function (...args: any[]) {
        const throttles = getThrottles(this);
        const argsThrottleKey = throttleKey(args);
        let queue = throttles.get(argsThrottleKey);
        if (queue == null) {
          queue = [];
          throttles.set(argsThrottleKey, queue);
        }

        return new Promise<T>((resolve, reject) => {
          const exec = () => {
            const onFinally = () => {
              queue.splice(queue.indexOf(exec), 1);
              if (queue.length >= limit) {
                queue[limit - 1]();
              } else if (queue.length === 0) {
                throttles.delete(argsThrottleKey);
                if (throttles.size === 0) {
                  allThrottles.delete(this);
                }
              }
            };
            originalMethod
              .apply(this, args)
              .then((val: any) => {
                onFinally();
                return val;
              })
              .catch((err: any) => {
                onFinally();
                throw err;
              })
              .then(resolve, reject);
          };
          queue.push(exec);
          if (queue.length <= limit) {
            exec();
          }
        });
      },
    };
  };
}