socket-function 0.151.0 → 0.153.0

package/package.json

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

package/src/batching.ts

@@ -1,6 +1,6 @@
 import { PromiseObj, isNode, timeoutToError } from "./misc";
 import { measureWrap } from "./profiling/measure";
-import { Args, MaybePromise } from "./types";
+import { AnyFunction, Args, MaybePromise } from "./types";
 
 /*
     "numbers" use setTimeout
@@ -298,4 +298,35 @@ async function runPollFnc(fnc: () => Promise<void> | void) {
 export async function shutdownPolling() {
     pollingRunning = false;
     await Promise.all(Array.from(pendingPolls));
+}
+
+
+const DEFAULT_RETRY_DELAY = 5000;
+const DEFAULT_MAX_RETRIES = 3;
+export function retryFunctional<T extends AnyFunction>(fnc: T, config?: {
+    maxRetries?: number;
+    shouldRetry?: (message: string) => boolean;
+    minDelay?: number;
+    maxDelay?: number;
+}): T {
+    let { maxRetries = DEFAULT_MAX_RETRIES, shouldRetry, minDelay = DEFAULT_RETRY_DELAY, maxDelay = DEFAULT_RETRY_DELAY } = config || {};
+    let expFactor = Math.max(1, Math.log(maxDelay / minDelay) / Math.log(Math.max(maxRetries, 2)));
+    async function runFnc(args: any[], retries: number): Promise<ReturnType<T>> {
+        try {
+            return await (fnc as any)(...args);
+        } catch (e: any) {
+            if (shouldRetry && !shouldRetry(String(e.stack))) {
+                throw e;
+            }
+            if (retries < 0) throw e;
+            console.warn(`Retrying ${fnc.name}, due to error ${String(e.stack)}`);
+            retries--;
+            let curCount = maxRetries - retries;
+            await delay(minDelay * expFactor ** curCount);
+            return runFnc(args, retries);
+        }
+    }
+    return async function (...args: any[]) {
+        return await runFnc(args, maxRetries);
+    } as any;
 }

package/src/misc.ts

@@ -77,6 +77,7 @@ export function recursiveFreeze<T>(obj: T): T {
         if (!canHaveChildren(obj)) return;
         if (visited.has(obj)) return;
         visited.add(obj);
+        if (ArrayBuffer.isView(obj)) return;
         Object.freeze(obj);
         let keys = getKeys(obj);
         for (let key of keys) {
@@ -338,6 +339,9 @@ export class QueueLimited<T> {
 export function binarySearchBasic<T, V>(array: T[], getVal: (val: T) => V, searchValue: V): number {
     return binarySearchIndex(array.length, i => compare(getVal(array[i]), searchValue));
 }
+export function binarySearchBasic2<T, V>(array: T[], getVal: (val: T) => V, searchValue: T): number {
+    return binarySearchIndex(array.length, i => compare(getVal(array[i]), getVal(searchValue)));
+}
 
 /**
  *  Searches indexes, allowing you to query structures that aren't arrays. To search an array, use: