@rozenite/network-activity-plugin 1.1.0 → 1.3.0

package/dist/useNetworkActivityDevTools.cjs

@@ -2,989 +2,137 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const react = require("react");
 const pluginBridge = require("@rozenite/plugin-bridge");
-const nanoevents = require("nanoevents");
-const reactNative = require("react-native");
-const WebSocketInterceptor = require("react-native/Libraries/WebSocket/WebSocketInterceptor");
-const eventSource = require("./event-source.cjs");
-const _interopDefault = (e) => e && e.__esModule ? e : { default: e };
-const WebSocketInterceptor__default = /* @__PURE__ */ _interopDefault(WebSocketInterceptor);
-function safeStringify(data) {
-  try {
-    return typeof data === "string" ? data : JSON.stringify(data);
-  } catch {
-    return String(data);
-  }
-}
-function getHttpHeader(headers, name) {
-  const lowerName = name.toLowerCase();
-  for (const key in headers) {
-    if (key.toLowerCase() === lowerName) {
-      return { value: headers[key], originalKey: key };
-    }
-  }
-  return void 0;
-}
-function getContentTypeMime(headers) {
-  const contentType = getHttpHeader(headers, "content-type");
-  if (!contentType) {
-    return void 0;
-  }
-  const { value } = contentType;
-  const actualValue = Array.isArray(value) ? value[0] : value;
-  return actualValue.split(";")[0].trim();
-}
-const getContentType = (request) => {
-  const responseHeaders = request.responseHeaders;
-  const responseType = request.responseType;
-  const contentType = getContentTypeMime(responseHeaders || {});
-  if (contentType) {
-    return contentType;
-  }
-  switch (responseType) {
-    case "arraybuffer":
-    case "blob":
-      return "application/octet-stream";
-    case "text":
-    case "":
-      return "text/plain";
-    case "json":
-      return "application/json";
-    case "document":
-      return "text/html";
-  }
-};
-const REQUEST_TTL = 1e3 * 60 * 5;
-const getNetworkRequestsRegistry = () => {
-  const registry = /* @__PURE__ */ new Map();
-  const trimRegistry = () => {
-    const now = Date.now();
-    registry.forEach((entry) => {
-      if (now - entry.sentAt < REQUEST_TTL) {
-        return;
-      }
-      registry.delete(entry.id);
-    });
-  };
-  const addEntry = (id, request) => {
-    trimRegistry();
-    registry.set(id, {
-      id,
-      request,
-      sentAt: Date.now()
-    });
-  };
-  const getEntry = (id) => {
-    var _a;
-    return ((_a = registry.get(id)) == null ? void 0 : _a.request) ?? null;
-  };
-  const clear = () => {
-    registry.clear();
-  };
-  return {
-    addEntry,
-    getEntry,
-    clear
-  };
-};
-function getBlobName(blob) {
-  if (typeof (blob == null ? void 0 : blob.name) === "string") {
-    return blob.name;
-  }
-  if ((blob == null ? void 0 : blob.data) && typeof blob.data.name === "string") {
-    return blob.data.name;
-  }
-  return void 0;
-}
-function getFormDataEntries(formData) {
-  if (!formData || typeof formData !== "object") {
-    return [];
-  }
-  if (typeof formData.entries === "function") {
-    return formData.entries();
-  }
-  if (Array.isArray(formData._parts)) {
-    return formData._parts;
-  }
-  return [];
-}
-const XMLHttpRequest = global.XMLHttpRequest || window.XMLHttpRequest;
-const originalXHROpen = XMLHttpRequest.prototype.open;
-const originalXHRSend = XMLHttpRequest.prototype.send;
-const originalXHRSetRequestHeader = XMLHttpRequest.prototype.setRequestHeader;
-let openCallback;
-let sendCallback;
-let requestHeaderCallback;
-let headerReceivedCallback;
-let responseCallback;
-let overrideCallback;
-let isInterceptorEnabled$1 = false;
-const XHRInterceptor = {
-  /**
-   * Invoked before XMLHttpRequest.open(...) is called.
-   */
-  setOpenCallback(callback) {
-    openCallback = callback;
-  },
-  /**
-   * Invoked before XMLHttpRequest.send(...) is called.
-   */
-  setSendCallback(callback) {
-    sendCallback = callback;
-  },
-  /**
-   * Invoked after xhr's readyState becomes xhr.HEADERS_RECEIVED.
-   */
-  setHeaderReceivedCallback(callback) {
-    headerReceivedCallback = callback;
-  },
-  /**
-   * Invoked after xhr's readyState becomes xhr.DONE.
-   */
-  setResponseCallback(callback) {
-    responseCallback = callback;
-  },
-  /**
-   * Invoked before XMLHttpRequest.setRequestHeader(...) is called.
-   */
-  setRequestHeaderCallback(callback) {
-    requestHeaderCallback = callback;
-  },
-  /**
-   * Invoked before XMLHttpRequest.send(...) is called.
-   */
-  setOverrideCallback(callback) {
-    overrideCallback = callback;
-  },
-  isInterceptorEnabled() {
-    return isInterceptorEnabled$1;
-  },
-  enableInterception() {
-    if (isInterceptorEnabled$1) {
-      return;
-    }
-    XMLHttpRequest.prototype.open = function(method, url) {
-      if (openCallback) {
-        openCallback(method, url, this);
-      }
-      originalXHROpen.apply(this, arguments);
-    };
-    XMLHttpRequest.prototype.setRequestHeader = function(header, value) {
-      if (requestHeaderCallback) {
-        requestHeaderCallback(header, value, this);
-      }
-      originalXHRSetRequestHeader.apply(this, arguments);
-    };
-    XMLHttpRequest.prototype.send = function(data) {
-      if (sendCallback) {
-        sendCallback(data, this);
-      }
-      if (overrideCallback) {
-        overrideCallback(this);
-      }
-      if (this.addEventListener) {
-        this.addEventListener(
-          "readystatechange",
-          () => {
-            if (!isInterceptorEnabled$1) {
-              return;
-            }
-            if (this.readyState === this.HEADERS_RECEIVED) {
-              const contentTypeString = this.getResponseHeader("Content-Type");
-              const contentLengthString = this.getResponseHeader("Content-Length");
-              let responseContentType, responseSize;
-              if (contentTypeString) {
-                responseContentType = contentTypeString.split(";")[0];
-              }
-              if (contentLengthString) {
-                responseSize = parseInt(contentLengthString, 10);
-              }
-              if (headerReceivedCallback) {
-                headerReceivedCallback(
-                  responseContentType,
-                  responseSize,
-                  this.getAllResponseHeaders(),
-                  this
-                );
-              }
-            }
-            if (this.readyState === this.DONE) {
-              if (responseCallback) {
-                responseCallback(
-                  this.status,
-                  this.timeout,
-                  this.response,
-                  this.responseURL,
-                  this.responseType,
-                  this
-                );
-              }
-            }
-          },
-          false
-        );
-      }
-      originalXHRSend.apply(this, arguments);
-    };
-    isInterceptorEnabled$1 = true;
-  },
-  // Unpatch XMLHttpRequest methods and remove the callbacks.
-  disableInterception() {
-    if (!isInterceptorEnabled$1) {
-      return;
-    }
-    isInterceptorEnabled$1 = false;
-    XMLHttpRequest.prototype.send = originalXHRSend;
-    XMLHttpRequest.prototype.open = originalXHROpen;
-    XMLHttpRequest.prototype.setRequestHeader = originalXHRSetRequestHeader;
-    responseCallback = null;
-    openCallback = null;
-    sendCallback = null;
-    headerReceivedCallback = null;
-    requestHeaderCallback = null;
-    overrideCallback = null;
-  }
-};
-const getStringSizeInBytes = (value) => {
-  return new TextEncoder().encode(value).length;
-};
-const splitSetCookieHeaderByComma = (header) => {
-  const regex = /(?:^|,\s)([^=;,]+=[^;]+(?:;[^,]*)*)/g;
-  const matches = [];
-  let match;
-  while ((match = regex.exec(header)) !== null) {
-    matches.push(match[1].trim());
-  }
-  return matches;
-};
-const applyReactNativeResponseHeadersLogic = (headers) => {
-  const parsedHeaders = { ...headers };
-  const setCookieHeader = getHttpHeader(headers, "set-cookie");
-  if (setCookieHeader) {
-    const { value, originalKey } = setCookieHeader;
-    const cookies = splitSetCookieHeaderByComma(value);
-    parsedHeaders[originalKey] = cookies.length > 0 ? cookies : value;
-  }
-  return parsedHeaders;
-};
-const isBlob = (value) => value instanceof Blob;
-const isArrayBuffer = (value) => value instanceof ArrayBuffer || ArrayBuffer.isView(value);
-const isFormData = (value) => value instanceof FormData;
-const isNullOrUndefined = (value) => value === null || value === void 0;
-const createOverridesRegistry = () => {
-  let overrides = /* @__PURE__ */ new Map();
-  const setOverrides = (newOverrides) => {
-    overrides = new Map(newOverrides);
-  };
-  const getOverrideForUrl = (url) => {
-    return overrides.get(url);
-  };
-  return {
-    setOverrides,
-    getOverrideForUrl
-  };
-};
-let registryInstance = null;
-const getOverridesRegistry = () => {
-  if (!registryInstance) {
-    registryInstance = createOverridesRegistry();
-  }
-  return registryInstance;
-};
-const networkRequestsRegistry = getNetworkRequestsRegistry();
-const overridesRegistry$1 = getOverridesRegistry();
-const getBinaryPostData = (body) => ({
-  type: "binary",
-  value: {
-    size: body.size,
-    type: body.type,
-    name: getBlobName(body)
-  }
-});
-const getArrayBufferPostData = (body) => ({
-  type: "binary",
-  value: {
-    size: body.byteLength
-  }
-});
-const getTextPostData = (body) => ({
-  type: "text",
-  value: safeStringify(body)
-});
-const getFormDataPostData = (body) => ({
-  type: "form-data",
-  value: getFormDataEntries(body).reduce(
-    (acc, [key, value]) => {
-      if (isBlob(value)) {
-        acc[key] = getBinaryPostData(value);
-      } else if (isArrayBuffer(value)) {
-        acc[key] = getArrayBufferPostData(value);
-      } else {
-        acc[key] = getTextPostData(value);
-      }
-      return acc;
-    },
-    {}
-  )
-});
-const getRequestBody = (body) => {
-  if (isNullOrUndefined(body)) {
-    return body;
-  }
-  if (isBlob(body)) {
-    return getBinaryPostData(body);
-  }
-  if (isArrayBuffer(body)) {
-    return getArrayBufferPostData(body);
-  }
-  if (isFormData(body)) {
-    return getFormDataPostData(body);
-  }
-  return getTextPostData(body);
-};
-const getResponseSize = (request) => {
-  try {
-    const { responseType, response } = request;
-    if (response === null) {
-      return 0;
-    }
-    if (responseType === "" || responseType === "text") {
-      return getStringSizeInBytes(request.responseText);
-    }
-    if (responseType === "json") {
-      return getStringSizeInBytes(safeStringify(response));
-    }
-    if (responseType === "blob") {
-      return response.size;
-    }
-    if (responseType === "arraybuffer") {
-      return response.byteLength;
-    }
-    return 0;
-  } catch {
-    return null;
-  }
-};
-const getResponseBody = async (request) => {
-  const responseType = request.responseType;
-  if (responseType === "" || responseType === "text") {
-    return request.responseText;
-  }
-  if (responseType === "blob") {
-    const contentType = request.getResponseHeader("Content-Type") || "";
-    if (contentType.startsWith("text/") || contentType.startsWith("application/json")) {
-      return new Promise((resolve) => {
-        const reader = new FileReader();
-        reader.onload = () => {
-          resolve(reader.result);
-        };
-        reader.readAsText(request.response);
-      });
-    }
-  }
-  if (responseType === "json") {
-    return safeStringify(request.response);
-  }
-  return null;
-};
-const getInitiatorFromStack = () => {
-  try {
-    const stack = new Error().stack;
-    if (!stack) {
-      return { type: "other" };
-    }
-    const line = stack.split("\n")[9];
-    const match = line.match(/at\s+(.+?)\s+\((.+?):(\d+):(\d+)\)/);
-    if (match) {
-      return {
-        type: "script",
-        url: match[2],
-        lineNumber: parseInt(match[3]),
-        columnNumber: parseInt(match[4])
-      };
-    }
-  } catch {
-  }
-  return { type: "other" };
-};
-const READY_STATE_HEADERS_RECEIVED = 2;
-const getNetworkInspector = (pluginClient) => {
-  const generateRequestId = () => {
-    return `req_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-  };
-  const handleRequestSend = (data, request) => {
-    const sendTime = Date.now();
-    const requestId = generateRequestId();
-    request._rozeniteRequestId = requestId;
-    const initiator = getInitiatorFromStack();
-    networkRequestsRegistry.addEntry(requestId, request);
-    let ttfb = 0;
-    pluginClient.send("request-sent", {
-      requestId,
-      timestamp: sendTime,
-      request: {
-        url: request._url,
-        method: request._method,
-        headers: request._headers,
-        postData: getRequestBody(data)
-      },
-      type: "XHR",
-      initiator
-    });
-    request.addEventListener("progress", (event) => {
-      pluginClient.send("request-progress", {
-        requestId,
-        timestamp: Date.now(),
-        loaded: event.loaded,
-        total: event.total,
-        lengthComputable: event.lengthComputable
-      });
-    });
-    request.addEventListener("readystatechange", () => {
-      if (request.readyState === READY_STATE_HEADERS_RECEIVED) {
-        ttfb = Date.now() - sendTime;
-      }
-    });
-    request.addEventListener("load", () => {
-      pluginClient.send("response-received", {
-        requestId,
-        timestamp: Date.now(),
-        type: "XHR",
-        response: {
-          url: request._url,
-          status: request.status,
-          statusText: request.statusText,
-          headers: applyReactNativeResponseHeadersLogic(
-            request.responseHeaders || {}
-          ),
-          contentType: getContentType(request),
-          size: getResponseSize(request),
-          responseTime: Date.now()
-        }
-      });
-    });
-    request.addEventListener("loadend", () => {
-      pluginClient.send("request-completed", {
-        requestId,
-        timestamp: Date.now(),
-        duration: Date.now() - sendTime,
-        size: getResponseSize(request),
-        ttfb
-      });
-    });
-    request.addEventListener("error", () => {
-      pluginClient.send("request-failed", {
-        requestId,
-        timestamp: Date.now(),
-        type: "XHR",
-        error: "Failed",
-        canceled: false
-      });
-    });
-    request.addEventListener("abort", () => {
-      pluginClient.send("request-failed", {
-        requestId,
-        timestamp: Date.now(),
-        type: "XHR",
-        error: "Aborted",
-        canceled: true
-      });
-    });
-    request.addEventListener("timeout", () => {
-      pluginClient.send("request-failed", {
-        requestId,
-        timestamp: Date.now(),
-        type: "XHR",
-        error: "Timeout",
-        canceled: false
-      });
-    });
-  };
-  const handleRequestOverride = (request) => {
-    const override = overridesRegistry$1.getOverrideForUrl(
-      request._url
-    );
-    if (!override) {
+const bootRecording = require("./boot-recording.cjs");
+const overridesRegistry = bootRecording.getOverridesRegistry();
+const useHttpInspector = (client, httpInspector, isEnabled, isRecordingEnabled) => {
+  react.useEffect(() => {
+    if (!client || !isEnabled) {
       return;
     }
-    request.addEventListener("readystatechange", () => {
-      if (override.body !== void 0) {
-        Object.defineProperty(request, "responseType", {
-          writable: true
-        });
-        Object.defineProperty(request, "response", {
-          writable: true
-        });
-        Object.defineProperty(request, "responseText", {
-          writable: true
-        });
-        const contentType = getContentType(request);
-        if (contentType === "application/json") {
-          request.responseType = "json";
-        } else if (contentType === "text/plain") {
-          request.responseType = "text";
+    const networkRequestsRegistry = httpInspector.getNetworkRequestsRegistry();
+    const subscriptions = [
+      client.onMessage("network-enable", () => {
+        httpInspector.enable();
+      }),
+      client.onMessage("network-disable", () => {
+        httpInspector.disable();
+      }),
+      client.onMessage("set-overrides", (data) => {
+        overridesRegistry.setOverrides(data.overrides);
+      }),
+      client.onMessage("get-response-body", async ({ requestId }) => {
+        const request = networkRequestsRegistry.getEntry(requestId);
+        if (!request) {
+          return;
         }
-        request.response = override.body;
-        request.responseText = override.body;
-      }
-      if (override.status !== void 0) {
-        Object.defineProperty(request, "status", {
-          writable: true
+        const body = await bootRecording.getResponseBody(request);
+        client.send("response-body", {
+          requestId,
+          body
         });
-        request.status = override.status;
-      }
-    });
-  };
-  const enable = () => {
-    XHRInterceptor.disableInterception();
-    XHRInterceptor.setSendCallback(handleRequestSend);
-    XHRInterceptor.setOverrideCallback(handleRequestOverride);
-    XHRInterceptor.enableInterception();
-  };
-  const disable = () => {
-    XHRInterceptor.disableInterception();
-    networkRequestsRegistry.clear();
-  };
-  const isEnabled = () => {
-    return XHRInterceptor.isInterceptorEnabled();
-  };
-  const enableSubscription = pluginClient.onMessage("network-enable", () => {
-    enable();
-  });
-  const disableSubscription = pluginClient.onMessage("network-disable", () => {
-    disable();
-  });
-  const handleBodySubscription = pluginClient.onMessage(
-    "get-response-body",
-    async ({ requestId }) => {
-      const request = networkRequestsRegistry.getEntry(requestId);
-      if (!request) {
-        return;
-      }
-      const body = await getResponseBody(request);
-      pluginClient.send("response-body", {
-        requestId,
-        body
-      });
+      })
+    ];
+    if (isRecordingEnabled) {
+      httpInspector.enable();
     }
-  );
-  const dispose = () => {
-    disable();
-    enableSubscription.remove();
-    disableSubscription.remove();
-    handleBodySubscription.remove();
-  };
-  return {
-    enable,
-    disable,
-    isEnabled,
-    dispose
-  };
-};
-const getWebSocketInterceptor = () => {
-  if (reactNative.Platform.constants.reactNativeVersion.minor >= 79) {
-    return WebSocketInterceptor__default.default;
-  } else {
-    const WebSocketInterceptorPreRN079 = WebSocketInterceptor__default.default;
-    return {
-      ...WebSocketInterceptorPreRN079,
-      setOnMessageCallback: (callback) => {
-        WebSocketInterceptorPreRN079.setOnMessageCallback((socketId, data) => {
-          callback(data, socketId);
-        });
-      },
-      setOnCloseCallback: (callback) => {
-        WebSocketInterceptorPreRN079.setOnCloseCallback((error, socketId) => {
-          callback(socketId, error);
-        });
-      },
-      setOnErrorCallback: (callback) => {
-        WebSocketInterceptorPreRN079.setOnErrorCallback((error, socketId) => {
-          callback(socketId, error);
-        });
-      }
+    return () => {
+      subscriptions.forEach((subscription) => subscription.remove());
+      httpInspector.dispose();
     };
-  }
+  }, [client, httpInspector, isEnabled, isRecordingEnabled]);
 };
-const getWebSocketInspector = () => {
-  const eventEmitter = nanoevents.createNanoEvents();
-  const socketUrlMap = /* @__PURE__ */ new Map();
-  const webSocketInterceptor = getWebSocketInterceptor();
-  return {
-    enable: () => {
-      webSocketInterceptor.setConnectCallback(
-        (url, protocols, options, socketId) => {
-          socketUrlMap.set(socketId, url);
-          const event = {
-            type: "websocket-connect",
-            url,
-            socketId,
-            timestamp: Date.now(),
-            protocols,
-            options
-          };
-          eventEmitter.emit("websocket-connect", event);
-        }
-      );
-      webSocketInterceptor.setCloseCallback(
-        (code, reason, socketId) => {
-          const url = socketUrlMap.get(socketId);
-          if (!url) {
-            return;
-          }
-          const event = {
-            type: "websocket-close",
-            url,
-            socketId,
-            timestamp: Date.now(),
-            code: code || 0,
-            reason: reason || void 0
-          };
-          eventEmitter.emit("websocket-close", event);
-          socketUrlMap.delete(socketId);
-        }
-      );
-      webSocketInterceptor.setOnMessageCallback(
-        (data, socketId) => {
-          const url = socketUrlMap.get(socketId);
-          if (!url) {
-            return;
-          }
-          const event = {
-            type: "websocket-message-received",
-            url,
-            socketId,
-            timestamp: Date.now(),
-            data,
-            messageType: typeof data === "string" ? "text" : "binary"
-          };
-          eventEmitter.emit("websocket-message-received", event);
-        }
-      );
-      webSocketInterceptor.setOnErrorCallback(
-        (error, socketId) => {
-          const url = socketUrlMap.get(socketId);
-          if (!url) {
-            return;
-          }
-          const event = {
-            type: "websocket-error",
-            url,
-            socketId,
-            timestamp: Date.now(),
-            error
-          };
-          eventEmitter.emit("websocket-error", event);
-        }
-      );
-      webSocketInterceptor.setSendCallback((data, socketId) => {
-        const url = socketUrlMap.get(socketId);
-        if (!url) {
-          return;
-        }
-        const event = {
-          type: "websocket-message-sent",
-          url,
-          socketId,
-          timestamp: Date.now(),
-          data,
-          messageType: typeof data === "string" ? "text" : "binary"
-        };
-        eventEmitter.emit("websocket-message-sent", event);
-      });
-      webSocketInterceptor.setOnOpenCallback((socketId) => {
-        const url = socketUrlMap.get(socketId);
-        if (!url) {
-          return;
-        }
-        const event = {
-          type: "websocket-open",
-          url,
-          socketId,
-          timestamp: Date.now()
-        };
-        eventEmitter.emit("websocket-open", event);
-      });
-      webSocketInterceptor.setOnCloseCallback(
-        (error, socketId) => {
-          const url = socketUrlMap.get(socketId);
-          if (!url) {
-            return;
-          }
-          const event = {
-            type: "websocket-close",
-            url,
-            socketId,
-            timestamp: Date.now(),
-            code: error.code,
-            reason: error.reason
-          };
-          eventEmitter.emit("websocket-close", event);
-          socketUrlMap.delete(socketId);
-        }
-      );
-      webSocketInterceptor.enableInterception();
-    },
-    disable: () => {
-      webSocketInterceptor.disableInterception();
-    },
-    isEnabled: () => webSocketInterceptor.isInterceptorEnabled(),
-    dispose: () => {
-      eventEmitter.events = {};
-      socketUrlMap.clear();
-    },
-    on: (event, callback) => eventEmitter.on(event, callback)
-  };
-};
-let connectCallback;
-let messageCallback;
-let errorCallback;
-let openEventCallback;
-let closeCallback;
-let isInterceptorEnabled = false;
-const eventSourceClass = eventSource.getEventSource();
-const originalOpen = eventSourceClass.prototype.open;
-const originalDispatch = eventSourceClass.prototype.dispatch;
-const BUILT_IN_EVENT_TYPES = /* @__PURE__ */ new Set(["open", "error", "close", "done"]);
-const SSEInterceptor = {
-  /**
-   * Invoked when EventSource.open() is called (connection attempt starting).
-   */
-  setConnectCallback(callback) {
-    connectCallback = callback;
-  },
-  /**
-   * Invoked when a message event is received.
-   */
-  setMessageCallback(callback) {
-    messageCallback = callback;
-  },
-  /**
-   * Invoked when an error event occurs.
-   */
-  setErrorCallback(callback) {
-    errorCallback = callback;
-  },
-  /**
-   * Invoked when the connection is successfully opened (open event fired).
-   */
-  setOpenEventCallback(callback) {
-    openEventCallback = callback;
-  },
-  /**
-   * Invoked when the connection is closed.
-   */
-  setCloseCallback(callback) {
-    closeCallback = callback;
-  },
-  isInterceptorEnabled() {
-    return isInterceptorEnabled;
-  },
-  enableInterception() {
-    if (isInterceptorEnabled) {
+const useWebSocketInspector = (client, websocketInspector, isEnabled, isRecordingEnabled) => {
+  react.useEffect(() => {
+    if (!client || !isEnabled) {
       return;
     }
-    eventSourceClass.prototype.open = function() {
-      if (connectCallback) {
-        connectCallback(this.url, this);
-      }
-      this.addEventListener("open", (event) => {
-        if (openEventCallback) {
-          openEventCallback(event, this);
-        }
-      });
-      this.addEventListener(
-        "error",
-        (event) => {
-          if (errorCallback) {
-            errorCallback(event, this);
-          }
-        }
-      );
-      this.addEventListener("close", (event) => {
-        if (closeCallback) {
-          closeCallback(event, this);
-        }
-      });
-      return originalOpen.call(this);
-    };
-    eventSourceClass.prototype.dispatch = function(eventType, data) {
-      if (!BUILT_IN_EVENT_TYPES.has(eventType)) {
-        if (messageCallback) {
-          messageCallback(data, this);
-        }
-      }
-      return originalDispatch.call(this, eventType, data);
+    const subscriptions = [
+      client.onMessage("network-enable", () => {
+        websocketInspector.enable();
+      }),
+      client.onMessage("network-disable", () => {
+        websocketInspector.disable();
+      })
+    ];
+    if (isRecordingEnabled) {
+      websocketInspector.enable();
+    }
+    return () => {
+      subscriptions.forEach((subscription) => subscription.remove());
+      websocketInspector.dispose();
     };
-    isInterceptorEnabled = true;
-  },
-  // Unpatch EventSource open method and remove the callbacks.
-  disableInterception() {
-    if (!isInterceptorEnabled) {
+  }, [client, websocketInspector, isEnabled, isRecordingEnabled]);
+};
+const useSSEInspector = (client, sseInspector, isEnabled, isRecordingEnabled) => {
+  react.useEffect(() => {
+    if (!client || !isEnabled) {
       return;
     }
-    isInterceptorEnabled = false;
-    eventSourceClass.prototype.open = originalOpen;
-    eventSourceClass.prototype.dispatch = originalDispatch;
-    connectCallback = null;
-    messageCallback = null;
-    errorCallback = null;
-    openEventCallback = null;
-    closeCallback = null;
-  }
-};
-const getSSEInspector = () => {
-  const eventEmitter = nanoevents.createNanoEvents();
-  const getRequestId = (eventSource2) => {
-    var _a;
-    const requestId = (_a = eventSource2._xhr) == null ? void 0 : _a._rozeniteRequestId;
-    if (!requestId) {
-      return null;
+    const subscriptions = [
+      client.onMessage("network-enable", () => {
+        sseInspector.enable();
+      }),
+      client.onMessage("network-disable", () => {
+        sseInspector.disable();
+      })
+    ];
+    if (isRecordingEnabled) {
+      sseInspector.enable();
     }
-    return requestId;
-  };
-  return {
-    enable: () => {
-      SSEInterceptor.setOpenEventCallback((_, eventSource2) => {
-        const sseEventSource = eventSource2;
-        const requestId = getRequestId(sseEventSource);
-        if (!requestId) {
-          return;
-        }
-        const sseXhr = sseEventSource._xhr;
-        const event = {
-          type: "sse-open",
-          requestId,
-          timestamp: Date.now(),
-          response: {
-            url: sseXhr._url,
-            status: sseXhr.status,
-            statusText: sseXhr.statusText,
-            headers: sseXhr.responseHeaders || {},
-            contentType: getContentType(sseXhr),
-            size: 0,
-            responseTime: Date.now()
-          }
-        };
-        eventEmitter.emit("sse-open", event);
-      });
-      SSEInterceptor.setMessageCallback((messageEvent, eventSource2) => {
-        const sseEventSource = eventSource2;
-        const requestId = getRequestId(sseEventSource);
-        if (!requestId) {
-          return;
-        }
-        const event = {
-          type: "sse-message",
-          requestId,
-          timestamp: Date.now(),
-          payload: {
-            type: messageEvent.type,
-            data: messageEvent.data || ""
-          }
-        };
-        eventEmitter.emit("sse-message", event);
-      });
-      SSEInterceptor.setErrorCallback((errorEvent, eventSource2) => {
-        const sseEventSource = eventSource2;
-        const requestId = getRequestId(sseEventSource);
-        if (!requestId) {
-          return;
-        }
-        const event = {
-          type: "sse-error",
-          requestId,
-          timestamp: Date.now(),
-          error: {
-            type: errorEvent.type,
-            message: errorEvent.type === "timeout" ? "Timeout" : errorEvent.message
-          }
-        };
-        eventEmitter.emit("sse-error", event);
-      });
-      SSEInterceptor.setCloseCallback((_, eventSource2) => {
-        const sseEventSource = eventSource2;
-        const requestId = getRequestId(sseEventSource);
-        if (!requestId) {
-          return;
-        }
-        const event = {
-          type: "sse-close",
-          requestId,
-          timestamp: Date.now()
-        };
-        eventEmitter.emit("sse-close", event);
-      });
-      SSEInterceptor.enableInterception();
-    },
-    disable: () => {
-      SSEInterceptor.disableInterception();
-    },
-    isEnabled: () => SSEInterceptor.isInterceptorEnabled(),
-    dispose: () => {
-      SSEInterceptor.disableInterception();
-      eventEmitter.events = {};
-    },
-    on: (event, callback) => eventEmitter.on(event, callback)
-  };
-};
-const DEFAULT_CONFIG = {
-  inspectors: {
-    http: true,
-    websocket: true,
-    sse: true
-  },
-  clientUISettings: {
-    showUrlAsName: false
-  }
-};
-const validateConfig = (config) => {
-  const inspectors = config.inspectors;
-  if (!inspectors) {
-    return;
-  }
-  if (inspectors.sse && !inspectors.http) {
-    throw new Error("SSE inspector requires HTTP inspector to be enabled.");
-  }
+    return () => {
+      subscriptions.forEach((subscription) => subscription.remove());
+      sseInspector.dispose();
+    };
+  }, [client, sseInspector, isEnabled, isRecordingEnabled]);
 };
-const overridesRegistry = getOverridesRegistry();
-const useNetworkActivityDevTools = (config = DEFAULT_CONFIG) => {
-  var _a, _b, _c, _d;
+const inspectorsConfig = bootRecording.createNetworkInspectorsConfiguration();
+const useNetworkActivityDevTools = (config = bootRecording.DEFAULT_CONFIG) => {
   const isRecordingEnabledRef = react.useRef(false);
   const client = pluginBridge.useRozeniteDevToolsClient({
     pluginId: "@rozenite/network-activity-plugin"
   });
-  const isHttpInspectorEnabled = ((_a = config.inspectors) == null ? void 0 : _a.http) ?? true;
-  const isWebSocketInspectorEnabled = ((_b = config.inspectors) == null ? void 0 : _b.websocket) ?? true;
-  const isSSEInspectorEnabled = ((_c = config.inspectors) == null ? void 0 : _c.sse) ?? true;
-  const showUrlAsName = (_d = config.clientUISettings) == null ? void 0 : _d.showUrlAsName;
+  const isHttpInspectorEnabled = config.inspectors?.http ?? true;
+  const isWebSocketInspectorEnabled = config.inspectors?.websocket ?? true;
+  const isSSEInspectorEnabled = config.inspectors?.sse ?? true;
+  const showUrlAsName = config.clientUISettings?.showUrlAsName;
+  const { eventsListener, networkInspector } = inspectorsConfig;
   react.useEffect(() => {
     if (!client) {
       return;
     }
-    validateConfig(config);
+    bootRecording.validateConfig(config);
   }, [config]);
   react.useEffect(() => {
     if (!client) {
       return;
     }
     const sendClientUISettings = () => {
-      var _a2;
       client.send("client-ui-settings", {
         settings: {
-          showUrlAsName: showUrlAsName ?? ((_a2 = DEFAULT_CONFIG.clientUISettings) == null ? void 0 : _a2.showUrlAsName)
+          showUrlAsName: showUrlAsName ?? bootRecording.DEFAULT_CONFIG.clientUISettings?.showUrlAsName
         }
       });
     };
     const subscriptions = [
       client.onMessage("network-enable", () => {
         isRecordingEnabledRef.current = true;
+        eventsListener.connect(client.send, (message) => {
+          const type = message.type;
+          if (bootRecording.isHttpEvent(type)) {
+            return isHttpInspectorEnabled;
+          }
+          if (bootRecording.isWebSocketEvent(type)) {
+            return isWebSocketInspectorEnabled;
+          }
+          if (bootRecording.isSSEEvent(type)) {
+            return isSSEInspectorEnabled;
+          }
+          return true;
+        });
       }),
       client.onMessage("network-disable", () => {
         isRecordingEnabledRef.current = false;
       }),
-      client.onMessage("set-overrides", (data) => {
-        overridesRegistry.setOverrides(data.overrides);
-      }),
       client.onMessage("get-client-ui-settings", () => {
         sendClientUISettings();
       })
@@ -993,80 +141,31 @@ const useNetworkActivityDevTools = (config = DEFAULT_CONFIG) => {
     return () => {
       subscriptions.forEach((subscription) => subscription.remove());
     };
-  }, [client, showUrlAsName]);
-  react.useEffect(() => {
-    if (!client || !isHttpInspectorEnabled) {
-      return;
-    }
-    const networkInspector = getNetworkInspector(client);
-    if (isRecordingEnabledRef.current) {
-      networkInspector.enable();
-    }
-    return () => {
-      networkInspector.dispose();
-    };
-  }, [client, isHttpInspectorEnabled]);
-  react.useEffect(() => {
-    if (!client || !isWebSocketInspectorEnabled) {
-      return;
-    }
-    const eventsToForward = [
-      "websocket-connect",
-      "websocket-open",
-      "websocket-close",
-      "websocket-message-sent",
-      "websocket-message-received",
-      "websocket-error",
-      "websocket-connection-status-changed"
-    ];
-    const websocketInspector = getWebSocketInspector();
-    eventsToForward.forEach((event) => {
-      websocketInspector.on(event, (event2) => {
-        client.send(event2.type, event2);
-      });
-    });
-    client.onMessage("network-enable", () => {
-      websocketInspector.enable();
-    });
-    client.onMessage("network-disable", () => {
-      websocketInspector.disable();
-    });
-    if (isRecordingEnabledRef.current) {
-      websocketInspector.enable();
-    }
-    return () => {
-      websocketInspector.dispose();
-    };
-  }, [client, isWebSocketInspectorEnabled]);
-  react.useEffect(() => {
-    if (!client || !isSSEInspectorEnabled) {
-      return;
-    }
-    const eventsToForward = [
-      "sse-open",
-      "sse-message",
-      "sse-error",
-      "sse-close"
-    ];
-    const sseInspector = getSSEInspector();
-    eventsToForward.forEach((event) => {
-      sseInspector.on(event, (event2) => {
-        client.send(event2.type, event2);
-      });
-    });
-    client.onMessage("network-enable", () => {
-      sseInspector.enable();
-    });
-    client.onMessage("network-disable", () => {
-      sseInspector.disable();
-    });
-    if (isRecordingEnabledRef.current) {
-      sseInspector.enable();
-    }
-    return () => {
-      sseInspector.dispose();
-    };
-  }, [client, isSSEInspectorEnabled]);
+  }, [
+    client,
+    showUrlAsName,
+    isHttpInspectorEnabled,
+    isWebSocketInspectorEnabled,
+    isSSEInspectorEnabled
+  ]);
+  useHttpInspector(
+    client,
+    networkInspector.http,
+    isHttpInspectorEnabled,
+    isRecordingEnabledRef.current
+  );
+  useWebSocketInspector(
+    client,
+    networkInspector.websocket,
+    isWebSocketInspectorEnabled,
+    isRecordingEnabledRef.current
+  );
+  useSSEInspector(
+    client,
+    networkInspector.sse,
+    isSSEInspectorEnabled,
+    isRecordingEnabledRef.current
+  );
   return client;
 };
 exports.useNetworkActivityDevTools = useNetworkActivityDevTools;