@salve-software/mako-react-native 1.0.1

package/ios/PerformanceMonitor.swift

@@ -0,0 +1,223 @@
+//
+//  PerformanceMonitor.swift
+//  NitroMako
+//
+//  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.NitroMako = 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 NitroMako = exports.NitroMako = _reactNativeNitroModules.NitroModules.createHybridObject('NitroMako');
+//# sourceMappingURL=index.js.map

package/lib/commonjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNativeNitroModules","require","_library","_interopRequireDefault","e","__esModule","default","NitroMako","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,SAAS,GAAAC,OAAA,CAAAD,SAAA,GACpBE,qCAAY,CAACC,kBAAkB,CAAgB,WAAW,CAAC","ignoreList":[]}

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

@@ -0,0 +1,34 @@
+"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,
+  enableComponentInspector: false,
+  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","enableComponentInspector","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,wBAAwB,EAAE,KAAK;EAC/BC,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 _makoClient = require("./mako-client");
+var _constants = require("./constants");
+const client = exports.client = new _makoClient.MakoClient();
+//# sourceMappingURL=index.js.map

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

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