Move to libs

libs/common/src/misc/throttle.ts

@@ -0,0 +1,69 @@
+/**
+ * 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();
+          }
+        });
+      },
+    };
+  };
+}