socket-function 1.1.22 → 1.1.24

package/index.d.ts

@@ -609,13 +609,25 @@ declare module "socket-function/src/batching" {
         minDelay?: number;
         maxDelay?: number;
     }): T;
-    export declare const safeLoop: typeof unblockLoop;
+    /** @deprecated Use safeLoop instead */
     export declare const throttledLoop: typeof unblockLoop;
+    /** @deprecated Use safeLoop instead */
     export declare function unblockLoop<T, R>(config: {
         data: T[];
         maxBlockingTime?: number;
         backOffTime?: number;
     } | T[], fnc: (item: T) => MaybePromise<R>): Promise<R[]>;
+    export declare function safeLoop<T, R>(config: {
+        data: T[];
+        fnc: (item: T) => MaybePromise<R>;
+        /** If set, yields after blocking for this many ms. */
+        maxBlockingTime?: number;
+        /** If set (with maxBlockingTime), the fraction of time spent active vs yielded.
+         *      e.g. 0.5 => after blocking X ms, wait X ms before continuing. */
+        maxActiveFraction?: number;
+        doNotWarnOnSlow?: boolean;
+        name?: string;
+    }): Promise<R[]>;
 
 }
 

package/package.json

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

package/src/batching.d.ts

@@ -33,10 +33,22 @@ export declare function retryFunctional<T extends AnyFunction>(fnc: T, config?:
     minDelay?: number;
     maxDelay?: number;
 }): T;
-export declare const safeLoop: typeof unblockLoop;
+/** @deprecated Use safeLoop instead */
 export declare const throttledLoop: typeof unblockLoop;
+/** @deprecated Use safeLoop instead */
 export declare function unblockLoop<T, R>(config: {
     data: T[];
     maxBlockingTime?: number;
     backOffTime?: number;
 } | T[], fnc: (item: T) => MaybePromise<R>): Promise<R[]>;
+export declare function safeLoop<T, R>(config: {
+    data: T[];
+    fnc: (item: T) => MaybePromise<R>;
+    /** If set, yields after blocking for this many ms. */
+    maxBlockingTime?: number;
+    /** If set (with maxBlockingTime), the fraction of time spent active vs yielded.
+     *      e.g. 0.5 => after blocking X ms, wait X ms before continuing. */
+    maxActiveFraction?: number;
+    doNotWarnOnSlow?: boolean;
+    name?: string;
+}): Promise<R[]>;

package/src/batching.ts

@@ -1,3 +1,4 @@
+import { formatTime } from "./formatting/format";
 import { PromiseObj, isNode, timeoutToError } from "./misc";
 import { measureWrap } from "./profiling/measure";
 import { AnyFunction, Args, MaybePromise } from "./types";
@@ -333,8 +334,9 @@ export function retryFunctional<T extends AnyFunction>(fnc: T, config?: {
     } as any;
 }
 
-export const safeLoop = unblockLoop;
+/** @deprecated Use safeLoop instead */
 export const throttledLoop = unblockLoop;
+/** @deprecated Use safeLoop instead */
 export async function unblockLoop<T, R>(config: {
     data: T[];
     maxBlockingTime?: number;
@@ -368,4 +370,67 @@ export async function unblockLoop<T, R>(config: {
         }
     }
     return results;
+}
+
+export async function safeLoop<T, R>(config: {
+    data: T[];
+    fnc: (item: T) => MaybePromise<R>;
+    /** If set, yields after blocking for this many ms. */
+    maxBlockingTime?: number;
+    /** If set (with maxBlockingTime), the fraction of time spent active vs yielded.
+     *      e.g. 0.5 => after blocking X ms, wait X ms before continuing. */
+    maxActiveFraction?: number;
+    doNotWarnOnSlow?: boolean;
+    name?: string;
+}): Promise<R[]> {
+    let { data, fnc, maxBlockingTime, maxActiveFraction, doNotWarnOnSlow, name } = config;
+
+    let label = name || fnc.name || fnc.toString().slice(0, 100);
+    let startTime = Date.now();
+    let index = 0;
+    let indexStartTime = Date.now();
+    let done = false;
+
+    if (!doNotWarnOnSlow) {
+        void (async () => {
+            while (!done) {
+                await delay(5000);
+                if (done) break;
+                let message = `${label} @ ${index} / ${data.length} | ${formatTime(Date.now() - startTime)}`;
+                let timeOnCurrent = Date.now() - indexStartTime;
+                if (timeOnCurrent > 5000) {
+                    message += `| SLOW INDEX (${index}) ${formatTime(timeOnCurrent)}+`;
+                }
+                console.log(message);
+            }
+        })();
+    }
+
+    let results: R[] = [];
+    let lastYieldTime = Date.now();
+    try {
+        for (index = 0; index < data.length; index++) {
+            indexStartTime = Date.now();
+            let result = fnc(data[index]);
+            if (result && typeof result === "object" && "then" in result) {
+                result = await result;
+            }
+            results.push(result);
+
+            if (maxBlockingTime !== undefined) {
+                let blockedFor = Date.now() - lastYieldTime;
+                if (blockedFor > maxBlockingTime) {
+                    let backOffTime = 0;
+                    if (maxActiveFraction !== undefined && maxActiveFraction > 0 && maxActiveFraction < 1) {
+                        backOffTime = blockedFor / maxActiveFraction - blockedFor;
+                    }
+                    await delay(backOffTime);
+                    lastYieldTime = Date.now();
+                }
+            }
+        }
+    } finally {
+        done = true;
+    }
+    return results;
 }

package/src/promiseRace.ts

@@ -59,18 +59,18 @@ function connectPromiseToCallbackObj(promise: any, callbackObj: any) {
             // We need to delete the callback lists once on finally happens. Because we only connect to the promise once, And so it'll only trigger us once. So removing it is the only way to get it to trigger us again if someone subscribes to a finished promise. 
             promiseCallbacks.delete(promise);
             for (let fnc of callbackObj.onResolve.slice()) {
-                try { fnc(value); } finally { }
+                try { fnc(value); } catch { }
             }
         },
         (value: any) => {
             promiseCallbacks.delete(promise);
             for (let fnc of callbackObj.onReject.slice()) {
-                try { fnc(value); } finally { }
+                try { fnc(value); } catch { }
             }
         }
     ).finally(() => {
         for (let fnc of callbackObj.onFinally.slice()) {
-            try { fnc(); } finally { }
+            try { fnc(); } catch { }
         }
     });
 }