@rozenite/network-activity-plugin 1.7.0 → 1.8.1

package/dist/devtools/assets/{App-BrSkOkws.css → App-m6xge0az.css}

@@ -1023,6 +1023,10 @@ video {
 .p-\[1px\] {
   padding: 1px;
 }
+.px-1\.5 {
+  padding-left: 0.375rem;
+  padding-right: 0.375rem;
+}
 .px-2 {
   padding-left: 0.5rem;
   padding-right: 0.5rem;
@@ -1077,6 +1081,9 @@ video {
 .font-mono {
   font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
 }
+.text-\[10px\] {
+  font-size: 10px;
+}
 .text-base {
   font-size: 1rem;
   line-height: 1.5rem;
@@ -1099,12 +1106,18 @@ video {
 .font-semibold {
   font-weight: 600;
 }
+.uppercase {
+  text-transform: uppercase;
+}
 .capitalize {
   text-transform: capitalize;
 }
 .italic {
   font-style: italic;
 }
+.tracking-wide {
+  letter-spacing: 0.025em;
+}
 .tracking-widest {
   letter-spacing: 0.1em;
 }

package/dist/react-native/chunks/boot-recording.cjs

@@ -206,7 +206,7 @@ function getContentTypeMime(headers) {
   const actualValue = Array.isArray(value) ? value[0] : value;
   return actualValue.split(";")[0].trim();
 }
-const getContentType = (request) => {
+const getContentType$1 = (request) => {
   const responseHeaders = request.responseHeaders;
   const responseType = request.responseType;
   const contentType = getContentTypeMime(responseHeaders || {});
@@ -366,7 +366,7 @@ const setupRequestOverride = (overridesRegistry, request) => {
       Object.defineProperty(request, "responseType", { writable: true });
       Object.defineProperty(request, "response", { writable: true });
       Object.defineProperty(request, "responseText", { writable: true });
-      const contentType = getContentType(request);
+      const contentType = getContentType$1(request);
       if (contentType === "application/json") {
         request.responseType = "json";
       } else if (contentType === "text/plain") {
@@ -459,7 +459,8 @@ const getHTTPInspector = () => {
             postData: getRequestBody(data)
           },
           type: "XHR",
-          initiator
+          initiator,
+          source: "builtin"
         });
         request.addEventListener("readystatechange", () => {
           if (request.readyState === READY_STATE_HEADERS_RECEIVED) {
@@ -472,7 +473,8 @@ const getHTTPInspector = () => {
             timestamp: Date.now(),
             loaded: event.loaded,
             total: event.total,
-            lengthComputable: event.lengthComputable
+            lengthComputable: event.lengthComputable,
+            source: "builtin"
           });
         });
         request.addEventListener("load", () => {
@@ -487,10 +489,11 @@ const getHTTPInspector = () => {
               headers: applyReactNativeResponseHeadersLogic(
                 request.responseHeaders || {}
               ),
-              contentType: getContentType(request),
+              contentType: getContentType$1(request),
               size: getResponseSize(request),
               responseTime: Date.now()
-            }
+            },
+            source: "builtin"
           });
         });
         request.addEventListener("loadend", () => {
@@ -499,7 +502,8 @@ const getHTTPInspector = () => {
             timestamp: Date.now(),
             duration: Date.now() - sendTime,
             size: getResponseSize(request),
-            ttfb
+            ttfb,
+            source: "builtin"
           });
         });
         request.addEventListener("error", () => {
@@ -508,7 +512,8 @@ const getHTTPInspector = () => {
             timestamp: Date.now(),
             type: "XHR",
             error: "Failed",
-            canceled: false
+            canceled: false,
+            source: "builtin"
           });
         });
         request.addEventListener("abort", () => {
@@ -517,7 +522,8 @@ const getHTTPInspector = () => {
             timestamp: Date.now(),
             type: "XHR",
             error: "Aborted",
-            canceled: true
+            canceled: true,
+            source: "builtin"
           });
         });
         request.addEventListener("timeout", () => {
@@ -526,7 +532,8 @@ const getHTTPInspector = () => {
             timestamp: Date.now(),
             type: "XHR",
             error: "Timeout",
-            canceled: false
+            canceled: false,
+            source: "builtin"
           });
         });
       });
@@ -583,10 +590,10 @@ const WEBSOCKET_EVENTS = [
 const isWebSocketEvent = (type) => {
   return WEBSOCKET_EVENTS.includes(type);
 };
-const getWebSocketInspector = () => {
+const toSocketId = (socketId) => String(socketId);
+const createWebSocketInspector = (webSocketInterceptor = getWebSocketInterceptor()) => {
   const eventEmitter = nanoevents.createNanoEvents();
   const socketUrlMap = /* @__PURE__ */ new Map();
-  const webSocketInterceptor = getWebSocketInterceptor();
   return {
     enable: () => {
       webSocketInterceptor.setConnectCallback(
@@ -595,10 +602,11 @@ const getWebSocketInspector = () => {
           const event = {
             type: "websocket-connect",
             url,
-            socketId,
+            socketId: toSocketId(socketId),
             timestamp: Date.now(),
             protocols,
-            options
+            options,
+            source: "builtin"
           };
           eventEmitter.emit("websocket-connect", event);
         }
@@ -612,10 +620,11 @@ const getWebSocketInspector = () => {
           const event = {
             type: "websocket-close",
             url,
-            socketId,
+            socketId: toSocketId(socketId),
             timestamp: Date.now(),
             code: code || 0,
-            reason: reason || void 0
+            reason: reason || void 0,
+            source: "builtin"
           };
           eventEmitter.emit("websocket-close", event);
           socketUrlMap.delete(socketId);
@@ -630,10 +639,11 @@ const getWebSocketInspector = () => {
           const event = {
             type: "websocket-message-received",
             url,
-            socketId,
+            socketId: toSocketId(socketId),
             timestamp: Date.now(),
             data,
-            messageType: typeof data === "string" ? "text" : "binary"
+            messageType: typeof data === "string" ? "text" : "binary",
+            source: "builtin"
           };
           eventEmitter.emit("websocket-message-received", event);
         }
@@ -647,9 +657,10 @@ const getWebSocketInspector = () => {
           const event = {
             type: "websocket-error",
             url,
-            socketId,
+            socketId: toSocketId(socketId),
             timestamp: Date.now(),
-            error
+            error,
+            source: "builtin"
           };
           eventEmitter.emit("websocket-error", event);
         }
@@ -662,10 +673,11 @@ const getWebSocketInspector = () => {
         const event = {
           type: "websocket-message-sent",
           url,
-          socketId,
+          socketId: toSocketId(socketId),
           timestamp: Date.now(),
           data,
-          messageType: typeof data === "string" ? "text" : "binary"
+          messageType: typeof data === "string" ? "text" : "binary",
+          source: "builtin"
         };
         eventEmitter.emit("websocket-message-sent", event);
       });
@@ -677,8 +689,9 @@ const getWebSocketInspector = () => {
         const event = {
           type: "websocket-open",
           url,
-          socketId,
-          timestamp: Date.now()
+          socketId: toSocketId(socketId),
+          timestamp: Date.now(),
+          source: "builtin"
         };
         eventEmitter.emit("websocket-open", event);
       });
@@ -691,10 +704,11 @@ const getWebSocketInspector = () => {
           const event = {
             type: "websocket-close",
             url,
-            socketId,
+            socketId: toSocketId(socketId),
             timestamp: Date.now(),
             code: error.code,
-            reason: error.reason
+            reason: error.reason,
+            source: "builtin"
           };
           eventEmitter.emit("websocket-close", event);
           socketUrlMap.delete(socketId);
@@ -713,6 +727,9 @@ const getWebSocketInspector = () => {
     on: (event, callback) => eventEmitter.on(event, callback)
   };
 };
+const getWebSocketInspector = () => {
+  return createWebSocketInspector();
+};
 let connectCallback;
 let messageCallback;
 let errorCallback;
@@ -846,7 +863,7 @@ const getSSEInspector = () => {
             status: sseXhr.status,
             statusText: sseXhr.statusText,
             headers: sseXhr.responseHeaders || {},
-            contentType: getContentType(sseXhr),
+            contentType: getContentType$1(sseXhr),
             size: 0,
             responseTime: Date.now()
           }
@@ -935,6 +952,7 @@ class EventsListener {
   constructor() {
     this.messageQueue = [];
     this.sendFunction = null;
+    this.filterFunction = null;
     this.maxQueueSize = 200;
     this.isQueuing = false;
   }
@@ -952,6 +970,7 @@ class EventsListener {
    */
   connect(sendFn, filterFn) {
     this.sendFunction = sendFn;
+    this.filterFunction = filterFn ?? null;
     this.isQueuing = false;
     this.flushQueue(filterFn);
   }
@@ -965,6 +984,9 @@ class EventsListener {
     if (this.isQueuing) {
       this.enqueueMessage({ type, data });
     } else if (this.sendFunction) {
+      if (this.filterFunction && !this.filterFunction({ type, data })) {
+        return;
+      }
       this.sendFunction(type, data);
     }
   }
@@ -992,14 +1014,257 @@ class EventsListener {
 const createEventsListener = () => {
   return new EventsListener();
 };
+const NITRO_NETWORK_EVENTS = [
+  "request-sent",
+  "response-received",
+  "request-completed",
+  "request-failed",
+  "websocket-connect",
+  "websocket-open",
+  "websocket-close",
+  "websocket-message-sent",
+  "websocket-message-received",
+  "websocket-error"
+];
+const loadNitroModule = () => {
+  try {
+    return require("react-native-nitro-fetch");
+  } catch {
+    return null;
+  }
+};
+const timestampOrigin = typeof performance !== "undefined" && typeof performance.timeOrigin === "number" ? performance.timeOrigin : Date.now() - performance.now();
+const toEpochTime = (timestamp) => Math.round(timestampOrigin + timestamp);
+const toHeaders = (headers) => {
+  return headers.reduce((acc, { key, value }) => {
+    const existing = acc[key];
+    if (existing === void 0) {
+      acc[key] = value;
+      return acc;
+    }
+    acc[key] = Array.isArray(existing) ? [...existing, value] : [existing, value];
+    return acc;
+  }, {});
+};
+const toPostData = (body) => {
+  if (body == null) {
+    return void 0;
+  }
+  return {
+    type: "text",
+    value: body
+  };
+};
+const cloneEntry = (entry) => {
+  return JSON.parse(JSON.stringify(entry));
+};
+const getContentType = (headers) => {
+  return headers.find((header) => header.key.toLowerCase() === "content-type")?.value ?? "text/plain";
+};
+const normalizeReadyState = (readyState) => readyState.toUpperCase();
+const createNitroNetworkInspector = (getNitroModule = loadNitroModule) => {
+  const eventEmitter = nanoevents.createNanoEvents();
+  const previousEntries = /* @__PURE__ */ new Map();
+  const responseBodies = /* @__PURE__ */ new Map();
+  let nitroModule = null;
+  let unsubscribe = null;
+  const emitHttpEvents = (entry, previous) => {
+    if (!previous) {
+      eventEmitter.emit("request-sent", {
+        requestId: entry.id,
+        timestamp: toEpochTime(entry.startTime),
+        request: {
+          url: entry.url,
+          method: entry.method,
+          headers: toHeaders(entry.requestHeaders),
+          postData: toPostData(entry.requestBody)
+        },
+        initiator: { type: "other" },
+        type: "Fetch",
+        source: "nitro"
+      });
+    }
+    if (entry.error) {
+      if (!previous || previous.error !== entry.error) {
+        eventEmitter.emit("request-failed", {
+          requestId: entry.id,
+          timestamp: toEpochTime(entry.endTime || entry.startTime),
+          type: "Fetch",
+          error: entry.error,
+          canceled: entry.error === "Request canceled",
+          source: "nitro"
+        });
+      }
+      return;
+    }
+    const didResponseChange = !previous || previous.status !== entry.status || previous.statusText !== entry.statusText || previous.responseBodySize !== entry.responseBodySize || previous.endTime !== entry.endTime;
+    if (!didResponseChange) {
+      return;
+    }
+    const responseTimestamp = toEpochTime(entry.endTime || entry.startTime);
+    eventEmitter.emit("response-received", {
+      requestId: entry.id,
+      timestamp: responseTimestamp,
+      type: "Fetch",
+      response: {
+        url: entry.url,
+        status: entry.status,
+        statusText: entry.statusText,
+        headers: toHeaders(entry.responseHeaders),
+        contentType: getContentType(entry.responseHeaders),
+        size: entry.responseBodySize,
+        responseTime: responseTimestamp
+      },
+      source: "nitro"
+    });
+    eventEmitter.emit("request-completed", {
+      requestId: entry.id,
+      timestamp: responseTimestamp,
+      duration: entry.duration,
+      size: entry.responseBodySize,
+      ttfb: entry.duration,
+      source: "nitro"
+    });
+  };
+  const emitWebSocketEvents = (entry, previous) => {
+    const socketId = entry.id;
+    const readyState = normalizeReadyState(entry.readyState);
+    const previousReadyState = previous ? normalizeReadyState(previous.readyState) : null;
+    if (!previous) {
+      eventEmitter.emit("websocket-connect", {
+        type: "websocket-connect",
+        url: entry.url,
+        socketId,
+        timestamp: toEpochTime(entry.startTime),
+        protocols: entry.protocols,
+        options: [],
+        source: "nitro"
+      });
+    }
+    if (readyState === "OPEN" && previousReadyState !== "OPEN") {
+      eventEmitter.emit("websocket-open", {
+        type: "websocket-open",
+        url: entry.url,
+        socketId,
+        timestamp: toEpochTime(entry.startTime),
+        source: "nitro"
+      });
+    }
+    const previousMessageCount = previous?.messages.length ?? 0;
+    for (const message of entry.messages.slice(previousMessageCount)) {
+      const event = {
+        url: entry.url,
+        socketId,
+        timestamp: toEpochTime(message.timestamp),
+        data: message.data,
+        messageType: message.isBinary ? "binary" : "text",
+        source: "nitro"
+      };
+      if (message.direction === "sent") {
+        eventEmitter.emit("websocket-message-sent", {
+          type: "websocket-message-sent",
+          ...event
+        });
+      } else {
+        eventEmitter.emit("websocket-message-received", {
+          type: "websocket-message-received",
+          ...event
+        });
+      }
+    }
+    if (entry.error && (!previous || previous.error !== entry.error)) {
+      eventEmitter.emit("websocket-error", {
+        type: "websocket-error",
+        url: entry.url,
+        socketId,
+        timestamp: toEpochTime(entry.endTime || entry.startTime),
+        error: entry.error,
+        source: "nitro"
+      });
+    }
+    if (readyState === "CLOSED" && previousReadyState !== "CLOSED") {
+      eventEmitter.emit("websocket-close", {
+        type: "websocket-close",
+        url: entry.url,
+        socketId,
+        timestamp: toEpochTime(entry.endTime || entry.startTime),
+        code: entry.closeCode ?? 0,
+        reason: entry.closeReason,
+        source: "nitro"
+      });
+    }
+  };
+  const handleEntry = (entry) => {
+    const previous = previousEntries.get(entry.id);
+    if (entry.type === "http") {
+      responseBodies.set(entry.id, entry.responseBody ?? null);
+      emitHttpEvents(entry, previous);
+    } else {
+      emitWebSocketEvents(entry, previous);
+    }
+    previousEntries.set(entry.id, cloneEntry(entry));
+  };
+  return {
+    enable() {
+      if (unsubscribe) {
+        return;
+      }
+      nitroModule = getNitroModule();
+      if (!nitroModule) {
+        return;
+      }
+      nitroModule.NetworkInspector.enable();
+      for (const entry of nitroModule.NetworkInspector.getEntries()) {
+        previousEntries.set(entry.id, cloneEntry(entry));
+        if (entry.type === "http") {
+          responseBodies.set(entry.id, entry.responseBody ?? null);
+        }
+      }
+      unsubscribe = nitroModule.NetworkInspector.onEntry(handleEntry);
+    },
+    disable() {
+      unsubscribe?.();
+      unsubscribe = null;
+      nitroModule?.NetworkInspector.disable();
+    },
+    isEnabled() {
+      return nitroModule?.NetworkInspector.isEnabled() ?? false;
+    },
+    dispose() {
+      unsubscribe?.();
+      unsubscribe = null;
+      previousEntries.clear();
+      responseBodies.clear();
+      nitroModule?.NetworkInspector.disable();
+      nitroModule = null;
+    },
+    getResponseBody(requestId) {
+      return responseBodies.get(requestId) ?? null;
+    },
+    on(event, callback) {
+      return eventEmitter.on(event, callback);
+    }
+  };
+};
+const getNitroNetworkInspector = /* @__PURE__ */ (() => {
+  let instance = null;
+  return () => {
+    if (!instance) {
+      instance = createNitroNetworkInspector();
+    }
+    return instance;
+  };
+})();
 const createNetworkInspectorInstance = () => {
   const http = getHTTPInspector();
   const sse = getSSEInspector();
   const websocket = getWebSocketInspector();
+  const nitro = getNitroNetworkInspector();
   return {
     http,
     sse,
     websocket,
+    nitro,
     setup(eventsListener) {
       HTTP_EVENTS.forEach((event) => {
         http.on(event, (data) => {
@@ -1016,21 +1281,36 @@ const createNetworkInspectorInstance = () => {
           eventsListener.send(data.type, data);
         });
       });
+      NITRO_NETWORK_EVENTS.forEach((event) => {
+        nitro.on(event, (data) => {
+          eventsListener.send(event, data);
+        });
+      });
     },
     enable(config = { http: true, sse: true, websocket: true }) {
       if (config.http) http.enable();
       if (config.sse) sse.enable();
       if (config.websocket) websocket.enable();
+      if (config.http || config.websocket) nitro.enable();
     },
     disable() {
       http.disable();
       sse.disable();
       websocket.disable();
+      nitro.disable();
     },
     dispose() {
       http.dispose();
       sse.dispose();
       websocket.dispose();
+      nitro.dispose();
+    },
+    async getResponseBody(requestId) {
+      const request = http.getNetworkRequestsRegistry().getEntry(requestId);
+      if (request) {
+        return getResponseBody(request);
+      }
+      return nitro.getResponseBody(requestId);
     }
   };
 };
@@ -1078,7 +1358,6 @@ const withOnBootNetworkActivityRecording = (options) => {
 exports.DEFAULT_CONFIG = DEFAULT_CONFIG;
 exports.createNetworkInspectorsConfiguration = createNetworkInspectorsConfiguration;
 exports.getOverridesRegistry = getOverridesRegistry;
-exports.getResponseBody = getResponseBody;
 exports.isHttpEvent = isHttpEvent;
 exports.isSSEEvent = isSSEEvent;
 exports.isWebSocketEvent = isWebSocketEvent;