@rozenite/network-activity-plugin 1.0.0-alpha.1 → 1.0.0-alpha.10

package/dist/event-source.cjs

@@ -0,0 +1,22 @@
+"use strict";
+const NOOP = () => {
+};
+const MOCK_EVENT_SOURCE = class {
+  constructor() {
+    this.open = NOOP;
+    this.close = NOOP;
+    this.addEventListener = NOOP;
+    this.removeEventListener = NOOP;
+    this.dispatch = NOOP;
+    this.removeAllEventListeners = NOOP;
+  }
+};
+const getEventSource = () => {
+  try {
+    const { default: EventSource } = require("react-native-sse");
+    return EventSource;
+  } catch {
+    return MOCK_EVENT_SOURCE;
+  }
+};
+exports.getEventSource = getEventSource;

package/dist/event-source.js

@@ -0,0 +1,23 @@
+const NOOP = () => {
+};
+const MOCK_EVENT_SOURCE = class {
+  constructor() {
+    this.open = NOOP;
+    this.close = NOOP;
+    this.addEventListener = NOOP;
+    this.removeEventListener = NOOP;
+    this.dispatch = NOOP;
+    this.removeAllEventListeners = NOOP;
+  }
+};
+const getEventSource = () => {
+  try {
+    const { default: EventSource } = require("react-native-sse");
+    return EventSource;
+  } catch {
+    return MOCK_EVENT_SOURCE;
+  }
+};
+export {
+  getEventSource as g
+};

package/dist/react-native.cjs

@@ -1 +1,8 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const v=require("react"),k=require("@rozenite/plugin-bridge");let g=0;function S(){return(++g).toString()}function i(t){if(t instanceof Headers){const e={};return t.forEach((r,o)=>{e[o]=r}),e}else if(Array.isArray(t)){const e={};return t.forEach(([r,o])=>{e[r]=o}),e}return t}function E(t,e){let r,o,n,s;return typeof t=="string"?(r=t,o=(e==null?void 0:e.method)||"GET",n=i((e==null?void 0:e.headers)||{}),s=(e==null?void 0:e.body)||void 0):t instanceof Request?(r=t.url,o=t.method,n=i(t.headers),s=t.body||void 0):(r=t.toString(),o=(e==null?void 0:e.method)||"GET",n=i((e==null?void 0:e.headers)||{}),s=(e==null?void 0:e.body)||void 0),{url:r,method:o,headers:n,body:s}}const T=()=>{const t=k.useRozeniteDevToolsClient({pluginId:"@rozenite/network-activity-plugin"});return v.useEffect(()=>{if(!t)return;const e=window.fetch.bind(window),r=(o,n)=>{t.send(o,n)};return window.fetch=async function(o,n){const s=S(),c=E(o,n),d=Date.now()/1e3,w=d;r("Network.requestWillBeSent",{requestId:s,loaderId:s,documentURL:"",request:{url:c.url,method:c.method,headers:c.headers,postData:c.body,hasPostData:!!c.body},timestamp:d,wallTime:w,initiator:{type:"script",stack:{callFrames:[{functionName:"fetch",scriptId:"1",url:"",lineNumber:1,columnNumber:1}]}},redirectHasExtraInfo:!1,redirectResponse:null,referrerPolicy:"no-referrer",type:"Fetch",frameId:"1",hasUserGesture:!1}),r("Network.requestWillBeSentExtraInfo",{requestId:s,blockedCookies:[],headers:c.headers,connectTiming:{requestTime:d},clientSecurityState:{initiatorIsSecureContext:!1,initiatorIPAddressSpace:"Public",privateNetworkRequestPolicy:"Allow"},siteHasCookieInOtherPartition:!1});let a;try{a=await e(o,n);const l={};a.headers.forEach((y,m)=>{l[m]=y});const p=a.headers.get("content-type")||"",h=a.headers.get("content-length"),u=h?parseInt(h,10):0;let f=u;try{f=(await a.clone().arrayBuffer()).byteLength}catch{f=u}return r("Network.responseReceived",{requestId:s,loaderId:s,timestamp:Date.now()/1e3,type:"Fetch",response:{url:c.url,status:a.status,statusText:a.statusText,headers:l,mimeType:p,requestHeaders:c.headers,requestHeadersText:void 0,connectionReused:!1,connectionId:0,remoteIPAddress:void 0,remotePort:void 0,protocol:void 0,securityState:"unknown",encodedDataLength:u,timing:{requestTime:d,proxyStart:-1,proxyEnd:-1,dnsStart:-1,dnsEnd:-1,connectStart:-1,connectEnd:-1,sslStart:-1,sslEnd:-1,workerStart:-1,workerReadyStart:-1,workerReadyEnd:-1,sendStart:d,sendEnd:d,pushStart:-1,pushEnd:-1,receiveHeadersEnd:Date.now()/1e3},responseTime:Date.now()/1e3,fromDiskCache:!1,fromServiceWorker:!1,fromPrefetchCache:!1,encodedBodySize:u,decodedBodySize:f,headersText:void 0,serviceWorkerResponseSource:void 0,responseSource:"network",statusCode:a.status},hasExtraInfo:!1}),r("Network.loadingFinished",{requestId:s,timestamp:Date.now()/1e3,encodedDataLength:u,shouldReportCorbBlocking:!1}),a}catch(l){throw r("Network.loadingFailed",{requestId:s,timestamp:Date.now()/1e3,type:"Fetch",errorText:l instanceof Error?l.message:"Unknown error",canceled:!1,blockedReason:void 0}),l}},()=>{window.fetch=e}},[t]),t};exports.useNetworkActivityDevTools=void 0;process.env.NODE_ENV!=="production"?exports.useNetworkActivityDevTools=T:exports.useNetworkActivityDevTools=()=>null;
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+exports.useNetworkActivityDevTools = void 0;
+if (process.env.NODE_ENV !== "production") {
+  exports.useNetworkActivityDevTools = require("./useNetworkActivityDevTools.cjs").useNetworkActivityDevTools;
+} else {
+  exports.useNetworkActivityDevTools = () => null;
+}

package/dist/react-native.d.ts

@@ -1,5 +1 @@
-import { useNetworkActivityDevTools as useNetworkActivityDevTools_2 } from './src/react-native/useNetworkActivityDevTools';
-
-export declare let useNetworkActivityDevTools: useNetworkActivityDevTools_2;
-
-export { }
+export declare let useNetworkActivityDevTools: typeof import('./src/react-native/useNetworkActivityDevTools').useNetworkActivityDevTools;

package/dist/react-native.js

@@ -1,174 +1,9 @@
-import { useEffect as v } from "react";
-import { useRozeniteDevToolsClient as S } from "@rozenite/plugin-bridge";
-let E = 0;
-function g() {
-  return (++E).toString();
+let useNetworkActivityDevTools;
+if (process.env.NODE_ENV !== "production") {
+  useNetworkActivityDevTools = require("./useNetworkActivityDevTools.js").useNetworkActivityDevTools;
+} else {
+  useNetworkActivityDevTools = () => null;
 }
-function h(t) {
-  if (t instanceof Headers) {
-    const e = {};
-    return t.forEach((r, o) => {
-      e[o] = r;
-    }), e;
-  } else if (Array.isArray(t)) {
-    const e = {};
-    return t.forEach(([r, o]) => {
-      e[r] = o;
-    }), e;
-  }
-  return t;
-}
-function I(t, e) {
-  let r, o, n, s;
-  return typeof t == "string" ? (r = t, o = (e == null ? void 0 : e.method) || "GET", n = h((e == null ? void 0 : e.headers) || {}), s = (e == null ? void 0 : e.body) || void 0) : t instanceof Request ? (r = t.url, o = t.method, n = h(t.headers), s = t.body || void 0) : (r = t.toString(), o = (e == null ? void 0 : e.method) || "GET", n = h((e == null ? void 0 : e.headers) || {}), s = (e == null ? void 0 : e.body) || void 0), { url: r, method: o, headers: n, body: s };
-}
-const T = () => {
-  const t = S({
-    pluginId: "@rozenite/network-activity-plugin"
-  });
-  return v(() => {
-    if (!t)
-      return;
-    const e = window.fetch.bind(window), r = (o, n) => {
-      t.send(o, n);
-    };
-    return window.fetch = async function(o, n) {
-      const s = g(), d = I(o, n), c = Date.now() / 1e3, w = c;
-      r("Network.requestWillBeSent", {
-        requestId: s,
-        loaderId: s,
-        documentURL: "",
-        request: {
-          url: d.url,
-          method: d.method,
-          headers: d.headers,
-          postData: d.body,
-          hasPostData: !!d.body
-        },
-        timestamp: c,
-        wallTime: w,
-        initiator: {
-          type: "script",
-          stack: {
-            callFrames: [
-              {
-                functionName: "fetch",
-                scriptId: "1",
-                url: "",
-                lineNumber: 1,
-                columnNumber: 1
-              }
-            ]
-          }
-        },
-        redirectHasExtraInfo: !1,
-        redirectResponse: null,
-        referrerPolicy: "no-referrer",
-        type: "Fetch",
-        frameId: "1",
-        hasUserGesture: !1
-      }), r("Network.requestWillBeSentExtraInfo", {
-        requestId: s,
-        blockedCookies: [],
-        headers: d.headers,
-        connectTiming: {
-          requestTime: c
-        },
-        clientSecurityState: {
-          initiatorIsSecureContext: !1,
-          initiatorIPAddressSpace: "Public",
-          privateNetworkRequestPolicy: "Allow"
-        },
-        siteHasCookieInOtherPartition: !1
-      });
-      let a;
-      try {
-        a = await e(o, n);
-        const l = {};
-        a.headers.forEach((m, y) => {
-          l[y] = m;
-        });
-        const k = a.headers.get("content-type") || "", i = a.headers.get("content-length"), u = i ? parseInt(i, 10) : 0;
-        let f = u;
-        try {
-          f = (await a.clone().arrayBuffer()).byteLength;
-        } catch {
-          f = u;
-        }
-        return r("Network.responseReceived", {
-          requestId: s,
-          loaderId: s,
-          timestamp: Date.now() / 1e3,
-          type: "Fetch",
-          response: {
-            url: d.url,
-            status: a.status,
-            statusText: a.statusText,
-            headers: l,
-            mimeType: k,
-            requestHeaders: d.headers,
-            requestHeadersText: void 0,
-            connectionReused: !1,
-            connectionId: 0,
-            remoteIPAddress: void 0,
-            remotePort: void 0,
-            protocol: void 0,
-            securityState: "unknown",
-            encodedDataLength: u,
-            timing: {
-              requestTime: c,
-              proxyStart: -1,
-              proxyEnd: -1,
-              dnsStart: -1,
-              dnsEnd: -1,
-              connectStart: -1,
-              connectEnd: -1,
-              sslStart: -1,
-              sslEnd: -1,
-              workerStart: -1,
-              workerReadyStart: -1,
-              workerReadyEnd: -1,
-              sendStart: c,
-              sendEnd: c,
-              pushStart: -1,
-              pushEnd: -1,
-              receiveHeadersEnd: Date.now() / 1e3
-            },
-            responseTime: Date.now() / 1e3,
-            fromDiskCache: !1,
-            fromServiceWorker: !1,
-            fromPrefetchCache: !1,
-            encodedBodySize: u,
-            decodedBodySize: f,
-            headersText: void 0,
-            serviceWorkerResponseSource: void 0,
-            responseSource: "network",
-            statusCode: a.status
-          },
-          hasExtraInfo: !1
-        }), r("Network.loadingFinished", {
-          requestId: s,
-          timestamp: Date.now() / 1e3,
-          encodedDataLength: u,
-          shouldReportCorbBlocking: !1
-        }), a;
-      } catch (l) {
-        throw r("Network.loadingFailed", {
-          requestId: s,
-          timestamp: Date.now() / 1e3,
-          type: "Fetch",
-          errorText: l instanceof Error ? l.message : "Unknown error",
-          canceled: !1,
-          blockedReason: void 0
-        }), l;
-      }
-    }, () => {
-      window.fetch = e;
-    };
-  }, [t]), t;
-};
-let p;
-process.env.NODE_ENV !== "production" ? p = T : p = () => null;
 export {
-  p as useNetworkActivityDevTools
+  useNetworkActivityDevTools
 };

package/dist/rozenite.config.d.ts

@@ -0,0 +1,7 @@
+declare const _default: {
+    panels: {
+        name: string;
+        source: string;
+    }[];
+};
+export default _default;

package/dist/rozenite.json

@@ -1 +1 @@
-{"name":"@rozenite/network-activity-plugin","version":"1.0.0-alpha.1","description":"Network Activity for Rozenite.","panels":[{"name":"Network Activity","source":"/panel.html"}]}
+{"name":"@rozenite/network-activity-plugin","version":"1.0.0-alpha.8","description":"Network Activity for Rozenite.","panels":[{"name":"Network Activity","source":"/App.html"}]}

package/dist/src/react-native/http/network-inspector.d.ts

@@ -0,0 +1,8 @@
+import { NetworkActivityDevToolsClient } from '../../shared/client';
+export type NetworkInspector = {
+    enable: () => void;
+    disable: () => void;
+    isEnabled: () => boolean;
+    dispose: () => void;
+};
+export declare const getNetworkInspector: (pluginClient: NetworkActivityDevToolsClient) => NetworkInspector;

package/dist/src/react-native/http/network-requests-registry.d.ts

@@ -0,0 +1,6 @@
+export type NetworkRequestRegistry = {
+    addEntry: (id: string, request: XMLHttpRequest) => void;
+    getEntry: (id: string) => XMLHttpRequest | null;
+    clear: () => void;
+};
+export declare const getNetworkRequestsRegistry: () => NetworkRequestRegistry;

package/dist/src/react-native/http/xhr-interceptor.d.ts

@@ -0,0 +1,38 @@
+type XHRInterceptorOpenCallback = (method: string, url: string, request: XMLHttpRequest) => void;
+type XHRInterceptorSendCallback = (data: string, request: XMLHttpRequest) => void;
+type XHRInterceptorRequestHeaderCallback = (header: string, value: string, request: XMLHttpRequest) => void;
+type XHRInterceptorHeaderReceivedCallback = (responseContentType: string | undefined, responseSize: number | undefined, allHeaders: string, request: XMLHttpRequest) => void;
+type XHRInterceptorResponseCallback = (status: number, timeout: number, response: string, responseURL: string, responseType: string, request: XMLHttpRequest) => void;
+/**
+ * A network interceptor which monkey-patches XMLHttpRequest methods
+ * to gather all network requests/responses, in order to show their
+ * information in the React Native inspector development tool.
+ * This supports interception with XMLHttpRequest API, including Fetch API
+ * and any other third party libraries that depend on XMLHttpRequest.
+ */
+export declare const XHRInterceptor: {
+    /**
+     * Invoked before XMLHttpRequest.open(...) is called.
+     */
+    setOpenCallback(callback: XHRInterceptorOpenCallback): void;
+    /**
+     * Invoked before XMLHttpRequest.send(...) is called.
+     */
+    setSendCallback(callback: XHRInterceptorSendCallback): void;
+    /**
+     * Invoked after xhr's readyState becomes xhr.HEADERS_RECEIVED.
+     */
+    setHeaderReceivedCallback(callback: XHRInterceptorHeaderReceivedCallback): void;
+    /**
+     * Invoked after xhr's readyState becomes xhr.DONE.
+     */
+    setResponseCallback(callback: XHRInterceptorResponseCallback): void;
+    /**
+     * Invoked before XMLHttpRequest.setRequestHeader(...) is called.
+     */
+    setRequestHeaderCallback(callback: XHRInterceptorRequestHeaderCallback): void;
+    isInterceptorEnabled(): boolean;
+    enableInterception(): void;
+    disableInterception(): void;
+};
+export {};

package/dist/src/react-native/sse/event-source.d.ts

@@ -0,0 +1,2 @@
+import { default as EventSource } from 'react-native-sse';
+export declare const getEventSource: () => typeof EventSource;

package/dist/src/react-native/sse/sse-inspector.d.ts

@@ -0,0 +1,9 @@
+import { SSEEventMap } from '../../shared/sse-events';
+export type SSEInspector = {
+    enable: () => void;
+    disable: () => void;
+    isEnabled: () => boolean;
+    dispose: () => void;
+    on: <TEventType extends keyof SSEEventMap>(event: TEventType, callback: (data: SSEEventMap[TEventType]) => void) => () => void;
+};
+export declare const getSSEInspector: () => SSEInspector;

package/dist/src/react-native/sse/sse-interceptor.d.ts

@@ -0,0 +1,36 @@
+import { default as EventSource, MessageEvent, ErrorEvent, OpenEvent, CloseEvent, TimeoutEvent, ExceptionEvent } from 'react-native-sse';
+export type SSEInterceptorConnectCallback = (url: string, request: EventSource) => void;
+export type SSEInterceptorMessageCallback = (event: MessageEvent, request: EventSource) => void;
+export type SSEInterceptorErrorCallback = (error: ErrorEvent | TimeoutEvent | ExceptionEvent, request: EventSource) => void;
+export type SSEInterceptorOpenEventCallback = (event: OpenEvent, request: EventSource) => void;
+export type SSEInterceptorCloseCallback = (event: CloseEvent, request: EventSource) => void;
+/**
+ * A network interceptor which monkey-patches EventSource open method
+ * to gather all SSE connections and events, in order to show their
+ * information in the Network Activity panel.
+ */
+export declare const SSEInterceptor: {
+    /**
+     * Invoked when EventSource.open() is called (connection attempt starting).
+     */
+    setConnectCallback(callback: SSEInterceptorConnectCallback): void;
+    /**
+     * Invoked when a message event is received.
+     */
+    setMessageCallback(callback: SSEInterceptorMessageCallback): void;
+    /**
+     * Invoked when an error event occurs.
+     */
+    setErrorCallback(callback: SSEInterceptorErrorCallback): void;
+    /**
+     * Invoked when the connection is successfully opened (open event fired).
+     */
+    setOpenEventCallback(callback: SSEInterceptorOpenEventCallback): void;
+    /**
+     * Invoked when the connection is closed.
+     */
+    setCloseCallback(callback: SSEInterceptorCloseCallback): void;
+    isInterceptorEnabled(): boolean;
+    enableInterception(): void;
+    disableInterception(): void;
+};

package/dist/src/react-native/sse/types.d.ts

@@ -0,0 +1,6 @@
+import { default as EventSource } from 'react-native-sse';
+export interface EventSourceWithInternals<E extends string = never> extends EventSource<E> {
+    url: string;
+    /** Used internally to mark the underlying XHR to skip it in XHR interceptor. */
+    _xhr?: XMLHttpRequest;
+}

package/dist/src/react-native/useNetworkActivityDevTools.d.ts

@@ -0,0 +1,2 @@
+import { NetworkActivityEventMap } from '../shared/client';
+export declare const useNetworkActivityDevTools: () => import('@rozenite/plugin-bridge').RozeniteDevToolsClient<NetworkActivityEventMap> | null;

package/dist/src/react-native/utils.d.ts

@@ -0,0 +1,6 @@
+type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+type LastOf<T> = UnionToIntersection<T extends unknown ? () => T : never> extends () => infer R ? R : never;
+type Push<T extends unknown[], V> = [...T, V];
+export type UnionToTuple<T, L = LastOf<T>> = [T] extends [never] ? [] : Push<UnionToTuple<Exclude<T, L>>, L>;
+export declare const getContentType: (request: XMLHttpRequest) => string;
+export {};

package/dist/src/react-native/websocket/websocket-inspector.d.ts

@@ -0,0 +1,9 @@
+import { WebSocketEventMap } from '../../shared/websocket-events';
+export type WebSocketInspector = {
+    enable: () => void;
+    disable: () => void;
+    isEnabled: () => boolean;
+    dispose: () => void;
+    on: <TEventType extends keyof WebSocketEventMap>(event: TEventType, callback: (data: WebSocketEventMap[TEventType]) => void) => () => void;
+};
+export declare const getWebSocketInspector: () => WebSocketInspector;

package/dist/src/react-native/websocket/websocket-interceptor.d.ts

@@ -0,0 +1,74 @@
+import { default as WebSocketInterceptor } from 'react-native/Libraries/WebSocket/WebSocketInterceptor';
+export interface WebSocketInterceptor {
+    /**
+     * Invoked when RCTWebSocketModule.close(...) is called.
+     */
+    setCloseCallback(callback: (code: number | null, reason: string | null, socketId: number) => void): void;
+    /**
+     * Invoked when RCTWebSocketModule.send(...) or sendBinary(...) is called.
+     */
+    setSendCallback(callback: (data: string, socketId: number) => void): void;
+    /**
+     * Invoked when RCTWebSocketModule.connect(...) is called.
+     */
+    setConnectCallback(callback: (url: string, protocols: string[] | null, options: string[], socketId: number) => void): void;
+    /**
+     * Invoked when event "websocketOpen" happens.
+     */
+    setOnOpenCallback(callback: (socketId: number) => void): void;
+    /**
+     * Invoked when event "websocketMessage" happens.
+     */
+    setOnMessageCallback(callback: (data: string, socketId: number) => void): void;
+    /**
+     * Invoked when event "websocketFailed" happens.
+     */
+    setOnErrorCallback(callback: (error: string, socketId: number) => void): void;
+    /**
+     * Invoked when event "websocketClosed" happens.
+     */
+    setOnCloseCallback(callback: (error: {
+        code: number;
+        reason?: string;
+    }, socketId: number) => void): void;
+    isInterceptorEnabled(): boolean;
+    enableInterception(): void;
+    disableInterception(): void;
+}
+export interface WebSocketInterceptorPreRN079 {
+    /**
+     * Invoked when RCTWebSocketModule.close(...) is called.
+     */
+    setCloseCallback(callback: (code: number | null, reason: string | null, socketId: number) => void): void;
+    /**
+     * Invoked when RCTWebSocketModule.send(...) or sendBinary(...) is called.
+     */
+    setSendCallback(callback: (data: string, socketId: number) => void): void;
+    /**
+     * Invoked when RCTWebSocketModule.connect(...) is called.
+     */
+    setConnectCallback(callback: (url: string, protocols: string[] | null, options: string[], socketId: number) => void): void;
+    /**
+     * Invoked when event "websocketOpen" happens.
+     */
+    setOnOpenCallback(callback: (socketId: number) => void): void;
+    /**
+     * Invoked when event "websocketMessage" happens.
+     */
+    setOnMessageCallback(callback: (socketId: number, data: string) => void): void;
+    /**
+     * Invoked when event "websocketFailed" happens.
+     */
+    setOnErrorCallback(callback: (socketId: number, error: string) => void): void;
+    /**
+     * Invoked when event "websocketClosed" happens.
+     */
+    setOnCloseCallback(callback: (socketId: number, error: {
+        code: number;
+        reason?: string;
+    }) => void): void;
+    isInterceptorEnabled(): boolean;
+    enableInterception(): void;
+    disableInterception(): void;
+}
+export declare const getWebSocketInterceptor: () => WebSocketInterceptor;

package/dist/src/shared/client.d.ts

@@ -0,0 +1,68 @@
+import { RozeniteDevToolsClient } from '@rozenite/plugin-bridge';
+import { WebSocketEventMap } from './websocket-events';
+import { SSEEventMap } from './sse-events';
+export type HttpHeaders = Record<string, string>;
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD';
+export type RequestId = string;
+export type Timestamp = number;
+export type Request = {
+    url: string;
+    method: HttpMethod;
+    headers: HttpHeaders;
+    postData?: string;
+};
+export type Response = {
+    url: string;
+    status: number;
+    statusText: string;
+    headers: HttpHeaders;
+    contentType: string;
+    size: number;
+    responseTime: Timestamp;
+};
+export type Initiator = {
+    type: string;
+    url?: string;
+    lineNumber?: number;
+    columnNumber?: number;
+};
+export type ResourceType = 'XHR' | 'Fetch' | 'Other';
+export type NetworkActivityEventMap = {
+    'network-enable': unknown;
+    'network-disable': unknown;
+    'request-sent': {
+        requestId: RequestId;
+        request: Request;
+        timestamp: Timestamp;
+        initiator: Initiator;
+        type: ResourceType;
+    };
+    'response-received': {
+        requestId: RequestId;
+        timestamp: Timestamp;
+        type: ResourceType;
+        response: Response;
+    };
+    'request-completed': {
+        requestId: RequestId;
+        timestamp: Timestamp;
+        duration: number;
+        size: number;
+        ttfb: number;
+    };
+    'request-failed': {
+        requestId: RequestId;
+        timestamp: Timestamp;
+        type: ResourceType;
+        error: string;
+        canceled: boolean;
+    };
+    'get-response-body': {
+        requestId: RequestId;
+    };
+    'response-body': {
+        requestId: RequestId;
+        body: string | null;
+    };
+} & WebSocketEventMap & SSEEventMap;
+export type NetworkActivityDevToolsClient = RozeniteDevToolsClient<NetworkActivityEventMap>;

package/dist/src/shared/sse-events.d.ts

@@ -0,0 +1,35 @@
+import { Response } from './client';
+export type SSEConnectionStatus = 'connecting' | 'open' | 'closed';
+export type SSERequestId = string;
+export type SSEOpenEvent = {
+    type: 'sse-open';
+    requestId: SSERequestId;
+    timestamp: number;
+    response: Response;
+};
+export type SSEMessageEvent = {
+    type: 'sse-message';
+    requestId: SSERequestId;
+    timestamp: number;
+    data: string;
+};
+export type SSEErrorEvent = {
+    type: 'sse-error';
+    requestId: SSERequestId;
+    timestamp: number;
+    error: {
+        type: 'error' | 'timeout' | 'exception';
+        message: string;
+    };
+};
+export type SSECloseEvent = {
+    type: 'sse-close';
+    requestId: SSERequestId;
+    timestamp: number;
+};
+export type SSEEvent = SSEOpenEvent | SSEMessageEvent | SSEErrorEvent | SSECloseEvent;
+export type SSEEventMap = {
+    [K in SSEEvent['type']]: Extract<SSEEvent, {
+        type: K;
+    }>;
+};

package/dist/src/shared/websocket-events.d.ts

@@ -0,0 +1,60 @@
+export type WebSocketMessageType = 'text' | 'binary';
+export type WebSocketConnectionStatus = 'connecting' | 'open' | 'closing' | 'closed';
+export type WebSocketConnectEvent = {
+    type: 'websocket-connect';
+    url: string;
+    socketId: number;
+    timestamp: number;
+    protocols: string[] | null;
+    options: string[];
+};
+export type WebSocketOpenEvent = {
+    type: 'websocket-open';
+    url: string;
+    socketId: number;
+    timestamp: number;
+};
+export type WebSocketCloseEvent = {
+    type: 'websocket-close';
+    url: string;
+    socketId: number;
+    timestamp: number;
+    code: number;
+    reason?: string;
+};
+export type WebSocketMessageSentEvent = {
+    type: 'websocket-message-sent';
+    url: string;
+    socketId: number;
+    timestamp: number;
+    data: string;
+    messageType: WebSocketMessageType;
+};
+export type WebSocketMessageReceivedEvent = {
+    type: 'websocket-message-received';
+    url: string;
+    socketId: number;
+    timestamp: number;
+    data: string;
+    messageType: WebSocketMessageType;
+};
+export type WebSocketErrorEvent = {
+    type: 'websocket-error';
+    url: string;
+    socketId: number;
+    timestamp: number;
+    error: string;
+};
+export type WebSocketConnectionStatusChangedEvent = {
+    type: 'websocket-connection-status-changed';
+    url: string;
+    socketId: number;
+    timestamp: number;
+    status: WebSocketConnectionStatus;
+};
+export type WebSocketEvent = WebSocketConnectEvent | WebSocketOpenEvent | WebSocketCloseEvent | WebSocketMessageSentEvent | WebSocketMessageReceivedEvent | WebSocketErrorEvent | WebSocketConnectionStatusChangedEvent;
+export type WebSocketEventMap = {
+    [K in WebSocketEvent['type']]: Extract<WebSocketEvent, {
+        type: K;
+    }>;
+};

package/dist/src/ui/App.d.ts

@@ -0,0 +1 @@
+export default function NetworkActivityPanel(): import("react/jsx-runtime").JSX.Element;

package/dist/src/ui/components/Badge.d.ts

@@ -0,0 +1,9 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "destructive" | "outline" | "secondary" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface BadgeProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
+}
+declare function Badge({ className, variant, ...props }: BadgeProps): import("react/jsx-runtime").JSX.Element;
+export { Badge, badgeVariants };