@multiplayer-app/session-recorder-react-native 1.3.36 → 2.0.17-alpha.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@multiplayer-app/session-recorder-react-native",
-  "version": "1.3.36",
+  "version": "2.0.17-alpha.10",
   "description": "Multiplayer Fullstack Session Recorder for React Native",
   "author": {
     "name": "Multiplayer Software, Inc.",
@@ -56,7 +56,7 @@
   "scripts": {
     "test": "jest",
     "typecheck": "tsc",
-    "lint": "eslint \"**/*.{js,ts,tsx}\"",
+    "lint": "eslint 'src/**/*.{ts,tsx}' --config eslint.config.mjs",
     "build": "bob build",
     "prepublishOnly": "npm run build",
     "release": "release-it --only-version"
@@ -78,6 +78,12 @@
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
   },
+  "resolutions": {
+    "eslint-plugin-jest": "^28.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.0.0",
+    "@typescript-eslint/parser": "^8.0.0",
+    "@typescript-eslint/utils": "^8.0.0"
+  },
   "devDependencies": {
     "@commitlint/config-conventional": "^19.8.1",
     "@eslint/compat": "^1.3.2",
@@ -90,25 +96,24 @@
     "@react-native/eslint-config": "^0.81.1",
     "@release-it/conventional-changelog": "^10.0.1",
     "@types/jest": "^29.5.14",
-    "@types/react": "^19.1.0",
+    "@types/react": "^19.2.0",
     "commitlint": "^19.8.1",
     "del-cli": "^6.0.0",
-    "eslint": "^9.35.0",
+    "eslint": "10.1.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-prettier": "^5.5.4",
     "jest": "^29.7.0",
-    "prettier": "^3.6.2",
-    "react": "19.1.0",
+    "prettier": "3.8.1",
+    "react": "19.2.4",
     "react-native": "0.81.1",
     "react-native-builder-bob": "^0.40.13",
     "react-native-safe-area-context": "^5.6.1",
     "react-native-svg": "^15.14.0",
     "release-it": "^19.0.4",
-    "turbo": "^2.5.6",
     "typescript": "^5.9.2"
   },
   "dependencies": {
-    "@multiplayer-app/session-recorder-common": "1.3.36",
+    "@multiplayer-app/session-recorder-common": "2.0.17-alpha.10",
     "@opentelemetry/core": "2.0.1",
     "@opentelemetry/exporter-trace-otlp-http": "0.203.0",
     "@opentelemetry/instrumentation": "0.203.0",

package/src/NativeSessionRecorderModule.ts

@@ -24,10 +24,12 @@ export interface Spec extends TurboModule {
     x: number,
     y: number,
     target?: string,
-    metadata?: Object,
+    metadata?: object
   ): void;
   addListener(eventName: string): void;
   removeListeners(count: number): void;
 }
 
-export default TurboModuleRegistry.getEnforcing<Spec>('SessionRecorderNative') as Spec;
+export default TurboModuleRegistry.getEnforcing<Spec>(
+  'SessionRecorderNative'
+) as Spec;

package/src/NativeSessionRecorderModuleSpec.ts

@@ -24,10 +24,12 @@ export interface Spec extends TurboModule {
     x: number,
     y: number,
     target?: string,
-    metadata?: Object,
+    metadata?: object
   ): void;
   addListener(eventName: string): void;
   removeListeners(count: number): void;
 }
 
-export default TurboModuleRegistry.getEnforcing<Spec>('SessionRecorderNative') as Spec;
+export default TurboModuleRegistry.getEnforcing<Spec>(
+  'SessionRecorderNative'
+) as Spec;

package/src/NativeSessionRecorderNative.ts

@@ -24,7 +24,7 @@ export interface Spec extends TurboModule {
     x: number,
     y: number,
     target?: string,
-    metadata?: Object,
+    metadata?: object
   ): void;
   addListener(eventName: string): void;
   removeListeners(count: number): void;

package/src/index.ts

@@ -5,7 +5,6 @@ export * from './context/SessionRecorderContext';
 export * from './context/useSessionRecorderStore';
 export { ErrorBoundary } from './components';
 
-
 // Export the class for type checking
 export { SessionRecorder };
 // Export the instance as default

package/src/native/SessionRecorderNative.ts

@@ -1,6 +1,8 @@
 import { Platform, NativeEventEmitter } from 'react-native';
-import SessionRecorderNative, { type MaskingOptions, type Spec } from '../NativeSessionRecorderModule';
-
+import SessionRecorderNative, {
+  type MaskingOptions,
+  type Spec,
+} from '../NativeSessionRecorderModule';
 
 // Check if we're on web platform
 const isWeb = Platform.OS === 'web';
@@ -8,7 +10,6 @@ const isWeb = Platform.OS === 'web';
 // Get the Turbo Module
 let eventEmitter = new NativeEventEmitter(SessionRecorderNative as any);
 
-
 // Validate that the native module is available
 if (!SessionRecorderNative && !isWeb) {
   console.warn(
@@ -57,7 +58,13 @@ const SafeSessionRecorderNative: Spec = {
     return SessionRecorderNative.isGestureRecordingActive();
   },
 
-  recordGesture(gestureType: string, x: number, y: number, target?: string, metadata?: any): void {
+  recordGesture(
+    gestureType: string,
+    x: number,
+    y: number,
+    target?: string,
+    metadata?: any
+  ): void {
     if (isWeb || !SessionRecorderNative) {
       throw new Error('SessionRecorderNative is not available on web platform');
     }
@@ -75,13 +82,13 @@ const SafeSessionRecorderNative: Spec = {
 
 export interface NativeGestureEvent {
   type:
-  | 'tap'
-  | 'pan_start'
-  | 'pan_move'
-  | 'pan_end'
-  | 'long_press'
-  | 'pinch'
-  | 'swipe';
+    | 'tap'
+    | 'pan_start'
+    | 'pan_move'
+    | 'pan_end'
+    | 'long_press'
+    | 'pinch'
+    | 'swipe';
   timestamp: number;
   x: number;
   y: number;
@@ -103,7 +110,9 @@ export interface NativeGestureEvent {
 }
 
 // Helper function to set gesture callback using event emitter pattern
-export function setGestureCallback(callback: (event: NativeGestureEvent) => void): void {
+export function setGestureCallback(
+  callback: (event: NativeGestureEvent) => void
+): void {
   if (isWeb || !SessionRecorderNative) {
     throw new Error('SessionRecorderNative is not available on web platform');
   }
@@ -115,4 +124,4 @@ export default SafeSessionRecorderNative;
 
 // Export event emitter for gesture events to maintain previous API
 export const gestureEventEmitter = eventEmitter;
-export type { MaskingOptions };
+export type { MaskingOptions };

package/src/otel/helpers.ts

@@ -263,7 +263,11 @@ export async function extractResponseBody(
   } catch (error) {
     // If cloning fails (body already consumed), return null
 
-    logger.warn('MULTIPLAYER_SESSION_RECORDER', 'Failed to extract response body', error);
+    logger.warn(
+      'MULTIPLAYER_SESSION_RECORDER',
+      'Failed to extract response body',
+      error
+    );
     return null;
   }
 }

package/src/otel/index.ts

@@ -202,7 +202,7 @@ export class TracerReactNativeSDK {
     if (this.globalErrorHandlerRegistered) return;
 
     // React Native global error handler
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
     const ErrorUtilsRef: any = (global as any).ErrorUtils;
     if (ErrorUtilsRef && typeof ErrorUtilsRef.setGlobalHandler === 'function') {
       const previous = ErrorUtilsRef.getGlobalHandler?.();

package/src/otel/instrumentations/index.ts

@@ -32,29 +32,29 @@ export function getInstrumentations(config: TracerReactNativeConfig) {
 
             // Try to get data from our fetch wrapper first
             // @ts-ignore
-            const networkRequest = response?.networkRequest
+            const networkRequest = response?.networkRequest;
 
-            let requestBody: any = null
-            let responseBody: string | null = null
-            let requestHeaders: Record<string, string> = {}
-            let responseHeaders: Record<string, string> = {}
+            let requestBody: any = null;
+            let responseBody: string | null = null;
+            let requestHeaders: Record<string, string> = {};
+            let responseHeaders: Record<string, string> = {};
 
             if (networkRequest) {
               // Use data captured by our fetch wrapper
-              requestBody = networkRequest.requestBody
-              responseBody = networkRequest.responseBody
-              requestHeaders = networkRequest.requestHeaders || {}
-              responseHeaders = networkRequest.responseHeaders || {}
+              requestBody = networkRequest.requestBody;
+              responseBody = networkRequest.responseBody;
+              requestHeaders = networkRequest.requestHeaders || {};
+              responseHeaders = networkRequest.responseHeaders || {};
             } else {
               // Fallback to original OpenTelemetry approach
-              requestBody = request.body
-              requestHeaders = headersToObject(request.headers)
+              requestBody = request.body;
+              requestHeaders = headersToObject(request.headers);
               responseHeaders = headersToObject(
                 response instanceof Response ? response.headers : undefined
-              )
+              );
 
               if (response instanceof Response && response.body) {
-                responseBody = await extractResponseBody(response)
+                responseBody = await extractResponseBody(response);
               }
             }
 
@@ -94,17 +94,17 @@ export function getInstrumentations(config: TracerReactNativeConfig) {
             }
 
             // @ts-ignore
-            const networkRequest = xhr.networkRequest
-            let requestBody: any = null
-            let responseBody: string | null = null
-            let requestHeaders: Record<string, string> = {}
-            let responseHeaders: Record<string, string> = {}
+            const networkRequest = xhr.networkRequest;
+            let requestBody: any = null;
+            let responseBody: string | null = null;
+            let requestHeaders: Record<string, string> = {};
+            let responseHeaders: Record<string, string> = {};
 
             if (networkRequest) {
-              requestBody = networkRequest.requestBody
-              responseBody = networkRequest.responseBody
-              requestHeaders = networkRequest.requestHeaders || {}
-              responseHeaders = networkRequest.responseHeaders || {}
+              requestBody = networkRequest.requestBody;
+              responseBody = networkRequest.responseBody;
+              requestHeaders = networkRequest.requestHeaders || {};
+              responseHeaders = networkRequest.responseHeaders || {};
             }
 
             const payload = {

package/src/patch/configs.ts

@@ -1,18 +1,23 @@
-import { DEFAULT_MAX_HTTP_CAPTURING_PAYLOAD_SIZE } from '../config'
+import { DEFAULT_MAX_HTTP_CAPTURING_PAYLOAD_SIZE } from '../config';
 
 export const configs = {
   recordRequestHeaders: true,
   recordResponseHeaders: true,
   shouldRecordBody: true,
   maxCapturingHttpPayloadSize: DEFAULT_MAX_HTTP_CAPTURING_PAYLOAD_SIZE,
-}
+};
 
-export const setMaxCapturingHttpPayloadSize = (_maxCapturingHttpPayloadSize: number) => {
-  configs.maxCapturingHttpPayloadSize = _maxCapturingHttpPayloadSize
-}
+export const setMaxCapturingHttpPayloadSize = (
+  _maxCapturingHttpPayloadSize: number
+) => {
+  configs.maxCapturingHttpPayloadSize = _maxCapturingHttpPayloadSize;
+};
 
-export const setShouldRecordHttpData = (shouldRecordBody: boolean, shouldRecordHeaders: boolean) => {
-  configs.recordRequestHeaders = shouldRecordHeaders
-  configs.recordResponseHeaders = shouldRecordHeaders
-  configs.shouldRecordBody = shouldRecordBody
-}
+export const setShouldRecordHttpData = (
+  shouldRecordBody: boolean,
+  shouldRecordHeaders: boolean
+) => {
+  configs.recordRequestHeaders = shouldRecordHeaders;
+  configs.recordResponseHeaders = shouldRecordHeaders;
+  configs.shouldRecordBody = shouldRecordBody;
+};

package/src/patch/fetch.ts

@@ -1,38 +1,33 @@
-import {
-  isFormData,
-  isNullish,
-  isObject,
-  isString,
-} from '../utils/type-utils'
-import { formDataToQuery } from '../utils/request-utils'
-import { configs } from './configs'
+import { isFormData, isNullish, isObject, isString } from '../utils/type-utils';
+import { formDataToQuery } from '../utils/request-utils';
+import { configs } from './configs';
 
 function _tryReadFetchBody({
   body,
 }: {
-  body: any | null | undefined
+  body: any | null | undefined;
 }): string | null {
   if (isNullish(body)) {
-    return null
+    return null;
   }
 
   if (isString(body)) {
-    return body
+    return body;
   }
 
   if (isFormData(body)) {
-    return formDataToQuery(body)
+    return formDataToQuery(body);
   }
 
   if (isObject(body)) {
     try {
-      return JSON.stringify(body)
+      return JSON.stringify(body);
     } catch {
-      return '[Fetch] Failed to stringify request object'
+      return '[Fetch] Failed to stringify request object';
     }
   }
 
-  return `[Fetch] Cannot read body of type ${Object.prototype.toString.call(body)}`
+  return `[Fetch] Cannot read body of type ${Object.prototype.toString.call(body)}`;
 }
 
 /**
@@ -42,221 +37,235 @@ function _tryReadFetchBody({
  * - Corrupt the stream for the actual consumer
  */
 function _isStreamingResponse(response: Response): boolean {
-  const contentType = response.headers.get('content-type')?.toLowerCase() ?? ''
+  const contentType = response.headers.get('content-type')?.toLowerCase() ?? '';
 
   // SSE - Server-Sent Events (infinite stream)
   if (contentType.includes('text/event-stream')) {
-    return true
+    return true;
   }
 
   // Binary streams that are typically long-running
   if (contentType.includes('application/octet-stream')) {
-    return true
+    return true;
   }
 
   // NDJSON streaming (newline-delimited JSON, common in streaming APIs)
-  if (contentType.includes('application/x-ndjson') || contentType.includes('application/ndjson')) {
-    return true
+  if (
+    contentType.includes('application/x-ndjson') ||
+    contentType.includes('application/ndjson')
+  ) {
+    return true;
   }
 
   // gRPC-web streaming
   if (contentType.includes('application/grpc')) {
-    return true
+    return true;
   }
 
   // Check for chunked transfer encoding (often indicates streaming)
-  const transferEncoding = response.headers.get('transfer-encoding')?.toLowerCase()
+  const transferEncoding = response.headers
+    .get('transfer-encoding')
+    ?.toLowerCase();
   if (transferEncoding?.includes('chunked')) {
     // Chunked alone isn't definitive, but combined with no content-length = streaming
-    const contentLength = response.headers.get('content-length')
+    const contentLength = response.headers.get('content-length');
     if (!contentLength) {
-      return true
+      return true;
     }
   }
 
-  return false
+  return false;
 }
 
 /**
  * Safely reads response body for non-streaming responses.
  * Returns null for streaming responses to avoid blocking/corruption.
  */
-async function _tryReadResponseBody(response: Response): Promise<string | null> {
+async function _tryReadResponseBody(
+  response: Response
+): Promise<string | null> {
   // CRITICAL: Never attempt to read streaming response bodies
   if (_isStreamingResponse(response)) {
-    return null
+    return null;
   }
 
   try {
     // Clone the response to avoid consuming the original stream.
-    const clonedResponse = response.clone()
-    const contentType = response.headers.get('content-type')?.toLowerCase() ?? ''
+    const clonedResponse = response.clone();
+    const contentType =
+      response.headers.get('content-type')?.toLowerCase() ?? '';
 
     // Check content-length to avoid reading massive responses
-    const contentLength = response.headers.get('content-length')
+    const contentLength = response.headers.get('content-length');
     if (contentLength) {
-      const length = parseInt(contentLength, 10)
+      const length = parseInt(contentLength, 10);
       if (!isNaN(length) && length > configs.maxCapturingHttpPayloadSize) {
-        return `[Fetch] Response too large (${length} bytes)`
+        return `[Fetch] Response too large (${length} bytes)`;
       }
     }
 
     if (contentType.includes('application/json')) {
-      const json = await clonedResponse.json()
-      return JSON.stringify(json)
+      const json = await clonedResponse.json();
+      return JSON.stringify(json);
     }
 
     if (contentType.includes('text/')) {
-      return await clonedResponse.text()
+      return await clonedResponse.text();
     }
 
     // For unknown types, attempt text read
     try {
-      return await clonedResponse.text()
+      return await clonedResponse.text();
     } catch {
       try {
-        const arrayBuffer = await clonedResponse.arrayBuffer()
-        return `[Fetch] Binary data (${arrayBuffer.byteLength} bytes)`
+        const arrayBuffer = await clonedResponse.arrayBuffer();
+        return `[Fetch] Binary data (${arrayBuffer.byteLength} bytes)`;
       } catch {
-        return '[Fetch] Unable to read response body'
+        return '[Fetch] Unable to read response body';
       }
     }
   } catch (error) {
-    return `[Fetch] Error reading response body: ${error instanceof Error ? error.message : 'Unknown error'}`
+    return `[Fetch] Error reading response body: ${error instanceof Error ? error.message : 'Unknown error'}`;
   }
 }
 
 function _headersToObject(headers: Headers): Record<string, string> {
-  const result: Record<string, string> = {}
+  const result: Record<string, string> = {};
   headers.forEach((value, key) => {
-    result[key] = value
-  })
-  return result
+    result[key] = value;
+  });
+  return result;
 }
 
 // Convert HeadersInit to a plain object without needing to construct a Request
 function _headersInitToObject(headersInit?: any): Record<string, string> {
-  if (!headersInit) return {}
+  if (!headersInit) return {};
 
   // Headers instance
   if (typeof Headers !== 'undefined' && headersInit instanceof Headers) {
-    return _headersToObject(headersInit)
+    return _headersToObject(headersInit);
   }
 
-  const result: Record<string, string> = {}
+  const result: Record<string, string> = {};
 
   // Array of tuples
   if (Array.isArray(headersInit)) {
     for (const [key, value] of headersInit) {
-      result[String(key).toLowerCase()] = String(value)
+      result[String(key).toLowerCase()] = String(value);
     }
-    return result
+    return result;
   }
 
   // Record<string, string>
-  for (const [key, value] of Object.entries(headersInit as Record<string, string>)) {
-    result[String(key).toLowerCase()] = String(value)
+  for (const [key, value] of Object.entries(
+    headersInit as Record<string, string>
+  )) {
+    result[String(key).toLowerCase()] = String(value);
   }
 
-  return result
+  return result;
 }
 
 // Only patch fetch if available and safe to do so
 if (typeof fetch !== 'undefined' && typeof global !== 'undefined') {
   // Store original fetch
-  const originalFetch = global.fetch
+  const originalFetch = global.fetch;
 
   // Override fetch with safer implementation
-  global.fetch = async function (
-    input: any,
-    init?: any
-  ): Promise<Response> {
+  global.fetch = async function (input: any, init?: any): Promise<Response> {
     const networkRequest: {
-      requestHeaders?: Record<string, string>
-      requestBody?: string
-      responseHeaders?: Record<string, string>
-      responseBody?: string
-    } = {}
+      requestHeaders?: Record<string, string>;
+      requestBody?: string;
+      responseHeaders?: Record<string, string>;
+      responseBody?: string;
+    } = {};
 
     // Capture request data
-    const inputIsRequest = typeof Request !== 'undefined' && input instanceof Request
+    const inputIsRequest =
+      typeof Request !== 'undefined' && input instanceof Request;
 
     if (configs.recordRequestHeaders) {
       if (inputIsRequest) {
-        networkRequest.requestHeaders = _headersToObject((input as Request).headers)
+        networkRequest.requestHeaders = _headersToObject(
+          (input as Request).headers
+        );
       } else {
-        networkRequest.requestHeaders = _headersInitToObject(init?.headers)
+        networkRequest.requestHeaders = _headersInitToObject(init?.headers);
       }
     }
 
     if (configs.shouldRecordBody) {
       // Only attempt to read the body from init (safe); avoid constructing/cloning Requests
       // If the caller passed a Request as input, we do not attempt to read its body here
-      const candidateBody: any | null | undefined = init?.body
+      const candidateBody: any | null | undefined = init?.body;
 
       if (!isNullish(candidateBody)) {
         const requestBody = _tryReadFetchBody({
           body: candidateBody,
-        })
+        });
 
         if (
           requestBody?.length &&
           (typeof Blob !== 'undefined'
-            ? new Blob([requestBody]).size <= configs.maxCapturingHttpPayloadSize
+            ? new Blob([requestBody]).size <=
+              configs.maxCapturingHttpPayloadSize
             : requestBody.length <= configs.maxCapturingHttpPayloadSize)
         ) {
-          networkRequest.requestBody = requestBody
+          networkRequest.requestBody = requestBody;
         }
       }
     }
 
     try {
       // Make the actual fetch request
-      const response = await originalFetch(input, init)
+      const response = await originalFetch(input, init);
 
       // Capture response data
       if (configs.recordResponseHeaders) {
-        networkRequest.responseHeaders = _headersToObject(response.headers)
+        networkRequest.responseHeaders = _headersToObject(response.headers);
       }
 
       if (configs.shouldRecordBody) {
-        const responseBody = await _tryReadResponseBody(response)
+        const responseBody = await _tryReadResponseBody(response);
 
         if (
           responseBody?.length &&
           (typeof Blob !== 'undefined'
-            ? new Blob([responseBody]).size <= configs.maxCapturingHttpPayloadSize
+            ? new Blob([responseBody]).size <=
+              configs.maxCapturingHttpPayloadSize
             : responseBody.length <= configs.maxCapturingHttpPayloadSize)
         ) {
-          networkRequest.responseBody = responseBody
+          networkRequest.responseBody = responseBody;
         }
       }
 
-      // Attach network request data to the response for later access
-      // @ts-ignore
-      response.networkRequest = networkRequest
+      // @ts-expect-error Attach network request data to the response for later access
+      response.networkRequest = networkRequest;
 
-      return response
+      return response;
     } catch (error) {
       // Even if the fetch fails, we can still capture the request data
       // Attach captured request data to the thrown error for downstream handling
-      // @ts-ignore
       if (error && typeof error === 'object') {
-        // @ts-ignore
-        error.networkRequest = networkRequest
+        // @ts-expect-error
+        error.networkRequest = networkRequest;
       }
-      throw error
+      throw error;
     }
-  }
+  };
 
   // Preserve the original fetch function's properties
   try {
-    Object.setPrototypeOf(global.fetch, originalFetch)
-    Object.defineProperty(global.fetch, 'name', { value: 'fetch' })
-    Object.defineProperty(global.fetch, 'length', { value: originalFetch.length })
+    Object.setPrototypeOf(global.fetch, originalFetch);
+    Object.defineProperty(global.fetch, 'name', { value: 'fetch' });
+    Object.defineProperty(global.fetch, 'length', {
+      value: originalFetch.length,
+    });
   } catch (error) {
-    console.warn('[Fetch Patch] Failed to preserve fetch properties:', error)
+    console.warn('[Fetch Patch] Failed to preserve fetch properties:', error);
   }
 } else {
-  console.info('Fetch patch: Skipping fetch patching - fetch not available or unsafe environment')
-}
+  console.info(
+    'Fetch patch: Skipping fetch patching - fetch not available or unsafe environment'
+  );
+}