socket-function 0.119.0 → 0.121.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "0.119.0",
+	"version": "0.121.0",
 	"main": "index.js",
 	"license": "MIT",
 	"dependencies": {

package/src/batching.ts

@@ -1,6 +1,6 @@
-import { isNode } from "./misc";
+import { PromiseObj, isNode, timeoutToError } from "./misc";
 import { measureWrap } from "./profiling/measure";
-import { MaybePromise } from "./types";
+import { Args, MaybePromise } from "./types";
 
 /*
     "numbers" use setTimeout
@@ -197,6 +197,54 @@ export function runInSerial<T extends (...args: any[]) => Promise<any>>(fnc: T):
     }) as T;
 }
 
+
+export function runInParallel<T extends (...args: any[]) => Promise<any>>(
+    config: {
+        parallelCount: number;
+        callTimeout?: number;
+    },
+    fnc: T
+): T {
+    let queued: {
+        parameters: Args<T>;
+        result: PromiseObj<ReturnType<T>>;
+    }[] = [];
+    let runningCount = 0;
+
+    function runIfNeeded() {
+        if (runningCount >= config.parallelCount) {
+            return;
+        }
+        const queuedObj = queued.shift();
+        if (!queuedObj) return;
+
+        queuedObj.result.resolve((async () => {
+            runningCount++;
+            try {
+                if (config.callTimeout) {
+                    return await timeoutToError(config.callTimeout, fnc(...queuedObj.parameters), () => new Error(`Parallel call timed out for fnc ${fnc.name}`));
+                } else {
+                    return await fnc(...queuedObj.parameters);
+                }
+            } finally {
+                runningCount--;
+                runIfNeeded();
+            }
+        })());
+    }
+
+    function parallelCall(...args: Args<T>) {
+        queued.push({
+            parameters: args,
+            result: new PromiseObj<ReturnType<T>>(),
+        });
+        let queuedObj = queued[queued.length - 1];
+        runIfNeeded();
+        return queuedObj.result.promise;
+    }
+    return parallelCall as T;
+}
+
 export function runInfinitePoll(
     delayTime: number,
     fnc: () => Promise<void> | void

package/src/misc.ts

@@ -51,7 +51,7 @@ export function arrayEqual(a: { [key: number]: unknown; length: number }, b: { [
     return true;
 }
 export function isNode() {
-    return typeof document === "undefined";
+    return typeof document === "undefined" && typeof (globalThis as any).WorkerGlobalScope === "undefined";
 }
 
 export function isNodeTrue() {