@emeryld/rrroutes-client 2.6.4 → 2.6.6

package/dist/index.cjs

@@ -1375,63 +1375,93 @@ var SocketClient = class {
       });
       this.logSocketConfigSnapshot("constructor");
     }
-    this.onConnect = async () => {
+    this.onConnect = () => {
       if (!this.socket) {
         this.dbg({
           type: "connection",
           phase: "connect_event",
           err: "Socket is null"
         });
-        throw new Error("Socket is null in onConnect handler");
+        return;
       }
+      const socket = this.socket;
       this.dbg({
         type: "connection",
         phase: "connect_event",
-        id: this.socket.id,
+        id: socket.id,
         details: {
-          nsp: this.getNamespace(this.socket)
+          nsp: this.getNamespace(socket)
         }
       });
       this.logSocketConfigSnapshot("connect_event");
-      await this.getSysEvent("sys:connect")({
-        socket: this.socket,
-        client: this
+      void Promise.resolve(
+        this.getSysEvent("sys:connect")({
+          socket,
+          client: this
+        })
+      ).catch((error) => {
+        this.dbg({
+          type: "connection",
+          phase: "connect_event",
+          id: socket.id,
+          err: `sys:connect handler failed: ${this.formatError(error)}`,
+          details: this.getVerboseDetails({
+            nsp: this.getNamespace(socket),
+            rawError: error
+          })
+        });
       });
     };
-    this.onReconnect = async (attempt) => {
+    this.onReconnect = (attempt) => {
       if (!this.socket) {
         this.dbg({
           type: "connection",
           phase: "reconnect_event",
           err: "Socket is null"
         });
-        throw new Error("Socket is null in onReconnect handler");
+        return;
       }
+      const socket = this.socket;
       this.dbg({
         type: "connection",
         phase: "reconnect_event",
         attempt,
-        id: this.socket.id,
+        id: socket.id,
         details: {
-          nsp: this.getNamespace(this.socket)
+          nsp: this.getNamespace(socket)
         }
       });
       this.logSocketConfigSnapshot("reconnect_event");
-      await this.getSysEvent("sys:reconnect")({
-        attempt,
-        socket: this.socket,
-        client: this
+      void Promise.resolve(
+        this.getSysEvent("sys:reconnect")({
+          attempt,
+          socket,
+          client: this
+        })
+      ).catch((error) => {
+        this.dbg({
+          type: "connection",
+          phase: "reconnect_event",
+          attempt,
+          id: socket.id,
+          err: `sys:reconnect handler failed: ${this.formatError(error)}`,
+          details: this.getVerboseDetails({
+            nsp: this.getNamespace(socket),
+            rawError: error
+          })
+        });
       });
     };
-    this.onDisconnect = async (reason) => {
+    this.onDisconnect = (reason) => {
       if (!this.socket) {
         this.dbg({
           type: "connection",
           phase: "disconnect_event",
           err: "Socket is null"
         });
-        throw new Error("Socket is null in onDisconnect handler");
+        return;
       }
+      const socket = this.socket;
       this.dbg({
         type: "connection",
         phase: "disconnect_event",
@@ -1441,21 +1471,36 @@ var SocketClient = class {
         }
       });
       this.logSocketConfigSnapshot("disconnect_event");
-      await this.getSysEvent("sys:disconnect")({
-        reason: String(reason),
-        socket: this.socket,
-        client: this
+      void Promise.resolve(
+        this.getSysEvent("sys:disconnect")({
+          reason: String(reason),
+          socket,
+          client: this
+        })
+      ).catch((error) => {
+        this.dbg({
+          type: "connection",
+          phase: "disconnect_event",
+          reason: String(reason),
+          id: socket.id,
+          err: `sys:disconnect handler failed: ${this.formatError(error)}`,
+          details: this.getVerboseDetails({
+            roomsTracked: this.roomCounts.size,
+            rawError: error
+          })
+        });
       });
     };
-    this.onConnectError = async (err) => {
+    this.onConnectError = (err) => {
       if (!this.socket) {
         this.dbg({
           type: "connection",
           phase: "connect_error_event",
           err: "Socket is null"
         });
-        throw new Error("Socket is null in onConnectError handler");
+        return;
       }
+      const socket = this.socket;
       this.dbg({
         type: "connection",
         phase: "connect_error_event",
@@ -1463,21 +1508,34 @@ var SocketClient = class {
         details: this.getVerboseDetails({ rawError: err })
       });
       this.logSocketConfigSnapshot("connect_error_event");
-      await this.getSysEvent("sys:connect_error")({
-        error: String(err),
-        socket: this.socket,
-        client: this
+      void Promise.resolve(
+        this.getSysEvent("sys:connect_error")({
+          error: String(err),
+          socket,
+          client: this
+        })
+      ).catch((error) => {
+        this.dbg({
+          type: "connection",
+          phase: "connect_error_event",
+          id: socket.id,
+          err: `sys:connect_error handler failed: ${this.formatError(error)}`,
+          details: this.getVerboseDetails({
+            rawError: error
+          })
+        });
       });
     };
-    this.onPong = async (raw) => {
+    this.onPong = (raw) => {
       if (!this.socket) {
         this.dbg({
           type: "heartbeat",
           phase: "pong_recv",
           err: "Socket is null"
         });
-        throw new Error("Socket is null in onPong handler");
+        return;
       }
+      const socket = this.socket;
       const parsed = this.config.pongPayload.safeParse(raw);
       if (!parsed.success) {
         this.dbg({
@@ -1494,10 +1552,21 @@ var SocketClient = class {
         phase: "pong_recv",
         payload: validated
       });
-      await this.getSysEvent("sys:pong")({
-        socket: this.socket,
-        payload: validated,
-        client: this
+      void Promise.resolve(
+        this.getSysEvent("sys:pong")({
+          socket,
+          payload: validated,
+          client: this
+        })
+      ).catch((error) => {
+        this.dbg({
+          type: "heartbeat",
+          phase: "pong_recv",
+          err: `sys:pong handler failed: ${this.formatError(error)}`,
+          details: this.getVerboseDetails({
+            rawError: error
+          })
+        });
       });
     };
     if (this.socket) {
@@ -1558,6 +1627,15 @@ var SocketClient = class {
     if (!this.debug.verbose) return void 0;
     return details;
   }
+  formatError(error) {
+    if (error instanceof Error) return error.message;
+    if (typeof error === "string") return error;
+    try {
+      return JSON.stringify(error);
+    } catch {
+      return String(error);
+    }
+  }
   getNamespace(socket) {
     if (!socket) return void 0;
     const nsp = socket.nsp;
@@ -1571,7 +1649,13 @@ var SocketClient = class {
     if (!d.logger) return;
     if (!d[e.type]) return;
     if (d.only && "event" in e && !d.only.includes(e.event)) return;
-    d.logger(e);
+    try {
+      d.logger(e);
+    } catch (error) {
+      if (this.environment === "development" && typeof console !== "undefined" && typeof console.warn === "function") {
+        console.warn("[socket] debug logger threw", error);
+      }
+    }
   }
   /** internal stats snapshot */
   stats() {
@@ -1670,8 +1754,20 @@ var SocketClient = class {
         payload: dataToSend
       });
     };
-    this.hbTimer = setInterval(tick, this.hb.intervalMs);
-    tick();
+    const runTick = () => {
+      void tick().catch((error) => {
+        this.dbg({
+          type: "heartbeat",
+          phase: "ping_emit",
+          err: `sys:ping handler failed: ${this.formatError(error)}`,
+          details: this.getVerboseDetails({
+            rawError: error
+          })
+        });
+      });
+    };
+    this.hbTimer = setInterval(runTick, this.hb.intervalMs);
+    runTick();
   }
   /**
    * Public: stop the heartbeat loop.
@@ -1885,7 +1981,18 @@ var SocketClient = class {
           metadata: meta.envelope.metadata
         } : void 0
       });
-      handler(data, meta);
+      try {
+        handler(data, meta);
+      } catch (error) {
+        this.dbg({
+          type: "receive",
+          event,
+          err: `handler_failed: ${this.formatError(error)}`,
+          details: this.getVerboseDetails({
+            rawError: error
+          })
+        });
+      }
     };
     const wrappedDispatcher = (envelopeOrRaw) => {
       if (typeof envelopeOrRaw === "object" && envelopeOrRaw !== null && "eventName" in envelopeOrRaw && "sentAt" in envelopeOrRaw && "sentTo" in envelopeOrRaw && "data" in envelopeOrRaw) {
@@ -1896,7 +2003,18 @@ var SocketClient = class {
           event,
           envelope: void 0
         });
-        handler(envelopeOrRaw, void 0);
+        try {
+          handler(envelopeOrRaw, void 0);
+        } catch (error) {
+          this.dbg({
+            type: "receive",
+            event,
+            err: `handler_failed: ${this.formatError(error)}`,
+            details: this.getVerboseDetails({
+              rawError: error
+            })
+          });
+        }
       }
     };
     const errorWrapped = (e) => {
@@ -2045,26 +2163,48 @@ function useSocketConnection(args) {
     () => rooms == null ? [] : Array.isArray(rooms) ? rooms : [rooms],
     [rooms]
   );
+  const reportAsyncError = React2.useCallback(
+    (phase, error) => {
+      if (typeof console !== "undefined" && typeof console.warn === "function") {
+        console.warn(`[socket] useSocketConnection ${phase} failed`, error);
+      }
+    },
+    []
+  );
   React2.useEffect(() => {
     if (autoJoin && normalizedRooms.length > 0)
-      client.joinRooms(normalizedRooms, args.joinMeta);
+      void client.joinRooms(normalizedRooms, args.joinMeta).catch((error) => reportAsyncError("joinRooms", error));
     const unsubscribe = client.on(event, (payload, meta) => {
       onMessage(payload, meta);
     });
     return () => {
       unsubscribe();
       if (autoLeave && normalizedRooms.length > 0)
-        client.leaveRooms(normalizedRooms, args.leaveMeta);
+        void client.leaveRooms(normalizedRooms, args.leaveMeta).catch((error) => reportAsyncError("leaveRooms", error));
       if (onCleanup) onCleanup();
     };
-  }, [client, event, onMessage, autoJoin, autoLeave, ...normalizedRooms]);
+  }, [
+    client,
+    event,
+    onMessage,
+    autoJoin,
+    autoLeave,
+    reportAsyncError,
+    ...normalizedRooms
+  ]);
 }
 
 // src/sockets/socket.client.context.debug.ts
 function dbg(dbgOpts, e) {
   if (!dbgOpts?.logger) return;
   if (!dbgOpts[e.type]) return;
-  dbgOpts.logger(e);
+  try {
+    dbgOpts.logger(e);
+  } catch (error) {
+    if (typeof console !== "undefined" && typeof console.warn === "function") {
+      console.warn("[socket] provider debug logger threw", error);
+    }
+  }
 }
 function isProbablySocket(value) {
   if (!value || typeof value !== "object") return false;
@@ -2281,8 +2421,15 @@ function SocketProvider(props) {
     });
     return () => {
       if (client) {
-        client.destroy(destroyLeaveMetaRef.current);
-        dbg(providerDebugRef.current, { type: "client", phase: "destroy" });
+        void Promise.resolve(client.destroy(destroyLeaveMetaRef.current)).then(() => {
+          dbg(providerDebugRef.current, { type: "client", phase: "destroy" });
+        }).catch((error) => {
+          dbg(providerDebugRef.current, {
+            type: "resolve",
+            phase: "error",
+            err: `client.destroy failed: ${String(error)}`
+          });
+        });
       }
     };
   }, [client]);