@onekeyfe/react-native-device-utils 1.1.11

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 OneKey
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,36 @@
+# react-native-device-utils
+
+react-native-device-utils
+
+## Installation
+
+```sh
+npm install react-native-device-utils react-native-nitro-modules
+
+> `react-native-nitro-modules` is required as this library relies on [Nitro Modules](https://nitro.margelo.com/).
+```
+
+## Usage
+
+```js
+import { ReactNativeDeviceUtils } from 'react-native-device-utils';
+
+// ...
+
+const result = await ReactNativeDeviceUtils.hello({ message: 'World' });
+console.log(result); // { success: true, data: 'Hello, World!' }
+```
+
+## Contributing
+
+- [Development workflow](CONTRIBUTING.md#development-workflow)
+- [Sending a pull request](CONTRIBUTING.md#sending-a-pull-request)
+- [Code of conduct](CODE_OF_CONDUCT.md)
+
+## License
+
+MIT
+
+---
+
+Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)

package/ReactNativeDeviceUtils.podspec

@@ -0,0 +1,29 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "ReactNativeDeviceUtils"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/OneKeyHQ/app-modules/react-native-device-utils.git", :tag => "#{s.version}" }
+
+  s.source_files = [
+    "ios/**/*.{swift}",
+    "ios/**/*.{m,mm}",
+    "cpp/**/*.{hpp,cpp}",
+  ]
+
+  s.dependency 'React-jsi'
+  s.dependency 'React-callinvoker'
+
+  load 'nitrogen/generated/ios/ReactNativeDeviceUtils+autolinking.rb'
+  add_nitrogen_files(s)
+
+  install_modules_dependencies(s)
+end

package/android/CMakeLists.txt

@@ -0,0 +1,24 @@
+project(reactnativedeviceutils)
+cmake_minimum_required(VERSION 3.9.0)
+
+set(PACKAGE_NAME reactnativedeviceutils)
+set(CMAKE_VERBOSE_MAKEFILE ON)
+set(CMAKE_CXX_STANDARD 20)
+
+# Define C++ library and add all sources
+add_library(${PACKAGE_NAME} SHARED src/main/cpp/cpp-adapter.cpp)
+
+# Add Nitrogen specs :)
+include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/reactnativedeviceutils+autolinking.cmake)
+
+# Set up local includes
+include_directories("src/main/cpp" "../cpp")
+
+find_library(LOG_LIB log)
+
+# Link all libraries together
+target_link_libraries(
+        ${PACKAGE_NAME}
+        ${LOG_LIB}
+        android # <-- Android core
+)

package/android/build.gradle

@@ -0,0 +1,132 @@
+buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['ReactNativeDeviceUtils_' + name]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+apply from: '../nitrogen/generated/android/reactnativedeviceutils+autolinking.gradle'
+
+apply plugin: "com.facebook.react"
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["ReactNativeDeviceUtils_" + name]).toInteger()
+}
+
+android {
+  namespace "com.margelo.nitro.reactnativedeviceutils"
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-frtti -fexceptions -Wall -fstack-protector-all"
+        arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+        abiFilters (*reactNativeArchitectures())
+
+        buildTypes {
+          debug {
+            cppFlags "-O1 -g"
+          }
+          release {
+            cppFlags "-O2"
+          }
+        }
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  packagingOptions {
+    excludes = [
+            "META-INF",
+            "META-INF/**",
+            "**/libc++_shared.so",
+            "**/libfbjni.so",
+            "**/libjsi.so",
+            "**/libfolly_json.so",
+            "**/libfolly_runtime.so",
+            "**/libglog.so",
+            "**/libhermes.so",
+            "**/libhermes-executor-debug.so",
+            "**/libhermes_executor.so",
+            "**/libreactnative.so",
+            "**/libreactnativejni.so",
+            "**/libturbomodulejsijni.so",
+            "**/libreact_nativemodule_core.so",
+            "**/libjscexecutor.so"
+    ]
+  }
+
+  buildFeatures {
+    buildConfig true
+    prefab true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      java.srcDirs += [
+        "generated/java",
+        "generated/jni"
+      ]
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation project(":react-native-nitro-modules")
+  
+  // WindowManager library for foldable device detection
+  implementation "androidx.window:window:1.5.1"
+  implementation "androidx.window:window-java:1.5.1"
+}

package/android/gradle.properties

@@ -0,0 +1,4 @@
+ReactNativeDeviceUtils_kotlinVersion=1.9.25
+ReactNativeDeviceUtils_compileSdkVersion=35
+ReactNativeDeviceUtils_targetSdkVersion=35
+ReactNativeDeviceUtils_minSdkVersion=24

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" />

package/android/src/main/cpp/cpp-adapter.cpp

@@ -0,0 +1,6 @@
+#include <jni.h>
+#include "reactnativedeviceutilsOnLoad.hpp"
+
+extern "C" JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return margelo::nitro::reactnativedeviceutils::initialize(vm);
+}

package/android/src/main/java/com/margelo/nitro/reactnativedeviceutils/ReactNativeDeviceUtils.kt

@@ -0,0 +1,343 @@
+package com.margelo.nitro.reactnativedeviceutils
+
+import android.app.Activity
+import android.graphics.Color
+import android.graphics.Rect
+import android.os.Build
+import androidx.core.content.ContextCompat
+import androidx.core.util.Consumer
+import androidx.window.layout.FoldingFeature
+import androidx.window.layout.WindowInfoTracker
+import androidx.window.layout.WindowLayoutInfo
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.bridge.ReactApplicationContext
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.core.Promise
+import java.util.concurrent.Executor
+
+data class Listener(
+  val id: Double,
+  val callback: (Boolean) -> Unit
+)
+
+@DoNotStrip
+class ReactNativeDeviceUtils : HybridReactNativeDeviceUtilsSpec(), LifecycleEventListener {
+  
+  private var windowLayoutInfo: WindowLayoutInfo? = null
+  private var isSpanning = false
+  private var layoutInfoConsumer: Consumer<WindowLayoutInfo>? = null
+  private var windowInfoTracker: WindowInfoTracker? = null
+  private var spanningChangedListeners: MutableList<Listener> = mutableListOf()
+  private var isObservingLayoutChanges = false
+  private var nextListenerId = 0.0
+  private var isDualScreenDeviceDetected: Boolean? = null
+
+  companion object {
+    private var reactContext: ReactApplicationContext? = null
+    
+    fun setReactContext(context: ReactApplicationContext) {
+      reactContext = context
+    }
+   }
+
+  init {
+      NitroModules.applicationContext?.let { ctx ->
+          ctx.addLifecycleEventListener(this)
+      } ?: run {
+
+      }
+  }
+  
+  private fun getCurrentActivity(): Activity? {
+    return NitroModules.applicationContext?.currentActivity
+  }
+
+  override fun initEventListeners() {
+    startObservingLayoutChanges()
+  }
+
+    // MARK: - Dual Screen Detection
+  
+  override fun isDualScreenDevice(): Boolean {
+    if (isDualScreenDeviceDetected != null) {
+      return isDualScreenDeviceDetected!!
+    }
+    val activity = getCurrentActivity() ?: return false
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+      isDualScreenDeviceDetected = hasFoldingFeature(activity)
+      return isDualScreenDeviceDetected!!
+    }
+    isDualScreenDeviceDetected = false
+    return isDualScreenDeviceDetected!!
+  }
+  private fun isFoldableDeviceByName(): Boolean {
+    val deviceModel = Build.MODEL.lowercase()
+    val deviceManufacturer = Build.MANUFACTURER.lowercase()
+    
+    // Common foldable device patterns
+    val foldablePatterns = listOf(
+      "fold", "flip", "duo", "surface duo", "galaxy z",
+      "mate x", "mix fold", "find n", "magic v",
+      "pixel fold", "honor magic v", "vivo x fold",
+      "xiaomi mix fold", "oppo find n"
+    )
+    
+    for (pattern in foldablePatterns) {
+      if (deviceModel.contains(pattern) || 
+          (deviceManufacturer + " " + deviceModel).contains(pattern)) {
+        return true
+      }
+    }
+    return false
+  }
+  
+  private fun hasFoldingFeature(activity: Activity): Boolean {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
+      return isFoldableDeviceByName()
+    }
+    
+    // Check if device has folding features using WindowManager library
+    // This is the recommended approach for detecting foldable devices
+    try {
+      val windowInfoTracker = WindowInfoTracker.getOrCreate(activity)
+      // If WindowInfoTracker is available, the device supports foldable features
+      // We can also check for specific display features
+      val displayFeatures = windowLayoutInfo?.displayFeatures
+      if (displayFeatures != null) {
+        for (feature in displayFeatures) {
+          if (feature is FoldingFeature) {
+            return true
+          }
+        }
+      }
+      // Check device model name to determine if it's a foldable device
+      return isFoldableDeviceByName()
+    } catch (e: Exception) {
+      // WindowManager library not available or device doesn't support foldables
+      return false
+    }
+  }
+
+  override fun isSpanning(): Boolean {
+    return this.isSpanning
+  }
+  
+  private fun checkIsSpanning(layoutInfo: WindowLayoutInfo?): Boolean {
+    if (layoutInfo == null) {
+      return false
+    }
+    
+    val foldingFeature = getFoldingFeature(layoutInfo)
+    if (foldingFeature == null) {
+      return false
+    }
+    
+    // Consider spanning if the folding feature divides the screen
+    return foldingFeature.state == FoldingFeature.State.FLAT ||
+           foldingFeature.state == FoldingFeature.State.HALF_OPENED
+  }
+  
+  private fun getFoldingFeature(layoutInfo: WindowLayoutInfo?): FoldingFeature? {
+    if (layoutInfo == null) {
+      return null
+    }
+    
+    val features = layoutInfo.displayFeatures
+    for (feature in features) {
+      if (feature is FoldingFeature) {
+        return feature
+      }
+    }
+    return null
+  }
+  
+  // MARK: - Window Information
+  
+  override fun getWindowRects(): Promise<Array<DualScreenInfoRect>> {
+    return Promise.async {
+      val activity = getCurrentActivity()
+      if (activity == null || windowLayoutInfo == null) {
+        return@async arrayOf()
+      }
+      
+      val layoutInfo = windowLayoutInfo
+      if (layoutInfo != null) {
+        getWindowRectsFromLayoutInfo(activity, layoutInfo)
+      } else {
+        arrayOf()
+      }
+    }
+  }
+  
+  private fun getWindowRectsFromLayoutInfo(activity: Activity, layoutInfo: WindowLayoutInfo): Array<DualScreenInfoRect> {
+    val rects = mutableListOf<DualScreenInfoRect>()
+    
+    val foldingFeature = getFoldingFeature(layoutInfo)
+    if (foldingFeature == null) {
+      // No folding feature, return full screen rect
+      val screenRect = Rect()
+      activity.window.decorView.getWindowVisibleDisplayFrame(screenRect)
+      rects.add(rectToDualScreenInfoRect(screenRect))
+      return rects.toTypedArray()
+    }
+    
+    // Split screen based on folding feature
+    val hingeBounds = foldingFeature.bounds
+    val screenRect = Rect()
+    activity.window.decorView.getWindowVisibleDisplayFrame(screenRect)
+    
+    if (foldingFeature.orientation == FoldingFeature.Orientation.VERTICAL) {
+      // Vertical fold - left and right screens
+      val leftRect = Rect(screenRect.left, screenRect.top, hingeBounds.left, screenRect.bottom)
+      val rightRect = Rect(hingeBounds.right, screenRect.top, screenRect.right, screenRect.bottom)
+      rects.add(rectToDualScreenInfoRect(leftRect))
+      rects.add(rectToDualScreenInfoRect(rightRect))
+    } else {
+      // Horizontal fold - top and bottom screens
+      val topRect = Rect(screenRect.left, screenRect.top, screenRect.right, hingeBounds.top)
+      val bottomRect = Rect(screenRect.left, hingeBounds.bottom, screenRect.right, screenRect.bottom)
+      rects.add(rectToDualScreenInfoRect(topRect))
+      rects.add(rectToDualScreenInfoRect(bottomRect))
+    }
+    
+    return rects.toTypedArray()
+  }
+  
+  private fun rectToDualScreenInfoRect(rect: Rect): DualScreenInfoRect {
+    return DualScreenInfoRect(
+      x = rect.left.toDouble(),
+      y = rect.top.toDouble(),
+      width = rect.width().toDouble(),
+      height = rect.height().toDouble()
+    )
+  }
+  
+  override fun getHingeBounds(): Promise<DualScreenInfoRect> {
+    return Promise.async {
+      val layoutInfo = windowLayoutInfo
+      if (layoutInfo == null) {
+        return@async DualScreenInfoRect(x = 0.0, y = 0.0, width = 0.0, height = 0.0)
+      }
+      
+      val foldingFeature = getFoldingFeature(layoutInfo)
+      if (foldingFeature != null) {
+        val bounds = foldingFeature.bounds
+        DualScreenInfoRect(
+          x = bounds.left.toDouble(),
+          y = bounds.top.toDouble(),
+          width = bounds.width().toDouble(),
+          height = bounds.height().toDouble()
+        )
+      } else {
+        DualScreenInfoRect(x = 0.0, y = 0.0, width = 0.0, height = 0.0)
+      }
+    }
+  }
+
+  fun callSpanningChangedListeners(isSpanning: Boolean) {
+    for (listener in spanningChangedListeners) {
+      listener.callback(isSpanning)
+    }
+  }
+
+  override fun addSpanningChangedListener(callback: (isSpanning: Boolean) -> Unit): Double {
+    var id = nextListenerId
+    nextListenerId++
+    val listener = Listener(id, callback)
+    spanningChangedListeners.add(listener)
+    return id
+  }
+
+    override fun removeSpanningChangedListener(id: Double) {
+        spanningChangedListeners.removeIf { it.id == id }
+    }
+
+  private fun startObservingLayoutChanges() {
+    if (isObservingLayoutChanges) {
+      return
+    }
+    isObservingLayoutChanges = true
+    val activity = getCurrentActivity() ?: return
+    
+    // Window Manager library requires API 24+, but full foldable support is API 30+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+      try {
+        windowInfoTracker = WindowInfoTracker.getOrCreate(activity)
+        
+        // Create consumer for window layout info
+        layoutInfoConsumer = Consumer<WindowLayoutInfo> { layoutInfo ->
+          onWindowLayoutInfoChanged(layoutInfo)
+        }
+        
+        // Use main executor for callbacks
+        val mainExecutor: Executor = ContextCompat.getMainExecutor(activity)
+        
+        // Subscribe to window layout changes using the Java adapter
+        val callbackAdapter = androidx.window.java.layout.WindowInfoTrackerCallbackAdapter(windowInfoTracker!!)
+        
+        callbackAdapter.addWindowLayoutInfoListener(
+          activity,
+          mainExecutor,
+          layoutInfoConsumer!!
+        )
+      } catch (e: Exception) {
+        // Window tracking not supported on this device/API level, ignore
+      }
+    }
+  }
+  
+  private fun stopObservingLayoutChanges() {
+    if (!isObservingLayoutChanges) {
+      return
+    }
+    isObservingLayoutChanges = false
+    if (windowInfoTracker != null && layoutInfoConsumer != null) {
+      try {
+        // The listener will be cleaned up when the activity is destroyed
+        layoutInfoConsumer = null
+        windowInfoTracker = null
+      } catch (e: Exception) {
+        // Ignore cleanup errors
+      }
+    }
+  }
+  
+  private fun onWindowLayoutInfoChanged(layoutInfo: WindowLayoutInfo) {
+    this.windowLayoutInfo = layoutInfo
+    
+    val wasSpanning = this.isSpanning
+    this.isSpanning = checkIsSpanning(layoutInfo)
+    
+    // Emit event if spanning state changed
+    if (wasSpanning != this.isSpanning) {
+      this.callSpanningChangedListeners(this.isSpanning)
+    }
+  }
+  
+  // MARK: - Background Color
+  
+  override fun changeBackgroundColor(r: Double, g: Double, b: Double, a: Double) {
+    val activity = getCurrentActivity() ?: return
+    activity.runOnUiThread {
+      try {
+        val rootView = activity.window.decorView
+        rootView.rootView.setBackgroundColor(Color.rgb(r.toInt(), g.toInt(), b.toInt()))
+      } catch (e: Exception) {
+        e.printStackTrace()
+      }
+    }
+  }
+
+    override fun onHostResume() {
+        startObservingLayoutChanges()
+    }
+
+    override fun onHostPause() {
+        stopObservingLayoutChanges()
+    }
+
+    override fun onHostDestroy() {
+        stopObservingLayoutChanges()
+    }
+}

package/android/src/main/java/com/margelo/nitro/reactnativedeviceutils/ReactNativeDeviceUtilsPackage.kt

@@ -0,0 +1,26 @@
+package com.margelo.nitro.reactnativedeviceutils
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+class ReactNativeDeviceUtilsPackage : BaseReactPackage() {
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+        // Set the React context for the DeviceUtils module
+        ReactNativeDeviceUtils.setReactContext(reactContext)
+        return null
+    }
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+        return ReactModuleInfoProvider { HashMap() }
+    }
+
+    companion object {
+        init {
+            System.loadLibrary("reactnativedeviceutils")
+        }
+    }
+}
+
+

package/ios/ReactNativeDeviceUtils.swift

@@ -0,0 +1,41 @@
+import NitroModules
+import UIKit
+
+class ReactNativeDeviceUtils: HybridReactNativeDeviceUtilsSpec {
+    
+    public func isDualScreenDevice() throws -> Bool {
+        return false
+    }
+
+    public func initEventListeners() throws -> Void {
+    }
+    
+    public func isSpanning() throws -> Bool {
+        return false
+    }
+    
+    public func getWindowRects() throws -> Promise<[DualScreenInfoRect]> {
+        return Promise.resolved(withResult: [])
+    }
+    
+    public func getHingeBounds() throws -> Promise<DualScreenInfoRect> {
+        return Promise.resolved(withResult: DualScreenInfoRect(x: 0, y: 0, width: 0, height: 0))
+    }
+
+   
+    func addSpanningChangedListener(callback: @escaping (Bool) -> Void) throws -> Double {
+        return 0
+    }
+
+    func removeSpanningChangedListener(id: Double) throws -> Void {
+    }
+    
+    
+    public func changeBackgroundColor(r: Double, g: Double, b: Double, a: Double) throws -> Void {
+        DispatchQueue.main.async {
+            let color = UIColor(red: r/255, green: g/255, blue: b/255, alpha: a/255)
+            let rootViewController = UIApplication.shared.delegate?.window??.rootViewController
+            rootViewController?.view.backgroundColor = color
+        }
+    }
+}

package/lib/module/ReactNativeDeviceUtils.nitro.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=ReactNativeDeviceUtils.nitro.js.map

package/lib/module/ReactNativeDeviceUtils.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../src","sources":["ReactNativeDeviceUtils.nitro.ts"],"mappings":"","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,6 @@
+"use strict";
+
+import { NitroModules } from 'react-native-nitro-modules';
+const ReactNativeDeviceUtilsHybridObject = NitroModules.createHybridObject('ReactNativeDeviceUtils');
+export const ReactNativeDeviceUtils = ReactNativeDeviceUtilsHybridObject;
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NitroModules","ReactNativeDeviceUtilsHybridObject","createHybridObject","ReactNativeDeviceUtils"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,4BAA4B;AAGzD,MAAMC,kCAAkC,GACtCD,YAAY,CAACE,kBAAkB,CAA6B,wBAAwB,CAAC;AAEvF,OAAO,MAAMC,sBAAsB,GAAGF,kCAAkC","ignoreList":[]}