@multiplayer-app/session-recorder-react-native 1.0.1-beta.1 → 1.0.1-beta.10

package/android/src/main/java/com/sessionrecordernative/SessionRecorderNativePackage.kt

@@ -0,0 +1,33 @@
+package com.sessionrecordernative
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import java.util.HashMap
+
+class SessionRecorderNativePackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == SessionRecorderNativeModule.NAME) {
+      SessionRecorderNativeModule(reactContext) as NativeModule
+    } else {
+      null
+    }
+  }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider {
+      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+      moduleInfos[SessionRecorderNativeModule.NAME] = ReactModuleInfo(
+        SessionRecorderNativeModule.NAME,
+        SessionRecorderNativeModule.NAME,
+        false,  // canOverrideExistingModule
+        false,  // needsEagerInit
+        false,  // isCxxModule
+        false // isTurboModule
+      )
+      moduleInfos
+    }
+  }
+}

package/android/src/main/java/com/sessionrecordernative/SessionRecorderNativeSpec.kt

@@ -0,0 +1,79 @@
+package com.multiplayer.sessionrecordernative
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.Callback
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+
+/**
+ * Spec class for SessionRecorderNative TurboModule
+ * This class defines the interface that React Native expects for TurboModules
+ */
+class SessionRecorderNativeSpec(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+
+    override fun getName(): String {
+        return NAME
+    }
+
+    companion object {
+        const val NAME = "SessionRecorderNative"
+    }
+
+    // Delegate to the actual implementation
+    private val implementation = SessionRecorderNativeModule(reactContext)
+
+    @ReactMethod
+    fun captureAndMask(promise: Promise) {
+        implementation.captureAndMask(promise)
+    }
+
+    @ReactMethod
+    fun captureAndMaskWithOptions(options: ReadableMap, promise: Promise) {
+        implementation.captureAndMaskWithOptions(options, promise)
+    }
+
+    @ReactMethod
+    fun startGestureRecording(promise: Promise) {
+        implementation.startGestureRecording(promise)
+    }
+
+    @ReactMethod
+    fun stopGestureRecording(promise: Promise) {
+        implementation.stopGestureRecording(promise)
+    }
+
+    @ReactMethod
+    fun isGestureRecordingActive(promise: Promise) {
+        implementation.isGestureRecordingActive(promise)
+    }
+
+    @ReactMethod
+    fun setGestureCallback(callback: Callback) {
+        implementation.setGestureCallback(callback)
+    }
+
+    @ReactMethod
+    fun recordGesture(
+        gestureType: String,
+        x: Double,
+        y: Double,
+        target: String?,
+        metadata: ReadableMap?
+    ) {
+        implementation.recordGesture(gestureType, x, y, target, metadata)
+    }
+
+    @ReactMethod
+    fun addListener(eventName: String) {
+        implementation.addListener(eventName)
+    }
+
+    @ReactMethod
+    fun removeListeners(count: Int) {
+        implementation.removeListeners(count)
+    }
+}

package/android/src/main/java/com/sessionrecordernative/model/TargetInfo.kt

@@ -0,0 +1,9 @@
+package com.sessionrecordernative.model
+
+data class TargetInfo(
+        val identifier: String,
+        val label: String?,
+        val role: String?,
+        val testId: String?,
+        val text: String?
+)

package/android/src/main/java/com/sessionrecordernative/util/ViewUtils.kt

@@ -0,0 +1,72 @@
+package com.sessionrecordernative.util
+
+import android.graphics.PointF
+import android.view.View
+import android.view.ViewGroup
+import android.widget.*
+import com.sessionrecordernative.model.TargetInfo
+
+object ViewUtils {
+  fun findTargetView(point: PointF, rootView: ViewGroup?): TargetInfo {
+    if (rootView == null) {
+      return TargetInfo("unknown", null, null, null, null)
+    }
+
+    val targetView =
+            findViewAtPoint(point, rootView) ?: return TargetInfo("unknown", null, null, null, null)
+
+    val identifier =
+            targetView.contentDescription?.toString()
+                    ?: targetView.tag?.toString() ?: "view-${targetView.hashCode()}"
+
+    val label = targetView.contentDescription?.toString()
+    val role = getAccessibilityRole(targetView)
+    val testId = targetView.tag?.toString()
+
+    val text =
+            when (targetView) {
+              is TextView -> targetView.text?.toString()
+              is Button -> targetView.text?.toString()
+              is EditText -> targetView.text?.toString() ?: targetView.hint?.toString()
+              else -> null
+            }
+
+    return TargetInfo(identifier, label, role, testId, text)
+  }
+
+  private fun findViewAtPoint(point: PointF, viewGroup: ViewGroup): View? {
+    for (i in viewGroup.childCount - 1 downTo 0) {
+      val child = viewGroup.getChildAt(i)
+      if (child.visibility == View.VISIBLE && child.alpha > 0.01f) {
+        val location = IntArray(2)
+        child.getLocationOnScreen(location)
+        val childRect =
+                android.graphics.Rect(
+                        location[0],
+                        location[1],
+                        location[0] + child.width,
+                        location[1] + child.height
+                )
+
+        if (childRect.contains(point.x.toInt(), point.y.toInt())) {
+          return if (child is ViewGroup) {
+            findViewAtPoint(point, child) ?: child
+          } else {
+            child
+          }
+        }
+      }
+    }
+    return null
+  }
+
+  private fun getAccessibilityRole(view: View): String? {
+    return when (view) {
+      is Button -> "button"
+      is EditText -> "textbox"
+      is ImageView -> "image"
+      is TextView -> "text"
+      else -> null
+    }
+  }
+}

package/ios/GestureTargetFinder.swift

@@ -0,0 +1,50 @@
+import UIKit
+
+struct GestureTargetInfo {
+    let identifier: String
+    let label: String?
+    let role: String?
+    let testId: String?
+    let text: String?
+}
+
+enum GestureTargetFinder {
+    static func findTargetView(at point: CGPoint, in view: UIView) -> GestureTargetInfo {
+        let targetView = view.hitTest(point, with: nil)
+
+        guard let target = targetView else {
+            return GestureTargetInfo(identifier: "unknown", label: nil, role: nil, testId: nil, text: nil)
+        }
+
+        let identifier = target.accessibilityIdentifier ?? target.accessibilityLabel ?? "view-\(target.hash)"
+        let label = target.accessibilityLabel
+        let role = roleFromAccessibilityTraits(target.accessibilityTraits)
+        let testId = target.accessibilityIdentifier
+
+        var text: String?
+        if let labelView = target as? UILabel {
+            text = labelView.text
+        } else if let button = target as? UIButton {
+            text = button.titleLabel?.text
+        } else if let textField = target as? UITextField {
+            text = textField.text ?? textField.placeholder
+        } else if let textView = target as? UITextView {
+            text = textView.text
+        }
+
+        return GestureTargetInfo(identifier: identifier, label: label, role: role, testId: testId, text: text)
+    }
+
+    static func roleFromAccessibilityTraits(_ traits: UIAccessibilityTraits) -> String? {
+        if traits.contains(.button) { return "button" }
+        if traits.contains(.link) { return "link" }
+        if traits.contains(.image) { return "image" }
+        if traits.contains(.staticText) { return "text" }
+        if traits.contains(.header) { return "header" }
+        if traits.contains(.searchField) { return "search" }
+        if traits.contains(.keyboardKey) { return "key" }
+        if traits.contains(.adjustable) { return "adjustable" }
+        if traits.contains(.tabBar) { return "tabbar" }
+        return nil
+    }
+}

package/ios/SessionRecorderNative-Bridging-Header.h

@@ -0,0 +1,2 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>

package/ios/{GestureRecorderNative.m → SessionRecorderNative.mm}

@@ -1,21 +1,32 @@
 #import <React/RCTBridgeModule.h>
 #import <React/RCTEventEmitter.h>
 
-@interface RCT_EXTERN_MODULE(GestureRecorderNative, RCTEventEmitter)
+@interface RCT_EXTERN_MODULE(SessionRecorderNative, RCTEventEmitter)
 
-RCT_EXTERN_METHOD(startGestureRecording:(RCTPromiseResolveBlock)resolve
+RCT_EXTERN_METHOD(captureAndMask:(RCTPromiseResolveBlock)resolve
                   reject:(RCTPromiseRejectBlock)reject)
 
-RCT_EXTERN_METHOD(stopGestureRecording:(RCTPromiseResolveBlock)resolve
+RCT_EXTERN_METHOD(captureAndMaskWithOptions:(NSDictionary *)options
+                  resolve:(RCTPromiseResolveBlock)resolve
                   reject:(RCTPromiseRejectBlock)reject)
 
+// Gesture recording APIs
+RCT_EXTERN_METHOD(startGestureRecording:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(stopGestureRecording:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
 RCT_EXTERN_METHOD(isGestureRecordingActive:(RCTPromiseResolveBlock)resolve
                   reject:(RCTPromiseRejectBlock)reject)
-
+RCT_EXTERN_METHOD(setGestureCallback:(RCTResponseSenderBlock)callback)
 RCT_EXTERN_METHOD(recordGesture:(NSString *)gestureType
-                  x:(NSNumber *)x
-                  y:(NSNumber *)y
+                  x:(nonnull NSNumber *)x
+                  y:(nonnull NSNumber *)y
                   target:(NSString *)target
                   metadata:(NSDictionary *)metadata)
 
++ (BOOL)requiresMainQueueSetup
+{
+  return YES;
+}
+
 @end

package/ios/SessionRecorderNative.swift

@@ -3,7 +3,7 @@ import React
 import WebKit
 
 @objc(SessionRecorderNative)
-class SessionRecorderNative: NSObject {
+class SessionRecorderNative: RCTEventEmitter, UIGestureRecognizerDelegate {
 
   // Configuration options
   private var maskTextInputs: Bool = true
@@ -44,6 +44,7 @@ class SessionRecorderNative: NSObject {
     "SwiftUI.GradientLayer", // Views like LinearGradient, RadialGradient, or AngularGradient
   ].compactMap(NSClassFromString)
 
+  // MARK: - Screen capture APIs
   @objc func captureAndMask(_ resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
     DispatchQueue.main.async {
       guard let window = UIApplication.shared.windows.first(where: { $0.isKeyWindow }) else {
@@ -117,6 +118,74 @@ class SessionRecorderNative: NSObject {
     }
   }
 
+  // MARK: - Gesture recording state
+  private var isRecording = false
+  private var gestureCallback: RCTResponseSenderBlock?
+  private var rootViewController: UIViewController?
+
+  private var tapGestureRecognizer: UITapGestureRecognizer?
+  private var panGestureRecognizer: UIPanGestureRecognizer?
+  private var longPressGestureRecognizer: UILongPressGestureRecognizer?
+  private var pinchGestureRecognizer: UIPinchGestureRecognizer?
+
+  // MARK: - Event Emitter overrides
+  override func supportedEvents() -> [String]! {
+    return ["onGestureDetected"]
+  }
+
+  @objc override static func requiresMainQueueSetup() -> Bool {
+    return true
+  }
+
+  // MARK: - Gesture recording APIs
+  @objc func startGestureRecording(_ resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    DispatchQueue.main.async {
+      guard !self.isRecording else {
+        resolve(nil)
+        return
+      }
+
+      self.setupGestureRecognizers()
+      self.isRecording = true
+      resolve(nil)
+    }
+  }
+
+  @objc func stopGestureRecording(_ resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    DispatchQueue.main.async {
+      guard self.isRecording else {
+        resolve(nil)
+        return
+      }
+
+      self.removeGestureRecognizers()
+      self.isRecording = false
+      resolve(nil)
+    }
+  }
+
+  @objc func isGestureRecordingActive(_ resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    resolve(self.isRecording)
+  }
+
+  @objc func setGestureCallback(_ callback: @escaping RCTResponseSenderBlock) {
+    self.gestureCallback = callback
+  }
+
+  @objc func recordGesture(_ gestureType: String, x: NSNumber, y: NSNumber, target: String?, metadata: NSDictionary?) {
+    let gestureEvent: [String: Any] = [
+      "type": gestureType,
+      "timestamp": Date().timeIntervalSince1970 * 1000,
+      "x": x.doubleValue,
+      "y": y.doubleValue,
+      "target": target ?? "",
+      "metadata": metadata ?? [:]
+    ]
+
+    self.sendEvent(withName: "onGestureDetected", body: gestureEvent)
+    if let cb = gestureCallback { cb([gestureEvent]) }
+  }
+
   private func updateConfiguration(from options: NSDictionary) {
     print("SessionRecorder: updateConfiguration called with options: \(options)")
 
@@ -509,6 +578,192 @@ class SessionRecorderNative: NSObject {
       UIGraphicsEndImageContext()
       return newImage ?? image
   }
+
+  // MARK: - Gesture setup and handlers
+  private func setupGestureRecognizers() {
+    guard let window = UIApplication.shared.windows.first(where: { $0.isKeyWindow }),
+          let rootViewController = window.rootViewController else {
+      return
+    }
+
+    self.rootViewController = rootViewController
+
+    // Tap
+    tapGestureRecognizer = UITapGestureRecognizer(target: self, action: #selector(handleTap(_:)))
+    tapGestureRecognizer?.numberOfTapsRequired = 1
+    tapGestureRecognizer?.numberOfTouchesRequired = 1
+    rootViewController.view.addGestureRecognizer(tapGestureRecognizer!)
+
+    // Pan
+    panGestureRecognizer = UIPanGestureRecognizer(target: self, action: #selector(handlePan(_:)))
+    rootViewController.view.addGestureRecognizer(panGestureRecognizer!)
+
+    // Long press
+    longPressGestureRecognizer = UILongPressGestureRecognizer(target: self, action: #selector(handleLongPress(_:)))
+    longPressGestureRecognizer?.minimumPressDuration = 0.5
+    rootViewController.view.addGestureRecognizer(longPressGestureRecognizer!)
+
+    // Pinch
+    pinchGestureRecognizer = UIPinchGestureRecognizer(target: self, action: #selector(handlePinch(_:)))
+    rootViewController.view.addGestureRecognizer(pinchGestureRecognizer!)
+
+    // Allow simultaneous recognition
+    tapGestureRecognizer?.delegate = self
+    panGestureRecognizer?.delegate = self
+    longPressGestureRecognizer?.delegate = self
+    pinchGestureRecognizer?.delegate = self
+  }
+
+  private func removeGestureRecognizers() {
+    guard let rootViewController = rootViewController else { return }
+
+    if let tapGesture = tapGestureRecognizer { rootViewController.view.removeGestureRecognizer(tapGesture) }
+    if let panGesture = panGestureRecognizer { rootViewController.view.removeGestureRecognizer(panGesture) }
+    if let longPressGesture = longPressGestureRecognizer { rootViewController.view.removeGestureRecognizer(longPressGesture) }
+    if let pinchGesture = pinchGestureRecognizer { rootViewController.view.removeGestureRecognizer(pinchGesture) }
+
+    tapGestureRecognizer = nil
+    panGestureRecognizer = nil
+    longPressGestureRecognizer = nil
+    pinchGestureRecognizer = nil
+    self.rootViewController = nil
+  }
+
+  @objc private func handleTap(_ gesture: UITapGestureRecognizer) {
+    guard let view = gesture.view else { return }
+    let location = gesture.location(in: view)
+    let target = GestureTargetFinder.findTargetView(at: location, in: view)
+
+    let gestureEvent: [String: Any] = [
+      "type": "tap",
+      "timestamp": Date().timeIntervalSince1970 * 1000,
+      "x": location.x,
+      "y": location.y,
+      "target": target.identifier,
+      "targetInfo": [
+        "identifier": target.identifier,
+        "label": target.label as Any,
+        "role": target.role as Any,
+        "testId": target.testId as Any,
+        "text": target.text as Any
+      ],
+      "metadata": [
+        "pressure": 1.0
+      ]
+    ]
+
+    self.sendEvent(withName: "onGestureDetected", body: gestureEvent)
+    if let cb = gestureCallback { cb([gestureEvent]) }
+  }
+
+  @objc private func handlePan(_ gesture: UIPanGestureRecognizer) {
+    guard let view = gesture.view else { return }
+    let location = gesture.location(in: view)
+    let velocity = gesture.velocity(in: view)
+    let translation = gesture.translation(in: view)
+
+    let target = GestureTargetFinder.findTargetView(at: location, in: view)
+
+    let gestureType: String
+    switch gesture.state {
+    case .began: gestureType = "pan_start"
+    case .changed: gestureType = "pan_move"
+    case .ended, .cancelled: gestureType = "pan_end"
+    default: return
+    }
+
+    let gestureEvent: [String: Any] = [
+      "type": gestureType,
+      "timestamp": Date().timeIntervalSince1970 * 1000,
+      "x": location.x,
+      "y": location.y,
+      "target": target.identifier,
+      "targetInfo": [
+        "identifier": target.identifier,
+        "label": target.label as Any,
+        "role": target.role as Any,
+        "testId": target.testId as Any,
+        "text": target.text as Any
+      ],
+      "metadata": [
+        "velocity": sqrt(velocity.x * velocity.x + velocity.y * velocity.y),
+        "deltaX": translation.x,
+        "deltaY": translation.y
+      ]
+    ]
+
+    self.sendEvent(withName: "onGestureDetected", body: gestureEvent)
+    if let cb = gestureCallback { cb([gestureEvent]) }
+  }
+
+  @objc private func handleLongPress(_ gesture: UILongPressGestureRecognizer) {
+    guard gesture.state == .began else { return }
+    guard let view = gesture.view else { return }
+    let location = gesture.location(in: view)
+    let target = GestureTargetFinder.findTargetView(at: location, in: view)
+
+    let gestureEvent: [String: Any] = [
+      "type": "long_press",
+      "timestamp": Date().timeIntervalSince1970 * 1000,
+      "x": location.x,
+      "y": location.y,
+      "target": target.identifier,
+      "targetInfo": [
+        "identifier": target.identifier,
+        "label": target.label as Any,
+        "role": target.role as Any,
+        "testId": target.testId as Any,
+        "text": target.text as Any
+      ],
+      "metadata": [
+        "duration": 0.5,
+        "pressure": 1.0
+      ]
+    ]
+
+    self.sendEvent(withName: "onGestureDetected", body: gestureEvent)
+    if let cb = gestureCallback { cb([gestureEvent]) }
+  }
+
+  @objc private func handlePinch(_ gesture: UIPinchGestureRecognizer) {
+    guard let view = gesture.view else { return }
+    let location = gesture.location(in: view)
+    let scale = gesture.scale
+    let velocity = gesture.velocity
+
+    let target = GestureTargetFinder.findTargetView(at: location, in: view)
+
+    let gestureEvent: [String: Any] = [
+      "type": "pinch",
+      "timestamp": Date().timeIntervalSince1970 * 1000,
+      "x": location.x,
+      "y": location.y,
+      "target": target.identifier,
+      "targetInfo": [
+        "identifier": target.identifier,
+        "label": target.label as Any,
+        "role": target.role as Any,
+        "testId": target.testId as Any,
+        "text": target.text as Any
+      ],
+      "metadata": [
+        "scale": scale,
+        "velocity": velocity
+      ]
+    ]
+
+    self.sendEvent(withName: "onGestureDetected", body: gestureEvent)
+    if let cb = gestureCallback { cb([gestureEvent]) }
+  }
+
+  // MARK: - UIGestureRecognizerDelegate
+  func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldRecognizeSimultaneouslyWith otherGestureRecognizer: UIGestureRecognizer) -> Bool {
+    return true
+  }
+
+  func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldReceive touch: UITouch) -> Bool {
+    return true
+  }
 }
 
 private enum MaskingType {
@@ -557,9 +812,6 @@ extension UIView {
   }
 
   func isNoCapture() -> Bool {
-    // Check for common patterns that indicate sensitive content
-
-
     // Check accessibility label for sensitive keywords
     if let accessibilityLabel = accessibilityLabel?.lowercased() {
       let sensitiveKeywords = ["password", "secret", "private", "sensitive", "confidential"]

package/lib/module/SessionRecorderNativeSpec.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import { NativeModules } from 'react-native';
+export default NativeModules.SessionRecorderNative;
+//# sourceMappingURL=SessionRecorderNativeSpec.js.map

package/lib/module/SessionRecorderNativeSpec.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NativeModules","SessionRecorderNative"],"sourceRoot":"../../src","sources":["SessionRecorderNativeSpec.ts"],"mappings":";;AAAA,SAASA,aAAa,QAAQ,cAAc;AAmD5C,eAAeA,aAAa,CAACC,qBAAqB","ignoreList":[]}

package/lib/module/components/ScreenRecorderView/ScreenRecorderView.js

@@ -0,0 +1,23 @@
+"use strict";
+
+import SessionRecorder from '@multiplayer-app/session-recorder-react-native';
+import { View } from 'react-native';
+import { jsx as _jsx } from "react/jsx-runtime";
+export const ScreenRecorderView = ({
+  children
+}) => {
+  // Callback ref to set the viewshot ref immediately when available
+  const setViewShotRef = ref => {
+    if (ref) {
+      SessionRecorder.setViewShotRef?.(ref);
+    }
+  };
+  return /*#__PURE__*/_jsx(View, {
+    ref: setViewShotRef,
+    style: {
+      flex: 1
+    },
+    children: children
+  });
+};
+//# sourceMappingURL=ScreenRecorderView.js.map

package/lib/module/components/ScreenRecorderView/ScreenRecorderView.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["SessionRecorder","View","jsx","_jsx","ScreenRecorderView","children","setViewShotRef","ref","style","flex"],"sourceRoot":"../../../../src","sources":["components/ScreenRecorderView/ScreenRecorderView.tsx"],"mappings":";;AAAA,OAAOA,eAAe,MAAM,gDAAgD;AAE5E,SAASC,IAAI,QAAQ,cAAc;AAAC,SAAAC,GAAA,IAAAC,IAAA;AAIpC,OAAO,MAAMC,kBAAkB,GAAGA,CAAC;EAAEC;AAAkC,CAAC,KAAK;EAC3E;EACA,MAAMC,cAAc,GAAIC,GAAoB,IAAK;IAC/C,IAAIA,GAAG,EAAE;MACPP,eAAe,CAACM,cAAc,GAAGC,GAAG,CAAC;IACvC;EACF,CAAC;EAED,oBACEJ,IAAA,CAACF,IAAI;IAACM,GAAG,EAAED,cAAe;IAACE,KAAK,EAAE;MAAEC,IAAI,EAAE;IAAE,CAAE;IAAAJ,QAAA,EAC3CA;EAAQ,CACL,CAAC;AAEX,CAAC","ignoreList":[]}

package/lib/module/components/ScreenRecorderView/index.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export * from "./ScreenRecorderView.js";
+//# sourceMappingURL=index.js.map

package/lib/module/components/ScreenRecorderView/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../../src","sources":["components/ScreenRecorderView/index.ts"],"mappings":";;AAAA,cAAc,yBAAsB","ignoreList":[]}