@salve-software/salvetron-react-native 1.0.1

package/ios/PerformanceMonitor.swift

@@ -0,0 +1,223 @@
+//
+//  PerformanceMonitor.swift
+//  NitroRnTuiSdk
+//
+//  Performance metrics monitoring for iOS
+//  Measures UI FPS, JS FPS, memory usage, and CPU usage
+//
+
+import Foundation
+import QuartzCore
+import UIKit
+
+public struct PerformanceMetricsData {
+    let uiFps: Double
+    let jsFps: Double
+    let memoryUsageMB: Double
+    let cpuUsagePercent: Double
+}
+
+public typealias PerformanceMetricsCallback = (PerformanceMetricsData) -> Void
+
+public class PerformanceMonitor {
+
+    // MARK: - Properties
+
+    private var displayLink: CADisplayLink?
+    private var displayLinkProxy: DisplayLinkProxy?
+    private var reportTimer: Timer?
+    private var callback: PerformanceMetricsCallback?
+
+    // UI FPS tracking
+    private var uiFrameCount: Int = 0
+    private var lastUiFpsUpdateTime: CFTimeInterval = 0
+    private var currentUiFps: Double = 0
+
+    // JS FPS tracking (via callback timing)
+    private var lastJsCallbackTime: CFTimeInterval = 0
+    private var jsFrameCount: Int = 0
+    private var lastJsFpsUpdateTime: CFTimeInterval = 0
+    private var currentJsFps: Double = 0
+
+    private var isMonitoring = false
+    private var intervalMs: Int = 1000
+
+    // MARK: - DisplayLinkProxy
+
+    // DisplayLinkProxy to avoid retain cycle with CADisplayLink
+    private class DisplayLinkProxy {
+        weak var target: PerformanceMonitor?
+
+        init(target: PerformanceMonitor) {
+            self.target = target
+        }
+
+        @objc func handleDisplayLink(_ link: CADisplayLink) {
+            target?.handleDisplayLink(link)
+        }
+    }
+
+    // MARK: - Public Methods
+
+    public func start(callback: @escaping PerformanceMetricsCallback, intervalMs: Int = 1000) -> Bool {
+        guard !isMonitoring else {
+            return false // Already monitoring
+        }
+
+        self.callback = callback
+        self.intervalMs = intervalMs
+        self.isMonitoring = true
+
+        // Reset counters
+        uiFrameCount = 0
+        jsFrameCount = 0
+        lastUiFpsUpdateTime = CACurrentMediaTime()
+        lastJsFpsUpdateTime = CACurrentMediaTime()
+        lastJsCallbackTime = CACurrentMediaTime()
+        currentUiFps = 0
+        currentJsFps = 0
+
+        // Set up CADisplayLink for UI FPS
+        displayLinkProxy = DisplayLinkProxy(target: self)
+        displayLink = CADisplayLink(target: displayLinkProxy!, selector: #selector(DisplayLinkProxy.handleDisplayLink(_:)))
+        displayLink?.add(to: .main, forMode: .common)
+
+        // Set up timer for reporting metrics
+        let interval = TimeInterval(intervalMs) / 1000.0
+        reportTimer = Timer.scheduledTimer(withTimeInterval: interval, repeats: true) { [weak self] _ in
+            self?.reportMetrics()
+        }
+
+        return true
+    }
+
+    public func stop() {
+        guard isMonitoring else { return }
+
+        isMonitoring = false
+        callback = nil
+
+        // Stop display link
+        displayLink?.invalidate()
+        displayLink = nil
+        displayLinkProxy = nil
+
+        // Stop report timer
+        reportTimer?.invalidate()
+        reportTimer = nil
+    }
+
+    public func isRunning() -> Bool {
+        return isMonitoring
+    }
+
+    public func getSnapshot() -> PerformanceMetricsData {
+        return PerformanceMetricsData(
+            uiFps: currentUiFps,
+            jsFps: currentJsFps,
+            memoryUsageMB: getMemoryUsage(),
+            cpuUsagePercent: getCpuUsage()
+        )
+    }
+
+    public func recordJsFrame() {
+        guard isMonitoring else { return }
+
+        let now = CACurrentMediaTime()
+        lastJsCallbackTime = now
+        jsFrameCount += 1
+
+        // Calculate JS FPS every 500ms
+        let elapsed = now - lastJsFpsUpdateTime
+        if elapsed >= 0.5 {
+            currentJsFps = Double(jsFrameCount) / elapsed
+            jsFrameCount = 0
+            lastJsFpsUpdateTime = now
+        }
+    }
+
+    // MARK: - Private Methods
+
+    @objc private func handleDisplayLink(_ link: CADisplayLink) {
+        uiFrameCount += 1
+
+        let now = link.timestamp
+        let elapsed = now - lastUiFpsUpdateTime
+
+        // Calculate UI FPS every 500ms
+        if elapsed >= 0.5 {
+            currentUiFps = Double(uiFrameCount) / elapsed
+
+            // Cap at device refresh rate
+            let maxRefreshRate = Double(UIScreen.main.maximumFramesPerSecond)
+            if currentUiFps > maxRefreshRate {
+                currentUiFps = maxRefreshRate
+            }
+
+            uiFrameCount = 0
+            lastUiFpsUpdateTime = now
+        }
+    }
+
+    private func reportMetrics() {
+        let metrics = PerformanceMetricsData(
+            uiFps: currentUiFps,
+            jsFps: currentJsFps,
+            memoryUsageMB: getMemoryUsage(),
+            cpuUsagePercent: getCpuUsage()
+        )
+
+        callback?(metrics)
+    }
+
+    private func getMemoryUsage() -> Double {
+        var info = mach_task_basic_info()
+        var count = mach_msg_type_number_t(MemoryLayout<mach_task_basic_info>.size) / 4
+
+        let result = withUnsafeMutablePointer(to: &info) {
+            $0.withMemoryRebound(to: integer_t.self, capacity: 1) {
+                task_info(mach_task_self_, task_flavor_t(MACH_TASK_BASIC_INFO), $0, &count)
+            }
+        }
+
+        if result == KERN_SUCCESS {
+            return Double(info.resident_size) / 1024.0 / 1024.0 // Convert to MB
+        }
+
+        return 0
+    }
+
+    private func getCpuUsage() -> Double {
+        var totalUsage: Double = 0
+        var threadList: thread_act_array_t?
+        var threadCount: mach_msg_type_number_t = 0
+
+        let result = task_threads(mach_task_self_, &threadList, &threadCount)
+
+        if result == KERN_SUCCESS, let threads = threadList {
+            for i in 0..<Int(threadCount) {
+                var threadInfo = thread_basic_info()
+                var threadInfoCount = mach_msg_type_number_t(THREAD_INFO_MAX)
+
+                let infoResult = withUnsafeMutablePointer(to: &threadInfo) {
+                    $0.withMemoryRebound(to: integer_t.self, capacity: 1) {
+                        thread_info(threads[i], thread_flavor_t(THREAD_BASIC_INFO), $0, &threadInfoCount)
+                    }
+                }
+
+                if infoResult == KERN_SUCCESS {
+                    let cpuUsage = Double(threadInfo.cpu_usage) / Double(TH_USAGE_SCALE)
+                    totalUsage += cpuUsage * 100.0
+                }
+            }
+
+            vm_deallocate(mach_task_self_, vm_address_t(bitPattern: threads), vm_size_t(threadCount * UInt32(MemoryLayout<thread_t>.size)))
+        }
+
+        return totalUsage
+    }
+
+    deinit {
+        stop()
+    }
+}

package/lib/commonjs/index.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NitroRnTuiSdk = void 0;
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function () {
+    return _library.default;
+  }
+});
+var _reactNativeNitroModules = require("react-native-nitro-modules");
+var _library = _interopRequireDefault(require("./library"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const NitroRnTuiSdk = exports.NitroRnTuiSdk = _reactNativeNitroModules.NitroModules.createHybridObject('NitroRnTuiSdk');
+//# sourceMappingURL=index.js.map

package/lib/commonjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNativeNitroModules","require","_library","_interopRequireDefault","e","__esModule","default","NitroRnTuiSdk","exports","NitroModules","createHybridObject"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;;;;;;;AAAA,IAAAA,wBAAA,GAAAC,OAAA;AAMA,IAAAC,QAAA,GAAAC,sBAAA,CAAAF,OAAA;AAAmC,SAAAE,uBAAAC,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAH5B,MAAMG,aAAa,GAAAC,OAAA,CAAAD,aAAA,GACxBE,qCAAY,CAACC,kBAAkB,CAAoB,eAAe,CAAC","ignoreList":[]}

package/lib/commonjs/library/client/constants.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RECONNECT_CONFIG = exports.DEFAULT_IGNORED_URLS = exports.DEFAULT_CONFIG = void 0;
+/**
+ * Default URL patterns to ignore during network interception
+ * Includes Metro bundler, hot reload, and debugger URLs
+ */
+const DEFAULT_IGNORED_URLS = exports.DEFAULT_IGNORED_URLS = [/localhost:8081/, /127\.0\.0\.1:8081/, /10\.0\.2\.2:8081/,
+// Android emulator
+/symbolicate/, /\.hot-update\./, /hot$/, /\.bundle/, /__packager/, /debugger-ui/, /devtools/];
+
+/**
+ * WebSocket reconnection settings
+ */
+const RECONNECT_CONFIG = exports.RECONNECT_CONFIG = {
+  maxAttempts: 5,
+  maxDelay: 30000,
+  baseDelay: 1000
+};
+
+/**
+ * Default client configuration
+ */
+const DEFAULT_CONFIG = exports.DEFAULT_CONFIG = {
+  host: 'localhost',
+  port: 8765,
+  enableNetworkCapture: true,
+  enablePerformanceMonitoring: false
+};
+//# sourceMappingURL=constants.js.map

package/lib/commonjs/library/client/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["DEFAULT_IGNORED_URLS","exports","RECONNECT_CONFIG","maxAttempts","maxDelay","baseDelay","DEFAULT_CONFIG","host","port","enableNetworkCapture","enablePerformanceMonitoring"],"sourceRoot":"../../../../src","sources":["library/client/constants.ts"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACO,MAAMA,oBAA8B,GAAAC,OAAA,CAAAD,oBAAA,GAAG,CAC5C,gBAAgB,EAChB,mBAAmB,EACnB,kBAAkB;AAAE;AACpB,aAAa,EACb,gBAAgB,EAChB,MAAM,EACN,UAAU,EACV,YAAY,EACZ,aAAa,EACb,UAAU,CACX;;AAED;AACA;AACA;AACO,MAAME,gBAAgB,GAAAD,OAAA,CAAAC,gBAAA,GAAG;EAC9BC,WAAW,EAAE,CAAC;EACdC,QAAQ,EAAE,KAAK;EACfC,SAAS,EAAE;AACb,CAAU;;AAEV;AACA;AACA;AACO,MAAMC,cAAc,GAAAL,OAAA,CAAAK,cAAA,GAAG;EAC5BC,IAAI,EAAE,WAAW;EACjBC,IAAI,EAAE,IAAI;EACVC,oBAAoB,EAAE,IAAI;EAC1BC,2BAA2B,EAAE;AAC/B,CAAU","ignoreList":[]}

package/lib/commonjs/library/client/index.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "DEFAULT_CONFIG", {
+  enumerable: true,
+  get: function () {
+    return _constants.DEFAULT_CONFIG;
+  }
+});
+Object.defineProperty(exports, "DEFAULT_IGNORED_URLS", {
+  enumerable: true,
+  get: function () {
+    return _constants.DEFAULT_IGNORED_URLS;
+  }
+});
+Object.defineProperty(exports, "RECONNECT_CONFIG", {
+  enumerable: true,
+  get: function () {
+    return _constants.RECONNECT_CONFIG;
+  }
+});
+exports.client = void 0;
+var _salvetronClient = require("./salvetron-client");
+var _constants = require("./constants");
+const client = exports.client = new _salvetronClient.SalvetronClient();
+//# sourceMappingURL=index.js.map

package/lib/commonjs/library/client/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_salvetronClient","require","_constants","client","exports","SalvetronClient"],"sourceRoot":"../../../../src","sources":["library/client/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,gBAAA,GAAAC,OAAA;AAEA,IAAAC,UAAA,GAAAD,OAAA;AAMO,MAAME,MAAM,GAAAC,OAAA,CAAAD,MAAA,GAAG,IAAIE,gCAAe,CAAC,CAAC","ignoreList":[]}

package/lib/commonjs/library/client/salvetron-client.js

@@ -0,0 +1,363 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SalvetronClient = void 0;
+var _reactNative = require("react-native");
+var _reactNativeNitroModules = require("react-native-nitro-modules");
+var _constants = require("./constants");
+var _networkHandler = require("../network-handler");
+var _performanceHandler = require("../performance-handler");
+var _device = require("../device");
+var _project = require("../project");
+var _interceptors = require("../interceptors");
+/**
+ * WebSocket client for communicating with Salvetron CLI
+ */
+
+/**
+ * Salvetron WebSocket Client
+ */
+class SalvetronClient {
+  ws = null;
+  messageQueue = [];
+  reconnectAttempts = 0;
+  reconnectTimeout = null;
+  isConnecting = false;
+  manualDisconnect = false;
+
+  // Native log capture
+  nitroRnTuiSdk = null;
+  nativeLogCaptureEnabled = false;
+
+  // Network handler
+  networkHandler = null;
+
+  // Performance handler
+  performanceHandler = null;
+  performanceMonitoringEnabled = false;
+  constructor() {
+    this.config = {
+      host: _constants.DEFAULT_CONFIG.host,
+      port: _constants.DEFAULT_CONFIG.port,
+      enableNetworkCapture: _constants.DEFAULT_CONFIG.enableNetworkCapture,
+      enablePerformanceMonitoring: _constants.DEFAULT_CONFIG.enablePerformanceMonitoring,
+      ignoredUrls: [],
+      onConnect: () => {},
+      onDisconnect: () => {},
+      onError: () => {}
+    };
+  }
+
+  /**
+   * Connect to Salvetron CLI
+   */
+  connect(userConfig = {}) {
+    if (typeof __DEV__ !== 'undefined' && !__DEV__) {
+      console.warn('[Salvetron] SDK only works in development mode');
+      return;
+    }
+    this.config = {
+      host: userConfig.host ?? _constants.DEFAULT_CONFIG.host,
+      port: userConfig.port ?? _constants.DEFAULT_CONFIG.port,
+      enableNetworkCapture: userConfig.enableNetworkCapture ?? _constants.DEFAULT_CONFIG.enableNetworkCapture,
+      enablePerformanceMonitoring: userConfig.enablePerformanceMonitoring ?? _constants.DEFAULT_CONFIG.enablePerformanceMonitoring,
+      ignoredUrls: [..._constants.DEFAULT_IGNORED_URLS, ...(userConfig.ignoredUrls ?? [])],
+      onConnect: userConfig.onConnect ?? (() => {}),
+      onDisconnect: userConfig.onDisconnect ?? (() => {}),
+      onError: userConfig.onError ?? (() => {})
+    };
+    this.manualDisconnect = false;
+    this.connectWebSocket();
+  }
+
+  /**
+   * Disconnect from Salvetron
+   */
+  disconnect() {
+    this.manualDisconnect = true;
+    this.cleanup();
+  }
+
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+
+  /**
+   * Send a log event to Salvetron
+   */
+  sendLog(level, message, metadata) {
+    const event = {
+      type: 'log',
+      source: 'js',
+      level,
+      message,
+      timestamp: Date.now(),
+      metadata,
+      projectId: _project.projectHandler.getProjectId()
+    };
+    this.send(event);
+  }
+
+  /**
+   * Start capturing native platform logs
+   */
+  startNativeLogCapture() {
+    if (this.nativeLogCaptureEnabled) {
+      console.warn('[Salvetron] Native log capture already enabled');
+      return false;
+    }
+    try {
+      const nitro = this.getNitroRnTuiSdk();
+      const success = nitro.startLogCapture(log => {
+        this.handleNativeLog(log);
+      });
+      if (success) {
+        this.nativeLogCaptureEnabled = true;
+        console.log('[Salvetron] Native log capture enabled');
+      }
+      return success;
+    } catch (error) {
+      console.error('[Salvetron] Failed to start native log capture:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Stop capturing native platform logs
+   */
+  stopNativeLogCapture() {
+    if (!this.nativeLogCaptureEnabled) return;
+    try {
+      const nitro = this.getNitroRnTuiSdk();
+      nitro.stopLogCapture();
+      this.nativeLogCaptureEnabled = false;
+      console.log('[Salvetron] Native log capture disabled');
+    } catch (error) {
+      console.error('[Salvetron] Failed to stop native log capture:', error);
+    }
+  }
+
+  /**
+   * Check if native log capture is active
+   */
+  isNativeLogCaptureEnabled() {
+    return this.nativeLogCaptureEnabled;
+  }
+
+  /**
+   * Start performance monitoring
+   */
+  startPerformanceMonitoring() {
+    if (this.performanceMonitoringEnabled) {
+      console.warn('[Salvetron] Performance monitoring already enabled');
+      return false;
+    }
+    this.performanceHandler = new _performanceHandler.PerformanceHandler({
+      nitroRnTuiSdk: this.getNitroRnTuiSdk(),
+      onEvent: event => this.send(event)
+    });
+    const success = this.performanceHandler.start();
+    if (success) {
+      this.performanceMonitoringEnabled = true;
+      console.log('[Salvetron] Performance monitoring enabled');
+    }
+    return success;
+  }
+
+  /**
+   * Stop performance monitoring
+   */
+  stopPerformanceMonitoring() {
+    if (!this.performanceMonitoringEnabled) return;
+    try {
+      if (this.performanceHandler) {
+        this.performanceHandler.stop();
+        this.performanceHandler = null;
+      }
+      this.performanceMonitoringEnabled = false;
+      console.log('[Salvetron] Performance monitoring disabled');
+    } catch (error) {
+      console.error('[Salvetron] Failed to stop performance monitoring:', error);
+    }
+  }
+
+  /**
+   * Check if performance monitoring is active
+   */
+  isPerformanceMonitoringEnabled() {
+    return this.performanceMonitoringEnabled;
+  }
+  getNitroRnTuiSdk() {
+    if (!this.nitroRnTuiSdk) {
+      this.nitroRnTuiSdk = _reactNativeNitroModules.NitroModules.createHybridObject('NitroRnTuiSdk');
+    }
+    return this.nitroRnTuiSdk;
+  }
+  handleNativeLog(log) {
+    const platform = _reactNative.Platform.OS;
+    const level = log.level === 'verbose' ? 'debug' : log.level;
+    const event = {
+      type: 'native',
+      source: platform,
+      level: level,
+      message: log.message,
+      timestamp: log.timestamp,
+      metadata: log.tag ? {
+        tag: log.tag
+      } : undefined,
+      projectId: _project.projectHandler.getProjectId()
+    };
+    this.send(event);
+  }
+  connectWebSocket() {
+    _interceptors.jsConsoleInterceptor.start({
+      onLog: (level, message, metadata) => this.sendLog(level, message, metadata)
+    });
+    if (this.isConnecting || this.isConnected()) return;
+    this.isConnecting = true;
+    const url = `ws://${this.config.host}:${this.config.port}`;
+    try {
+      this.ws = new WebSocket(url);
+      this.ws.onopen = () => {
+        this.isConnecting = false;
+        this.reconnectAttempts = 0;
+        console.log(`[Salvetron] Connected to ${url}`);
+        this.config.onConnect();
+        this.sendProjectInfo();
+        this.sendDeviceInfo();
+        this.flushQueue();
+        if (this.config.enableNetworkCapture) {
+          this.setupNetworkInterception();
+        }
+        if (this.config.enablePerformanceMonitoring) {
+          this.startPerformanceMonitoring();
+        }
+        this.startNativeLogCapture();
+      };
+      this.ws.onclose = () => {
+        this.isConnecting = false;
+        console.log('[Salvetron] Disconnected');
+        this.config.onDisconnect();
+        if (!this.manualDisconnect) {
+          this.scheduleReconnect();
+        }
+      };
+      this.ws.onerror = event => {
+        this.isConnecting = false;
+        const error = new Error('WebSocket error');
+        console.error('[Salvetron] Connection error:', event);
+        this.config.onError(error);
+      };
+      this.ws.onmessage = event => {
+        console.log('[Salvetron] Received:', event.data);
+      };
+    } catch (error) {
+      this.isConnecting = false;
+      console.error('[Salvetron] Failed to create WebSocket:', error);
+      this.scheduleReconnect();
+    }
+  }
+  scheduleReconnect() {
+    if (this.manualDisconnect) return;
+    if (this.reconnectAttempts >= _constants.RECONNECT_CONFIG.maxAttempts) {
+      console.warn('[Salvetron] Max reconnection attempts reached');
+      return;
+    }
+    const delay = Math.min(_constants.RECONNECT_CONFIG.baseDelay * Math.pow(2, this.reconnectAttempts), _constants.RECONNECT_CONFIG.maxDelay);
+    this.reconnectAttempts++;
+    console.log(`[Salvetron] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
+    this.reconnectTimeout = setTimeout(() => {
+      this.connectWebSocket();
+    }, delay);
+  }
+  cleanup() {
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+    this.stopNativeLogCapture();
+    this.stopPerformanceMonitoring();
+    _interceptors.xhrInterceptor.disable();
+    _interceptors.jsConsoleInterceptor.stop();
+    if (this.networkHandler) {
+      this.networkHandler.clear();
+      this.networkHandler = null;
+    }
+    if (this.ws) {
+      this.ws.onopen = null;
+      this.ws.onclose = null;
+      this.ws.onerror = null;
+      this.ws.onmessage = null;
+      this.ws.close();
+      this.ws = null;
+    }
+    this.messageQueue = [];
+    this.reconnectAttempts = 0;
+    this.isConnecting = false;
+  }
+  send(event) {
+    if (this.isConnected() && this.ws) {
+      try {
+        this.ws.send(JSON.stringify(event));
+      } catch (error) {
+        console.error('[Salvetron] Failed to send event:', error);
+        this.messageQueue.push(event);
+      }
+    } else {
+      this.messageQueue.push(event);
+    }
+  }
+  sendProjectInfo() {
+    try {
+      const projectInfo = _project.projectHandler.getProjectInfo();
+      const event = {
+        type: 'project_info',
+        ...projectInfo
+      };
+      this.send(event);
+      console.log(`[Salvetron] Project registered: ${projectInfo.appName} (${projectInfo.projectId})`);
+    } catch (error) {
+      console.warn('[Salvetron] Failed to send project info:', error);
+    }
+  }
+  async sendDeviceInfo() {
+    try {
+      const deviceInfo = _device.deviceHandler.getDeviceInfo();
+      const projectId = _project.projectHandler.getProjectId();
+      const event = {
+        type: 'device_info',
+        ...deviceInfo,
+        projectId
+      };
+      this.send(event);
+      console.log(`[Salvetron] Device registered: ${deviceInfo.deviceName} (${deviceInfo.deviceId})`);
+    } catch (error) {
+      console.warn('[Salvetron] Failed to send device info:', error);
+    }
+  }
+  flushQueue() {
+    while (this.messageQueue.length > 0 && this.isConnected()) {
+      const event = this.messageQueue.shift();
+      if (event) {
+        this.send(event);
+      }
+    }
+  }
+  setupNetworkInterception() {
+    this.networkHandler = new _networkHandler.NetworkHandler({
+      ignoredUrls: this.config.ignoredUrls,
+      onEvent: event => this.send(event)
+    });
+    const success = _interceptors.xhrInterceptor.enable(this.networkHandler.getCallbacks());
+    if (success) {
+      console.log('[Salvetron] Network capture enabled');
+    }
+  }
+}
+exports.SalvetronClient = SalvetronClient;
+//# sourceMappingURL=salvetron-client.js.map