react-native-xenon 0.2.1 → 0.4.0

package/src/hooks/useNetworkInterceptor.ts

@@ -1,26 +1,16 @@
 import { useCallback, useEffect, useState } from 'react';
 import { useImmer } from 'use-immer';
-import { NETWORK_REQUEST_HEADER } from '../constants';
+import { NETWORK_REQUEST_HEADER } from '../core/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';
+import { keyValueToString } from '../core/utils';
 
 interface NetworkInterceptorParams {
   autoEnabled: boolean;
@@ -30,22 +20,26 @@ type NetworkRequests<T> = Map<NonNullable<ID>, T>;
 
 const initRequests = new Map<NonNullable<ID>, HttpRequest & WebSocketRequest>();
 
+const xhrInterceptor = new XHRInterceptor();
+const fetchInterceptor = new FetchInterceptor();
+const webSocketInterceptor = new WebSocketInterceptor();
+
 export default function useNetworkInterceptor({ autoEnabled }: NetworkInterceptorParams) {
   const [isInterceptorEnabled, setIsInterceptorEnabled] = useState(autoEnabled);
 
   const [networkRequests, setNetworkRequests] = useImmer(initRequests);
 
   const isEnabled = () =>
-    XHRInterceptor.instance.isInterceptorEnabled &&
-    FetchInterceptor.instance.isInterceptorEnabled &&
-    WebSocketInterceptor.instance.isInterceptorEnabled;
+    xhrInterceptor.isInterceptorEnabled &&
+    fetchInterceptor.isInterceptorEnabled &&
+    webSocketInterceptor.isInterceptorEnabled;
 
   const clearAllNetworkRequests = () => {
     setNetworkRequests(initRequests);
   };
 
   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 +47,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 +75,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 +85,7 @@ export default function useNetworkInterceptor({ autoEnabled }: NetworkIntercepto
       });
     };
 
-    const headerReceivedCallback: HttpHeaderReceivedCallback = (
+    const headerReceivedCallback: HttpHandlers['headerReceived'] = (
       id,
       responseContentType,
       responseSize,
@@ -108,7 +102,7 @@ export default function useNetworkInterceptor({ autoEnabled }: NetworkIntercepto
       });
     };
 
-    const responseCallback: HttpResponseCallback = (
+    const responseCallback: HttpHandlers['response'] = (
       id,
       status,
       timeout,
@@ -131,25 +125,25 @@ export default function useNetworkInterceptor({ autoEnabled }: NetworkIntercepto
       });
     };
 
-    XHRInterceptor.instance
-      .setOpenCallback(openCallback)
-      .setRequestHeaderCallback(requestHeaderCallback)
-      .setSendCallback(sendCallback)
-      .setHeaderReceivedCallback(headerReceivedCallback)
-      .setResponseCallback(responseCallback)
+    xhrInterceptor
+      .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)
+    fetchInterceptor
+      .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 +156,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 +167,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 +178,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 +188,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 +199,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 +209,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>) => {
@@ -225,14 +219,14 @@ export default function useNetworkInterceptor({ autoEnabled }: NetworkIntercepto
       });
     };
 
-    WebSocketInterceptor.instance
-      .setConnectCallback(connectCallback)
-      .setSendCallback(sendCallback)
-      .setCloseCallback(closeCallback)
-      .setOnOpenCallback(onOpenCallback)
-      .setOnMessageCallback(onMessageCallback)
-      .setOnErrorCallback(onErrorCallback)
-      .setOnCloseCallback(onCloseCallback)
+    webSocketInterceptor
+      .set('connect', connectCallback)
+      .set('send', sendCallback)
+      .set('close', closeCallback)
+      .set('onOpen', onOpenCallback)
+      .set('onMessage', onMessageCallback)
+      .set('onError', onErrorCallback)
+      .set('onClose', onCloseCallback)
       .enableInterception();
   }, [setNetworkRequests]);
 
@@ -241,22 +235,25 @@ export default function useNetworkInterceptor({ autoEnabled }: NetworkIntercepto
 
     enableHttpInterceptions();
     enableWebSocketInterception();
+
     setIsInterceptorEnabled(true);
   }, [enableHttpInterceptions, enableWebSocketInterception]);
 
   const disableInterception = useCallback(() => {
     if (!isEnabled()) return;
 
-    XHRInterceptor.instance.disableInterception();
-    FetchInterceptor.instance.disableInterception();
-    WebSocketInterceptor.instance.disableInterception();
+    xhrInterceptor.disableInterception();
+    fetchInterceptor.disableInterception();
+    webSocketInterceptor.disableInterception();
+
     setIsInterceptorEnabled(false);
   }, []);
 
   useEffect(() => {
-    if (autoEnabled) enableInterception();
-
-    if (autoEnabled) return disableInterception;
+    if (autoEnabled) {
+      enableInterception();
+      return disableInterception;
+    }
   }, [autoEnabled, disableInterception, enableInterception]);
 
   return {

package/src/interceptors/ConsoleInterceptor.ts

@@ -1,4 +1,6 @@
 /* eslint-disable no-console */
+import type { ConsoleHandlers } from '../types';
+import { frozen, singleton } from '../core/utils';
 import Interceptor from './Interceptor';
 
 const originalConsoleError = console.error;
@@ -12,24 +14,17 @@ const originalConsoleGroupCollapsed = console.groupCollapsed;
 const originalConsoleGroupEnd = console.groupEnd;
 const originalConsoleGroup = console.group;
 
-export default class ConsoleInterceptor extends Interceptor {
-  static readonly instance = new ConsoleInterceptor();
-
-  private constructor() {
-    super();
-  }
-
-  private callback: ((type: string, args: any[]) => void) | null = null;
-
-  setCallback(callback: typeof this.callback) {
-    this.callback = callback;
-    return this;
-  }
+@singleton
+export default class ConsoleInterceptor extends Interceptor<ConsoleHandlers> {
+  protected readonly handlers: ConsoleHandlers = {
+    callback: null,
+  };
 
+  @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 +89,7 @@ export default class ConsoleInterceptor extends Interceptor {
     this.isInterceptorEnabled = true;
   }
 
+  @frozen
   disableInterception(): void {
     if (!this.isInterceptorEnabled) return;
 
@@ -110,6 +106,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,17 +1,19 @@
-import { NETWORK_REQUEST_HEADER } from '../constants';
+import { NETWORK_REQUEST_HEADER } from '../core/constants';
+import {
+  formatRequestMethod,
+  frozen,
+  getHttpInterceptorId,
+  keyValueToString,
+  singleton,
+} from '../core/utils';
 import { NetworkType } from '../types';
-import { formatRequestMethod, getHttpInterceptorId, keyValueToString } from '../utils';
 import HttpInterceptor from './HttpInterceptor';
 
 const originalFetch = global.fetch;
 
+@singleton
 export default class FetchInterceptor extends HttpInterceptor {
-  static readonly instance = new FetchInterceptor();
-
-  private constructor() {
-    super();
-  }
-
+  @frozen
   enableInterception() {
     if (this.isInterceptorEnabled) return;
 
@@ -36,7 +38,6 @@ export default class FetchInterceptor extends HttpInterceptor {
       const method = formatRequestMethod(init?.method);
 
       let url: string;
-
       switch (true) {
         case input instanceof Request:
           url = input.url;
@@ -76,13 +77,13 @@ export default class FetchInterceptor extends HttpInterceptor {
       //#endregion
 
       //#region send
-      const timeStart = Date.now();
+      const startTime = Date.now();
       sendCallback?.(interceptionId, init?.body ?? null);
       //#endregion
 
       const response = await originalFetch.call(this, input, requestInit);
 
-      const timeEnd = Date.now();
+      const endTime = Date.now();
       const clonedResponse = response.clone();
       const clonedResponseHeaders = clonedResponse.headers;
 
@@ -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);
@@ -107,7 +105,7 @@ export default class FetchInterceptor extends HttpInterceptor {
 
       //#region response
       const responseBody: string | null = await clonedResponse.text().catch(() => null);
-      const duration = timeEnd - timeStart;
+      const duration = endTime - startTime;
 
       responseCallback?.(
         interceptionId,
@@ -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,65 +1,12 @@
-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;
-  }
-
-  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);
-
-    return {
-      openCallback,
-      requestHeaderCallback,
-      sendCallback,
-      headerReceivedCallback,
-      responseCallback,
-    };
-  }
-
-  protected clearCallbacks(): void {
-    this.openCallback = null;
-    this.requestHeaderCallback = null;
-    this.sendCallback = null;
-    this.headerReceivedCallback = null;
-    this.responseCallback = null;
-  }
+export default abstract class HttpInterceptor extends NetworkInterceptor<HttpHandlers> {
+  protected handlers: HttpHandlers = {
+    open: null,
+    requestHeader: null,
+    send: null,
+    headerReceived: null,
+    response: null,
+  };
 }

package/src/interceptors/Interceptor.ts

@@ -1,4 +1,6 @@
-export default abstract class Interceptor {
+import { frozen } from '../core/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,21 @@
 import Interceptor from './Interceptor';
 
-export abstract class NetworkInterceptor extends Interceptor {
-  protected abstract getCallbacks(): any;
-  protected abstract clearCallbacks(): void;
+type Callbacks<T> = { [K in keyof T as `${string & K}Callback`]: T[K] };
+
+export abstract class NetworkInterceptor<T extends Object> extends Interceptor<T> {
+  protected getCallbacks(): Callbacks<T> {
+    const callbacks = {} as Callbacks<T>;
+
+    for (const key in this.handlers) {
+      (callbacks as any)[`${key}Callback`] = this.handlers[key as keyof T];
+    }
+
+    return callbacks;
+  }
+
+  protected clearCallbacks(): void {
+    for (const key in this.handlers) {
+      (this.handlers as any)[key] = null;
+    }
+  }
 }