react-native-unistyles 3.0.0-alpha.36 → 3.0.0-alpha.37

package/Unistyles.podspec

@@ -19,7 +19,7 @@ Pod::Spec.new do |s|
   ]
   s.pod_target_xcconfig = {
     "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
-    "GCC_PREPROCESSOR_DEFINITIONS" => "$(inherited) FOLLY_NO_CONFIG FOLLY_CFG_NO_COROUTINES"
+    "GCC_PREPROCESSOR_DEFINITIONS" => "$(inherited) FOLLY_NO_CONFIG FOLLY_CFG_NO_COROUTINES FOLLY_MOBILE"
   }
 
   s.public_header_files = [

package/android/CMakeLists.txt

@@ -23,7 +23,7 @@ include_directories(
     ../cxx/shadowTree
 )
 
-string(APPEND CMAKE_CXX_FLAGS "-DFOLLY_NO_CONFIG")
+string(APPEND CMAKE_CXX_FLAGS "-DFOLLY_NO_CONFIG=1 -DFOLLY_CFG_NO_COROUTINES=1 -DFOLLY_MOBILE=1")
 
 set_target_properties(unistyles PROPERTIES
     CXX_STANDARD 20
@@ -32,17 +32,5 @@ set_target_properties(unistyles PROPERTIES
     POSITION_INDEPENDENT_CODE ON
 )
 
-# todo included by nitrogen
-# find_package(ReactAndroid REQUIRED CONFIG)
-# find_package(fbjni REQUIRED CONFIG)
-
-#if (ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
-#     target_link_libraries(unistyles ReactAndroid::reactnative)
-#else()
-#    target_link_libraries(unistyles
-#        ReactAndroid::turbomodulejsijni
-#        ReactAndroid::react_nativemodule_core
-#         android
-#        fbjni::fbjni
-#    )
-#endif()
+# For React Native 0.76 and above, we don't need to link anything
+# as NitroModules will automatically add ReactAndroid::reactnative prefab

package/android/src/main/cxx/NativeUnistylesModule.cpp

@@ -49,7 +49,7 @@ jni::local_ref<BindingsInstallerHolder::javaobject> UnistylesModule::getBindings
         }
 
         auto runOnJSThread = [&runtimeExecutor](std::function<void(jsi::Runtime&)>&& callback) {
-            runtimeExecutor([&](jsi::Runtime &rt) {
+            runtimeExecutor([callback = std::move(callback)](jsi::Runtime &rt) {
                 callback(rt);
             });
         };

package/android/src/main/java/com/unistyles/Equatable.kt

@@ -0,0 +1,61 @@
+package com.unistyles
+
+import com.margelo.nitro.unistyles.Dimensions
+import com.margelo.nitro.unistyles.Insets
+import com.margelo.nitro.unistyles.UnistyleDependency
+import com.margelo.nitro.unistyles.UnistylesNativeMiniRuntime
+
+fun Dimensions.isEqualTo(other: Dimensions): Boolean {
+    return this.width == other.width && this.height == other.height
+}
+
+fun Insets.isEqualTo(other: Insets): Boolean {
+    return this.top == other.top && this.bottom == other.bottom &&
+        this.left == other.left && this.right == other.right &&
+        this.ime == other.ime
+}
+
+fun NativePlatformAndroid.diffMiniRuntimes(lhs: UnistylesNativeMiniRuntime, rhs: UnistylesNativeMiniRuntime): Array<UnistyleDependency> {
+    val dependencies: MutableList<UnistyleDependency> = mutableListOf()
+
+    if (lhs.colorScheme != rhs.colorScheme) {
+        dependencies.add(UnistyleDependency.COLORSCHEME)
+    }
+
+    if (!lhs.screen.isEqualTo(rhs.screen)) {
+        dependencies.add(UnistyleDependency.DIMENSIONS)
+    }
+
+    if (lhs.screen.width != rhs.screen.width) {
+        dependencies.add(UnistyleDependency.BREAKPOINTS)
+    }
+
+    // no need to check isLandscape, as it's always opposite
+    if (lhs.isPortrait != rhs.isPortrait) {
+        dependencies.add(UnistyleDependency.ORIENTATION)
+    }
+
+    if (lhs.contentSizeCategory != rhs.contentSizeCategory) {
+        dependencies.add(UnistyleDependency.CONTENTSIZECATEGORY)
+    }
+
+    if (!lhs.insets.isEqualTo(rhs.insets)) {
+        dependencies.add(UnistyleDependency.INSETS)
+    }
+
+    if (lhs.fontScale != rhs.fontScale) {
+        dependencies.add(UnistyleDependency.FONTSCALE)
+    }
+
+    if (!lhs.statusBar.isEqualTo(rhs.statusBar)) {
+        dependencies.add(UnistyleDependency.STATUSBAR)
+    }
+
+    if (!lhs.navigationBar.isEqualTo(rhs.navigationBar)) {
+        dependencies.add(UnistyleDependency.NAVIGATIONBAR)
+    }
+
+    // rtl and pixel ratio are not dynamic
+
+    return dependencies.toTypedArray()
+}

package/android/src/main/java/com/unistyles/NativePlatform+android.kt

@@ -0,0 +1,302 @@
+package com.unistyles
+
+import android.content.Context
+import android.content.res.Configuration
+import android.os.Build
+import android.util.DisplayMetrics
+import android.view.View
+import android.view.WindowManager
+import androidx.core.text.TextUtilsCompat
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowCompat
+import androidx.core.view.WindowInsetsCompat
+import androidx.core.view.WindowInsetsControllerCompat
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.bridge.ReactApplicationContext
+import com.margelo.nitro.unistyles.ColorScheme
+import com.margelo.nitro.unistyles.Dimensions
+import com.margelo.nitro.unistyles.HybridNativePlatformSpec
+import com.margelo.nitro.unistyles.Insets
+import com.margelo.nitro.unistyles.Orientation
+import com.margelo.nitro.unistyles.UnistyleDependency
+import com.margelo.nitro.unistyles.UnistylesNativeMiniRuntime
+import java.util.Locale
+
+class NativePlatformAndroid(private val reactContext: ReactApplicationContext): HybridNativePlatformSpec(), LifecycleEventListener {
+    private val _insets = NativePlatformInsets(reactContext) { this.diffMiniRuntime() }
+    private var _miniRuntime: UnistylesNativeMiniRuntime = buildMiniRuntime()
+    private val _listener = NativePlatformListener(reactContext) { this.diffMiniRuntime() }
+
+    init {
+        reactContext.addLifecycleEventListener(this)
+    }
+
+    fun invalidate() {
+        reactContext.removeLifecycleEventListener(this)
+        _listener.invalidate()
+    }
+
+    override fun onHostResume() {
+        enableEdgeToEdge()
+        _insets.startInsetsListener()
+    }
+
+    override fun onHostPause() {
+        _insets.stopInsetsListener()
+    }
+
+    override fun onHostDestroy() {}
+
+    override val memorySize: Long
+        get() = 0
+
+    override fun getInsets(): Insets {
+        return _insets.getInsets()
+    }
+
+    override fun getColorScheme(): ColorScheme {
+        val uiMode = reactContext.resources.configuration.uiMode
+
+        val colorScheme = when (uiMode.and(Configuration.UI_MODE_NIGHT_MASK)) {
+            Configuration.UI_MODE_NIGHT_YES -> ColorScheme.DARK
+            Configuration.UI_MODE_NIGHT_NO -> ColorScheme.LIGHT
+            else -> ColorScheme.UNSPECIFIED
+        }
+
+        return colorScheme
+    }
+
+    override fun getFontScale(): Double {
+        return reactContext.resources.configuration.fontScale.toDouble()
+    }
+
+    override fun getPixelRatio(): Double {
+        return reactContext.resources.displayMetrics.density.toDouble()
+    }
+
+    override fun getOrientation(): Orientation {
+        val orientation = when (reactContext.resources.configuration.orientation) {
+            Configuration.ORIENTATION_PORTRAIT -> Orientation.PORTRAIT
+            Configuration.ORIENTATION_LANDSCAPE -> Orientation.LANDSCAPE
+            else -> Orientation.PORTRAIT
+        }
+
+        return orientation
+    }
+
+    override fun getContentSizeCategory(): String {
+        val fontScale = getFontScale()
+
+        val contentSizeCategory = when {
+            fontScale <= 0.85f -> "Small"
+            fontScale <= 1.0f -> "Default"
+            fontScale <= 1.15f -> "Large"
+            fontScale <= 1.3f -> "ExtraLarge"
+            fontScale <= 1.5f -> "Huge"
+            fontScale <= 1.8 -> "ExtraHuge"
+            else -> "ExtraExtraHuge"
+        }
+
+        return contentSizeCategory
+    }
+
+    override fun getScreenDimensions(): Dimensions {
+        // function takes in count edge-to-edge layout
+        when {
+            Build.VERSION.SDK_INT < Build.VERSION_CODES.R -> {
+                val windowManager = reactContext.getSystemService(Context.WINDOW_SERVICE) as WindowManager
+                val metrics = DisplayMetrics()
+
+                @Suppress("DEPRECATION")
+                windowManager.defaultDisplay.getRealMetrics(metrics)
+
+                val screenWidth = (metrics.widthPixels / metrics.density).toDouble()
+                val screenHeight = (metrics.heightPixels / metrics.density).toDouble()
+
+                return Dimensions(screenWidth, screenHeight)
+            }
+            else -> {
+                val displayMetrics = reactContext.resources.displayMetrics
+
+                reactContext.currentActivity?.windowManager?.currentWindowMetrics?.bounds?.let {
+                    val boundsWidth = (it.width() / displayMetrics.density).toDouble()
+                    val boundsHeight = (it.height() / displayMetrics.density).toDouble()
+
+                    return Dimensions(boundsWidth, boundsHeight)
+                } ?: run {
+                    val screenWidth = (displayMetrics.widthPixels / displayMetrics.density).toDouble()
+                    val screenHeight = (displayMetrics.heightPixels / displayMetrics.density).toDouble()
+
+                    return Dimensions(screenWidth, screenHeight)
+                }
+            }
+        }
+    }
+
+    override fun getStatusBarDimensions(): Dimensions {
+        val screenWidth = getScreenDimensions().width
+
+        return Dimensions(screenWidth, _insets.getInsets().top)
+    }
+
+    override fun getNavigationBarDimensions(): Dimensions {
+        val screenWidth = getScreenDimensions().width
+
+        return Dimensions(screenWidth, _insets.getInsets().bottom)
+    }
+
+    override fun getPrefersRtlDirection(): Boolean {
+        // forced by React Native
+        val sharedPrefs = reactContext.getSharedPreferences(
+            "com.facebook.react.modules.i18nmanager.I18nUtil",
+            Context.MODE_PRIVATE
+        )
+        val hasForcedRtl = sharedPrefs.getBoolean("RCTI18nUtil_forceRTL", false)
+        // user preferences
+        val isRtl = TextUtilsCompat.getLayoutDirectionFromLocale(Locale.getDefault()) == ViewCompat.LAYOUT_DIRECTION_RTL
+
+        return hasForcedRtl || isRtl
+    }
+
+    override fun setRootViewBackgroundColor(color: Double) {
+        reactContext.currentActivity?.let { activity ->
+            activity.window?.decorView?.let { decorView ->
+                activity.runOnUiThread {
+                    decorView.rootView.setBackgroundColor(color.toInt())
+                }
+            }
+        }
+    }
+
+    @Suppress("DEPRECATION")
+    override fun setNavigationBarBackgroundColor(color: Double) {
+        reactContext.currentActivity?.let { activity ->
+            activity.runOnUiThread {
+                activity.window.navigationBarColor = color.toInt()
+            }
+        }
+    }
+
+    override fun setNavigationBarHidden(isHidden: Boolean) {
+        reactContext.currentActivity?.let { activity ->
+            WindowInsetsControllerCompat(activity.window, activity.window.decorView).apply {
+                activity.window?.decorView?.let { decorView ->
+                    @Suppress("DEPRECATION")
+                    activity.runOnUiThread {
+                        if (isHidden) {
+                            // below Android 11, we need to use window flags to hide the navigation bar
+                            if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.Q) {
+                                decorView.systemUiVisibility = (View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
+                                    or View.SYSTEM_UI_FLAG_HIDE_NAVIGATION or View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY)
+                            } else {
+                                hide(WindowInsetsCompat.Type.navigationBars())
+                                systemBarsBehavior =
+                                    WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
+                            }
+
+                            // dispatch new insets to invoke the insets listener
+                            val newInsets = WindowInsetsCompat.Builder()
+                                .setInsets(WindowInsetsCompat.Type.navigationBars(), androidx.core.graphics.Insets.of(0, 0, 0, 0))
+                                .build()
+
+                            ViewCompat.dispatchApplyWindowInsets(activity.findViewById(android.R.id.content), newInsets)
+                        } else {
+                            show(WindowInsetsCompat.Type.navigationBars())
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    override fun setStatusBarHidden(isHidden: Boolean) {
+        reactContext.currentActivity?.let { activity ->
+            WindowInsetsControllerCompat(activity.window, activity.window.decorView).apply {
+                activity.window?.let { window ->
+                    @Suppress("DEPRECATION")
+                    activity.runOnUiThread {
+                        if (isHidden) {
+                            if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.Q) {
+                                window.addFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN)
+                                window.clearFlags(WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN)
+                            } else {
+                                hide(WindowInsetsCompat.Type.statusBars())
+                            }
+                        } else {
+                            show(WindowInsetsCompat.Type.statusBars())
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    @Suppress("DEPRECATION")
+    override fun setStatusBarBackgroundColor(color: Double) {
+        reactContext.currentActivity?.let { activity ->
+            activity.runOnUiThread {
+                activity.window.addFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS)
+                activity.window.statusBarColor = color.toInt()
+            }
+        }
+    }
+
+    override fun setImmersiveMode(isEnabled: Boolean) {
+        this.setStatusBarHidden(isEnabled)
+        this.setNavigationBarHidden(isEnabled)
+    }
+
+    override fun getMiniRuntime(): UnistylesNativeMiniRuntime {
+        return _miniRuntime
+    }
+
+    private fun buildMiniRuntime(): UnistylesNativeMiniRuntime {
+        val orientation = this.getOrientation()
+
+        return UnistylesNativeMiniRuntime(
+            colorScheme = this.getColorScheme(),
+            screen = this.getScreenDimensions(),
+            contentSizeCategory = this.getContentSizeCategory(),
+            insets = this.getInsets(),
+            pixelRatio = this.getPixelRatio(),
+            fontScale = this.getFontScale(),
+            rtl = this.getPrefersRtlDirection(),
+            statusBar = this.getStatusBarDimensions(),
+            navigationBar = this.getNavigationBarDimensions(),
+            isPortrait = orientation == Orientation.PORTRAIT,
+            isLandscape = orientation == Orientation.LANDSCAPE
+        )
+    }
+
+    private fun diffMiniRuntime(): Array<UnistyleDependency> {
+        val newMiniRuntime = this.buildMiniRuntime()
+        val changedDependencies = diffMiniRuntimes(this._miniRuntime, newMiniRuntime)
+
+        if (changedDependencies.isNotEmpty()) {
+            this._miniRuntime = newMiniRuntime
+        }
+
+        return changedDependencies
+    }
+
+    override fun registerPlatformListener(callback: (dependencies: Array<UnistyleDependency>) -> Unit) {
+        this._listener.addPlatformListener(callback)
+    }
+
+    override fun registerImeListener(callback: () -> Unit) {
+        this._insets.addImeListener(callback)
+    }
+
+    override fun unregisterPlatformListeners() {
+        this._listener.removePlatformListeners()
+        this._insets.removeImeListeners()
+    }
+
+    private fun enableEdgeToEdge() {
+        reactContext.currentActivity?.let { activity ->
+            activity.runOnUiThread {
+                WindowCompat.setDecorFitsSystemWindows(activity.window, false)
+            }
+        }
+    }
+}

package/android/src/main/java/com/unistyles/NativePlatform+insets.kt

@@ -0,0 +1,148 @@
+package com.unistyles
+
+import android.graphics.Rect
+import android.os.Build
+import android.view.View
+import android.view.Window
+import android.view.WindowManager
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsAnimationCompat
+import androidx.core.view.WindowInsetsCompat
+import com.facebook.react.bridge.ReactApplicationContext
+import com.margelo.nitro.unistyles.Insets
+import com.margelo.nitro.unistyles.UnistyleDependency
+
+typealias CxxImeListener = () -> Unit
+
+class NativePlatformInsets(private val reactContext: ReactApplicationContext, private val diffMiniRuntime: () -> Array<UnistyleDependency>) {
+    private val _imeListeners: MutableList<CxxImeListener> = mutableListOf()
+    private var _insets: Insets = Insets(0.0, 0.0, 0.0, 0.0, 0.0)
+
+    fun getInsets(): Insets {
+        val density = reactContext.resources.displayMetrics.density
+
+        return Insets(
+            this._insets.top / density,
+            this._insets.bottom / density,
+            this._insets.left / density,
+            this._insets.right / density,
+            this._insets.ime / density
+        )
+    }
+
+    fun setInsets(insetsCompat: WindowInsetsCompat, window: Window, animatedBottomInsets: Double?) {
+        // below Android 11, we need to use window flags to detect status bar visibility
+        val isStatusBarVisible = when(Build.VERSION.SDK_INT) {
+            in 30..Int.MAX_VALUE -> {
+                insetsCompat.isVisible(WindowInsetsCompat.Type.statusBars())
+            }
+            else -> {
+                @Suppress("DEPRECATION")
+                window.attributes.flags and WindowManager.LayoutParams.FLAG_FULLSCREEN != WindowManager.LayoutParams.FLAG_FULLSCREEN
+            }
+        }
+        // React Native is forcing insets to make status bar translucent
+        // so we need to calculate top inset manually, as WindowInsetCompat will always return 0
+        val statusBarTopInset = when(isStatusBarVisible) {
+            true -> {
+                val visibleRect = Rect()
+
+                window.decorView.getWindowVisibleDisplayFrame(visibleRect)
+
+                visibleRect.top
+            }
+            false -> 0
+        }
+
+        val insets = insetsCompat.getInsets(WindowInsetsCompat.Type.systemBars() or WindowInsetsCompat.Type.displayCutout())
+
+        // Android 10 and below - set bottom insets to 0 while keyboard is visible and use default bottom insets otherwise
+        // Android 11 and above - animate bottom insets while keyboard is appearing and disappearing
+        val imeInsets = if (Build.VERSION.SDK_INT >= 30) {
+            animatedBottomInsets ?: this._insets.ime
+        } else {
+            val nextBottomInset = insetsCompat.getInsets(WindowInsetsCompat.Type.ime()).bottom - insets.bottom
+
+            // call new IME event here, as for SDK >= 30 it's called in AnimationCallback
+            this@NativePlatformInsets.emitImeEvent()
+
+            if (nextBottomInset < 0) {
+                0
+            } else {
+                nextBottomInset
+            }
+        }
+
+        this._insets = Insets(
+            statusBarTopInset.toDouble(),
+            insets.bottom.toDouble(),
+            insets.left.toDouble(),
+            insets.right.toDouble(),
+            imeInsets.toDouble()
+        )
+
+        diffMiniRuntime()
+    }
+
+    fun startInsetsListener() {
+        reactContext.currentActivity?.let { activity ->
+            activity.findViewById<View>(android.R.id.content)?.let { mainView ->
+                ViewCompat.setOnApplyWindowInsetsListener(mainView) { _, insets ->
+                    setInsets(insets, activity.window, null)
+
+                    insets
+                }
+
+                // IME insets are available from Android 11
+                if (Build.VERSION.SDK_INT >= 30) {
+                    ViewCompat.setWindowInsetsAnimationCallback(
+                        mainView,
+                        object : WindowInsetsAnimationCompat.Callback(DISPATCH_MODE_STOP) {
+                            override fun onProgress(
+                                insets: WindowInsetsCompat,
+                                runningAnimations: List<WindowInsetsAnimationCompat>
+                            ): WindowInsetsCompat {
+                                runningAnimations.firstOrNull()?.let {
+                                    val bottomInset = insets.getInsets(WindowInsetsCompat.Type.ime()).bottom.toDouble() - this@NativePlatformInsets._insets.bottom
+                                    val nextBottomInset = if (bottomInset < 0) {
+                                        0.0
+                                    } else {
+                                        bottomInset
+                                    }
+
+                                    this@NativePlatformInsets.setInsets(insets, activity.window, nextBottomInset)
+                                    this@NativePlatformInsets.emitImeEvent()
+                                }
+
+                                return insets
+                            }
+                        }
+                    )
+                }
+            }
+        }
+    }
+
+    fun emitImeEvent() {
+        _imeListeners.forEach { listener ->
+            listener()
+        }
+    }
+
+    fun stopInsetsListener() {
+        reactContext.currentActivity?.let { activity ->
+            activity.window?.decorView?.let { view ->
+                ViewCompat.setOnApplyWindowInsetsListener(view, null)
+                ViewCompat.setWindowInsetsAnimationCallback(view, null)
+            }
+        }
+    }
+
+    fun addImeListener(listener: CxxImeListener) {
+        this._imeListeners.add(listener)
+    }
+
+    fun removeImeListeners() {
+        this._imeListeners.clear()
+    }
+}

package/android/src/main/java/com/unistyles/NativePlatform+listener.kt

@@ -0,0 +1,54 @@
+package com.unistyles
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.os.Handler
+import android.os.Looper
+import com.facebook.react.bridge.ReactApplicationContext
+import com.margelo.nitro.unistyles.UnistyleDependency
+
+typealias CxxDependencyListener = (dependencies: Array<UnistyleDependency>) -> Unit
+
+class NativePlatformListener(private val reactContext: ReactApplicationContext, private val diffMiniRuntime: () -> Array<UnistyleDependency>) {
+    private val _dependencyListeners: MutableList<CxxDependencyListener> = mutableListOf()
+
+    private val configurationChangeReceiver = object : BroadcastReceiver() {
+        override fun onReceive(context: Context, intent: Intent) {
+            Handler(Looper.getMainLooper()).postDelayed({
+                this@NativePlatformListener.onConfigChange()
+            }, 10)
+        }
+    }
+
+    init {
+        reactContext.registerReceiver(configurationChangeReceiver, IntentFilter(Intent.ACTION_CONFIGURATION_CHANGED))
+    }
+
+    fun invalidate() {
+        reactContext.unregisterReceiver(configurationChangeReceiver)
+    }
+
+    fun addPlatformListener(listener: CxxDependencyListener) {
+        this._dependencyListeners.add(listener)
+    }
+
+    fun removePlatformListeners() {
+        this._dependencyListeners.clear()
+    }
+
+    private fun emitCxxEvent(dependencies: Array<UnistyleDependency>) {
+        this._dependencyListeners.forEach { listener ->
+            listener(dependencies)
+        }
+    }
+
+    fun onConfigChange() {
+        val changedDependencies = diffMiniRuntime()
+
+        if (changedDependencies.isNotEmpty()) {
+            emitCxxEvent(changedDependencies)
+        }
+    }
+}

package/android/src/main/java/com/unistyles/UnistylesModule.kt

@@ -16,7 +16,7 @@ import com.margelo.nitro.unistyles.HybridNativePlatformSpec
 class UnistylesModule(reactContext: ReactApplicationContext): NativeTurboUnistylesSpec(reactContext), TurboModuleWithJSIBindings {
     @DoNotStrip
     private var mHybridData: HybridData?
-    private val _nativePlatform = NativePlatform(reactContext)
+    private val _nativePlatform = NativePlatformAndroid(reactContext)
 
     companion object {
         const val NAME = NativeTurboUnistylesSpec.NAME
@@ -26,6 +26,10 @@ class UnistylesModule(reactContext: ReactApplicationContext): NativeTurboUnistyl
         mHybridData = initializeHybridData(reactContext)
     }
 
+    override fun invalidate() {
+        _nativePlatform.invalidate()
+    }
+
     private fun initializeHybridData(reactContext: ReactApplicationContext): HybridData {
         val runtimeExecutor = reactContext.catalystInstance?.runtimeExecutor
             ?: throw IllegalStateException("Unistyles: React Native runtime executor is not available. Please follow installation guides.")

package/cxx/core/UnistyleData.h

@@ -12,7 +12,7 @@ struct UnistyleData {
         : unistyle{unistyle}, variants(std::move(variants)), dynamicFunctionMetadata{std::move(arguments)} {}
 
     UnistyleData(const UnistyleData&) = delete;
-    UnistyleData(UnistyleData&& other): unistyle{other.unistyle}, variants(std::move(other.variants)) {}
+    UnistyleData(UnistyleData&& other) = delete;
 
     core::Unistyle::Shared unistyle;
     core::Variants variants;

package/cxx/core/UnistyleWrapper.h

@@ -32,7 +32,6 @@ inline static Unistyle::Shared unistyleFromStaticStyleSheet(jsi::Runtime& rt, js
     return exoticUnistyle;
 }
 
-
 inline static std::vector<Unistyle::Shared> unistylesFromNonExistentNativeState(jsi::Runtime& rt, jsi::Object& value) {
     auto hasUnistyleName = value.hasProperty(rt, helpers::NAME_STYLE_KEY.c_str());
 
@@ -71,7 +70,7 @@ inline static jsi::Object generateUnistylesPrototype(
     auto hostFn = jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forUtf8(rt, "getStyle"), 0, [unistyle, unistylesRuntime](jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count){
         auto variants = helpers::variantsToPairs(rt, thisValue.asObject(rt).getProperty(rt, "variants").asObject(rt));
         auto arguments = helpers::parseDynamicFunctionArguments(rt, thisValue.asObject(rt).getProperty(rt, "arguments").asObject(rt).asArray(rt));
-        
+
         parser::Parser(unistylesRuntime).rebuildUnistyle(rt, unistyle->parent, unistyle, variants, std::make_optional<std::vector<folly::dynamic>>(arguments));
 
         return jsi::Value(rt, unistyle->parsedStyle.value()).asObject(rt);

package/cxx/core/UnistylesCommitHook.cpp

@@ -31,7 +31,7 @@ RootShadowNode::Unshared core::UnistylesCommitHook::shadowTreeWillCommit(
     auto& registry = core::UnistylesRegistry::get();
     auto& shadowLeafUpdates = registry.trafficController.getUpdates();
 
-    // oops, not updates from Unistyles yet, skip it!
+    // oops, no updates from Unistyles yet, skip it!
     if (shadowLeafUpdates.size() == 0) {
         return newRootShadowNode;
     }

package/cxx/core/UnistylesMountHook.cpp

@@ -23,6 +23,6 @@ void core::UnistylesMountHook::shadowTreeDidMount(RootShadowNode::Shared const &
     auto& registry = core::UnistylesRegistry::get();
 
     if (!registry.trafficController.shouldStop()) {
-        shadow::ShadowTreeManager::updateShadowTree(this->_unistylesRuntime->getRuntime());
+        shadow::ShadowTreeManager::updateShadowTree(this->_uiManager->getShadowTreeRegistry());
     }
 }

package/cxx/core/UnistylesRegistry.cpp

@@ -78,10 +78,6 @@ void core::UnistylesRegistry::linkShadowNodeWithUnistyle(
     auto parser = parser::Parser(nullptr);
     shadow::ShadowLeafUpdates updates;
 
-    if (!this->_shadowRegistry[&rt].contains(shadowNodeFamily)) {
-        this->_shadowRegistry[&rt][shadowNodeFamily] = {};
-    }
-
     std::for_each(unistyles.begin(), unistyles.end(), [&, this](Unistyle::Shared unistyle){
         this->_shadowRegistry[&rt][shadowNodeFamily].emplace_back(std::make_shared<UnistyleData>(unistyle, variants, arguments));
 
@@ -104,16 +100,11 @@ void core::UnistylesRegistry::linkShadowNodeWithUnistyle(
 
 void core::UnistylesRegistry::unlinkShadowNodeWithUnistyles(jsi::Runtime& rt, const ShadowNodeFamily* shadowNodeFamily) {
     this->_shadowRegistry[&rt].erase(shadowNodeFamily);
-}
+    this->trafficController.removeShadowNode(shadowNodeFamily);
 
-core::Unistyle::Shared core::UnistylesRegistry::findUnistyleFromKey(jsi::Runtime& rt, std::string styleKey, int tag) {
-    auto targetStyleSheet = this->_styleSheetRegistry[&rt][tag];
-
-    if (targetStyleSheet == nullptr) {
-        return nullptr;
+    if (this->_shadowRegistry[&rt].empty()) {
+        this->_shadowRegistry.erase(&rt);
     }
-
-    return targetStyleSheet.get()->unistyles[styleKey];
 }
 
 std::shared_ptr<core::StyleSheet> core::UnistylesRegistry::addStyleSheet(jsi::Runtime& rt, int unid, core::StyleSheetType type, jsi::Object&& rawValue) {
@@ -162,7 +153,7 @@ void core::UnistylesRegistry::shadowLeafUpdateFromUnistyle(jsi::Runtime& rt, Uni
     for (const auto& [family, unistyles] : this->_shadowRegistry[&rt]) {
         for (const auto& unistyleData : unistyles) {
             if (unistyleData->unistyle == unistyle) {
-                updates[family] = parser.parseStylesToShadowTreeStyles(rt, {unistyleData});
+                updates[family] = parser.parseStylesToShadowTreeStyles(rt, { unistyleData });
             }
         }
     }

package/cxx/core/UnistylesRegistry.h

@@ -41,7 +41,6 @@ struct UnistylesRegistry: public StyleSheetRegistry {
     void unlinkShadowNodeWithUnistyles(jsi::Runtime& rt, const ShadowNodeFamily*);
     std::shared_ptr<core::StyleSheet> addStyleSheet(jsi::Runtime& rt, int tag, core::StyleSheetType type, jsi::Object&& rawValue);
     DependencyMap buildDependencyMap(jsi::Runtime& rt, std::vector<UnistyleDependency>& deps);
-    Unistyle::Shared findUnistyleFromKey(jsi::Runtime& rt, std::string styleKey, int tag);
     void shadowLeafUpdateFromUnistyle(jsi::Runtime& rt, Unistyle::Shared unistyle);
     shadow::ShadowTrafficController trafficController{};
 
@@ -50,7 +49,7 @@ private:
 
     std::unordered_map<jsi::Runtime*, UnistylesState> _states{};
     std::unordered_map<jsi::Runtime*, std::unordered_map<int, std::shared_ptr<core::StyleSheet>>> _styleSheetRegistry{};
-    std::unordered_map<jsi::Runtime*, std::unordered_map<const ShadowNodeFamily*, std::vector<std::shared_ptr<UnistyleData>>>> _shadowRegistry{};
+    std::unordered_map<jsi::Runtime*, std::unordered_map<const ShadowNodeFamily*, std::vector<const std::shared_ptr<UnistyleData>>>> _shadowRegistry{};
 };
 
 inline UnistylesRegistry& UnistylesRegistry::get() {

package/cxx/core/UnistylesState.cpp

@@ -25,7 +25,7 @@ std::optional<std::string>& core::UnistylesState::getCurrentThemeName() {
 
 jsi::Object core::UnistylesState::getCurrentJSTheme() {
     auto hasSomeThemes = _registeredThemeNames.size() > 0;
-    
+
     if (!hasSomeThemes && !this->hasUserConfig) {
         helpers::assertThat(*_rt, false, "Unistyles: One of your stylesheets is trying to get the theme, but no theme has been selected yet. Did you forget to call StyleSheet.configure? If you called it, make sure you did so before any StyleSheet.create.");
     }
@@ -99,15 +99,18 @@ int core::UnistylesState::parseColor(jsi::Value& maybeColor) {
     if (!maybeColor.isString()) {
         return 0;
     }
-    
+
     auto colorString = maybeColor.asString(*_rt);
-    
+
     if (!this->_colorCache.contains(colorString.utf8(*_rt).c_str())) {
-        // we must convert it to uint32_t first, otherwise color will be broken
-        uint32_t color = this->_processColorFn.get()->call(*_rt, colorString).asNumber();
-        
+        #ifdef ANDROID
+            int color = this->_processColorFn.get()->call(*_rt, colorString).asNumber();
+        #else
+            uint32_t color = this->_processColorFn.get()->call(*_rt, colorString).asNumber();
+        #endif
+
         this->_colorCache[colorString.utf8(*_rt).c_str()] = color ? color : 0;
     }
-    
+
     return this->_colorCache[colorString.utf8(*_rt).c_str()];
 }

package/cxx/hybridObjects/HybridStyleSheet.cpp

@@ -15,7 +15,7 @@ double HybridStyleSheet::getUnid() {
 
 jsi::Value HybridStyleSheet::create(jsi::Runtime& rt, const jsi::Value &thisVal, const jsi::Value *arguments, size_t count) {
     if (count == 1) {
-        helpers::assertThat(rt, count == 2, "Unistyles is not initialized correctly. Please add babel plugin to your babel config.");
+        helpers::assertThat(rt, false, "Unistyles is not initialized correctly. Please add babel plugin to your babel config.");
     }
 
     // second argument is hidden, so validation is perfectly fine
@@ -128,7 +128,7 @@ void HybridStyleSheet::parseSettings(jsi::Runtime &rt, jsi::Object settings) {
 void HybridStyleSheet::parseBreakpoints(jsi::Runtime &rt, jsi::Object breakpoints){
     helpers::Breakpoints sortedBreakpoints = helpers::jsiBreakpointsToVecPairs(rt, std::move(breakpoints));
 
-    helpers::assertThat(rt, sortedBreakpoints.size() > 0, "StyleSheet.configure's breakpoints can't be empty.");
+    helpers::assertThat(rt, !sortedBreakpoints.empty(), "StyleSheet.configure's breakpoints can't be empty.");
     helpers::assertThat(rt, sortedBreakpoints.front().second == 0, "StyleSheet.configure's first breakpoint must start from 0.");
 
     auto& registry = core::UnistylesRegistry::get();
@@ -197,7 +197,7 @@ void HybridStyleSheet::verifyAndSelectTheme(jsi::Runtime &rt) {
 
 void HybridStyleSheet::setThemeFromColorScheme(jsi::Runtime& rt) {
     auto& state = core::UnistylesRegistry::get().getState(rt);
-    ColorScheme colorScheme = static_cast<ColorScheme>(this->_unistylesRuntime->getColorScheme());
+    auto colorScheme = static_cast<ColorScheme>(this->_unistylesRuntime->getColorScheme());
 
     switch (colorScheme) {
         case ColorScheme::LIGHT:
@@ -232,7 +232,7 @@ void HybridStyleSheet::loadExternalMethods(const jsi::Value& thisValue, jsi::Run
 void HybridStyleSheet::registerHooks(jsi::Runtime& rt) {
     // cleanup Shadow updates
     core::UnistylesRegistry::get().trafficController.restore();
-    
+
     this->_unistylesCommitHook = std::make_shared<core::UnistylesCommitHook>(this->_uiManager);
     this->_unistylesMountHook = std::make_shared<core::UnistylesMountHook>(this->_uiManager, this->_unistylesRuntime);
 }
@@ -248,20 +248,20 @@ void HybridStyleSheet::onPlatformDependenciesChange(std::vector<UnistyleDependen
         auto dependencies = std::move(unistylesDependencies);
 
         // re-compute new breakpoint
-        auto dimensionsIt = std::find(dependencies.begin(), dependencies.end(), UnistyleDependency::DIMENSIONS);
+        auto dimensionsIt = std::find(unistylesDependencies.begin(), unistylesDependencies.end(), UnistyleDependency::DIMENSIONS);
 
-        if (dimensionsIt != dependencies.end()) {
+        if (dimensionsIt != unistylesDependencies.end()) {
             registry.getState(rt).computeCurrentBreakpoint(this->_unistylesRuntime->getScreen().width);
         }
 
         // check if color scheme changed and then if Unistyles state depend on it (adaptive themes)
-        auto colorSchemeIt = std::find(dependencies.begin(), dependencies.end(), UnistyleDependency::COLORSCHEME);
-        auto hasNewColorScheme = colorSchemeIt != dependencies.end();
+        auto colorSchemeIt = std::find(unistylesDependencies.begin(), unistylesDependencies.end(), UnistyleDependency::COLORSCHEME);
+        auto hasNewColorScheme = colorSchemeIt != unistylesDependencies.end();
 
         // in a later step, we will rebuild only Unistyles with mounted StyleSheets
         // however, user may have StyleSheets with components that haven't mounted yet
         // we need to rebuild all dependent StyleSheets as well
-        auto dependentStyleSheets = registry.getStyleSheetsToRefresh(rt, hasNewColorScheme, dependencies.size() > 1);
+        auto dependentStyleSheets = registry.getStyleSheetsToRefresh(rt, hasNewColorScheme, unistylesDependencies.size() > 1);
 
         if (hasNewColorScheme) {
             this->_unistylesRuntime->includeDependenciesForColorSchemeChange(dependencies);
@@ -269,17 +269,17 @@ void HybridStyleSheet::onPlatformDependenciesChange(std::vector<UnistyleDependen
 
         auto dependencyMap = registry.buildDependencyMap(rt, dependencies);
 
-        if (dependencyMap.size() == 0) {
+        if (dependencyMap.empty()) {
             this->notifyJSListeners(dependencies);
 
             return;
         }
 
         parser.rebuildUnistylesInDependencyMap(rt, dependencyMap, dependentStyleSheets);
-        parser.rebuildShadowLeafUpdates(dependencyMap);
-        
+        parser.rebuildShadowLeafUpdates(rt, dependencyMap);
+
         this->notifyJSListeners(dependencies);
-        shadow::ShadowTreeManager::updateShadowTree(rt);
+        shadow::ShadowTreeManager::updateShadowTree(UIManagerBinding::getBinding(rt)->getUIManager().getShadowTreeRegistry());
     });
 }
 
@@ -298,18 +298,21 @@ void HybridStyleSheet::onImeChange() {
 
         auto dependencyMap = registry.buildDependencyMap(rt, dependencies);
 
-        if (dependencyMap.size() == 0) {
+        if (dependencyMap.empty()) {
             return;
         }
+        
+        std::vector<std::shared_ptr<core::StyleSheet>> styleSheet;
+
+        parser.rebuildUnistylesInDependencyMap(rt, dependencyMap, styleSheet);
+        parser.rebuildShadowLeafUpdates(rt, dependencyMap);
 
-        parser.rebuildUnistylesInDependencyMap(rt, dependencyMap, {});
-        parser.rebuildShadowLeafUpdates(dependencyMap);
-        shadow::ShadowTreeManager::updateShadowTree(rt);
+        shadow::ShadowTreeManager::updateShadowTree(UIManagerBinding::getBinding(rt)->getUIManager().getShadowTreeRegistry());
     });
 }
 
 void HybridStyleSheet::notifyJSListeners(std::vector<UnistyleDependency>& dependencies) {
-    if (dependencies.size() > 0) {
+    if (!dependencies.empty()) {
         std::for_each(this->_changeListeners.begin(), this->_changeListeners.end(), [&](auto& listener){
             (*listener)(dependencies);
         });

package/cxx/hybridObjects/HybridUnistylesRuntime.cpp

@@ -228,10 +228,6 @@ jsi::Value HybridUnistylesRuntime::getMiniRuntimeAsValue(jsi::Runtime& rt) {
     return obj;
 }
 
-jsi::Runtime& HybridUnistylesRuntime::getRuntime() {
-    return *this->_rt;
-}
-
 void HybridUnistylesRuntime::registerPlatformListener(const std::function<void(std::vector<UnistyleDependency>)>& listener) {
     this->_nativePlatform.registerPlatformListener(listener);
     this->_onDependenciesChange = listener;

package/cxx/hybridObjects/HybridUnistylesRuntime.h

@@ -67,7 +67,6 @@ struct HybridUnistylesRuntime: public HybridUnistylesRuntimeSpec {
     std::unordered_map<std::string, double> getBreakpoints() override;
 
     jsi::Value getMiniRuntimeAsValue(jsi::Runtime& rt);
-    jsi::Runtime& getRuntime();
     void includeDependenciesForColorSchemeChange(std::vector<UnistyleDependency>& deps);
     void calculateNewThemeAndDependencies(std::vector<UnistyleDependency>& deps);
     std::function<void(std::function<void(jsi::Runtime&)>&&)> runOnJSThread;

package/cxx/parser/Parser.cpp

@@ -93,13 +93,12 @@ void parser::Parser::rebuildUnistylesWithVariants(jsi::Runtime& rt, std::shared_
             continue;
         }
 
-        // todo skip dynamic functions
         this->rebuildUnistyle(rt, styleSheet, unistyle, variants, std::nullopt);
     }
 }
 
 // rebuild all unistyles that are affected by platform event
-void parser::Parser::rebuildUnistylesInDependencyMap(jsi::Runtime& rt, DependencyMap& dependencyMap, std::vector<std::shared_ptr<core::StyleSheet>> styleSheets) {
+void parser::Parser::rebuildUnistylesInDependencyMap(jsi::Runtime& rt, DependencyMap& dependencyMap, std::vector<std::shared_ptr<core::StyleSheet>>& styleSheets) {
     std::unordered_map<std::shared_ptr<StyleSheet>, jsi::Value> parsedStyleSheets{};
     std::unordered_map<std::shared_ptr<core::Unistyle>, bool> parsedUnistyles{};
 
@@ -121,7 +120,7 @@ void parser::Parser::rebuildUnistylesInDependencyMap(jsi::Runtime& rt, Dependenc
             auto& unistyle = unistyleData->unistyle;
 
             // for RN styles or inline styles, compute styles only once
-            if (unistyle->styleKey == helpers::EXOTIC_STYLE_KEY.c_str()) {
+            if (unistyle->styleKey == helpers::EXOTIC_STYLE_KEY) {
                 if (!unistyleData->parsedStyle.has_value()) {
                     unistyleData->parsedStyle = jsi::Value(rt, unistyle->rawValue).asObject(rt);
 
@@ -206,10 +205,9 @@ void parser::Parser::rebuildUnistyle(jsi::Runtime& rt, std::shared_ptr<StyleShee
 }
 
 // convert dependency map to shadow tree updates
-void parser::Parser::rebuildShadowLeafUpdates(core::DependencyMap& dependencyMap) {
+void parser::Parser::rebuildShadowLeafUpdates(jsi::Runtime& rt, core::DependencyMap& dependencyMap) {
     shadow::ShadowLeafUpdates updates;
     auto& registry = core::UnistylesRegistry::get();
-    auto& rt = this->_unistylesRuntime->getRuntime();
 
     for (const auto& [shadowNode, unistyles] : dependencyMap) {
         auto rawProps = this->parseStylesToShadowTreeStyles(rt, unistyles);
@@ -218,8 +216,6 @@ void parser::Parser::rebuildShadowLeafUpdates(core::DependencyMap& dependencyMap
     }
 
     registry.trafficController.setUpdates(updates);
-
-    // this is required, we need to indicate that there are new changes
     registry.trafficController.resumeUnistylesTraffic();
 }
 
@@ -764,26 +760,6 @@ folly::dynamic parser::Parser::parseStylesToShadowTreeStyles(jsi::Runtime& rt, c
     return jsi::dynamicFromValue(rt, std::move(convertedStyles));
 }
 
-folly::dynamic parser::Parser::parseUnistyleToShadowTreeStyles(jsi::Runtime& rt, const Unistyle::Shared unistyle) {
-    jsi::Object convertedStyles = jsi::Object(rt);
-    auto& state = core::UnistylesRegistry::get().getState(rt);
-
-    // can happen for exotic styles
-    if (!unistyle->parsedStyle.has_value()) {
-        return nullptr;
-    }
-
-    helpers::enumerateJSIObject(rt, unistyle->parsedStyle.value(), [&](const std::string& propertyName, jsi::Value& propertyValue){
-        if (this->isColor(propertyName)) {
-            return convertedStyles.setProperty(rt, propertyName.c_str(), jsi::Value(state.parseColor(propertyValue)));
-        }
-
-        convertedStyles.setProperty(rt, propertyName.c_str(), propertyValue);
-    });
-
-    return jsi::dynamicFromValue(rt, std::move(convertedStyles));
-}
-
 // check is styleKey contains color
 bool parser::Parser::isColor(const std::string& propertyName) {
     std::string str = propertyName;

package/cxx/parser/Parser.h

@@ -24,9 +24,8 @@ struct Parser {
     void buildUnistyles(jsi::Runtime& rt, std::shared_ptr<StyleSheet> styleSheet);
     void parseUnistyles(jsi::Runtime& rt, std::shared_ptr<StyleSheet> styleSheet);
     void rebuildUnistylesWithVariants(jsi::Runtime& rt, std::shared_ptr<StyleSheet> styleSheet, Variants& variants);
-    void rebuildUnistylesInDependencyMap(jsi::Runtime& rt, core::DependencyMap& dependencyMap, std::vector<std::shared_ptr<core::StyleSheet>> styleSheets);
-    void rebuildShadowLeafUpdates(core::DependencyMap& dependencyMap);
-    folly::dynamic parseUnistyleToShadowTreeStyles(jsi::Runtime& rt, const Unistyle::Shared unistyle);
+    void rebuildUnistylesInDependencyMap(jsi::Runtime& rt, core::DependencyMap& dependencyMap, std::vector<std::shared_ptr<core::StyleSheet>>& styleSheets);
+    void rebuildShadowLeafUpdates(jsi::Runtime& rt, core::DependencyMap& dependencyMap);
     folly::dynamic parseStylesToShadowTreeStyles(jsi::Runtime& rt, const std::vector<std::shared_ptr<UnistyleData>>& unistyles);
     void rebuildUnistyle(jsi::Runtime& rt, std::shared_ptr<StyleSheet> styleSheet, Unistyle::Shared unistyle, const Variants& variants, std::optional<std::vector<folly::dynamic>>);
 

package/cxx/shadowTree/ShadowTrafficController.h

@@ -13,20 +13,16 @@ struct ShadowTrafficController {
     }
 
     inline void stopUnistylesTraffic() {
-        std::lock_guard<std::mutex> lock(_mutex);
-
         this->_canCommit = false;
     }
 
     inline void resumeUnistylesTraffic() {
-        std::lock_guard<std::mutex> lock(_mutex);
-
         this->_canCommit = true;
     }
 
     inline shadow::ShadowLeafUpdates& getUpdates() {
         std::lock_guard<std::mutex> lock(_mutex);
-
+ 
         return _unistylesUpdates;
     }
 
@@ -47,6 +43,14 @@ struct ShadowTrafficController {
             targetUpdates.emplace(pair.first, std::move(pair.second));
         });
     }
+    
+    inline void removeShadowNode(const ShadowNodeFamily* shadowNodeFamily) {
+        std::lock_guard<std::mutex> lock(_mutex);
+        
+        if (_unistylesUpdates.contains(shadowNodeFamily)) {
+            _unistylesUpdates.erase(shadowNodeFamily);
+        }
+    }
 
     inline void restore() {
         std::lock_guard<std::mutex> lock(_mutex);

package/cxx/shadowTree/ShadowTreeManager.cpp

@@ -6,13 +6,11 @@ using namespace facebook;
 
 using AffectedNodes = std::unordered_map<const ShadowNodeFamily*, std::unordered_set<int>>;
 
-void shadow::ShadowTreeManager::updateShadowTree(facebook::jsi::Runtime& rt) {
+void shadow::ShadowTreeManager::updateShadowTree(const ShadowTreeRegistry& shadowTreeRegistry) {
     auto& registry = core::UnistylesRegistry::get();
-    auto& uiManager = UIManagerBinding::getBinding(rt)->getUIManager();
-    const auto &shadowTreeRegistry = uiManager.getShadowTreeRegistry();
     auto updates = registry.trafficController.getUpdates();
 
-    if (updates.size() == 0) {
+    if (updates.empty()) {
         return;
     }
 
@@ -111,9 +109,16 @@ ShadowNode::Unshared shadow::ShadowTreeManager::cloneShadowTree(const ShadowNode
             *shadowNode.getContextContainer()
         };
 
+        #ifdef ANDROID
+            auto safeProps = rawPropsIt->second == nullptr ? folly::dynamic::object() : rawPropsIt->second;
+            auto newProps = folly::dynamic::merge(shadowNode.getProps()->rawProps, safeProps);
+        #else
+            auto newProps = rawPropsIt->second;
+        #endif
+
         updatedProps = shadowNode
             .getComponentDescriptor()
-            .cloneProps(propsParserContext, shadowNode.getProps(), RawProps(rawPropsIt->second));
+            .cloneProps(propsParserContext, shadowNode.getProps(), RawProps(newProps));
     }
 
     return shadowNode.clone({

package/cxx/shadowTree/ShadowTreeManager.h

@@ -16,7 +16,7 @@ using namespace facebook;
 using AffectedNodes = std::unordered_map<const ShadowNodeFamily *, std::unordered_set<int>>;
 
 struct ShadowTreeManager {
-    static void updateShadowTree(jsi::Runtime& rt);
+    static void updateShadowTree(const ShadowTreeRegistry& shadowTreeRegistry);
     static AffectedNodes findAffectedNodes(const RootShadowNode& rootNode, ShadowLeafUpdates& updates);
     static ShadowNode::Unshared cloneShadowTree(const ShadowNode &shadowNode, ShadowLeafUpdates& updates, AffectedNodes& affectedNodes);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-unistyles",
-  "version": "3.0.0-alpha.36",
+  "version": "3.0.0-alpha.37",
   "description": "Level up your React Native StyleSheet",
   "scripts": {
     "test": "jest",
@@ -74,11 +74,11 @@
     "husky": "9.1.6",
     "jest": "29.7.0",
     "metro-react-native-babel-preset": "0.77.0",
-    "nitro-codegen": "0.15.0",
+    "nitro-codegen": "0.16.2",
     "react": "18.3.1",
     "react-native": "0.76.0",
     "react-native-builder-bob": "0.30.2",
-    "react-native-nitro-modules": "0.15.0",
+    "react-native-nitro-modules": "0.16.2",
     "react-test-renderer": "18.3.1",
     "release-it": "17.10.0",
     "typescript": "5.6.3"

package/android/src/main/java/com/unistyles/NativePlatform.kt

@@ -1,184 +0,0 @@
-package com.unistyles
-
-import UnistylesModuleInsets
-import android.content.Context
-import android.content.res.Configuration
-import android.os.Build
-import android.util.DisplayMetrics
-import android.view.WindowManager
-import androidx.core.text.TextUtilsCompat
-import androidx.core.view.ViewCompat
-import com.facebook.react.bridge.ReactApplicationContext
-import com.margelo.nitro.unistyles.ColorScheme
-import com.margelo.nitro.unistyles.Dimensions
-import com.margelo.nitro.unistyles.HybridNativePlatformSpec
-import com.margelo.nitro.unistyles.Insets
-import com.margelo.nitro.unistyles.Orientation
-import com.margelo.nitro.unistyles.UnistyleDependency
-import com.margelo.nitro.unistyles.UnistylesNativeMiniRuntime
-import java.util.Locale
-
-class NativePlatform(private val reactContext: ReactApplicationContext): HybridNativePlatformSpec() {
-    private val _insets = UnistylesModuleInsets(reactContext)
-
-    override fun getInsets(): Insets {
-        return _insets.getInsets()
-    }
-
-    override fun getColorScheme(): ColorScheme {
-        val uiMode = reactContext.resources.configuration.uiMode
-
-        val colorScheme = when (uiMode.and(Configuration.UI_MODE_NIGHT_MASK)) {
-            Configuration.UI_MODE_NIGHT_YES -> ColorScheme.DARK
-            Configuration.UI_MODE_NIGHT_NO -> ColorScheme.LIGHT
-            else -> ColorScheme.UNSPECIFIED
-        }
-
-        return colorScheme
-    }
-
-    override fun getFontScale(): Double {
-        return reactContext.resources.configuration.fontScale.toDouble()
-    }
-
-    override fun getPixelRatio(): Double {
-        return reactContext.resources.displayMetrics.density.toDouble()
-    }
-
-    override fun getOrientation(): Orientation {
-        val orientation = when (reactContext.resources.configuration.orientation) {
-            Configuration.ORIENTATION_PORTRAIT -> Orientation.PORTRAIT
-            Configuration.ORIENTATION_LANDSCAPE -> Orientation.LANDSCAPE
-            else -> Orientation.PORTRAIT
-        }
-
-        return orientation
-    }
-
-    override fun getContentSizeCategory(): String {
-        val fontScale = reactContext.resources.configuration.fontScale
-
-        val contentSizeCategory = when {
-            fontScale <= 0.85f -> "Small"
-            fontScale <= 1.0f -> "Default"
-            fontScale <= 1.15f -> "Large"
-            fontScale <= 1.3f -> "ExtraLarge"
-            fontScale <= 1.5f -> "Huge"
-            fontScale <= 1.8 -> "ExtraHuge"
-            else -> "ExtraExtraHuge"
-        }
-
-        return contentSizeCategory
-    }
-
-    override fun getScreenDimensions(): Dimensions {
-        // function takes in count edge-to-edge layout
-        when {
-            Build.VERSION.SDK_INT < Build.VERSION_CODES.R -> {
-                val windowManager = reactContext.getSystemService(Context.WINDOW_SERVICE) as WindowManager
-                val metrics = DisplayMetrics()
-
-                windowManager.defaultDisplay.getRealMetrics(metrics)
-
-                val screenWidth = (metrics.widthPixels / metrics.density).toDouble()
-                val screenHeight = (metrics.heightPixels / metrics.density).toDouble()
-
-                return Dimensions(screenWidth, screenHeight)
-            }
-            else -> {
-                val displayMetrics = reactContext.resources.displayMetrics
-
-                reactContext.currentActivity?.windowManager?.currentWindowMetrics?.bounds?.let {
-                    val boundsWidth = (it.width() / displayMetrics.density).toDouble()
-                    val boundsHeight = (it.height() / displayMetrics.density).toDouble()
-
-                    return Dimensions(boundsWidth, boundsHeight)
-                } ?: run {
-                    val screenWidth = (displayMetrics.widthPixels / displayMetrics.density).toDouble()
-                    val screenHeight = (displayMetrics.heightPixels / displayMetrics.density).toDouble()
-
-                    return Dimensions(screenWidth, screenHeight)
-                }
-            }
-        }
-    }
-
-    override fun getStatusBarDimensions(): Dimensions {
-        // todo
-        return Dimensions(0.0, 0.0)
-    }
-
-    override fun getNavigationBarDimensions(): Dimensions {
-        // todo
-        return Dimensions(0.0, 0.0)
-    }
-
-    override fun getPrefersRtlDirection(): Boolean {
-        // forced by React Native
-        val sharedPrefs = reactContext.getSharedPreferences(
-            "com.facebook.react.modules.i18nmanager.I18nUtil",
-            Context.MODE_PRIVATE
-        )
-        val hasForcedRtl = sharedPrefs.getBoolean("RCTI18nUtil_forceRTL", false)
-        // user preferences
-        val isRtl = TextUtilsCompat.getLayoutDirectionFromLocale(Locale.getDefault()) == ViewCompat.LAYOUT_DIRECTION_RTL
-
-        return hasForcedRtl || isRtl
-    }
-
-    override fun setRootViewBackgroundColor(color: Double) {
-        // todo
-    }
-
-    override fun setNavigationBarBackgroundColor(color: Double) {
-        // todo
-    }
-
-    override fun setNavigationBarHidden(isHidden: Boolean) {
-        // todo
-    }
-
-    override fun setStatusBarHidden(isHidden: Boolean) {
-        // todo
-    }
-
-    override fun setStatusBarBackgroundColor(color: Double) {
-        // todo
-    }
-
-    override fun setImmersiveMode(isEnabled: Boolean) {
-        this.setStatusBarHidden(isEnabled)
-        this.setNavigationBarHidden(isEnabled)
-    }
-
-    override fun getMiniRuntime(): UnistylesNativeMiniRuntime {
-        return UnistylesNativeMiniRuntime(
-            colorScheme = this.getColorScheme(),
-            screen = this.getScreenDimensions(),
-            contentSizeCategory = this.getContentSizeCategory(),
-            insets = this.getInsets(),
-            pixelRatio = this.getPixelRatio(),
-            fontScale = this.getFontScale(),
-            rtl = this.getPrefersRtlDirection(),
-            statusBar = this.getStatusBarDimensions(),
-            navigationBar = this.getNavigationBarDimensions(),
-            isPortrait = this.getOrientation() == Orientation.PORTRAIT,
-            isLandscape = this.getOrientation() == Orientation.LANDSCAPE
-        )
-    }
-
-    override fun registerPlatformListener(callback: (dependencies: Array<UnistyleDependency>) -> Unit) {
-        // todo
-    }
-
-    override fun registerImeListener(callback: () -> Unit) {
-        // todo
-    }
-
-    override fun unregisterPlatformListeners() {
-        // todo
-    }
-
-    override val memorySize: Long
-        get() = 0
-}

package/android/src/main/java/com/unistyles/UnistylesModule+insets.kt

@@ -1,8 +0,0 @@
-import com.facebook.react.bridge.ReactApplicationContext
-import com.margelo.nitro.unistyles.Insets
-
-class UnistylesModuleInsets(private val reactContext: ReactApplicationContext) {
-    fun getInsets(): Insets {
-        return Insets(top = 0.0, bottom = 0.0, left = 0.0, right = 0.0, ime = 0.0)
-    }
-}