@emeryld/rrroutes-client 2.6.1 → 2.6.3

package/dist/index.cjs

@@ -1593,7 +1593,9 @@ function useSocketConnection(args) {
   React.useEffect(() => {
     if (autoJoin && normalizedRooms.length > 0)
       client.joinRooms(normalizedRooms, args.joinMeta);
-    const unsubscribe = client.on(event, onMessage);
+    const unsubscribe = client.on(event, (payload, meta) => {
+      onMessage(payload, meta);
+    });
     return () => {
       unsubscribe();
       if (autoLeave && normalizedRooms.length > 0)
@@ -1650,6 +1652,16 @@ function arrayShallowEqual(a, b) {
 function roomStateEqual(prev, next) {
   return arrayShallowEqual(prev.rooms, next.rooms) && safeJsonKey(prev.joinMeta) === safeJsonKey(next.joinMeta) && safeJsonKey(prev.leaveMeta) === safeJsonKey(next.leaveMeta);
 }
+function isSameObjectReference(prev, next) {
+  if (prev !== next) return false;
+  if (next == null) return false;
+  const valueType = typeof next;
+  return valueType === "object" || valueType === "function";
+}
+function shouldWarnSocketMutationGuard() {
+  const nodeEnv = globalThis.process?.env?.NODE_ENV;
+  return nodeEnv !== "production";
+}
 function safeDescribeHookValue2(value) {
   if (value == null) return value;
   const valueType = typeof value;
@@ -1930,28 +1942,67 @@ function buildSocketedRoute(options) {
         }
       });
       if (!client) return;
+      const queue = [];
+      const sameRefWarnedEvents = /* @__PURE__ */ new Set();
+      let draining = false;
+      let active = true;
+      const drainQueue = () => {
+        if (!active || draining) return;
+        draining = true;
+        try {
+          while (active && queue.length > 0) {
+            const nextUpdate = queue.shift();
+            if (!nextUpdate) continue;
+            built.setData(
+              (prev) => {
+                const next = nextUpdate.fn(
+                  prev,
+                  nextUpdate.payload,
+                  nextUpdate.meta ? { ...nextUpdate.meta, args: useArgs } : { args: useArgs }
+                );
+                if (next === null) return prev;
+                if (shouldWarnSocketMutationGuard() && isSameObjectReference(prev, next) && !sameRefWarnedEvents.has(nextUpdate.event)) {
+                  sameRefWarnedEvents.add(nextUpdate.event);
+                  console.warn(
+                    `[socketedRoute] applySocket("${nextUpdate.event}") returned the previous reference. Return a new object/array for updates, or return null for no change.`
+                  );
+                }
+                const nextRoomState = roomsFromData(
+                  next,
+                  toRooms
+                );
+                setRoomState(
+                  (prevRoomState) => roomStateEqual(prevRoomState, nextRoomState) ? prevRoomState : nextRoomState
+                );
+                return next;
+              },
+              ...useArgs
+            );
+          }
+        } finally {
+          draining = false;
+          if (active && queue.length > 0) drainQueue();
+        }
+      };
       const entries = Object.entries(applySocket).filter(
         ([_event, fn]) => typeof fn === "function"
       );
       const unsubscribes = entries.map(
         ([ev, fn]) => client.on(ev, (payload, meta) => {
-          built.setData(
-            (prev) => {
-              const next = fn(prev, payload, meta);
-              const nextRoomState = roomsFromData(
-                next,
-                toRooms
-              );
-              setRoomState(
-                (prevRoomState) => roomStateEqual(prevRoomState, nextRoomState) ? prevRoomState : nextRoomState
-              );
-              return next;
-            },
-            ...useArgs
-          );
+          queue.push({
+            event: ev,
+            fn,
+            payload,
+            ...meta ? { meta } : {}
+          });
+          drainQueue();
         })
       );
-      return () => unsubscribes.forEach((u) => u?.());
+      return () => {
+        active = false;
+        queue.length = 0;
+        unsubscribes.forEach((u) => u?.());
+      };
     }, [client, applySocket, built, argsKey, toRooms, debug]);
     return { ...endpointResult, rooms: roomState.rooms };
   };
@@ -2464,9 +2515,9 @@ var SocketClient = class {
       };
     }
     const socket = this.socket;
-    const wrapped = (envelopeOrRaw) => {
-      const maybeEnvelope = envelopeOrRaw;
-      const rawData = maybeEnvelope?.data ?? maybeEnvelope;
+    const toStringList = (value) => Array.isArray(value) ? value.filter((entry2) => typeof entry2 === "string") : [];
+    const wrappedEnv = (envelope) => {
+      const rawData = envelope.data;
       const parsed = schema.safeParse(rawData);
       if (!parsed.success) {
         this.dbg({
@@ -2477,15 +2528,17 @@ var SocketClient = class {
         });
         return;
       }
+      const data = parsed.data;
       const receivedAt = /* @__PURE__ */ new Date();
-      const sentAt = maybeEnvelope?.sentAt ? new Date(maybeEnvelope.sentAt) : void 0;
+      const sentAt = envelope?.sentAt ? new Date(envelope.sentAt) : void 0;
       const meta = {
         envelope: {
-          eventName: maybeEnvelope?.eventName ?? event,
-          sentAt: maybeEnvelope?.sentAt ?? receivedAt.toISOString(),
-          sentTo: maybeEnvelope?.sentTo ?? [],
-          data: void 0,
-          metadata: maybeEnvelope?.metadata
+          eventName: typeof envelope?.eventName === "string" ? envelope.eventName : event,
+          sentAt: envelope?.sentAt ?? receivedAt.toISOString(),
+          sentTo: toStringList(envelope?.sentTo),
+          data,
+          metadata: envelope?.metadata,
+          rooms: toStringList(envelope?.rooms)
         },
         ctx: {
           receivedAt,
@@ -2505,22 +2558,38 @@ var SocketClient = class {
           metadata: meta.envelope.metadata
         } : void 0
       });
-      handler(parsed.data, meta);
+      handler(data, meta);
+    };
+    const wrappedDispatcher = (envelopeOrRaw) => {
+      if (typeof envelopeOrRaw === "object" && envelopeOrRaw !== null && "eventName" in envelopeOrRaw && "sentAt" in envelopeOrRaw && "sentTo" in envelopeOrRaw && "data" in envelopeOrRaw) {
+        wrappedEnv(envelopeOrRaw);
+      } else {
+        this.dbg({
+          type: "receive",
+          event,
+          envelope: void 0
+        });
+        handler(envelopeOrRaw, void 0);
+      }
     };
     const errorWrapped = (e) => {
       this.dbg({ type: "receive", event, err: String(e) });
     };
-    socket.on(String(event), wrapped);
+    socket.on(String(event), wrappedDispatcher);
     socket.on(`${String(event)}:error`, errorWrapped);
     let set = this.handlerMap.get(String(event));
     if (!set) {
       set = /* @__PURE__ */ new Set();
       this.handlerMap.set(String(event), set);
     }
-    const entry = { orig: handler, wrapped, errorWrapped };
+    const entry = {
+      orig: handler,
+      wrapped: wrappedDispatcher,
+      errorWrapped
+    };
     set.add(entry);
     return () => {
-      socket.off(String(event), wrapped);
+      socket.off(String(event), wrappedDispatcher);
       socket.off(`${String(event)}:error`, errorWrapped);
       const s = this.handlerMap.get(String(event));
       if (s) {