@emeryld/rrroutes-client 2.7.10 → 2.7.12

package/dist/index.cjs

@@ -1578,10 +1578,10 @@ 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 (!ctx) {
+  if (typeof ctx === "undefined" || !ctx) {
     return null;
   }
   return ctx;
@@ -1596,7 +1596,8 @@ function useSocketConnection(args) {
     onMessage,
     onCleanup,
     autoJoin = true,
-    autoLeave = true
+    autoLeave = true,
+    debug
   } = args;
   const client = useSocketClient();
   const normalizedRooms = React2.useMemo(
@@ -1607,6 +1608,57 @@ function useSocketConnection(args) {
     () => 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 onMessageRef = React2.useRef(onMessage);
+  const onCleanupRef = React2.useRef(onCleanup);
+  const joinMetaRef = React2.useRef(args.joinMeta);
+  const leaveMetaRef = React2.useRef(args.leaveMeta);
+  const debugRef = React2.useRef(debug);
+  React2.useEffect(() => {
+    onMessageRef.current = onMessage;
+  }, [onMessage]);
+  React2.useEffect(() => {
+    onCleanupRef.current = onCleanup;
+  }, [onCleanup]);
+  React2.useEffect(() => {
+    joinMetaRef.current = args.joinMeta;
+  }, [args.joinMeta]);
+  React2.useEffect(() => {
+    leaveMetaRef.current = args.leaveMeta;
+  }, [args.leaveMeta]);
+  React2.useEffect(() => {
+    debugRef.current = debug;
+  }, [debug]);
+  const emitDebug = React2.useCallback(
+    (event2) => {
+      const dbg3 = debugRef.current;
+      if (!dbg3?.enabled) return;
+      if (dbg3[event2.type] === false) return;
+      const logger = dbg3.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);
+      }
+    },
+    []
+  );
   const reportAsyncError = React2.useCallback(
     (phase, error) => {
       if (typeof console !== "undefined" && typeof console.warn === "function") {
@@ -1616,28 +1668,115 @@ 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 (debugRef.current?.throwIfClientMissing) {
+        throw new Error(
+          `useSocketConnection("${event}") missing SocketClient. Wrap with <SocketProvider>.`
+        );
+      }
+      if (debugRef.current?.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, joinMetaRef.current).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) => {
-      onMessage(payload, meta);
+      emitDebug({ type: "subscription", phase: "message", event });
+      onMessageRef.current(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 (onCleanup) onCleanup();
+      if (autoLeave && normalizedRooms.length > 0) {
+        emitDebug({
+          type: "room",
+          phase: "leave_attempt",
+          rooms: normalizedRooms
+        });
+        void client.leaveRooms(normalizedRooms, leaveMetaRef.current).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 (onCleanupRef.current) onCleanupRef.current();
+      emitDebug({
+        type: "lifecycle",
+        phase: "effect_cleanup",
+        event,
+        rooms: normalizedRooms,
+        autoJoin,
+        autoLeave
+      });
     };
   }, [
     client,
     event,
-    onMessage,
-    onCleanup,
     autoJoin,
     autoLeave,
+    emitDebug,
     reportAsyncError,
-    normalizedRooms,
-    normalizedRoomsKey
+    normalizedRoomsKey,
+    joinMetaKey,
+    leaveMetaKey
   ]);
 }