@emeryld/rrroutes-client 2.1.0 → 2.1.2

package/dist/index.cjs

@@ -35,7 +35,9 @@ __export(index_exports, {
   buildRoomPayloadSchema: () => buildRoomPayloadSchema,
   buildSocketProvider: () => buildSocketProvider,
   createRouteClient: () => createRouteClient,
-  defaultFetcher: () => defaultFetcher
+  defaultFetcher: () => defaultFetcher,
+  useSocketClient: () => useSocketClient,
+  useSocketConnection: () => useSocketConnection
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -473,7 +475,6 @@ var buildRoomPayloadSchema = (metaSchema) => import_zod.z.object({
 
 // src/sockets/socket.client.context.tsx
 var React = __toESM(require("react"), 1);
-var import_socket = require("socket.io-client");
 var import_jsx_runtime = require("react/jsx-runtime");
 var SocketCtx = React.createContext(null);
 function dbg(dbgOpts, e) {
@@ -481,16 +482,31 @@ function dbg(dbgOpts, e) {
   if (!dbgOpts[e.type]) return;
   dbgOpts.logger(e);
 }
+function isProbablySocket(value) {
+  if (!value || typeof value !== "object") return false;
+  const anyVal = value;
+  const ctorName = anyVal.constructor?.name;
+  if (ctorName === "Socket") return true;
+  return ("connected" in anyVal || "recovered" in anyVal) && typeof anyVal.on === "function" && typeof anyVal.emit === "function";
+}
+function describeSocketLike(value) {
+  if (!value) return null;
+  const id = value.id ?? "unknown";
+  const connected = value.connected ?? false;
+  const recovered = typeof value.recovered === "boolean" ? ` recovered=${value.recovered}` : "";
+  return `[Socket id=${id} connected=${connected}${recovered}]`;
+}
 function safeDescribeHookValue(value) {
   if (value == null) return value;
   const valueType = typeof value;
-  if (valueType === "string" || valueType === "number" || valueType === "boolean") return value;
+  if (valueType === "string" || valueType === "number" || valueType === "boolean") {
+    return value;
+  }
   if (valueType === "bigint" || valueType === "symbol") return String(value);
   if (valueType === "function") return `[function ${value.name || "anonymous"}]`;
   if (Array.isArray(value)) return `[array length=${value.length}]`;
-  if (value instanceof import_socket.Socket) {
-    const socket = value;
-    return `[Socket id=${socket.id ?? "unknown"} connected=${socket.connected ?? false}]`;
+  if (isProbablySocket(value)) {
+    return describeSocketLike(value);
   }
   const ctorName = value.constructor?.name ?? "object";
   const keys = Object.keys(value);
@@ -498,20 +514,56 @@ function safeDescribeHookValue(value) {
   const suffix = keys.length > 4 ? ",\u2026" : "";
   return `[${ctorName} keys=${keyPreview}${suffix}]`;
 }
+function summarizeEvents(events) {
+  if (!events || typeof events !== "object") return safeDescribeHookValue(events);
+  const keys = Object.keys(events);
+  if (!keys.length) return "[events empty]";
+  const preview = keys.slice(0, 4).join(",");
+  const suffix = keys.length > 4 ? ",\u2026" : "";
+  return `[events count=${keys.length} keys=${preview}${suffix}]`;
+}
+function summarizeBaseOptions(options) {
+  if (!options || typeof options !== "object") return safeDescribeHookValue(options);
+  const obj = options;
+  const keys = Object.keys(obj);
+  if (!keys.length) return "[baseOptions empty]";
+  const preview = keys.slice(0, 4).join(",");
+  const suffix = keys.length > 4 ? ",\u2026" : "";
+  const hasDebug = "debug" in obj;
+  return `[baseOptions keys=${preview}${suffix} debug=${hasDebug}]`;
+}
+function summarizeMeta(meta, label) {
+  if (meta == null) return null;
+  if (typeof meta !== "object") return safeDescribeHookValue(meta);
+  const keys = Object.keys(meta);
+  if (!keys.length) return `[${label} empty]`;
+  const preview = keys.slice(0, 4).join(",");
+  const suffix = keys.length > 4 ? ",\u2026" : "";
+  return `[${label} keys=${preview}${suffix}]`;
+}
 function createHookDebugEvent(prev, next, hook) {
   const reason = prev ? "change" : "init";
   const changed = Object.keys(next).reduce((acc, dependency) => {
     const prevValue = prev ? prev[dependency] : void 0;
     const nextValue = next[dependency];
     if (!prev || !Object.is(prevValue, nextValue)) {
-      acc.push({ dependency, previous: safeDescribeHookValue(prevValue), next: safeDescribeHookValue(nextValue) });
+      acc.push({
+        dependency,
+        previous: safeDescribeHookValue(prevValue),
+        next: safeDescribeHookValue(nextValue)
+      });
     }
     return acc;
   }, []);
   if (!changed.length) return null;
   return { type: "hook", hook, reason, changes: changed };
 }
-function trackHookTrigger({ ref, hook, providerDebug, snapshot }) {
+function trackHookTrigger({
+  ref,
+  hook,
+  providerDebug,
+  snapshot
+}) {
   const prev = ref.current;
   ref.current = snapshot;
   if (!providerDebug?.logger || !providerDebug?.hook) return;
@@ -526,6 +578,7 @@ function buildSocketProvider(args) {
       {
         events,
         baseOptions,
+        providerDebug: baseOptions.debug,
         ...props
       }
     ),
@@ -547,7 +600,9 @@ function SocketProvider(props) {
       ref: resolveEffectDebugRef,
       hook: "resolve_effect",
       providerDebug: providerDebugRef.current,
-      snapshot: { resolvedSocket }
+      snapshot: {
+        resolvedSocket: describeSocketLike(resolvedSocket)
+      }
     });
     if (!("getSocket" in props)) return;
     let cancelled = false;
@@ -559,7 +614,7 @@ function SocketProvider(props) {
           return;
         }
         if (!s) {
-          dbg(providerDebugRef.current, { type: "resolve", phase: "missing" });
+          dbg(providerDebugRef.current, { type: "resolve", phase: "socketMissing" });
           return;
         }
         setResolvedSocket(s);
@@ -577,7 +632,11 @@ function SocketProvider(props) {
     ref: clientMemoDebugRef,
     hook: "client_memo",
     providerDebug: providerDebugRef.current,
-    snapshot: { events, baseOptions, socket }
+    snapshot: {
+      events: summarizeEvents(events),
+      baseOptions: summarizeBaseOptions(baseOptions),
+      socket: describeSocketLike(socket)
+    }
   });
   const client = React.useMemo(() => {
     if (!socket) {
@@ -593,7 +652,10 @@ function SocketProvider(props) {
       ref: destroyEffectDebugRef,
       hook: "destroy_effect",
       providerDebug: providerDebugRef.current,
-      snapshot: { client, destroyLeaveMeta }
+      snapshot: {
+        hasClient: !!client,
+        destroyLeaveMeta: summarizeMeta(destroyLeaveMeta, "destroyLeaveMeta")
+      }
     });
     return () => {
       if (client) {
@@ -658,23 +720,20 @@ var SocketClient = class {
       this.dbg({
         type: "lifecycle",
         phase: "init",
-        socketId: this.socket.id,
-        details: {
-          heartbeatIntervalMs: this.hb.intervalMs,
-          heartbeatTimeoutMs: this.hb.timeoutMs,
-          environment: this.environment
-        }
+        heartbeatIntervalMs: this.hb.intervalMs,
+        heartbeatTimeoutMs: this.hb.timeoutMs,
+        environment: this.environment
       });
       this.logSocketConfigSnapshot("constructor");
     }
     this.onConnect = () => {
       if (!this.socket) {
-        this.dbg({ type: "connection", phase: "connect", err: "Socket is null" });
+        this.dbg({ type: "connection", phase: "connect_event", err: "Socket is null" });
         throw new Error("Socket is null in onConnect handler");
       }
       this.dbg({
         type: "connection",
-        phase: "connect",
+        phase: "connect_event",
         id: this.socket.id,
         details: {
           nsp: this.getNamespace(this.socket)
@@ -688,12 +747,12 @@ var SocketClient = class {
     };
     this.onReconnect = (attempt) => {
       if (!this.socket) {
-        this.dbg({ type: "connection", phase: "reconnect", err: "Socket is null" });
+        this.dbg({ type: "connection", phase: "reconnect_event", err: "Socket is null" });
         throw new Error("Socket is null in onReconnect handler");
       }
       this.dbg({
         type: "connection",
-        phase: "reconnect",
+        phase: "reconnect_event",
         attempt,
         id: this.socket.id,
         details: {
@@ -709,12 +768,12 @@ var SocketClient = class {
     };
     this.onDisconnect = (reason) => {
       if (!this.socket) {
-        this.dbg({ type: "connection", phase: "disconnect", err: "Socket is null" });
+        this.dbg({ type: "connection", phase: "disconnect_event", err: "Socket is null" });
         throw new Error("Socket is null in onDisconnect handler");
       }
       this.dbg({
         type: "connection",
-        phase: "disconnect",
+        phase: "disconnect_event",
         reason: String(reason),
         details: {
           roomsTracked: this.roomCounts.size
@@ -729,12 +788,12 @@ var SocketClient = class {
     };
     this.onConnectError = (err) => {
       if (!this.socket) {
-        this.dbg({ type: "connection", phase: "connect_error", err: "Socket is null" });
+        this.dbg({ type: "connection", phase: "connect_error_event", err: "Socket is null" });
         throw new Error("Socket is null in onConnectError handler");
       }
       this.dbg({
         type: "connection",
-        phase: "connect_error",
+        phase: "connect_error_event",
         err: String(err),
         details: this.getVerboseDetails({ rawError: err })
       });
@@ -883,7 +942,7 @@ var SocketClient = class {
    * call it yourself from any sysHandler to change when heartbeats start.
    */
   startHeartbeat() {
-    this.stopHeartbeat();
+    this.stopHeartbeat("stop_before_start");
     if (!this.socket) {
       this.dbg({
         type: "heartbeat",
@@ -944,7 +1003,7 @@ var SocketClient = class {
    * This is called by the default 'sys:disconnect' handler, but you can also
    * call it yourself from any sysHandler to fully control heartbeat lifecycle.
    */
-  stopHeartbeat() {
+  stopHeartbeat(reason) {
     const hadTimer = Boolean(this.hbTimer);
     if (this.hbTimer) {
       clearInterval(this.hbTimer);
@@ -953,9 +1012,8 @@ var SocketClient = class {
     this.dbg({
       type: "heartbeat",
       phase: "stop",
-      details: {
-        hadTimer
-      }
+      reason,
+      hadTimer
     });
   }
   emit(event, payload, metadata) {
@@ -1149,7 +1207,7 @@ var SocketClient = class {
    * Call when disposing the client instance.
    */
   destroy(leaveMeta) {
-    this.stopHeartbeat();
+    this.stopHeartbeat("destroy");
     const socket = this.socket;
     this.dbg({
       type: "lifecycle",
@@ -1200,7 +1258,7 @@ var SocketClient = class {
       });
       return;
     }
-    this.stopHeartbeat();
+    this.stopHeartbeat("disconnect");
     this.socket.disconnect();
     this.dbg({
       type: "connection",
@@ -1239,6 +1297,8 @@ var SocketClient = class {
   buildRoomPayloadSchema,
   buildSocketProvider,
   createRouteClient,
-  defaultFetcher
+  defaultFetcher,
+  useSocketClient,
+  useSocketConnection
 });
 //# sourceMappingURL=index.cjs.map