@multiplayer-app/session-recorder-react-native 1.0.1-beta.4 → 1.0.1-beta.5

package/src/services/api.service.ts

@@ -1,38 +1,42 @@
-import { type IResourceAttributes, type ISessionAttributes, type ApiServiceConfig } from '../types'
+import {
+  type IResourceAttributes,
+  type ISessionAttributes,
+  type ApiServiceConfig,
+} from '../types';
 
 export interface StartSessionRequest {
-  name?: string
-  stoppedAt?: string | number
-  sessionAttributes?: ISessionAttributes
-  resourceAttributes?: IResourceAttributes
-  debugSessionData?: Record<string, any>
-  tags?: { key?: string, value: string }[]
+  name?: string;
+  stoppedAt?: string | number;
+  sessionAttributes?: ISessionAttributes;
+  resourceAttributes?: IResourceAttributes;
+  debugSessionData?: Record<string, any>;
+  tags?: { key?: string; value: string }[];
 }
 
 export interface StopSessionRequest {
-  sessionAttributes?: ISessionAttributes
-  stoppedAt: string | number
+  sessionAttributes?: ISessionAttributes;
+  stoppedAt: string | number;
 }
 
 export class ApiService {
-  private config?: ApiServiceConfig
-  private baseUrl: string = 'https://api.multiplayer.app'
+  private config?: ApiServiceConfig;
+  private baseUrl: string = 'https://api.multiplayer.app';
 
   constructor() {
     this.config = {
       apiKey: '',
       apiBaseUrl: '',
       exporterEndpoint: '',
-    }
+    };
   }
 
   init(config: ApiServiceConfig): void {
     this.config = {
       ...this.config,
       ...config,
-    }
+    };
     if (config.apiBaseUrl) {
-      this.baseUrl = config.apiBaseUrl
+      this.baseUrl = config.apiBaseUrl;
     }
   }
 
@@ -42,7 +46,7 @@ export class ApiService {
    */
   public updateConfigs(config: Partial<ApiServiceConfig>) {
     if (this.config) {
-      this.config = { ...this.config, ...config }
+      this.config = { ...this.config, ...config };
     }
   }
 
@@ -52,7 +56,7 @@ export class ApiService {
    */
   setApiKey(apiKey: string): void {
     if (this.config) {
-      this.config.apiKey = apiKey
+      this.config.apiKey = apiKey;
     }
   }
 
@@ -67,9 +71,9 @@ export class ApiService {
     path: string,
     method: string,
     body?: any,
-    signal?: AbortSignal,
+    signal?: AbortSignal
   ): Promise<any> {
-    const url = `${this.baseUrl}/v0/radar${path}`
+    const url = `${this.baseUrl}/v0/radar${path}`;
     const params = {
       method,
       body: body ? JSON.stringify(body) : null,
@@ -77,28 +81,28 @@ export class ApiService {
         'Content-Type': 'application/json',
         ...(this.config?.apiKey && { 'X-Api-Key': this.config.apiKey }),
       },
-    }
+    };
 
     try {
       const response = await fetch(url, {
         ...params,
         signal,
-      })
+      });
 
       if (!response.ok) {
-        throw new Error('Network response was not ok: ' + response.statusText)
+        throw new Error('Network response was not ok: ' + response.statusText);
       }
 
       if (response.status === 204) {
-        return null
+        return null;
       }
 
-      return await response.json()
+      return await response.json();
     } catch (error: any) {
       if (error?.name === 'AbortError') {
-        throw new Error('Request aborted')
+        throw new Error('Request aborted');
       }
-      throw new Error('Error making request: ' + error.message)
+      throw new Error('Error making request: ' + error.message);
     }
   }
 
@@ -109,18 +113,18 @@ export class ApiService {
    */
   async startSession(
     request: StartSessionRequest,
-    signal?: AbortSignal,
+    signal?: AbortSignal
   ): Promise<any> {
     try {
       const res = await this.makeRequest(
         '/debug-sessions/start',
         'POST',
         request,
-        signal,
-      )
-      return res
+        signal
+      );
+      return res;
     } catch (error: any) {
-      throw error
+      throw error;
     }
   }
 
@@ -131,13 +135,13 @@ export class ApiService {
    */
   async stopSession(
     sessionId: string,
-    request: StopSessionRequest,
+    request: StopSessionRequest
   ): Promise<any> {
     return this.makeRequest(
       `/debug-sessions/${sessionId}/stop`,
       'PATCH',
-      request,
-    )
+      request
+    );
   }
 
   /**
@@ -145,10 +149,7 @@ export class ApiService {
    * @param sessionId - ID of the session to cancel
    */
   async cancelSession(sessionId: string): Promise<any> {
-    return this.makeRequest(
-      `/debug-sessions/${sessionId}/cancel`,
-      'DELETE',
-    )
+    return this.makeRequest(`/debug-sessions/${sessionId}/cancel`, 'DELETE');
   }
 
   /**
@@ -158,14 +159,14 @@ export class ApiService {
    */
   async startContinuousDebugSession(
     request: StartSessionRequest,
-    signal?: AbortSignal,
+    signal?: AbortSignal
   ): Promise<any> {
     return this.makeRequest(
       '/continuous-debug-sessions/start',
       'POST',
       request,
-      signal,
-    )
+      signal
+    );
   }
 
   /**
@@ -177,14 +178,14 @@ export class ApiService {
   async saveContinuousDebugSession(
     sessionId: string,
     request: StartSessionRequest,
-    signal?: AbortSignal,
+    signal?: AbortSignal
   ): Promise<any> {
     return this.makeRequest(
       `/continuous-debug-sessions/${sessionId}/save`,
       'POST',
       request,
-      signal,
-    )
+      signal
+    );
   }
 
   /**
@@ -194,8 +195,8 @@ export class ApiService {
   async stopContinuousDebugSession(sessionId: string): Promise<any> {
     return this.makeRequest(
       `/continuous-debug-sessions/${sessionId}/cancel`,
-      'DELETE',
-    )
+      'DELETE'
+    );
   }
 
   /**
@@ -203,13 +204,13 @@ export class ApiService {
    */
   async checkRemoteSession(
     requestBody: StartSessionRequest,
-    signal?: AbortSignal,
+    signal?: AbortSignal
   ): Promise<{ state: 'START' | 'STOP' }> {
     return this.makeRequest(
       '/remote-debug-session/check',
       'POST',
       requestBody,
-      signal,
-    )
+      signal
+    );
   }
 }

package/src/services/network.service.ts

@@ -1,45 +1,46 @@
-import { Platform } from 'react-native'
-import { logger } from '../utils'
-import { sessionRecorderStore } from '../context/SessionRecorderStore'
+import { Platform } from 'react-native';
+import { logger } from '../utils';
+import { sessionRecorderStore } from '../context/SessionRecorderStore';
 
 // Safe import for NetInfo with web fallback
-let NetInfo: any = null
-const isWeb = Platform.OS === 'web'
+let NetInfo: any = null;
+const isWeb = Platform.OS === 'web';
 
 if (!isWeb) {
   try {
-    NetInfo = require('@react-native-community/netinfo').default
+    NetInfo = require('@react-native-community/netinfo').default;
   } catch (error) {
-    console.warn('NetInfo not available:', error)
+    console.warn('NetInfo not available:', error);
   }
 } else {
   // Web fallback using navigator.onLine
   NetInfo = {
-    fetch: () => Promise.resolve({
-      isConnected: true, // Default to connected for web
-      type: 'unknown',
-      isInternetReachable: true
-    }),
+    fetch: () =>
+      Promise.resolve({
+        isConnected: true, // Default to connected for web
+        type: 'unknown',
+        isInternetReachable: true,
+      }),
     addEventListener: (_callback: (state: any) => void) => {
       // Return a no-op function for web
-      return () => { }
-    }
-  }
+      return () => {};
+    },
+  };
 }
 
 export interface NetworkState {
-  isConnected: boolean
-  type: string | null
-  isInternetReachable: boolean | null
+  isConnected: boolean;
+  type: string | null;
+  isInternetReachable: boolean | null;
 }
 
-export type NetworkStateChangeCallback = (state: NetworkState) => void
+export type NetworkStateChangeCallback = (state: NetworkState) => void;
 
 export class NetworkService {
-  private static instance: NetworkService | null = null
-  private _isOnline = true
-  private unsubscribe: (() => void) | null = null
-  private callbacks: NetworkStateChangeCallback[] = []
+  private static instance: NetworkService | null = null;
+  private _isOnline = true;
+  private unsubscribe: (() => void) | null = null;
+  private callbacks: NetworkStateChangeCallback[] = [];
 
   private constructor() {
     // Private constructor for singleton
@@ -47,9 +48,9 @@ export class NetworkService {
 
   static getInstance(): NetworkService {
     if (!NetworkService.instance) {
-      NetworkService.instance = new NetworkService()
+      NetworkService.instance = new NetworkService();
     }
-    return NetworkService.instance
+    return NetworkService.instance;
   }
 
   /**
@@ -58,45 +59,49 @@ export class NetworkService {
   async init(): Promise<void> {
     try {
       // Get initial network state
-      const initialState = await NetInfo.fetch()
-      this._isOnline = initialState.isConnected ?? true
+      const initialState = await NetInfo.fetch();
+      this._isOnline = initialState.isConnected ?? true;
 
       // Update store with initial state
-      sessionRecorderStore.setState({ isOnline: this._isOnline })
+      sessionRecorderStore.setState({ isOnline: this._isOnline });
 
       // Notify callbacks
       this.notifyCallbacks({
         isConnected: this._isOnline,
         type: initialState.type,
         isInternetReachable: initialState.isInternetReachable,
-      })
+      });
 
       // Listen for network state changes
       this.unsubscribe = NetInfo.addEventListener((state: any) => {
-        const wasOnline = this._isOnline
-        this._isOnline = state.isConnected ?? true
+        const wasOnline = this._isOnline;
+        this._isOnline = state.isConnected ?? true;
 
         // Update store
-        sessionRecorderStore.setState({ isOnline: this._isOnline })
+        sessionRecorderStore.setState({ isOnline: this._isOnline });
 
         // Notify callbacks
         this.notifyCallbacks({
           isConnected: this._isOnline,
           type: state.type,
           isInternetReachable: state.isInternetReachable,
-        })
+        });
 
         // Log state changes
         if (wasOnline && !this._isOnline) {
-          logger.info('NetworkService', 'Network went offline')
+          logger.info('NetworkService', 'Network went offline');
         } else if (!wasOnline && this._isOnline) {
-          logger.info('NetworkService', 'Network came back online')
+          logger.info('NetworkService', 'Network came back online');
         }
-      })
+      });
 
-      logger.info('NetworkService', 'Network monitoring initialized')
+      logger.info('NetworkService', 'Network monitoring initialized');
     } catch (error) {
-      logger.error('NetworkService', 'Failed to initialize network monitoring', error)
+      logger.error(
+        'NetworkService',
+        'Failed to initialize network monitoring',
+        error
+      );
     }
   }
 
@@ -108,41 +113,45 @@ export class NetworkService {
       isConnected: this._isOnline,
       type: null, // We don't store this in the service
       isInternetReachable: null, // We don't store this in the service
-    }
+    };
   }
 
   /**
    * Check if device is online
    */
   isOnline(): boolean {
-    return this._isOnline
+    return this._isOnline;
   }
 
   /**
    * Add callback for network state changes
    */
   addCallback(callback: NetworkStateChangeCallback): void {
-    this.callbacks.push(callback)
+    this.callbacks.push(callback);
   }
 
   /**
    * Remove callback for network state changes
    */
   removeCallback(callback: NetworkStateChangeCallback): void {
-    this.callbacks = this.callbacks.filter(cb => cb !== callback)
+    this.callbacks = this.callbacks.filter((cb) => cb !== callback);
   }
 
   /**
    * Notify all callbacks of network state change
    */
   private notifyCallbacks(state: NetworkState): void {
-    this.callbacks.forEach(callback => {
+    this.callbacks.forEach((callback) => {
       try {
-        callback(state)
+        callback(state);
       } catch (error) {
-        logger.error('NetworkService', 'Error in network state callback', error)
+        logger.error(
+          'NetworkService',
+          'Error in network state callback',
+          error
+        );
       }
-    })
+    });
   }
 
   /**
@@ -150,11 +159,11 @@ export class NetworkService {
    */
   cleanup(): void {
     if (this.unsubscribe) {
-      this.unsubscribe()
-      this.unsubscribe = null
+      this.unsubscribe();
+      this.unsubscribe = null;
     }
-    this.callbacks = []
-    logger.info('NetworkService', 'Network monitoring cleaned up')
+    this.callbacks = [];
+    logger.info('NetworkService', 'Network monitoring cleaned up');
   }
 
   /**
@@ -162,21 +171,21 @@ export class NetworkService {
    */
   async refresh(): Promise<NetworkState> {
     try {
-      const state = await NetInfo.fetch()
-      this._isOnline = state.isConnected ?? true
-      sessionRecorderStore.setState({ isOnline: this._isOnline })
+      const state = await NetInfo.fetch();
+      this._isOnline = state.isConnected ?? true;
+      sessionRecorderStore.setState({ isOnline: this._isOnline });
 
       const networkState: NetworkState = {
         isConnected: this._isOnline,
         type: state.type,
         isInternetReachable: state.isInternetReachable,
-      }
+      };
 
-      this.notifyCallbacks(networkState)
-      return networkState
+      this.notifyCallbacks(networkState);
+      return networkState;
     } catch (error) {
-      logger.error('NetworkService', 'Failed to refresh network state', error)
-      throw error
+      logger.error('NetworkService', 'Failed to refresh network state', error);
+      throw error;
     }
   }
 }

package/src/services/screenMaskingService.ts

@@ -1,39 +1,42 @@
-import SessionRecorderNative, { type MaskingOptions } from '../native/SessionRecorderNative'
-import { logger } from '../utils'
-
+import SessionRecorderNative, {
+  type MaskingOptions,
+} from '../native/SessionRecorderNative';
+import { logger } from '../utils';
 
 export interface ScreenMaskingConfig {
   /** Whether screen masking is enabled */
-  enabled: boolean
+  enabled: boolean;
   /** Whether to mask text inputs (UITextField, UITextView, React Native text components) */
-  maskTextInputs?: boolean
+  maskTextInputs?: boolean;
   /** Whether to mask images (UIImageView, React Native Image components) */
-  maskImages?: boolean
+  maskImages?: boolean;
   /** Whether to mask buttons (UIButton) */
-  maskButtons?: boolean
+  maskButtons?: boolean;
   /** Whether to mask labels (UILabel) */
-  maskLabels?: boolean
+  maskLabels?: boolean;
   /** Whether to mask web views (WKWebView) */
-  maskWebViews?: boolean
+  maskWebViews?: boolean;
   /** Whether to mask sandboxed views (system views that don't belong to current process) */
-  maskSandboxedViews?: boolean
+  maskSandboxedViews?: boolean;
 }
 
 export class ScreenMaskingService {
-  private config: ScreenMaskingConfig
-  private isAvailable: boolean = false
+  private config: ScreenMaskingConfig;
+  private isAvailable: boolean = false;
 
-  constructor(config: ScreenMaskingConfig = {
-    enabled: true,
-    maskTextInputs: true,
-    maskImages: false,
-    maskButtons: false,
-    maskLabels: false,
-    maskWebViews: false,
-    maskSandboxedViews: false
-  }) {
-    this.config = config
-    this.checkAvailability()
+  constructor(
+    config: ScreenMaskingConfig = {
+      enabled: true,
+      maskTextInputs: true,
+      maskImages: false,
+      maskButtons: false,
+      maskLabels: false,
+      maskWebViews: false,
+      maskSandboxedViews: false,
+    }
+  ) {
+    this.config = config;
+    this.checkAvailability();
   }
 
   /**
@@ -42,17 +45,29 @@ export class ScreenMaskingService {
   private checkAvailability(): void {
     try {
       // Try to access the native module to check if it's available
-      if (SessionRecorderNative && typeof SessionRecorderNative.captureAndMask === 'function') {
-        this.isAvailable = true
-        logger.info('ScreenMaskingService', 'Screen masking native module is available')
+      if (
+        SessionRecorderNative &&
+        typeof SessionRecorderNative.captureAndMask === 'function'
+      ) {
+        this.isAvailable = true;
+        logger.info(
+          'ScreenMaskingService',
+          'Screen masking native module is available'
+        );
       } else {
-        this.isAvailable = false
-        logger.warn('ScreenMaskingService', 'Screen masking native module is not available - auto-linking may still be in progress')
-
+        this.isAvailable = false;
+        logger.warn(
+          'ScreenMaskingService',
+          'Screen masking native module is not available - auto-linking may still be in progress'
+        );
       }
     } catch (error) {
-      this.isAvailable = false
-      logger.error('ScreenMaskingService', 'Error checking screen masking availability:', error)
+      this.isAvailable = false;
+      logger.error(
+        'ScreenMaskingService',
+        'Error checking screen masking availability:',
+        error
+      );
     }
   }
 
@@ -61,19 +76,28 @@ export class ScreenMaskingService {
    */
   async captureMaskedScreen(options: MaskingOptions): Promise<string | null> {
     if (!this.isAvailable || !this.config.enabled) {
-      logger.warn('ScreenMaskingService', 'Screen masking is not available or disabled')
-      return null
+      logger.warn(
+        'ScreenMaskingService',
+        'Screen masking is not available or disabled'
+      );
+      return null;
     }
 
     try {
       const maskingOptions: MaskingOptions = {
-        ...this.config, ...options,
-      }
-      const maskedImageBase64 = await SessionRecorderNative.captureAndMaskWithOptions(maskingOptions)
-      return maskedImageBase64
+        ...this.config,
+        ...options,
+      };
+      const maskedImageBase64 =
+        await SessionRecorderNative.captureAndMaskWithOptions(maskingOptions);
+      return maskedImageBase64;
     } catch (error) {
-      logger.error('ScreenMaskingService', 'Failed to capture masked screen:', error)
-      return null
+      logger.error(
+        'ScreenMaskingService',
+        'Failed to capture masked screen:',
+        error
+      );
+      return null;
     }
   }
 
@@ -82,16 +106,23 @@ export class ScreenMaskingService {
    */
   async captureMaskedScreenBasic(): Promise<string | null> {
     if (!this.isAvailable || !this.config.enabled) {
-      logger.warn('ScreenMaskingService', 'Screen masking is not available or disabled')
-      return null
+      logger.warn(
+        'ScreenMaskingService',
+        'Screen masking is not available or disabled'
+      );
+      return null;
     }
 
     try {
-      const maskedImageBase64 = await SessionRecorderNative.captureAndMask()
-      return maskedImageBase64
+      const maskedImageBase64 = await SessionRecorderNative.captureAndMask();
+      return maskedImageBase64;
     } catch (error) {
-      logger.error('ScreenMaskingService', 'Failed to capture masked screen (basic):', error)
-      return null
+      logger.error(
+        'ScreenMaskingService',
+        'Failed to capture masked screen (basic):',
+        error
+      );
+      return null;
     }
   }
 
@@ -99,24 +130,24 @@ export class ScreenMaskingService {
    * Update the masking configuration
    */
   updateConfig(config: Partial<ScreenMaskingConfig>): void {
-    this.config = { ...this.config, ...config }
-    logger.info('ScreenMaskingService', 'Screen masking configuration updated')
+    this.config = { ...this.config, ...config };
+    logger.info('ScreenMaskingService', 'Screen masking configuration updated');
   }
 
   /**
    * Check if screen masking is available
    */
   isScreenMaskingAvailable(): boolean {
-    return this.isAvailable && this.config.enabled
+    return this.isAvailable && this.config.enabled;
   }
 
   /**
    * Get the current configuration
    */
   getConfig(): ScreenMaskingConfig {
-    return { ...this.config }
+    return { ...this.config };
   }
 }
 
 // Create a singleton instance
-export const screenMaskingService = new ScreenMaskingService()
+export const screenMaskingService = new ScreenMaskingService();