@emeryld/rrroutes-client 2.7.9 → 2.7.11

package/dist/index.cjs

@@ -1578,9 +1578,12 @@ var React3 = __toESM(require("react"), 1);
 
 // src/sockets/socket.client.context.client.ts
 var React = __toESM(require("react"), 1);
-var SocketCtx = React.createContext(null);
+var SocketCtx = React.createContext(void 0);
 function useSocketClient() {
   const ctx = React.useContext(SocketCtx);
+  if (typeof ctx === "undefined") {
+    throw new Error("SocketClient not found. Wrap with <SocketProvider>.");
+  }
   if (!ctx) {
     return null;
   }
@@ -1596,13 +1599,48 @@ function useSocketConnection(args) {
     onMessage,
     onCleanup,
     autoJoin = true,
-    autoLeave = true
+    autoLeave = true,
+    debug
   } = args;
   const client = useSocketClient();
   const normalizedRooms = React2.useMemo(
     () => rooms == null ? [] : Array.isArray(rooms) ? rooms : [rooms],
     [rooms]
   );
+  const normalizedRoomsKey = React2.useMemo(
+    () => normalizedRooms.join("
"),
+    [normalizedRooms]
+  );
+  const joinMetaKey = React2.useMemo(
+    () => JSON.stringify(args.joinMeta ?? null),
+    [args.joinMeta]
+  );
+  const leaveMetaKey = React2.useMemo(
+    () => JSON.stringify(args.leaveMeta ?? null),
+    [args.leaveMeta]
+  );
+  const missingClientWarnedRef = React2.useRef(false);
+  const emitDebug = React2.useCallback(
+    (event2) => {
+      if (!debug?.enabled) return;
+      if (debug[event2.type] === false) return;
+      const logger = debug.logger;
+      if (logger) {
+        try {
+          logger(event2);
+        } catch (error) {
+          if (typeof console !== "undefined" && typeof console.warn === "function") {
+            console.warn("[socket] useSocketConnection debug logger threw", error);
+          }
+        }
+        return;
+      }
+      if (typeof console !== "undefined" && typeof console.log === "function") {
+        console.log("[socket] useSocketConnection", event2);
+      }
+    },
+    [debug]
+  );
   const reportAsyncError = React2.useCallback(
     (phase, error) => {
       if (typeof console !== "undefined" && typeof console.warn === "function") {
@@ -1612,26 +1650,118 @@ function useSocketConnection(args) {
     []
   );
   React2.useEffect(() => {
-    if (!client) return;
-    if (autoJoin && normalizedRooms.length > 0)
-      void client.joinRooms(normalizedRooms, args.joinMeta).catch((error) => reportAsyncError("joinRooms", error));
+    emitDebug({
+      type: "lifecycle",
+      phase: "effect_start",
+      event,
+      rooms: normalizedRooms,
+      autoJoin,
+      autoLeave
+    });
+    if (!client) {
+      emitDebug({
+        type: "lifecycle",
+        phase: "client_missing",
+        event,
+        rooms: normalizedRooms,
+        autoJoin,
+        autoLeave
+      });
+      if (debug?.throwIfClientMissing) {
+        throw new Error(
+          `useSocketConnection("${event}") missing SocketClient. Wrap with <SocketProvider>.`
+        );
+      }
+      if (debug?.warnIfClientMissing && !missingClientWarnedRef.current && typeof console !== "undefined" && typeof console.warn === "function") {
+        missingClientWarnedRef.current = true;
+        console.warn(
+          `[socket] useSocketConnection("${event}") skipped because SocketClient is null.`
+        );
+      }
+      return;
+    }
+    missingClientWarnedRef.current = false;
+    emitDebug({ type: "subscription", phase: "register", event });
+    if (autoJoin && normalizedRooms.length > 0) {
+      emitDebug({
+        type: "room",
+        phase: "join_attempt",
+        rooms: normalizedRooms
+      });
+      void client.joinRooms(normalizedRooms, args.joinMeta).then(() => {
+        emitDebug({ type: "room", phase: "join_ok", rooms: normalizedRooms });
+      }).catch((error) => {
+        emitDebug({
+          type: "room",
+          phase: "join_error",
+          rooms: normalizedRooms,
+          err: String(error)
+        });
+        reportAsyncError("joinRooms", error);
+      });
+    } else {
+      emitDebug({
+        type: "room",
+        phase: "join_skip",
+        rooms: normalizedRooms,
+        reason: autoJoin ? "no_rooms" : "auto_disabled"
+      });
+    }
     const unsubscribe = client.on(event, (payload, meta) => {
+      emitDebug({ type: "subscription", phase: "message", event });
       onMessage(payload, meta);
     });
     return () => {
+      emitDebug({ type: "subscription", phase: "unregister", event });
       unsubscribe();
-      if (autoLeave && normalizedRooms.length > 0)
-        void client.leaveRooms(normalizedRooms, args.leaveMeta).catch((error) => reportAsyncError("leaveRooms", error));
+      if (autoLeave && normalizedRooms.length > 0) {
+        emitDebug({
+          type: "room",
+          phase: "leave_attempt",
+          rooms: normalizedRooms
+        });
+        void client.leaveRooms(normalizedRooms, args.leaveMeta).then(() => {
+          emitDebug({ type: "room", phase: "leave_ok", rooms: normalizedRooms });
+        }).catch((error) => {
+          emitDebug({
+            type: "room",
+            phase: "leave_error",
+            rooms: normalizedRooms,
+            err: String(error)
+          });
+          reportAsyncError("leaveRooms", error);
+        });
+      } else {
+        emitDebug({
+          type: "room",
+          phase: "leave_skip",
+          rooms: normalizedRooms,
+          reason: autoLeave ? "no_rooms" : "auto_disabled"
+        });
+      }
       if (onCleanup) onCleanup();
+      emitDebug({
+        type: "lifecycle",
+        phase: "effect_cleanup",
+        event,
+        rooms: normalizedRooms,
+        autoJoin,
+        autoLeave
+      });
     };
   }, [
     client,
     event,
     onMessage,
+    onCleanup,
     autoJoin,
     autoLeave,
+    debug,
+    emitDebug,
     reportAsyncError,
-    ...normalizedRooms
+    normalizedRoomsKey,
+    joinMetaKey,
+    leaveMetaKey
   ]);
 }