react-native-xenon 0.2.1 → 0.3.0

package/src/hooks/useNetworkInterceptor.ts

@@ -4,21 +4,11 @@ import { NETWORK_REQUEST_HEADER } from '../constants';
 import { FetchInterceptor, WebSocketInterceptor, XHRInterceptor } from '../interceptors';
 import {
   NetworkType,
-  type HttpHeaderReceivedCallback,
-  type HttpOpenCallback,
+  type HttpHandlers,
   type HttpRequest,
-  type HttpRequestHeaderCallback,
-  type HttpResponseCallback,
-  type HttpSendCallback,
   type ID,
-  type WebSocketCloseCallback,
-  type WebSocketConnectCallback,
-  type WebSocketOnCloseCallback,
-  type WebSocketOnErrorCallback,
-  type WebSocketOnMessageCallback,
-  type WebSocketOnOpenCallback,
+  type WebSocketHandlers,
   type WebSocketRequest,
-  type WebSocketSendCallback,
 } from '../types';
 import { keyValueToString } from '../utils';
 
@@ -45,7 +35,7 @@ export default function useNetworkInterceptor({ autoEnabled }: NetworkIntercepto
   };
 
   const enableHttpInterceptions = useCallback(() => {
-    const openCallback: HttpOpenCallback = (id, type, method, url) => {
+    const openCallback: HttpHandlers['open'] = (id, type, method, url) => {
       if (!id) return;
 
       setNetworkRequests((draft: NetworkRequests<HttpRequest>) => {
@@ -53,7 +43,7 @@ export default function useNetworkInterceptor({ autoEnabled }: NetworkIntercepto
       });
     };
 
-    const requestHeaderCallback: HttpRequestHeaderCallback = (id, header, value) => {
+    const requestHeaderCallback: HttpHandlers['requestHeader'] = (id, header, value) => {
       if (!id) return;
 
       setNetworkRequests((draft: NetworkRequests<HttpRequest>) => {
@@ -81,7 +71,7 @@ export default function useNetworkInterceptor({ autoEnabled }: NetworkIntercepto
       });
     };
 
-    const sendCallback: HttpSendCallback = (id, data) => {
+    const sendCallback: HttpHandlers['send'] = (id, data) => {
       if (!id) return;
 
       setNetworkRequests((draft: NetworkRequests<HttpRequest>) => {
@@ -91,7 +81,7 @@ export default function useNetworkInterceptor({ autoEnabled }: NetworkIntercepto
       });
     };
 
-    const headerReceivedCallback: HttpHeaderReceivedCallback = (
+    const headerReceivedCallback: HttpHandlers['headerReceived'] = (
       id,
       responseContentType,
       responseSize,
@@ -108,7 +98,7 @@ export default function useNetworkInterceptor({ autoEnabled }: NetworkIntercepto
       });
     };
 
-    const responseCallback: HttpResponseCallback = (
+    const responseCallback: HttpHandlers['response'] = (
       id,
       status,
       timeout,
@@ -132,24 +122,24 @@ export default function useNetworkInterceptor({ autoEnabled }: NetworkIntercepto
     };
 
     XHRInterceptor.instance
-      .setOpenCallback(openCallback)
-      .setRequestHeaderCallback(requestHeaderCallback)
-      .setSendCallback(sendCallback)
-      .setHeaderReceivedCallback(headerReceivedCallback)
-      .setResponseCallback(responseCallback)
+      .set('open', openCallback)
+      .set('requestHeader', requestHeaderCallback)
+      .set('send', sendCallback)
+      .set('headerReceived', headerReceivedCallback)
+      .set('response', responseCallback)
       .enableInterception();
 
     FetchInterceptor.instance
-      .setOpenCallback(openCallback)
-      .setRequestHeaderCallback(requestHeaderCallback)
-      .setSendCallback(sendCallback)
-      .setHeaderReceivedCallback(headerReceivedCallback)
-      .setResponseCallback(responseCallback)
+      .set('open', openCallback)
+      .set('requestHeader', requestHeaderCallback)
+      .set('send', sendCallback)
+      .set('headerReceived', headerReceivedCallback)
+      .set('response', responseCallback)
       .enableInterception();
   }, [setNetworkRequests]);
 
   const enableWebSocketInterception = useCallback(() => {
-    const connectCallback: WebSocketConnectCallback = (url, protocols, options, socketId) => {
+    const connectCallback: WebSocketHandlers['connect'] = (url, protocols, options, socketId) => {
       if (typeof socketId !== 'number') return;
 
       setNetworkRequests((draft: NetworkRequests<WebSocketRequest>) => {
@@ -162,7 +152,7 @@ export default function useNetworkInterceptor({ autoEnabled }: NetworkIntercepto
       });
     };
 
-    const sendCallback: WebSocketSendCallback = (data, socketId) => {
+    const sendCallback: WebSocketHandlers['send'] = (data, socketId) => {
       if (typeof socketId !== 'number') return;
 
       setNetworkRequests((draft: NetworkRequests<WebSocketRequest>) => {
@@ -173,7 +163,7 @@ export default function useNetworkInterceptor({ autoEnabled }: NetworkIntercepto
       });
     };
 
-    const closeCallback: WebSocketCloseCallback = (code, reason, socketId) => {
+    const closeCallback: WebSocketHandlers['close'] = (code, reason, socketId) => {
       if (typeof socketId !== 'number') return;
 
       setNetworkRequests((draft: NetworkRequests<WebSocketRequest>) => {
@@ -184,7 +174,7 @@ export default function useNetworkInterceptor({ autoEnabled }: NetworkIntercepto
       });
     };
 
-    const onOpenCallback: WebSocketOnOpenCallback = (socketId, duration) => {
+    const onOpenCallback: WebSocketHandlers['onOpen'] = (socketId, duration) => {
       if (typeof socketId !== 'number') return;
 
       setNetworkRequests((draft: NetworkRequests<WebSocketRequest>) => {
@@ -194,7 +184,7 @@ export default function useNetworkInterceptor({ autoEnabled }: NetworkIntercepto
       });
     };
 
-    const onMessageCallback: WebSocketOnMessageCallback = (socketId, message) => {
+    const onMessageCallback: WebSocketHandlers['onMessage'] = (socketId, message) => {
       if (typeof socketId !== 'number') return;
 
       setNetworkRequests((draft: NetworkRequests<WebSocketRequest>) => {
@@ -205,7 +195,7 @@ export default function useNetworkInterceptor({ autoEnabled }: NetworkIntercepto
       });
     };
 
-    const onErrorCallback: WebSocketOnErrorCallback = (socketId, data) => {
+    const onErrorCallback: WebSocketHandlers['onError'] = (socketId, data) => {
       if (typeof socketId !== 'number') return;
 
       setNetworkRequests((draft: NetworkRequests<WebSocketRequest>) => {
@@ -215,7 +205,7 @@ export default function useNetworkInterceptor({ autoEnabled }: NetworkIntercepto
       });
     };
 
-    const onCloseCallback: WebSocketOnCloseCallback = (socketId, data) => {
+    const onCloseCallback: WebSocketHandlers['onClose'] = (socketId, data) => {
       if (typeof socketId !== 'number') return;
 
       setNetworkRequests((draft: NetworkRequests<WebSocketRequest>) => {
@@ -226,13 +216,13 @@ export default function useNetworkInterceptor({ autoEnabled }: NetworkIntercepto
     };
 
     WebSocketInterceptor.instance
-      .setConnectCallback(connectCallback)
-      .setSendCallback(sendCallback)
-      .setCloseCallback(closeCallback)
-      .setOnOpenCallback(onOpenCallback)
-      .setOnMessageCallback(onMessageCallback)
-      .setOnErrorCallback(onErrorCallback)
-      .setOnCloseCallback(onCloseCallback)
+      .set('connect', connectCallback)
+      .set('send', sendCallback)
+      .set('close', closeCallback)
+      .set('onOpen', onOpenCallback)
+      .set('onMessage', onMessageCallback)
+      .set('onError', onErrorCallback)
+      .set('onClose', onCloseCallback)
       .enableInterception();
   }, [setNetworkRequests]);
 

package/src/icons.ts

@@ -1,5 +1,5 @@
 const icons = Object.freeze({
-  code: require('./assets/icons/code.png'),
+  bug: require('./assets/icons/bug.png'),
   delete: require('./assets/icons/delete.png'),
   hide: require('./assets/icons/hide.png'),
   move: require('./assets/icons/move.png'),

package/src/interceptors/ConsoleInterceptor.ts

@@ -1,4 +1,6 @@
 /* eslint-disable no-console */
+import type { ConsoleHandlers } from '../types';
+import { frozen } from '../utils';
 import Interceptor from './Interceptor';
 
 const originalConsoleError = console.error;
@@ -12,24 +14,22 @@ const originalConsoleGroupCollapsed = console.groupCollapsed;
 const originalConsoleGroupEnd = console.groupEnd;
 const originalConsoleGroup = console.group;
 
-export default class ConsoleInterceptor extends Interceptor {
+export default class ConsoleInterceptor extends Interceptor<ConsoleHandlers> {
   static readonly instance = new ConsoleInterceptor();
 
+  protected readonly handlers: ConsoleHandlers = {
+    callback: null,
+  };
+
   private constructor() {
     super();
   }
 
-  private callback: ((type: string, args: any[]) => void) | null = null;
-
-  setCallback(callback: typeof this.callback) {
-    this.callback = callback;
-    return this;
-  }
-
+  @frozen
   enableInterception(): void {
     if (this.isInterceptorEnabled) return;
 
-    const callback = this.callback?.bind(this);
+    const callback = this.handlers.callback;
 
     console.error = function (...args) {
       callback?.('error', args);
@@ -94,6 +94,7 @@ export default class ConsoleInterceptor extends Interceptor {
     this.isInterceptorEnabled = true;
   }
 
+  @frozen
   disableInterception(): void {
     if (!this.isInterceptorEnabled) return;
 
@@ -110,6 +111,6 @@ export default class ConsoleInterceptor extends Interceptor {
     console.groupEnd = originalConsoleGroupEnd;
     console.group = originalConsoleGroup;
 
-    this.callback = null;
+    this.handlers.callback = null;
   }
 }

package/src/interceptors/FetchInterceptor.ts

@@ -1,6 +1,6 @@
 import { NETWORK_REQUEST_HEADER } from '../constants';
 import { NetworkType } from '../types';
-import { formatRequestMethod, getHttpInterceptorId, keyValueToString } from '../utils';
+import { formatRequestMethod, frozen, getHttpInterceptorId, keyValueToString } from '../utils';
 import HttpInterceptor from './HttpInterceptor';
 
 const originalFetch = global.fetch;
@@ -12,6 +12,7 @@ export default class FetchInterceptor extends HttpInterceptor {
     super();
   }
 
+  @frozen
   enableInterception() {
     if (this.isInterceptorEnabled) return;
 
@@ -90,13 +91,10 @@ export default class FetchInterceptor extends HttpInterceptor {
       const contentTypeString = clonedResponseHeaders.get('Content-Type');
       const contentLengthString = clonedResponseHeaders.get('Content-Length');
 
-      let responseContentType: string | undefined;
-      let responseSize: number | undefined;
-      let responseHeaders: string = '';
-
-      if (contentTypeString) responseContentType = contentTypeString.split(';')[0];
+      const responseContentType = contentTypeString ? contentTypeString.split(';')[0] : undefined;
+      const responseSize = contentLengthString ? parseInt(contentLengthString, 10) : undefined;
 
-      if (contentLengthString) responseSize = parseInt(contentLengthString, 10);
+      let responseHeaders: string = '';
 
       for (const [headerKey, headerValue] of clonedResponseHeaders.entries()) {
         responseHeaders += keyValueToString(headerKey, headerValue);
@@ -126,6 +124,7 @@ export default class FetchInterceptor extends HttpInterceptor {
     this.isInterceptorEnabled = true;
   }
 
+  @frozen
   disableInterception() {
     if (!this.isInterceptorEnabled) return;
 

package/src/interceptors/HttpInterceptor.ts

@@ -1,50 +1,21 @@
-import type {
-  HttpHeaderReceivedCallback,
-  HttpOpenCallback,
-  HttpRequestHeaderCallback,
-  HttpResponseCallback,
-  HttpSendCallback,
-} from '../types';
+import type { HttpHandlers } from '../types';
 import { NetworkInterceptor } from './NetworkInterceptor';
 
-export default abstract class HttpInterceptor extends NetworkInterceptor {
-  protected openCallback: HttpOpenCallback = null;
-  protected requestHeaderCallback: HttpRequestHeaderCallback = null;
-  protected sendCallback: HttpSendCallback = null;
-  protected headerReceivedCallback: HttpHeaderReceivedCallback = null;
-  protected responseCallback: HttpResponseCallback = null;
-
-  setOpenCallback(callback: typeof this.openCallback) {
-    this.openCallback = callback;
-    return this;
-  }
-
-  setRequestHeaderCallback(callback: typeof this.requestHeaderCallback) {
-    this.requestHeaderCallback = callback;
-    return this;
-  }
-
-  setSendCallback(callback: typeof this.sendCallback) {
-    this.sendCallback = callback;
-    return this;
-  }
-
-  setHeaderReceivedCallback(callback: typeof this.headerReceivedCallback) {
-    this.headerReceivedCallback = callback;
-    return this;
-  }
-
-  setResponseCallback(callback: typeof this.responseCallback) {
-    this.responseCallback = callback;
-    return this;
-  }
+export default abstract class HttpInterceptor extends NetworkInterceptor<HttpHandlers> {
+  protected handlers: HttpHandlers = {
+    open: null,
+    requestHeader: null,
+    send: null,
+    headerReceived: null,
+    response: null,
+  };
 
   protected getCallbacks() {
-    const openCallback = this.openCallback?.bind(this);
-    const requestHeaderCallback = this.requestHeaderCallback?.bind(this);
-    const sendCallback = this.sendCallback?.bind(this);
-    const headerReceivedCallback = this.headerReceivedCallback?.bind(this);
-    const responseCallback = this.responseCallback?.bind(this);
+    const openCallback = this.handlers.open;
+    const requestHeaderCallback = this.handlers.requestHeader;
+    const sendCallback = this.handlers.send;
+    const headerReceivedCallback = this.handlers.headerReceived;
+    const responseCallback = this.handlers.response;
 
     return {
       openCallback,
@@ -56,10 +27,10 @@ export default abstract class HttpInterceptor extends NetworkInterceptor {
   }
 
   protected clearCallbacks(): void {
-    this.openCallback = null;
-    this.requestHeaderCallback = null;
-    this.sendCallback = null;
-    this.headerReceivedCallback = null;
-    this.responseCallback = null;
+    this.handlers.open = null;
+    this.handlers.requestHeader = null;
+    this.handlers.send = null;
+    this.handlers.headerReceived = null;
+    this.handlers.response = null;
   }
 }

package/src/interceptors/Interceptor.ts

@@ -1,4 +1,6 @@
-export default abstract class Interceptor {
+import { frozen } from '../utils';
+
+export default abstract class Interceptor<T extends Object> {
   #isInterceptorEnabled = false;
 
   get isInterceptorEnabled() {
@@ -9,6 +11,14 @@ export default abstract class Interceptor {
     this.#isInterceptorEnabled = value;
   }
 
+  protected abstract handlers: T;
+
+  @frozen
+  set<K extends keyof T>(key: K, handler: T[K]) {
+    this.handlers[key] = handler;
+    return this;
+  }
+
   abstract enableInterception(): void;
   abstract disableInterception(): void;
 }

package/src/interceptors/NetworkInterceptor.ts

@@ -1,6 +1,6 @@
 import Interceptor from './Interceptor';
 
-export abstract class NetworkInterceptor extends Interceptor {
+export abstract class NetworkInterceptor<T extends Object> extends Interceptor<T> {
   protected abstract getCallbacks(): any;
   protected abstract clearCallbacks(): void;
 }

package/src/interceptors/WebSocketInterceptor.ts

@@ -1,93 +1,48 @@
 import { NativeEventEmitter, type EmitterSubscription } from 'react-native';
 import NativeWebSocketModule from 'react-native/Libraries/WebSocket/NativeWebSocketModule';
-import type {
-  WebSocketCloseCallback,
-  WebSocketConnectCallback,
-  WebSocketOnCloseCallback,
-  WebSocketOnErrorCallback,
-  WebSocketOnMessageCallback,
-  WebSocketOnOpenCallback,
-  WebSocketSendCallback,
-} from '../types';
+import type { WebSocketHandlers } from '../types';
 import { NetworkInterceptor } from './NetworkInterceptor';
+import { frozen } from '../utils';
 
 const originalWebSocketConnect = NativeWebSocketModule.connect;
 const originalWebSocketSend = NativeWebSocketModule.send;
 const originalWebSocketSendBinary = NativeWebSocketModule.sendBinary;
 const originalWebSocketClose = NativeWebSocketModule.close;
 
-export default class WebSocketInterceptor extends NetworkInterceptor {
+export default class WebSocketInterceptor extends NetworkInterceptor<WebSocketHandlers> {
   static readonly instance = new WebSocketInterceptor();
 
+  protected handlers: WebSocketHandlers = {
+    connect: null,
+    send: null,
+    close: null,
+    onOpen: null,
+    onMessage: null,
+    onError: null,
+    onClose: null,
+  };
+
   private constructor() {
     super();
   }
 
-  private connectCallback: WebSocketConnectCallback = null;
-  private sendCallback: WebSocketSendCallback = null;
-  private closeCallback: WebSocketCloseCallback = null;
-  private onOpenCallback: WebSocketOnOpenCallback = null;
-  private onMessageCallback: WebSocketOnMessageCallback = null;
-  private onErrorCallback: WebSocketOnErrorCallback = null;
-  private onCloseCallback: WebSocketOnCloseCallback = null;
-
-  setConnectCallback(callback: typeof this.connectCallback) {
-    this.connectCallback = callback;
-    return this;
-  }
-
-  setSendCallback(callback: typeof this.sendCallback) {
-    this.sendCallback = callback;
-    return this;
-  }
-
-  setCloseCallback(callback: typeof this.closeCallback) {
-    this.closeCallback = callback;
-    return this;
-  }
-
-  setOnOpenCallback(callback: typeof this.onOpenCallback) {
-    this.onOpenCallback = callback;
-    return this;
-  }
-
-  setOnMessageCallback(callback: typeof this.onMessageCallback) {
-    this.onMessageCallback = callback;
-    return this;
-  }
-
-  setOnErrorCallback(callback: typeof this.onErrorCallback) {
-    this.onErrorCallback = callback;
-    return this;
-  }
-
-  setOnCloseCallback(callback: typeof this.onCloseCallback) {
-    this.onCloseCallback = callback;
-    return this;
-  }
-
   protected getCallbacks() {
-    const connectCallback = this.connectCallback?.bind(this);
-    const sendCallback = this.sendCallback?.bind(this);
-    const closeCallback = this.closeCallback?.bind(this);
-    const arrayBufferToString = this.arrayBufferToString?.bind(this);
-
-    return {
-      connectCallback,
-      sendCallback,
-      closeCallback,
-      arrayBufferToString,
-    };
+    const connect = this.handlers.connect;
+    const send = this.handlers.send;
+    const close = this.handlers.close;
+    const arrayBufferToString = this.arrayBufferToString;
+
+    return { connect, send, close, arrayBufferToString };
   }
 
   protected clearCallbacks(): void {
-    this.connectCallback = null;
-    this.sendCallback = null;
-    this.closeCallback = null;
-    this.onOpenCallback = null;
-    this.onMessageCallback = null;
-    this.onErrorCallback = null;
-    this.onCloseCallback = null;
+    this.handlers.connect = null;
+    this.handlers.send = null;
+    this.handlers.close = null;
+    this.handlers.onOpen = null;
+    this.handlers.onMessage = null;
+    this.handlers.onError = null;
+    this.handlers.onClose = null;
   }
 
   private eventEmitter: NativeEventEmitter | null = null;
@@ -118,19 +73,19 @@ export default class WebSocketInterceptor extends NetworkInterceptor {
         const duration = timeEnd - (timeStart ?? 0);
         this.timeStart.delete(ev.id);
 
-        this.onOpenCallback?.(ev.id, duration);
+        this.handlers.onOpen?.(ev.id, duration);
       }),
       this.eventEmitter.addListener('websocketMessage', ev => {
-        this.onMessageCallback?.(
+        this.handlers.onMessage?.(
           ev.id,
           ev.type === 'binary' ? this.arrayBufferToString(ev.data) : ev.data,
         );
       }),
       this.eventEmitter.addListener('websocketClosed', ev => {
-        this.onCloseCallback?.(ev.id, { code: ev.code, reason: ev.reason });
+        this.handlers.onClose?.(ev.id, { code: ev.code, reason: ev.reason });
       }),
       this.eventEmitter.addListener('websocketFailed', ev => {
-        this.onErrorCallback?.(ev.id, { message: ev.message });
+        this.handlers.onError?.(ev.id, { message: ev.message });
       }),
     ];
   }
@@ -141,6 +96,7 @@ export default class WebSocketInterceptor extends NetworkInterceptor {
     this.eventEmitter = null;
   }
 
+  @frozen
   enableInterception(): void {
     if (this.isInterceptorEnabled) return;
 
@@ -148,12 +104,11 @@ export default class WebSocketInterceptor extends NetworkInterceptor {
 
     this.registerEvents();
 
-    const { connectCallback, sendCallback, closeCallback, arrayBufferToString } =
-      this.getCallbacks();
+    const { connect, send, close, arrayBufferToString } = this.getCallbacks();
 
     const timeStart = this.timeStart;
     NativeWebSocketModule.connect = function (...args) {
-      connectCallback?.(...args);
+      connect?.(...args);
 
       timeStart.set(args[3], Date.now());
 
@@ -161,19 +116,19 @@ export default class WebSocketInterceptor extends NetworkInterceptor {
     };
 
     NativeWebSocketModule.send = function (...args) {
-      sendCallback?.(...args);
+      send?.(...args);
 
       originalWebSocketSend.call(this, ...args);
     };
 
     NativeWebSocketModule.sendBinary = function (base64String, socketId) {
-      sendCallback?.(arrayBufferToString(base64String), socketId);
+      send?.(arrayBufferToString(base64String), socketId);
 
       originalWebSocketSendBinary.call(this, base64String, socketId);
     };
 
     NativeWebSocketModule.close = function (code, reason, socketId) {
-      closeCallback?.(code, reason, socketId);
+      close?.(code, reason, socketId);
 
       originalWebSocketClose.call(this, code, reason, socketId);
     };
@@ -181,6 +136,7 @@ export default class WebSocketInterceptor extends NetworkInterceptor {
     this.isInterceptorEnabled = true;
   }
 
+  @frozen
   disableInterception(): void {
     if (!this.isInterceptorEnabled) return;
 

package/src/interceptors/XHRInterceptor.ts

@@ -1,5 +1,5 @@
 import { NetworkType } from '../types';
-import { getHttpInterceptorId } from '../utils';
+import { frozen, getHttpInterceptorId } from '../utils';
 import HttpInterceptor from './HttpInterceptor';
 
 const originalXHROpen = XMLHttpRequest.prototype.open;
@@ -13,6 +13,7 @@ export default class XHRInterceptor extends HttpInterceptor {
     super();
   }
 
+  @frozen
   enableInterception() {
     if (this.isInterceptorEnabled) return;
 
@@ -52,12 +53,11 @@ export default class XHRInterceptor extends HttpInterceptor {
           const contentTypeString = this.getResponseHeader('Content-Type');
           const contentLengthString = this.getResponseHeader('Content-Length');
 
-          let responseContentType: string | undefined;
-          let responseSize: number | undefined;
+          const responseContentType = contentTypeString
+            ? contentTypeString.split(';')[0]
+            : undefined;
 
-          if (contentTypeString) responseContentType = contentTypeString.split(';')[0];
-
-          if (contentLengthString) responseSize = parseInt(contentLengthString, 10);
+          const responseSize = contentLengthString ? parseInt(contentLengthString, 10) : undefined;
 
           headerReceivedCallback?.(
             this._interceptionId,
@@ -89,6 +89,7 @@ export default class XHRInterceptor extends HttpInterceptor {
     this.isInterceptorEnabled = true;
   }
 
+  @frozen
   disableInterception() {
     if (!this.isInterceptorEnabled) return;
 

package/src/types/console.ts

@@ -2,3 +2,7 @@ export interface LogMessage {
   type: string;
   values: any[];
 }
+
+export interface ConsoleHandlers {
+  callback: ((type: string, args: any[]) => void) | null;
+}

package/src/types/http.ts

@@ -14,15 +14,15 @@ export interface HttpRequest extends NetworkRequest {
   responseType?: string;
 }
 
-export type HttpOpenCallback =
+type HttpOpenCallback =
   | ((id: ID, type: HttpRequest['type'], method: string, url: string) => void)
   | null;
 
-export type HttpRequestHeaderCallback = ((id: ID, header: string, value: string) => void) | null;
+type HttpRequestHeaderCallback = ((id: ID, header: string, value: string) => void) | null;
 
-export type HttpSendCallback = ((id: ID, data?: any) => void) | null;
+type HttpSendCallback = ((id: ID, data?: any) => void) | null;
 
-export type HttpHeaderReceivedCallback =
+type HttpHeaderReceivedCallback =
   | ((
       id: ID,
       responseContentType: string | undefined,
@@ -31,7 +31,7 @@ export type HttpHeaderReceivedCallback =
     ) => void)
   | null;
 
-export type HttpResponseCallback =
+type HttpResponseCallback =
   | ((
       id: ID,
       status: number | undefined,
@@ -42,3 +42,11 @@ export type HttpResponseCallback =
       responseType: string | undefined,
     ) => void)
   | null;
+
+export interface HttpHandlers {
+  open: HttpOpenCallback;
+  requestHeader: HttpRequestHeaderCallback;
+  send: HttpSendCallback;
+  headerReceived: HttpHeaderReceivedCallback;
+  response: HttpResponseCallback;
+}