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

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());
     }
 }