socket-function 1.1.9 → 1.1.11

package/SocketFunction.d.ts

@@ -64,6 +64,7 @@ export declare class SocketFunction {
     private static socketCache;
     static rehydrateSocketCaller<Controller>(socketRegistered: SocketRegisterType<Controller>, shapeFnc?: () => SocketExposedShape): SocketRegistered<Controller>;
     private static callFromGuid;
+    /** Will dedupe callbacks, so if you call with the same callback it won't call it multiple times (otherwise it's difficult to manage this, as this only calls on the NEXT callback). */
     static onNextDisconnect(nodeId: string, callback: () => void): void;
     static getLastDisconnectTime(nodeId: string): number | undefined;
     static isNodeConnected(nodeId: string): boolean;

package/SocketFunction.ts

@@ -289,6 +289,7 @@ export class SocketFunction {
         }
     }
 
+    /** Will dedupe callbacks, so if you call with the same callback it won't call it multiple times (otherwise it's difficult to manage this, as this only calls on the NEXT callback). */
     public static onNextDisconnect(nodeId: string, callback: () => void) {
         (async () => {
             let factory = await getCallFactory(nodeId);

package/index.d.ts

@@ -73,6 +73,7 @@ declare module "socket-function/SocketFunction" {
         private static socketCache;
         static rehydrateSocketCaller<Controller>(socketRegistered: SocketRegisterType<Controller>, shapeFnc?: () => SocketExposedShape): SocketRegistered<Controller>;
         private static callFromGuid;
+        /** Will dedupe callbacks, so if you call with the same callback it won't call it multiple times (otherwise it's difficult to manage this, as this only calls on the NEXT callback). */
         static onNextDisconnect(nodeId: string, callback: () => void): void;
         static getLastDisconnectTime(nodeId: string): number | undefined;
         static isNodeConnected(nodeId: string): boolean;
@@ -591,8 +592,12 @@ declare module "socket-function/src/batching" {
         parallelCount: number;
         callTimeout?: number;
     }, fnc: T): T;
-    export declare function runInfinitePoll(delayTime: number, fnc: () => Promise<void> | void): void;
-    export declare function runInfinitePollCallAtStart(delayTime: number, fnc: () => Promise<void> | void): Promise<void>;
+    export declare function runInfinitePoll(delayTime: number, fnc: () => Promise<void> | void, stopObj?: {
+        stop: boolean;
+    }): void;
+    export declare function runInfinitePollCallAtStart(delayTime: number, fnc: () => Promise<void> | void, stopObj?: {
+        stop: boolean;
+    }): Promise<void>;
     /** Disables polling, called on shutdown. Blocks until all pending poll loops finish */
     export declare function shutdownPolling(): Promise<void>;
     export declare function retryFunctional<T extends AnyFunction>(fnc: T, config?: {

package/package.json

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

package/src/CallFactory.ts

@@ -145,9 +145,9 @@ export async function createCallFactory(
         localNodeId
     };
 
-    let disconnectCallbacks: (() => void)[] = [];
+    let disconnectCallbacks = new Set<() => void>();
     function onNextDisconnect(callback: () => void): void {
-        disconnectCallbacks.push(callback);
+        disconnectCallbacks.add(callback);
     }
 
     let callFactory: CallFactory = {
@@ -315,7 +315,7 @@ export async function createCallFactory(
             }
 
             let callbacks = disconnectCallbacks;
-            disconnectCallbacks = [];
+            disconnectCallbacks = new Set();
             for (let callback of callbacks) {
                 try {
                     callback();

package/src/batching.d.ts

@@ -19,8 +19,12 @@ export declare function runInParallel<T extends (...args: any[]) => Promise<any>
     parallelCount: number;
     callTimeout?: number;
 }, fnc: T): T;
-export declare function runInfinitePoll(delayTime: number, fnc: () => Promise<void> | void): void;
-export declare function runInfinitePollCallAtStart(delayTime: number, fnc: () => Promise<void> | void): Promise<void>;
+export declare function runInfinitePoll(delayTime: number, fnc: () => Promise<void> | void, stopObj?: {
+    stop: boolean;
+}): void;
+export declare function runInfinitePollCallAtStart(delayTime: number, fnc: () => Promise<void> | void, stopObj?: {
+    stop: boolean;
+}): Promise<void>;
 /** Disables polling, called on shutdown. Blocks until all pending poll loops finish */
 export declare function shutdownPolling(): Promise<void>;
 export declare function retryFunctional<T extends AnyFunction>(fnc: T, config?: {

package/src/batching.ts

@@ -253,10 +253,11 @@ let pendingPolls = new Set<Promise<unknown>>();
 
 export function runInfinitePoll(
     delayTime: number,
-    fnc: () => Promise<void> | void
+    fnc: () => Promise<void> | void,
+    stopObj?: { stop: boolean; }
 ) {
     void (async () => {
-        while (pollingRunning) {
+        while (!stopObj?.stop && pollingRunning) {
             await delay(delayTime);
             if (!pollingRunning) break;
             await runPollFnc(fnc);
@@ -266,13 +267,14 @@ export function runInfinitePoll(
 
 export async function runInfinitePollCallAtStart(
     delayTime: number,
-    fnc: () => Promise<void> | void
+    fnc: () => Promise<void> | void,
+    stopObj?: { stop: boolean; }
 ) {
     try {
         return await fnc();
     } finally {
         void (async () => {
-            while (true) {
+            while (!stopObj?.stop && pollingRunning) {
                 await delay(delayTime);
                 if (!pollingRunning) break;
                 await runPollFnc(fnc);