socket-function 1.1.24 → 1.1.26

package/index.d.ts

@@ -619,15 +619,13 @@ declare module "socket-function/src/batching" {
     } | 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. */
+        /** If set, yields after blocking for this many ms. ONLY applies if your function does not return promises. Default = 1000ms */
         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. */
+        /** Fraction of time spent active vs yielded. e.g. 0.5 => after running X ms, wait X ms before continuing. */
         maxActiveFraction?: number;
         doNotWarnOnSlow?: boolean;
         name?: string;
-    }): Promise<R[]>;
+    }, fnc: (item: T) => MaybePromise<R>): Promise<R[]>;
 
 }
 

package/package.json

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

package/src/batching.d.ts

@@ -43,12 +43,10 @@ export declare function unblockLoop<T, R>(config: {
 } | 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. */
+    /** If set, yields after blocking for this many ms. ONLY applies if your function does not return promises. Default = 1000ms */
     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. */
+    /** Fraction of time spent active vs yielded. e.g. 0.5 => after running X ms, wait X ms before continuing. */
     maxActiveFraction?: number;
     doNotWarnOnSlow?: boolean;
     name?: string;
-}): Promise<R[]>;
+}, fnc: (item: T) => MaybePromise<R>): Promise<R[]>;

package/src/batching.ts

@@ -374,16 +374,15 @@ export async function unblockLoop<T, R>(config: {
 
 export async function safeLoop<T, R>(config: {
     data: T[];
-    fnc: (item: T) => MaybePromise<R>;
-    /** If set, yields after blocking for this many ms. */
+    /** If set, yields after blocking for this many ms. ONLY applies if your function does not return promises. Default = 1000ms */
     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. */
+    /** Fraction of time spent active vs yielded. e.g. 0.5 => after running X ms, wait X ms before continuing. */
     maxActiveFraction?: number;
     doNotWarnOnSlow?: boolean;
     name?: string;
-}): Promise<R[]> {
-    let { data, fnc, maxBlockingTime, maxActiveFraction, doNotWarnOnSlow, name } = config;
+}, fnc: (item: T) => MaybePromise<R>): Promise<R[]> {
+    let { data, maxActiveFraction, doNotWarnOnSlow, name } = config;
+    let maxBlockingTime = config.maxBlockingTime ?? 1000;
 
     let label = name || fnc.name || fnc.toString().slice(0, 100);
     let startTime = Date.now();
@@ -407,26 +406,34 @@ export async function safeLoop<T, R>(config: {
     }
 
     let results: R[] = [];
-    let lastYieldTime = Date.now();
+    let activeTimeSinceYield = 0;
     try {
         for (index = 0; index < data.length; index++) {
             indexStartTime = Date.now();
             let result = fnc(data[index]);
+            let isPromise = false;
             if (result && typeof result === "object" && "then" in result) {
+                isPromise = true;
                 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();
-                }
+            activeTimeSinceYield += Date.now() - indexStartTime;
+
+            let backOffTime: number | undefined;
+
+            if (!isPromise && activeTimeSinceYield > maxBlockingTime) {
+                backOffTime = 0;
+            }
+
+            if (maxActiveFraction !== undefined && maxActiveFraction > 0 && maxActiveFraction < 1) {
+                let target = activeTimeSinceYield / maxActiveFraction - activeTimeSinceYield;
+                backOffTime = Math.max(backOffTime ?? 0, target);
+            }
+
+            if (backOffTime !== undefined) {
+                await delay(backOffTime);
+                activeTimeSinceYield = 0;
             }
         }
     } finally {