@multiplayer-app/session-recorder-react-native 1.2.37 → 1.3.2

package/src/services/api.service.ts

@@ -2,6 +2,7 @@ import {
   type IResourceAttributes,
   type ISessionAttributes,
   type ApiServiceConfig,
+  type IUserAttributes,
 } from '../types';
 
 export interface StartSessionRequest {
@@ -9,6 +10,7 @@ export interface StartSessionRequest {
   stoppedAt?: string | number;
   sessionAttributes?: ISessionAttributes;
   resourceAttributes?: IResourceAttributes;
+  userAttributes?: IUserAttributes;
   debugSessionData?: Record<string, any>;
   tags?: { key?: string; value: string }[];
 }
@@ -18,6 +20,13 @@ export interface StopSessionRequest {
   stoppedAt: string | number;
 }
 
+
+export interface CheckRemoteSessionRequest {
+  sessionAttributes?: ISessionAttributes
+  resourceAttributes?: IResourceAttributes
+  userAttributes?: IUserAttributes
+}
+
 export class ApiService {
   private config?: ApiServiceConfig;
   private baseUrl: string = 'https://api.multiplayer.app';
@@ -200,17 +209,17 @@ export class ApiService {
   }
 
   /**
-   * Check debug session should be started remotely
-   */
+  * Check debug session should be started remotely
+  */
   async checkRemoteSession(
-    requestBody: StartSessionRequest,
-    signal?: AbortSignal
+    requestBody: CheckRemoteSessionRequest,
+    signal?: AbortSignal,
   ): Promise<{ state: 'START' | 'STOP' }> {
     return this.makeRequest(
       '/remote-debug-session/check',
       'POST',
       requestBody,
-      signal
-    );
+      signal,
+    )
   }
 }

package/src/services/socket.service.ts

@@ -0,0 +1,225 @@
+import io, { Socket } from 'socket.io-client';
+import { Observable } from 'lib0/observable';
+
+import { type ISession, type IUserAttributes } from '../types';
+import { logger } from '../utils';
+
+import {
+  SESSION_ADD_EVENT,
+  SESSION_AUTO_CREATED,
+  SESSION_STOPPED_EVENT,
+  SESSION_SUBSCRIBE_EVENT,
+  SESSION_UNSUBSCRIBE_EVENT,
+  SOCKET_SET_USER_EVENT,
+  REMOTE_SESSION_RECORDING_START,
+  REMOTE_SESSION_RECORDING_STOP,
+  SESSION_STARTED_EVENT,
+} from '../config';
+
+const MAX_RECONNECTION_ATTEMPTS = 2;
+
+export type SocketServiceEvents =
+  | typeof SESSION_STOPPED_EVENT
+  | typeof SESSION_AUTO_CREATED
+  | typeof REMOTE_SESSION_RECORDING_START
+  | typeof REMOTE_SESSION_RECORDING_STOP;
+
+export interface SocketServiceOptions {
+  apiKey: string;
+  socketUrl: string;
+  keepAlive?: boolean;
+}
+
+export class SocketService extends Observable<SocketServiceEvents> {
+  private socket: Socket | null = null;
+  private queue: any[] = [];
+  private isConnecting: boolean = false;
+  private isConnected: boolean = false;
+  private attempts: number = 0;
+  private sessionId: string | null = null;
+  private options: SocketServiceOptions;
+
+  constructor() {
+    super();
+    this.options = {
+      apiKey: '',
+      socketUrl: '',
+      keepAlive: false,
+    };
+  }
+
+  /**
+   * Initialize the socket service
+   * @param config - Socket service configuration
+   */
+  public init(config: SocketServiceOptions): void {
+    this.options = {
+      ...this.options,
+      ...config,
+    };
+    if (
+      this.options.keepAlive &&
+      this.options.socketUrl &&
+      this.options.apiKey
+    ) {
+      this._initConnection();
+    }
+  }
+
+  /**
+   * Update the socket service configuration
+   * @param config - Partial configuration to update
+   */
+  public updateConfigs(config: Partial<SocketServiceOptions>): void {
+    // If any config changed, reconnect if connected
+    const hasChanges = Object.keys(config).some(
+      (key) => {
+        const typedKey = key as keyof SocketServiceOptions;
+        return (
+          config[typedKey] !== undefined &&
+          config[typedKey] !== this.options[typedKey]
+        );
+      }
+    );
+
+    if (hasChanges) {
+      this.options = { ...this.options, ...config };
+      if (this.socket?.connected) {
+        this.close().then(() => {
+          if (
+            this.options.keepAlive &&
+            this.options.socketUrl &&
+            this.options.apiKey
+          ) {
+            this._initConnection();
+          }
+        });
+      }
+    }
+  }
+
+  private _initConnection(): void {
+    if (this.isConnecting || this.isConnected) return;
+    this.attempts++;
+    this.isConnecting = true;
+    this.socket = io(this.options.socketUrl, {
+      path: '/v0/radar/ws',
+      auth: {
+        'x-api-key': this.options.apiKey,
+      },
+      reconnectionAttempts: 2,
+      transports: ['websocket'],
+    });
+
+    this.socket.on('ready', () => {
+      this.isConnecting = false;
+      this.isConnected = true;
+      logger.info('SocketService', 'Connected to server');
+      this.flushQueue();
+    });
+
+    this.socket.on('disconnect', (_err: any) => {
+      this.isConnecting = false;
+      this.isConnected = false;
+      logger.info('SocketService', 'Disconnected from server');
+    });
+
+    this.socket.on('connect_error', (err: any) => {
+      this.isConnecting = false;
+      this.isConnected = false;
+      this.checkReconnectionAttempts();
+      logger.error('SocketService', 'Error connecting to server', err);
+    });
+
+    this.socket.on(SESSION_STOPPED_EVENT, (data: any) => {
+      this.emit(SESSION_STOPPED_EVENT, [data]);
+    });
+
+    this.socket.on(SESSION_AUTO_CREATED, (data: any) => {
+      this.emit(SESSION_AUTO_CREATED, [data]);
+    });
+
+    this.socket.on(REMOTE_SESSION_RECORDING_START, (data: any) => {
+      this.emit(REMOTE_SESSION_RECORDING_START, [data]);
+    });
+
+    this.socket.on(REMOTE_SESSION_RECORDING_STOP, (data: any) => {
+      this.emit(REMOTE_SESSION_RECORDING_STOP, [data]);
+    });
+  }
+
+  private checkReconnectionAttempts(): void {
+    if (this.attempts >= MAX_RECONNECTION_ATTEMPTS) {
+      this.flushQueue();
+    }
+  }
+
+  private emitSocketEvent(name: string, data: any): void {
+    if (this.socket?.connected) {
+      this.socket.emit(name, data)
+    } else {
+      this.queue.push({ data, name })
+      this._initConnection()
+    }
+  }
+
+  private flushQueue(): void {
+    while (this.queue.length > 0 && this.socket?.connected) {
+      const event = this.queue.shift();
+      if (!event) continue;
+
+      if (this.socket?.connected) {
+        this.socket.emit(event.name, event.data);
+      }
+    }
+  }
+
+
+  public send(event: any): void {
+    this.emitSocketEvent(SESSION_ADD_EVENT, event)
+  }
+
+
+  public subscribeToSession(session: ISession): void {
+    this.sessionId = session.shortId || session._id;
+    const payload = {
+      projectId: session.project,
+      workspaceId: session.workspace,
+      debugSessionId: this.sessionId,
+      sessionType: session.creationType,
+    };
+    this.emitSocketEvent(SESSION_SUBSCRIBE_EVENT, payload)
+    this.emitSocketEvent(SESSION_STARTED_EVENT, { debugSessionId: this.sessionId })
+  }
+
+  public unsubscribeFromSession(stopSession?: boolean) {
+    if (this.sessionId) {
+      this.emitSocketEvent(SESSION_UNSUBSCRIBE_EVENT, { debugSessionId: this.sessionId })
+      if (stopSession) {
+        this.emitSocketEvent(SESSION_STOPPED_EVENT, {})
+      }
+    }
+  }
+
+  public setUser(userAttributes: IUserAttributes | undefined): void {
+    this.emitSocketEvent(SOCKET_SET_USER_EVENT, userAttributes)
+  }
+
+  public close(): Promise<void> {
+    return new Promise((resolve) => {
+      if (this.socket?.connected) {
+        setTimeout(() => {
+          this.unsubscribeFromSession();
+          this.attempts = 0;
+          this.isConnected = false;
+          this.isConnecting = false;
+          this.socket?.disconnect();
+          this.socket = null;
+          resolve();
+        }, 500);
+      } else {
+        resolve();
+      }
+    });
+  }
+}

package/src/session-recorder.ts

@@ -13,7 +13,13 @@ import {
   type SessionRecorderConfigs,
   type SessionRecorderOptions,
   type EventRecorder,
+  type IUserAttributes,
 } from './types';
+import {
+  SESSION_STOPPED_EVENT,
+  REMOTE_SESSION_RECORDING_START,
+  REMOTE_SESSION_RECORDING_STOP
+} from './config';
 import { getFormattedDate, isSessionActive, getNavigatorInfo } from './utils';
 import {
   setShouldRecordHttpData,
@@ -28,6 +34,7 @@ import {
   type StartSessionRequest,
   type StopSessionRequest,
 } from './services/api.service';
+import { SocketService } from './services/socket.service';
 
 type SessionRecorderEvents = 'state-change' | 'init';
 
@@ -36,6 +43,7 @@ class SessionRecorder
   implements ISessionRecorder, EventRecorder {
   private _configs: SessionRecorderConfigs;
   private _apiService = new ApiService();
+  private _socketService = new SocketService();
   private _tracer = new TracerReactNativeSDK();
   private _recorder = new RecorderReactNativeSDK();
   private _storageService = StorageService.getInstance();
@@ -110,6 +118,8 @@ class SessionRecorder
     this._sessionAttributes = attributes;
   }
 
+  private _userAttributes: IUserAttributes | undefined = undefined;
+
   /**
    * Error message getter and setter
    */
@@ -200,10 +210,16 @@ class SessionRecorder
     );
 
     this._tracer.init(this._configs);
-    this._recorder.init(this._configs);
     this._apiService.init(this._configs);
+    this._socketService.init({
+      apiKey: this._configs.apiKey,
+      socketUrl: this._configs.apiBaseUrl,
+      keepAlive: this._configs.useWebsocket
+    });
+    this._recorder.init(this._configs, this._socketService);
     await this._networkService.init();
     this._setupNetworkCallbacks();
+    this._registerSocketServiceListeners();
 
     if (
       this.sessionId &&
@@ -215,6 +231,30 @@ class SessionRecorder
     this.emit('init', []);
   }
 
+  /**
+   * Register socket service event listeners
+   */
+  private _registerSocketServiceListeners(): void {
+    this._socketService.on(SESSION_STOPPED_EVENT, () => {
+      this._stop();
+      this._clearSession();
+    });
+
+    this._socketService.on(REMOTE_SESSION_RECORDING_START, (payload: any) => {
+      logger.info('SessionRecorder', 'Remote session recording started', payload);
+      if (this.sessionState === SessionState.stopped) {
+        this.start();
+      }
+    });
+
+    this._socketService.on(REMOTE_SESSION_RECORDING_STOP, (payload: any) => {
+      logger.info('SessionRecorder', 'Remote session recording stopped', payload);
+      if (this.sessionState !== SessionState.stopped) {
+        this.stop();
+      }
+    });
+  }
+
   /**
    * Setup network state change callbacks
    */
@@ -361,13 +401,9 @@ class SessionRecorder
         {
           sessionAttributes: this.sessionAttributes,
           resourceAttributes: getNavigatorInfo(),
+          userAttributes: this._userAttributes,
           stoppedAt: Date.now(),
-          name: this.sessionAttributes.userName
-            ? `${this.sessionAttributes.userName}'s session on ${getFormattedDate(
-              Date.now(),
-              { month: 'short', day: 'numeric' }
-            )}`
-            : `Session on ${getFormattedDate(Date.now())}`,
+          name: this._getSessionName()
         }
       );
 
@@ -385,6 +421,15 @@ class SessionRecorder
     this._sessionAttributes = attributes;
   }
 
+  /**
+   * Set the user attributes
+   * @param userAttributes - the user attributes to set
+   */
+  public setUserAttributes(userAttributes: IUserAttributes | undefined): void {
+    this._userAttributes = userAttributes;
+    this._socketService.setUser(this._userAttributes);
+  }
+
   /**
    * @description Check if session should be started/stopped automatically
    * @param {ISession} [sessionPayload]
@@ -406,6 +451,7 @@ class SessionRecorder
         ...getNavigatorInfo(),
         ...(sessionPayload?.resourceAttributes || {}),
       },
+      userAttributes: this._userAttributes,
     };
 
     const { state } = await this._apiService.checkRemoteSession(payload);
@@ -430,9 +476,8 @@ class SessionRecorder
       const payload = {
         sessionAttributes: this.sessionAttributes,
         resourceAttributes: getNavigatorInfo(),
-        name: this.sessionAttributes.userName
-          ? `${this.sessionAttributes.userName}'s session on ${getFormattedDate(Date.now(), { month: 'short', day: 'numeric' })}`
-          : `Session on ${getFormattedDate(Date.now())}`,
+        userAttributes: this._userAttributes,
+        name: this._getSessionName()
       };
       const request: StartSessionRequest = !this.continuousRecording
         ? payload
@@ -467,6 +512,9 @@ class SessionRecorder
     if (this.sessionId) {
       this._tracer.start(this.sessionId, this.sessionType);
       this._recorder.start(this.sessionId, this.sessionType);
+      if (this.session) {
+        this._socketService.subscribeToSession(this.session);
+      }
     }
   }
 
@@ -475,6 +523,7 @@ class SessionRecorder
    */
   private _stop(): void {
     this.sessionState = SessionState.stopped;
+    this._socketService.unsubscribeFromSession(true);
     this._tracer.shutdown();
     this._recorder.stop();
   }
@@ -506,8 +555,8 @@ class SessionRecorder
     if (configureExporters && session.tempApiKey) {
       this._configs.apiKey = session.tempApiKey;
       this._tracer.setApiKey(session.tempApiKey);
-      this._recorder.setApiKey(session.tempApiKey);
       this._apiService.setApiKey(session.tempApiKey);
+      this._socketService.updateConfigs({ apiKey: session.tempApiKey });
     }
 
     this._setSession(session);
@@ -685,6 +734,17 @@ class SessionRecorder
       return { errorInfo: String(errorInfo) }
     }
   }
+
+  /**
+   * Get the session name
+   * @returns the session name
+   */
+  private _getSessionName(date: Date = new Date()): string {
+    const userName = this.sessionAttributes?.userName || this._userAttributes?.userName || this._userAttributes?.name || '';
+    return userName
+      ? `${userName}'s session on ${getFormattedDate(date, { month: 'short', day: 'numeric' })}`
+      : `Session on ${getFormattedDate(date)}`;
+  }
 }
 
 export default new SessionRecorder();

package/src/types/session-recorder.ts

@@ -1,7 +1,7 @@
 import { type Span } from '@opentelemetry/api';
 import { SessionType } from '@multiplayer-app/session-recorder-common';
 import { type PropagateTraceHeaderCorsUrls } from '@opentelemetry/sdk-trace-web';
-import type { ISession } from './session';
+import type { ISession, IUserAttributes } from './session';
 
 // WidgetButtonPlacement moved to configs.ts
 
@@ -155,6 +155,13 @@ export interface SessionRecorderOptions {
     level?: number;
     enabled?: boolean;
   };
+
+  /**
+  * @description
+  * If true, webSocket will be used to manage remote recording sessions.
+  * @default true
+  */
+  useWebsocket?: boolean
 }
 
 /**
@@ -332,6 +339,12 @@ export interface ISessionRecorder {
    */
   setSessionAttributes(attributes: Record<string, any>): void;
 
+  /**
+   * Set the user attributes
+   * @param userAttributes - the user attributes to set
+   */
+  setUserAttributes(userAttributes: IUserAttributes | undefined): void;
+
   /**
    * Capture an exception and send it as an error trace
    */

package/src/types/session.ts

@@ -1,5 +1,6 @@
-import { SessionType } from '@multiplayer-app/session-recorder-common';
-import type { UserType } from './client-type.enum';
+import { SessionType, UserType } from '@multiplayer-app/session-recorder-common';
+
+
 
 export interface IResourceAttributes {
   browserInfo?: string;

package/src/utils/logger.ts

@@ -24,7 +24,7 @@ class Logger {
     ['ScreenRecorder', '📸'],
     ['NativeGestureRecorder', '👆'],
     ['SessionRecorderContext', '🎯'],
-    ['EventExporter', '📤'],
+    ['SocketService', '📤'],
     ['NavigationTracker', '📸'],
     ['RecorderReactNativeSDK', '📤'],
     ['DEBUGGER_LIB', '🔍'],

package/lib/module/recorder/eventExporter.js

@@ -1,130 +0,0 @@
-"use strict";
-
-import io from 'socket.io-client';
-import { logger } from "../utils/index.js";
-import { SESSION_ADD_EVENT, SESSION_AUTO_CREATED, SESSION_STOPPED_EVENT, SESSION_SUBSCRIBE_EVENT, SESSION_UNSUBSCRIBE_EVENT } from "../config/index.js";
-const MAX_RECONNECTION_ATTEMPTS = 2;
-export class EventExporter {
-  socket = null;
-  queue = [];
-  isConnecting = false;
-  isConnected = false;
-  attempts = 0;
-  sessionId = null;
-  constructor(options) {
-    this.socketUrl = options.socketUrl;
-    this.apiKey = options.apiKey;
-  }
-  init() {
-    if (this.isConnecting || this.isConnected) return;
-    this.attempts++;
-    this.isConnecting = true;
-    this.socket = io(this.socketUrl, {
-      path: '/v0/radar/ws',
-      auth: {
-        'x-api-key': this.apiKey
-      },
-      reconnectionAttempts: 2,
-      transports: ['websocket']
-    });
-
-    // this.socket.on('connect', () => {
-    //   this.isConnecting = false
-    //   this.isConnected = true
-    //   this.usePostMessage = false
-    //   this.flushQueue()
-    // })
-
-    this.socket.on('ready', () => {
-      this.isConnecting = false;
-      this.isConnected = true;
-      logger.info('EventExporter', 'Connected to server');
-      this.flushQueue();
-    });
-    this.socket.on('disconnect', _err => {
-      this.isConnecting = false;
-      this.isConnected = false;
-      logger.info('EventExporter', 'Disconnected from server');
-    });
-    this.socket.on('connect_error', err => {
-      this.isConnecting = false;
-      this.isConnected = false;
-      this.checkReconnectionAttempts();
-      logger.error('EventExporter', 'Error connecting to server', err);
-    });
-    this.socket.on(SESSION_STOPPED_EVENT, _ => {
-      this.unsubscribeFromSession();
-    });
-    this.socket.on(SESSION_AUTO_CREATED, _ => {});
-  }
-  setApiKey(apiKey) {
-    this.apiKey = apiKey;
-  }
-  setSocketUrl(socketUrl) {
-    this.socketUrl = socketUrl;
-  }
-  checkReconnectionAttempts() {
-    if (this.attempts >= MAX_RECONNECTION_ATTEMPTS) {
-      this.flushQueue();
-    }
-  }
-  flushQueue() {
-    while (this.queue.length > 0 && this.socket?.connected) {
-      const event = this.queue.shift();
-      if (!event) continue;
-      if (this.socket?.connected) {
-        this.socket.emit(event.name, event.data);
-      }
-    }
-  }
-  unsubscribeFromSession() {
-    const payload = {
-      debugSessionId: this.sessionId
-    };
-    if (this.socket?.connected) {
-      this.socket.emit(SESSION_UNSUBSCRIBE_EVENT, payload);
-    }
-  }
-  send(event) {
-    if (this.socket?.connected) {
-      this.socket.emit(SESSION_ADD_EVENT, event);
-    } else {
-      this.queue.push({
-        data: event,
-        name: SESSION_ADD_EVENT
-      });
-      this.init();
-    }
-  }
-  subscribeToSession(session) {
-    this.sessionId = session.shortId || session._id;
-    const payload = {
-      projectId: session.project,
-      workspaceId: session.workspace,
-      debugSessionId: this.sessionId,
-      sessionType: session.creationType
-    };
-    if (this.socket?.connected) {
-      this.socket.emit(SESSION_SUBSCRIBE_EVENT, payload);
-    } else {
-      this.queue.push({
-        data: payload,
-        name: SESSION_SUBSCRIBE_EVENT
-      });
-      this.init();
-    }
-  }
-  close() {
-    if (this.socket?.connected) {
-      setTimeout(() => {
-        this.unsubscribeFromSession();
-        this.attempts = 0;
-        this.isConnected = false;
-        this.isConnecting = false;
-        this.socket?.disconnect();
-        this.socket = null;
-      }, 500);
-    }
-  }
-}
-//# sourceMappingURL=eventExporter.js.map

package/lib/module/recorder/eventExporter.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["io","logger","SESSION_ADD_EVENT","SESSION_AUTO_CREATED","SESSION_STOPPED_EVENT","SESSION_SUBSCRIBE_EVENT","SESSION_UNSUBSCRIBE_EVENT","MAX_RECONNECTION_ATTEMPTS","EventExporter","socket","queue","isConnecting","isConnected","attempts","sessionId","constructor","options","socketUrl","apiKey","init","path","auth","reconnectionAttempts","transports","on","info","flushQueue","_err","err","checkReconnectionAttempts","error","_","unsubscribeFromSession","setApiKey","setSocketUrl","length","connected","event","shift","emit","name","data","payload","debugSessionId","send","push","subscribeToSession","session","shortId","_id","projectId","project","workspaceId","workspace","sessionType","creationType","close","setTimeout","disconnect"],"sourceRoot":"../../../src","sources":["recorder/eventExporter.ts"],"mappings":";;AAAA,OAAOA,EAAE,MAAkB,kBAAkB;AAG7C,SAASC,MAAM,QAAQ,mBAAU;AAEjC,SACEC,iBAAiB,EACjBC,oBAAoB,EACpBC,qBAAqB,EACrBC,uBAAuB,EACvBC,yBAAyB,QACpB,oBAAW;AAElB,MAAMC,yBAAyB,GAAG,CAAC;AAEnC,OAAO,MAAMC,aAAa,CAAC;EACjBC,MAAM,GAAkB,IAAI;EAC5BC,KAAK,GAAU,EAAE;EACjBC,YAAY,GAAY,KAAK;EAC7BC,WAAW,GAAY,KAAK;EAC5BC,QAAQ,GAAW,CAAC;EACpBC,SAAS,GAAkB,IAAI;EAKvCC,WAAWA,CAACC,OAA8C,EAAE;IAC1D,IAAI,CAACC,SAAS,GAAGD,OAAO,CAACC,SAAS;IAClC,IAAI,CAACC,MAAM,GAAGF,OAAO,CAACE,MAAM;EAC9B;EAEQC,IAAIA,CAAA,EAAS;IACnB,IAAI,IAAI,CAACR,YAAY,IAAI,IAAI,CAACC,WAAW,EAAE;IAC3C,IAAI,CAACC,QAAQ,EAAE;IACf,IAAI,CAACF,YAAY,GAAG,IAAI;IACxB,IAAI,CAACF,MAAM,GAAGT,EAAE,CAAC,IAAI,CAACiB,SAAS,EAAE;MAC/BG,IAAI,EAAE,cAAc;MACpBC,IAAI,EAAE;QACJ,WAAW,EAAE,IAAI,CAACH;MACpB,CAAC;MACDI,oBAAoB,EAAE,CAAC;MACvBC,UAAU,EAAE,CAAC,WAAW;IAC1B,CAAC,CAAC;;IAEF;IACA;IACA;IACA;IACA;IACA;;IAEA,IAAI,CAACd,MAAM,CAACe,EAAE,CAAC,OAAO,EAAE,MAAM;MAC5B,IAAI,CAACb,YAAY,GAAG,KAAK;MACzB,IAAI,CAACC,WAAW,GAAG,IAAI;MACvBX,MAAM,CAACwB,IAAI,CAAC,eAAe,EAAE,qBAAqB,CAAC;MACnD,IAAI,CAACC,UAAU,CAAC,CAAC;IACnB,CAAC,CAAC;IAEF,IAAI,CAACjB,MAAM,CAACe,EAAE,CAAC,YAAY,EAAGG,IAAS,IAAK;MAC1C,IAAI,CAAChB,YAAY,GAAG,KAAK;MACzB,IAAI,CAACC,WAAW,GAAG,KAAK;MACxBX,MAAM,CAACwB,IAAI,CAAC,eAAe,EAAE,0BAA0B,CAAC;IAC1D,CAAC,CAAC;IAEF,IAAI,CAAChB,MAAM,CAACe,EAAE,CAAC,eAAe,EAAGI,GAAQ,IAAK;MAC5C,IAAI,CAACjB,YAAY,GAAG,KAAK;MACzB,IAAI,CAACC,WAAW,GAAG,KAAK;MACxB,IAAI,CAACiB,yBAAyB,CAAC,CAAC;MAChC5B,MAAM,CAAC6B,KAAK,CAAC,eAAe,EAAE,4BAA4B,EAAEF,GAAG,CAAC;IAClE,CAAC,CAAC;IAEF,IAAI,CAACnB,MAAM,CAACe,EAAE,CAACpB,qBAAqB,EAAG2B,CAAM,IAAK;MAChD,IAAI,CAACC,sBAAsB,CAAC,CAAC;IAC/B,CAAC,CAAC;IAEF,IAAI,CAACvB,MAAM,CAACe,EAAE,CAACrB,oBAAoB,EAAG4B,CAAM,IAAK,CAAC,CAAC,CAAC;EACtD;EAEAE,SAASA,CAACf,MAAc,EAAQ;IAC9B,IAAI,CAACA,MAAM,GAAGA,MAAM;EACtB;EAEAgB,YAAYA,CAACjB,SAAiB,EAAQ;IACpC,IAAI,CAACA,SAAS,GAAGA,SAAS;EAC5B;EAEQY,yBAAyBA,CAAA,EAAS;IACxC,IAAI,IAAI,CAAChB,QAAQ,IAAIN,yBAAyB,EAAE;MAC9C,IAAI,CAACmB,UAAU,CAAC,CAAC;IACnB;EACF;EAEQA,UAAUA,CAAA,EAAS;IACzB,OAAO,IAAI,CAAChB,KAAK,CAACyB,MAAM,GAAG,CAAC,IAAI,IAAI,CAAC1B,MAAM,EAAE2B,SAAS,EAAE;MACtD,MAAMC,KAAK,GAAG,IAAI,CAAC3B,KAAK,CAAC4B,KAAK,CAAC,CAAC;MAChC,IAAI,CAACD,KAAK,EAAE;MAEZ,IAAI,IAAI,CAAC5B,MAAM,EAAE2B,SAAS,EAAE;QAC1B,IAAI,CAAC3B,MAAM,CAAC8B,IAAI,CAACF,KAAK,CAACG,IAAI,EAAEH,KAAK,CAACI,IAAI,CAAC;MAC1C;IACF;EACF;EAEQT,sBAAsBA,CAAA,EAAG;IAC/B,MAAMU,OAAO,GAAG;MACdC,cAAc,EAAE,IAAI,CAAC7B;IACvB,CAAC;IACD,IAAI,IAAI,CAACL,MAAM,EAAE2B,SAAS,EAAE;MAC1B,IAAI,CAAC3B,MAAM,CAAC8B,IAAI,CAACjC,yBAAyB,EAAEoC,OAAO,CAAC;IACtD;EACF;EAEOE,IAAIA,CAACP,KAAU,EAAQ;IAC5B,IAAI,IAAI,CAAC5B,MAAM,EAAE2B,SAAS,EAAE;MAC1B,IAAI,CAAC3B,MAAM,CAAC8B,IAAI,CAACrC,iBAAiB,EAAEmC,KAAK,CAAC;IAC5C,CAAC,MAAM;MACL,IAAI,CAAC3B,KAAK,CAACmC,IAAI,CAAC;QAAEJ,IAAI,EAAEJ,KAAK;QAAEG,IAAI,EAAEtC;MAAkB,CAAC,CAAC;MACzD,IAAI,CAACiB,IAAI,CAAC,CAAC;IACb;EACF;EAEO2B,kBAAkBA,CAACC,OAAiB,EAAQ;IACjD,IAAI,CAACjC,SAAS,GAAGiC,OAAO,CAACC,OAAO,IAAID,OAAO,CAACE,GAAG;IAC/C,MAAMP,OAAO,GAAG;MACdQ,SAAS,EAAEH,OAAO,CAACI,OAAO;MAC1BC,WAAW,EAAEL,OAAO,CAACM,SAAS;MAC9BV,cAAc,EAAE,IAAI,CAAC7B,SAAS;MAC9BwC,WAAW,EAAEP,OAAO,CAACQ;IACvB,CAAC;IACD,IAAI,IAAI,CAAC9C,MAAM,EAAE2B,SAAS,EAAE;MAC1B,IAAI,CAAC3B,MAAM,CAAC8B,IAAI,CAAClC,uBAAuB,EAAEqC,OAAO,CAAC;IACpD,CAAC,MAAM;MACL,IAAI,CAAChC,KAAK,CAACmC,IAAI,CAAC;QAAEJ,IAAI,EAAEC,OAAO;QAAEF,IAAI,EAAEnC;MAAwB,CAAC,CAAC;MACjE,IAAI,CAACc,IAAI,CAAC,CAAC;IACb;EACF;EAEOqC,KAAKA,CAAA,EAAS;IACnB,IAAI,IAAI,CAAC/C,MAAM,EAAE2B,SAAS,EAAE;MAC1BqB,UAAU,CAAC,MAAM;QACf,IAAI,CAACzB,sBAAsB,CAAC,CAAC;QAC7B,IAAI,CAACnB,QAAQ,GAAG,CAAC;QACjB,IAAI,CAACD,WAAW,GAAG,KAAK;QACxB,IAAI,CAACD,YAAY,GAAG,KAAK;QACzB,IAAI,CAACF,MAAM,EAAEiD,UAAU,CAAC,CAAC;QACzB,IAAI,CAACjD,MAAM,GAAG,IAAI;MACpB,CAAC,EAAE,GAAG,CAAC;IACT;EACF;AACF","ignoreList":[]}

package/lib/module/types/client-type.enum.js

@@ -1,9 +0,0 @@
-"use strict";
-
-export let UserType = /*#__PURE__*/function (UserType) {
-  UserType["USER"] = "USER";
-  UserType["VISITOR"] = "VISITOR";
-  UserType["API_CLIENT"] = "API_CLIENT";
-  return UserType;
-}({});
-//# sourceMappingURL=client-type.enum.js.map

package/lib/module/types/client-type.enum.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["UserType"],"sourceRoot":"../../../src","sources":["types/client-type.enum.ts"],"mappings":";;AAAA,WAAYA,QAAQ,0BAARA,QAAQ;EAARA,QAAQ;EAARA,QAAQ;EAARA,QAAQ;EAAA,OAARA,QAAQ;AAAA","ignoreList":[]}

package/lib/typescript/src/recorder/eventExporter.d.ts

@@ -1,25 +0,0 @@
-import { type ISession } from '../types';
-export declare class EventExporter {
-    private socket;
-    private queue;
-    private isConnecting;
-    private isConnected;
-    private attempts;
-    private sessionId;
-    private socketUrl;
-    private apiKey;
-    constructor(options: {
-        socketUrl: string;
-        apiKey: string;
-    });
-    private init;
-    setApiKey(apiKey: string): void;
-    setSocketUrl(socketUrl: string): void;
-    private checkReconnectionAttempts;
-    private flushQueue;
-    private unsubscribeFromSession;
-    send(event: any): void;
-    subscribeToSession(session: ISession): void;
-    close(): void;
-}
-//# sourceMappingURL=eventExporter.d.ts.map