@teardown/react-native 1.0.12 → 1.1.0-beta-04

package/src/debugger.ts

@@ -1,72 +0,0 @@
-import {NativeModules, Platform} from 'react-native';
-import {
-  ClientWebsocketEvents,
-  ConnectionEstablishedWebsocketEvent,
-  WebsocketClient,
-  WebsocketClientOptions,
-  WebsocketConnectionStatus,
-} from '@teardown/websocket';
-
-export type DebuggerStatus = WebsocketConnectionStatus;
-
-export type DebuggerOptions = WebsocketClientOptions;
-
-export class Debugger extends WebsocketClient<ClientWebsocketEvents> {
-
-  constructor(options?: DebuggerOptions) {
-    super(options);
-  }
-
-  public onEvent(event: ClientWebsocketEvents[keyof ClientWebsocketEvents]) {
-    this.logger.log('onEvent', event);
-    return event;
-  }
-
-  public onConnectionEstablished(event: ConnectionEstablishedWebsocketEvent) {
-    this.logger.log('Connection established', event);
-
-    this.client_id = event.client_id;
-
-    this.send('CLIENT_CONNECTION_ESTABLISHED', {
-      deviceName: '~~~--- device name here ---~~~',
-      platform: Platform.OS,
-      platformVersion: Platform.Version,
-      reactNativeVersion: Platform.constants.reactNativeVersion,
-      isDisableAnimations: Platform.constants.isDisableAnimations ?? false,
-      isTesting: Platform.constants.isTesting,
-    });
-  }
-
-  getHostFromUrl(url: string) {
-    const host = url.match(
-      /^(?:https?:\/\/)?(\[[^\]]+\]|[^/:\s]+)(?::\d+)?(?:[/?#]|$)/,
-    )?.[1];
-
-    if (typeof host !== 'string') {
-      throw new Error('Invalid URL - host not found');
-    }
-    return host;
-  }
-
-  getHost() {
-    try {
-      // https://github.com/facebook/react-native/blob/2a7f969500cef73b621269299619ee1f0ee9521a/packages/react-native/src/private/specs/modules/NativeSourceCode.js#L16
-      const scriptURL = NativeModules?.SourceCode?.getConstants().scriptURL
-      if (typeof scriptURL !== "string") throw new Error("Invalid non-string URL")
-      console.log('scriptURL', scriptURL);
-
-      return this.getHostFromUrl(scriptURL)
-    } catch (error) {
-      const superHost = super.getHost();
-      this.logger.warn(`Failed to get host: "${error.message}" - Falling back to ${superHost}`);
-      return superHost;
-    }
-  }
-
-  public send<
-    Type extends keyof ClientWebsocketEvents,
-    Payload extends ClientWebsocketEvents[Type]['payload'],
-  >(type: Type, payload: Payload) {
-    super.send(type, payload);
-  }
-}

package/src/index.ts

@@ -1,5 +0,0 @@
-// export * from './components';
-// export * from './containers';
-// export * from './services';
-export * from './teardown.client';
-export * from './plugins';

package/src/plugins/http.plugin.ts

@@ -1,171 +0,0 @@
-// @ts-ignore
-import XHRInterceptor from 'react-native/Libraries/Network/XHRInterceptor';
-import type {Plugin, TeardownClient} from '../teardown.client';
-import {Logger} from '@teardown/logger';
-import {Util} from '@teardown/util';
-import type {HTTPRequestInfo, RequestMethod} from '@teardown/websocket';
-
-interface ExtendedXMLHttpRequest extends XMLHttpRequest {
-  _id: number;
-}
-
-export type HTTPPluginOptions = {
-  ignoreURLs?: RegExp[];
-};
-
-export class HTTPPlugin implements Plugin {
-  private logger = new Logger('HTTPPlugin');
-  private client: TeardownClient<any> | null = null;
-  private requests: Map<number, HTTPRequestInfo> = new Map();
-  private ignoreURLs: RegExp[];
-
-  constructor(options: HTTPPluginOptions = {}) {
-    this.ignoreURLs = options.ignoreURLs || [];
-  }
-
-  install(client: TeardownClient<any>): void {
-    this.client = client;
-    this.setupXHRInterceptor();
-  }
-
-  private setupXHRInterceptor(): void {
-    if (XHRInterceptor.isInterceptorEnabled()) {
-      this.logger.warn(
-          'XHRInterceptor is already enabled by another library. Disable it or run this plugin first when your app loads.',
-      );
-    }
-
-    XHRInterceptor.setOpenCallback(this.xhrOpenCallback);
-    XHRInterceptor.setRequestHeaderCallback(this.xhrRequestHeaderCallback);
-    XHRInterceptor.setSendCallback(this.xhrSendCallback);
-    XHRInterceptor.setResponseCallback(this.xhrResponseCallback);
-
-    XHRInterceptor.enableInterception();
-  }
-
-  private shouldIgnoreURL(url: string): boolean {
-    return this.ignoreURLs.some(ignoreRegex => ignoreRegex.test(url));
-  }
-
-  private xhrOpenCallback = (
-      method: string,
-      url: string,
-      xhr: ExtendedXMLHttpRequest,
-  ): void => {
-    if (this.shouldIgnoreURL(url)) {
-      return;
-    }
-
-    const requestId = Util.generateUUID();
-
-    const HTTPRequestInfo: HTTPRequestInfo = {
-      id: requestId,
-      type: 'XMLHttpRequest',
-      url,
-      method: method as RequestMethod,
-      requestHeaders: {'TD-Request-ID': requestId},
-      startTime: Date.now(),
-      updatedAt: Date.now(),
-    };
-
-    this.requests.set(xhr._id, HTTPRequestInfo);
-  };
-
-  private xhrRequestHeaderCallback = (
-      header: string,
-      value: string,
-      xhr: ExtendedXMLHttpRequest,
-  ): void => {
-    const request = this.requests.get(xhr._id);
-    if (request) {
-      request.requestHeaders[header] = value;
-      request.updatedAt = Date.now();
-    }
-  };
-
-  private xhrSendCallback = (data: any, xhr: ExtendedXMLHttpRequest): void => {
-    const request = this.requests.get(xhr._id);
-    if (request) {
-      xhr.setRequestHeader('TD-Request-ID', request.id);
-
-      request.dataSent = this.serializeRequestBody(data);
-      request.updatedAt = Date.now();
-      this.sendHTTPEvent(request);
-    }
-  };
-
-  private serializeRequestBody(data: any): string {
-    if (typeof data === 'string') {
-      return data;
-    }
-    try {
-      return JSON.stringify(data);
-    } catch (error) {
-      this.logger.warn('Failed to stringify request body', error);
-      return '[Unable to serialize request body]';
-    }
-  }
-
-  private xhrResponseCallback = (
-      status: number,
-      timeout: number,
-      response: string,
-      responseURL: string,
-      responseType: XMLHttpRequestResponseType,
-      xhr: ExtendedXMLHttpRequest,
-  ): void => {
-    const request = this.requests.get(xhr._id);
-    if (request) {
-      request.status = status;
-      request.responseHeaders = this.parseResponseHeaders(
-          xhr.getAllResponseHeaders(),
-      );
-      request.response = this.parseResponseBody(response, responseType);
-      request.responseURL = responseURL;
-      request.responseType = responseType;
-      request.timeout = timeout;
-      request.endTime = Date.now();
-      request.updatedAt = Date.now();
-
-      this.sendHTTPEvent(request);
-      this.requests.delete(xhr._id);
-    }
-  };
-
-  private parseResponseHeaders(headersString: string): Record<string, string> {
-    const headersObject: Record<string, string> = {};
-    if (headersString) {
-      const headerPairs = headersString.trim().split(/[\r\n]+/);
-      headerPairs.forEach(headerPair => {
-        const [key, value] = headerPair.split(': ');
-        headersObject[key] = value;
-      });
-    }
-    return headersObject;
-  }
-
-  private parseResponseBody(
-      response: string,
-      responseType: XMLHttpRequestResponseType,
-  ): string {
-    if (responseType === 'json') {
-      try {
-        return JSON.stringify(JSON.parse(response), null, 2);
-      } catch (error) {
-        this.logger.warn('Failed to parse JSON response', error);
-      }
-    }
-    return response;
-  }
-
-  private sendHTTPEvent(httpRequestInfo: HTTPRequestInfo): void {
-    if (this.client?.debugger) {
-      this.client.debugger.send('NETWORK_HTTP_REQUEST', httpRequestInfo);
-    }
-  }
-
-  disableInterception(): void {
-    XHRInterceptor.disableInterception();
-    this.requests.clear();
-  }
-}

package/src/plugins/logging.plugin.ts

@@ -1,52 +0,0 @@
-import {Plugin, TeardownClient} from '../teardown.client';
-
-const originalConsoleLog = console.log;
-const originalConsoleWarn = console.warn;
-const originalConsoleDebug = console.debug;
-const originalConsoleError = console.error;
-
-export class LoggingPlugin implements Plugin {
-  private client: TeardownClient<any> | null = null;
-
-  install(client: TeardownClient<any>): void {
-    this.client = client;
-
-    console.log = (...args: Parameters<typeof console.log>) => {
-      originalConsoleLog(...args);
-
-      this.client?.debugger?.send('CONSOLE_LOG', {
-        type: 'log',
-        args,
-      });
-    };
-
-    console.warn = (...args: Parameters<typeof console.warn>) => {
-      originalConsoleWarn(...args);
-
-      this.client?.debugger?.send('CONSOLE_LOG', {
-        type: 'warn',
-        args,
-      });
-    };
-
-    console.debug = (...args: Parameters<typeof console.debug>) => {
-      originalConsoleDebug(...args);
-
-      this.client?.debugger?.send('CONSOLE_LOG', {
-        type: 'debug',
-        args,
-      });
-    };
-
-    console.error = (...args: Parameters<typeof console.error>) => {
-      originalConsoleError(...args);
-
-      this.client?.debugger?.send('CONSOLE_LOG', {
-        type: 'error',
-        args,
-      });
-    };
-  }
-
-  uninstall() {}
-}

package/src/plugins/websocket.plugin.ts

@@ -1,130 +0,0 @@
-// @ts-ignore
-import WebSocketInterceptor from 'react-native/Libraries/WebSocket/WebSocketInterceptor';
-
-import type {Plugin, TeardownClient} from '../teardown.client';
-import {Logger} from '@teardown/logger';
-import {Util} from '@teardown/util';
-import {
-  WebSocketInfo,
-  WebSocketMessageInfo,
-  WebSocketCloseInfo,
-} from '@teardown/websocket';
-
-export class WebSocketPlugin implements Plugin {
-  private logger = new Logger('WebSocketPlugin');
-  private client: TeardownClient<any> | null = null;
-  private sockets: Map<string, WebSocketInfo> = new Map();
-
-  constructor() {
-    this.setupWebSocketInterceptor();
-  }
-
-  install(client: TeardownClient<any>): void {
-    this.client = client;
-  }
-
-  private setupWebSocketInterceptor(): void {
-    if (WebSocketInterceptor.isInterceptorEnabled()) {
-      this.logger.warn(
-        'WebSocketInterceptor is already enabled by another library, disable it or run this first when your app loads',
-      );
-      this.disableInterception();
-    }
-
-    WebSocketInterceptor.setConnectCallback(this.wsConnectCallback);
-    WebSocketInterceptor.setSendCallback(this.wsSendCallback);
-    WebSocketInterceptor.setOnMessageCallback(this.wsOnMessageCallback);
-    WebSocketInterceptor.setOnCloseCallback(this.wsOnCloseCallback);
-
-    WebSocketInterceptor.enableInterception();
-
-    this.logger.log('WebSocketInterceptor enabled');
-  }
-
-  private wsConnectCallback = (
-    url: string,
-    protocols: string | string[] | undefined,
-    options: Object,
-    socketId: string,
-  ): void => {
-    const requestId = Util.generateUUID();
-    const socketInfo: WebSocketInfo = {
-      id: requestId,
-      url,
-      protocols,
-      timestamp: Date.now(),
-    };
-    this.sockets.set(socketId, socketInfo);
-    this.sendOpenEvent(socketInfo);
-  };
-
-  private wsSendCallback = (
-    data: string | ArrayBuffer | ArrayBufferView,
-    socketId: string,
-  ): void => {
-    const socket = this.sockets.get(socketId);
-    if (socket) {
-      const messageInfo: WebSocketMessageInfo = {
-        id: socket.id,
-        data: '', // TODO: Currently getting array buffer length errors here when sending data
-        timestamp: Date.now(),
-        direction: 'sent',
-      };
-      console.log('messageInfo', messageInfo);
-      // this.sendMessageEvent(messageInfo);
-    }
-  };
-
-  private wsOnMessageCallback = (
-    socketId: string,
-    message: WebSocketMessageEvent,
-  ): void => {
-    const socket = this.sockets.get(socketId);
-    if (socket) {
-      const messageInfo: WebSocketMessageInfo = {
-        id: socket.id,
-        data: '', // TODO: Currently getting array buffer length errors here when sending data
-        timestamp: Date.now(),
-        direction: 'received',
-      };
-      this.sendMessageEvent(messageInfo);
-    }
-  };
-
-  private wsOnCloseCallback = (socketId: string, event: any): void => {
-    const socket = this.sockets.get(socketId);
-    if (socket) {
-      const closeInfo: WebSocketCloseInfo = {
-        id: socket.id,
-        code: event.code,
-        reason: event.reason,
-        timestamp: Date.now(),
-      };
-      this.sendCloseEvent(closeInfo);
-      this.sockets.delete(socketId);
-    }
-  };
-
-  private sendOpenEvent(info: WebSocketInfo): void {
-    if (this.client && this.client.debugger) {
-      this.client.debugger.send('NETWORK_WEBSOCKET_OPEN', info);
-    }
-  }
-
-  private sendMessageEvent(info: WebSocketMessageInfo): void {
-    if (this.client && this.client.debugger) {
-      this.client.debugger.send('NETWORK_WEBSOCKET_MESSAGE', info);
-    }
-  }
-
-  private sendCloseEvent(info: WebSocketCloseInfo): void {
-    if (this.client && this.client.debugger) {
-      this.client.debugger.send('NETWORK_WEBSOCKET_CLOSE', info);
-    }
-  }
-
-  disableInterception(): void {
-    WebSocketInterceptor.disableInterception();
-    this.sockets.clear();
-  }
-}

package/src/services/teardown.service.ts

@@ -1,27 +0,0 @@
-import {useContext, createContext} from "react";
-import type {PluginTuple, TeardownClient} from "../teardown.client";
-
-export type TeardownServiceContextType<T extends readonly PluginTuple[]> = {
-	client: TeardownClient<T>
-};
-
-const Context = createContext<TeardownServiceContextType<any> | null>(null);
-
-export const TeardownService = {
-    Context,
-    Provider: Context.Provider,
-
-    useState<T extends readonly PluginTuple[]>() {
-        const state = useContext(Context);
-        if (state == null) {
-            throw new Error("TeardownService not found");
-        }
-        return state as TeardownServiceContextType<T>
-    },
-
-    useProvidedState<T extends readonly PluginTuple[]>(client: TeardownClient<T>): TeardownServiceContextType<T> {
-        return {
-			client
-        };
-    },
-};

package/src/teardown.client.ts

@@ -1,74 +0,0 @@
-import {Logger} from '@teardown/logger';
-import {Debugger, DebuggerOptions} from './debugger';
-
-export interface Plugin {
-  install?(client: TeardownClient<any>): void;
-  uninstall?(): void;
-}
-
-export type PluginTuple = readonly [string, Plugin];
-
-type InferPluginFromTuple<T extends PluginTuple> = {
-  [K in T[0]]: Omit<T[1], 'install' | 'uninstall'>;
-};
-
-type InferPluginsFromArray<T extends readonly PluginTuple[]> =
-  UnionToIntersection<InferPluginFromTuple<T[number]>>;
-
-type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
-  k: infer I,
-) => void
-  ? I
-  : never;
-
-export type TeardownClientOptions<T extends readonly PluginTuple[]> = {
-  plugins?: T;
-  debug?: boolean;
-} & DebuggerOptions;
-
-export class TeardownClient<T extends readonly PluginTuple[]> {
-  private logger = new Logger('TeardownClient');
-
-  private readonly plugins: Map<string, Plugin> = new Map();
-
-  public debugger: Debugger | null;
-
-  public api: InferPluginsFromArray<T> = {} as InferPluginsFromArray<T>;
-
-  constructor(options?: TeardownClientOptions<T>) {
-    this.debugger = __DEV__ ? new Debugger(options) : null;
-
-    options?.plugins?.forEach(([key, plugin]) => {
-      this.plugins.set(key, plugin);
-    });
-
-    this.installPlugins();
-  }
-
-  private installPlugins() {
-    this.logger.log('Installing plugins');
-    this.plugins.forEach((plugin, key) => {
-      plugin.install?.(this);
-      (this.api as any)[key] = plugin;
-    });
-    this.logger.log('Plugins installed');
-  }
-
-  uninstallPlugin(key: string) {
-    const plugin = this.plugins.get(key);
-    if (plugin) {
-      plugin.uninstall?.();
-      this.plugins.delete(key);
-      delete (this.api as any)[key];
-    }
-  }
-
-  uninstallAllPlugins() {
-    this.plugins.forEach((_, key) => this.uninstallPlugin(key));
-  }
-
-  reinstallPlugins() {
-    this.uninstallAllPlugins();
-    this.installPlugins();
-  }
-}