@emeryld/rrroutes-client 2.2.4 → 2.2.6

package/dist/index.cjs

@@ -690,63 +690,237 @@ var import_react = require("react");
 function createSocketedRouteHook(args) {
   const { buildRoute, useClient = () => useSocketClient() } = args;
   return function useSocketedRoute(params) {
-    const { routeKey, socketEvent, handlers, buildOptions, buildMeta, useOptions } = params;
+    const { routeKey, socketEvent, handlers, buildOptions, buildMeta, debug, useOptions } = params;
+    const renderRef = (0, import_react.useRef)(0);
+    const prevInputsRef = (0, import_react.useRef)();
+    const debugName = buildMeta?.name;
+    const render = ++renderRef.current;
+    const renderChanged = [];
+    const prevInputs = prevInputsRef.current;
+    if (prevInputs) {
+      if (!Object.is(prevInputs.routeKey, routeKey)) renderChanged.push("routeKey");
+      if (!Object.is(prevInputs.socketEvent, socketEvent)) renderChanged.push("socketEvent");
+      if (!Object.is(prevInputs.buildOptions, buildOptions)) renderChanged.push("buildOptions");
+      if (!Object.is(prevInputs.buildMeta, buildMeta)) renderChanged.push("buildMeta");
+      if (!Object.is(prevInputs.debug, debug)) renderChanged.push("debug");
+      if (!Object.is(prevInputs.args, useOptions?.args)) renderChanged.push("args");
+      if (!Object.is(prevInputs.options, useOptions?.options)) renderChanged.push("options");
+    }
+    prevInputsRef.current = {
+      routeKey,
+      socketEvent,
+      buildOptions,
+      buildMeta,
+      debug,
+      args: useOptions?.args,
+      options: useOptions?.options
+    };
+    const debugRef = (0, import_react.useRef)(debug);
+    (0, import_react.useEffect)(() => {
+      debugRef.current = debug;
+    }, [debug]);
+    const emitDebug = (0, import_react.useCallback)(
+      (event) => {
+        const d = debugRef.current;
+        if (!d?.logger) return;
+        if (!d[event.type]) return;
+        const name = event.name ?? debugName;
+        if (d.only && name && !d.only.includes(name)) return;
+        d.logger({ ...event, name });
+      },
+      [debugName]
+    );
+    const verboseRef = (0, import_react.useRef)(!!debug?.verbose);
+    (0, import_react.useEffect)(() => {
+      verboseRef.current = !!debug?.verbose;
+    }, [debug]);
+    const handlersRef = (0, import_react.useRef)(handlers);
+    (0, import_react.useEffect)(() => {
+      handlersRef.current = handlers;
+    }, [handlers]);
     const endpoint = (0, import_react.useMemo)(
       () => buildRoute(routeKey, buildOptions, buildMeta),
       [buildRoute, routeKey, buildOptions, buildMeta]
     );
+    (0, import_react.useEffect)(() => {
+      emitDebug({
+        type: "build",
+        routeKey,
+        socketEvent,
+        options: verboseRef.current ? { buildOptions, buildMeta, useOptions } : void 0
+      });
+    }, [emitDebug, routeKey, socketEvent, buildOptions, buildMeta, useOptions]);
     const client = useClient();
     const [rooms, setRooms] = (0, import_react.useState)([]);
     const roomsKey = rooms.slice().sort().join("|");
+    const roomsRef = (0, import_react.useRef)([]);
+    roomsRef.current = rooms;
+    const prevRoomsKeyRef = (0, import_react.useRef)(roomsKey);
+    const prevClientRef = (0, import_react.useRef)(client);
+    const prevRouteKeyRef = (0, import_react.useRef)(routeKey);
+    const prevSocketEventRef = (0, import_react.useRef)(socketEvent);
+    const prevSubscribeDepsRef = (0, import_react.useRef)({
+      client,
+      socketEvent,
+      routeArgs: useOptions?.args,
+      routeKey
+    });
+    (0, import_react.useEffect)(() => {
+      emitDebug({
+        type: "render",
+        render,
+        routeKey,
+        socketEvent,
+        changed: renderChanged,
+        rooms: verboseRef.current ? roomsRef.current : void 0
+      });
+    }, [emitDebug, render, routeKey, socketEvent]);
     const applyRooms = (0, import_react.useCallback)(
-      (page) => {
-        if (!handlers.onReceiveRooms) return;
+      (page, source) => {
+        const onReceiveRooms = handlersRef.current.onReceiveRooms;
+        if (!onReceiveRooms) return;
         setRooms((prev) => {
-          const next = handlers.onReceiveRooms(page, prev);
-          return Array.from(new Set(next.filter(Boolean)));
+          const next = onReceiveRooms(page, prev);
+          const unique = Array.from(new Set(next.filter(Boolean)));
+          if (prev.length === unique.length && prev.every((room, idx) => room === unique[idx])) {
+            emitDebug({
+              type: "rooms",
+              phase: "derive",
+              routeKey,
+              socketEvent,
+              rooms: unique,
+              prev,
+              reason: "unchanged",
+              meta: verboseRef.current ? { page, source } : void 0,
+              source
+            });
+            return prev;
+          }
+          emitDebug({
+            type: "rooms",
+            phase: "derive",
+            routeKey,
+            socketEvent,
+            rooms: unique,
+            prev,
+            meta: verboseRef.current ? { page, source } : void 0,
+            source
+          });
+          return unique;
         });
       },
-      [handlers]
+      [emitDebug, routeKey, socketEvent]
     );
     const routeArgs = useOptions?.args;
     const callerOptions = useOptions?.options;
-    const mergedOptions = {
-      ...callerOptions ?? {},
-      onReceive(page) {
-        callerOptions?.onReceive?.(page);
-        applyRooms(page);
-      }
-    };
+    const mergedOptions = (0, import_react.useMemo)(
+      () => ({
+        ...callerOptions ?? {},
+        onReceive(page) {
+          callerOptions?.onReceive?.(page);
+          applyRooms(page, "onReceive");
+          emitDebug({
+            type: "onReceive",
+            routeKey,
+            socketEvent,
+            page: verboseRef.current ? page : void 0,
+            rooms: verboseRef.current ? roomsRef.current : void 0
+          });
+        }
+      }),
+      [callerOptions, applyRooms, emitDebug, routeKey, socketEvent]
+    );
     const endpointArgs = routeArgs ? [routeArgs, mergedOptions] : [mergedOptions];
     const { data } = endpoint.useEndpoint(...endpointArgs);
     (0, import_react.useEffect)(() => {
       if (!data) return;
       const pages = data?.pages;
       if (Array.isArray(pages)) {
-        pages.forEach(applyRooms);
+        pages.forEach((p) => applyRooms(p, "hydrate"));
         return;
       }
-      applyRooms(data);
+      applyRooms(data, "hydrate");
     }, [data, applyRooms]);
     (0, import_react.useEffect)(() => {
+      const prev = prevSubscribeDepsRef.current;
+      const changedDeps = [];
+      if (prev.client !== client) changedDeps.push("client");
+      if (prev.socketEvent !== socketEvent) changedDeps.push("socketEvent");
+      if (!Object.is(prev.routeArgs, routeArgs)) changedDeps.push("args");
+      if (prev.routeKey !== routeKey) changedDeps.push("routeKey");
+      prevSubscribeDepsRef.current = { client, socketEvent, routeArgs, routeKey };
+      emitDebug({
+        type: "effect",
+        effect: "subscribe",
+        phase: "run",
+        changedDeps: changedDeps.length ? changedDeps : void 0
+      });
       const stop = client.on(socketEvent, (payload, meta) => {
-        const updater = (prev) => handlers.handleMessage(prev, payload, meta);
+        const updater = (prev2) => handlersRef.current.handleMessage(prev2, payload, meta);
         const setDataArgs = routeArgs ? [routeArgs] : [];
         endpoint.setData(updater, ...setDataArgs);
+        emitDebug({
+          type: "receive",
+          routeKey,
+          socketEvent,
+          payload: verboseRef.current ? payload : void 0,
+          envelope: verboseRef.current ? {
+            eventName: meta.envelope.eventName,
+            sentAt: meta.envelope.sentAt,
+            sentTo: meta.envelope.sentTo,
+            metadata: meta.envelope.metadata
+          } : void 0
+        });
+        emitDebug({
+          type: "setData",
+          routeKey,
+          socketEvent,
+          args: verboseRef.current ? routeArgs : void 0
+        });
       });
-      return stop;
-    }, [client, socketEvent, endpoint, handlers]);
+      emitDebug({ type: "subscribe", phase: "start", routeKey, socketEvent });
+      return () => {
+        emitDebug({ type: "subscribe", phase: "stop", routeKey, socketEvent });
+        stop();
+        emitDebug({ type: "effect", effect: "subscribe", phase: "cleanup" });
+      };
+    }, [client, socketEvent, endpoint, routeArgs, emitDebug, routeKey]);
     (0, import_react.useEffect)(() => {
       let cancelled = false;
+      const { joinMeta, leaveMeta } = handlersRef.current;
+      const changedDeps = [];
+      if (prevRoomsKeyRef.current !== roomsKey) changedDeps.push("rooms");
+      if (prevClientRef.current !== client) changedDeps.push("client");
+      if (prevRouteKeyRef.current !== routeKey) changedDeps.push("routeKey");
+      if (prevSocketEventRef.current !== socketEvent) changedDeps.push("socketEvent");
+      prevRoomsKeyRef.current = roomsKey;
+      prevClientRef.current = client;
+      prevRouteKeyRef.current = routeKey;
+      prevSocketEventRef.current = socketEvent;
+      emitDebug({
+        type: "effect",
+        effect: "rooms",
+        phase: "run",
+        changedDeps: changedDeps.length ? changedDeps : void 0,
+        rooms
+      });
       (async () => {
         if (!rooms.length) return;
+        emitDebug({
+          type: "rooms",
+          phase: "join",
+          routeKey,
+          socketEvent,
+          rooms,
+          meta: verboseRef.current ? joinMeta : void 0
+        });
         try {
-          await client.joinRooms(rooms, handlers.joinMeta);
+          await client.joinRooms(rooms, joinMeta);
         } catch {
         }
         if (cancelled) {
           try {
-            await client.leaveRooms(rooms, handlers.leaveMeta);
+            await client.leaveRooms(rooms, leaveMeta);
           } catch {
           }
         }
@@ -754,10 +928,24 @@ function createSocketedRouteHook(args) {
       return () => {
         cancelled = true;
         if (!rooms.length) return;
-        client.leaveRooms(rooms, handlers.leaveMeta).catch(() => {
+        client.leaveRooms(rooms, leaveMeta).catch(() => {
+        });
+        emitDebug({
+          type: "rooms",
+          phase: "leave",
+          routeKey,
+          socketEvent,
+          rooms,
+          meta: verboseRef.current ? leaveMeta : void 0
+        });
+        emitDebug({
+          type: "effect",
+          effect: "rooms",
+          phase: "cleanup",
+          rooms
         });
       };
-    }, [client, roomsKey, handlers.joinMeta, handlers.leaveMeta, rooms]);
+    }, [client, roomsKey, rooms, emitDebug, routeKey, socketEvent]);
     return { data, rooms };
   };
 }