socket-function 1.1.8 → 1.1.10

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;

package/package.json

@@ -1,13 +1,12 @@
 {
 	"name": "socket-function",
-	"version": "1.1.8",
+	"version": "1.1.10",
 	"main": "index.js",
 	"license": "MIT",
 	"dependencies": {
 		"@types/pako": "^2.0.3",
 		"@types/ws": "^8.5.3",
 		"cbor-x": "^1.6.0",
-		"lmdb": "^3.5.1",
 		"mobx": "^6.6.2",
 		"pako": "^2.1.0",
 		"preact": "10.24.3",
@@ -15,6 +14,9 @@
 		"typenode": "^6.0.1",
 		"ws": "^8.17.1"
 	},
+	"optionalDependencies": {
+		"lmdb": "^3.5.1"
+	},
 	"types": "index.d.ts",
 	"scripts": {
 		"test": "yarn typenode ./test.ts",

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();
@@ -720,12 +720,13 @@ export async function createCallFactory(
                 if (!pendingCall) {
                     throw new Error(`Received data without size ${message.byteLength}B, first 100 bytes: ${message.slice(0, 100).toString("hex")}`);
                 }
-                if (message.byteLength > 1000 * 1000 * 10 || pendingCall.bufferCount > 1000 && (pendingCall.buffers.length % 100 === 0)) {
+                let totalSize = message.byteLength + pendingCall.buffers.reduce((a, b) => a + b.length, 0);
+                if (totalSize > 1000 * 1000 * 10 || pendingCall.bufferCount > 1000 && (pendingCall.buffers.length % 100 === 0)) {
                     if (pendingCall.buffers.length === 0) {
-                        console.log(`Received large/many packets ${formatNumber(message.byteLength)}B (${pendingCall.buffers.length} / ${pendingCall.bufferCount}) at ${Date.now()}`);
+                        console.log(`Received large/many packets ${formatNumber(totalSize)}B (${pendingCall.buffers.length} / ${pendingCall.bufferCount}) at ${Date.now()}`);
                     } else {
                         let elapsed = Date.now() - (pendingCall.firstReceivedTime || 0);
-                        console.log(`Received large/many packets ${formatNumber(message.byteLength)}B (${pendingCall.buffers.length} / ${pendingCall.bufferCount}) after ${formatTime(elapsed)}`);
+                        console.log(`Received large/many packets ${formatNumber(totalSize)}B (${pendingCall.buffers.length} / ${pendingCall.bufferCount}) after ${formatTime(elapsed)}`);
                     }
                 }
                 if (pendingCall.buffers.length === 0) {