@rozenite/network-activity-plugin 1.7.0 → 1.8.1

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

@@ -203,7 +203,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 || {});
@@ -363,7 +363,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") {
@@ -456,7 +456,8 @@ const getHTTPInspector = () => {
             postData: getRequestBody(data)
           },
           type: "XHR",
-          initiator
+          initiator,
+          source: "builtin"
         });
         request.addEventListener("readystatechange", () => {
           if (request.readyState === READY_STATE_HEADERS_RECEIVED) {
@@ -469,7 +470,8 @@ const getHTTPInspector = () => {
             timestamp: Date.now(),
             loaded: event.loaded,
             total: event.total,
-            lengthComputable: event.lengthComputable
+            lengthComputable: event.lengthComputable,
+            source: "builtin"
           });
         });
         request.addEventListener("load", () => {
@@ -484,10 +486,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", () => {
@@ -496,7 +499,8 @@ const getHTTPInspector = () => {
             timestamp: Date.now(),
             duration: Date.now() - sendTime,
             size: getResponseSize(request),
-            ttfb
+            ttfb,
+            source: "builtin"
           });
         });
         request.addEventListener("error", () => {
@@ -505,7 +509,8 @@ const getHTTPInspector = () => {
             timestamp: Date.now(),
             type: "XHR",
             error: "Failed",
-            canceled: false
+            canceled: false,
+            source: "builtin"
           });
         });
         request.addEventListener("abort", () => {
@@ -514,7 +519,8 @@ const getHTTPInspector = () => {
             timestamp: Date.now(),
             type: "XHR",
             error: "Aborted",
-            canceled: true
+            canceled: true,
+            source: "builtin"
           });
         });
         request.addEventListener("timeout", () => {
@@ -523,7 +529,8 @@ const getHTTPInspector = () => {
             timestamp: Date.now(),
             type: "XHR",
             error: "Timeout",
-            canceled: false
+            canceled: false,
+            source: "builtin"
           });
         });
       });
@@ -580,10 +587,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 = createNanoEvents();
   const socketUrlMap = /* @__PURE__ */ new Map();
-  const webSocketInterceptor = getWebSocketInterceptor();
   return {
     enable: () => {
       webSocketInterceptor.setConnectCallback(
@@ -592,10 +599,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);
         }
@@ -609,10 +617,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);
@@ -627,10 +636,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);
         }
@@ -644,9 +654,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);
         }
@@ -659,10 +670,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);
       });
@@ -674,8 +686,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);
       });
@@ -688,10 +701,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);
@@ -710,6 +724,9 @@ const getWebSocketInspector = () => {
     on: (event, callback) => eventEmitter.on(event, callback)
   };
 };
+const getWebSocketInspector = () => {
+  return createWebSocketInspector();
+};
 let connectCallback;
 let messageCallback;
 let errorCallback;
@@ -843,7 +860,7 @@ const getSSEInspector = () => {
             status: sseXhr.status,
             statusText: sseXhr.statusText,
             headers: sseXhr.responseHeaders || {},
-            contentType: getContentType(sseXhr),
+            contentType: getContentType$1(sseXhr),
             size: 0,
             responseTime: Date.now()
           }
@@ -932,6 +949,7 @@ class EventsListener {
   constructor() {
     this.messageQueue = [];
     this.sendFunction = null;
+    this.filterFunction = null;
     this.maxQueueSize = 200;
     this.isQueuing = false;
   }
@@ -949,6 +967,7 @@ class EventsListener {
    */
   connect(sendFn, filterFn) {
     this.sendFunction = sendFn;
+    this.filterFunction = filterFn ?? null;
     this.isQueuing = false;
     this.flushQueue(filterFn);
   }
@@ -962,6 +981,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);
     }
   }
@@ -989,14 +1011,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 = 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) => {
@@ -1013,21 +1278,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);
     }
   };
 };
@@ -1074,11 +1354,10 @@ const withOnBootNetworkActivityRecording = (options) => {
 };
 export {
   DEFAULT_CONFIG as D,
-  getOverridesRegistry as a,
-  isWebSocketEvent as b,
+  isWebSocketEvent as a,
+  isSSEEvent as b,
   createNetworkInspectorsConfiguration as c,
-  isSSEEvent as d,
-  getResponseBody as g,
+  getOverridesRegistry as g,
   isHttpEvent as i,
   safeStringify as s,
   validateConfig as v,