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

package/android/build.gradle

@@ -7,8 +7,8 @@ buildscript {
         gradlePluginPortal()
     }
     dependencies {
-        classpath("com.android.tools.build:gradle:7.3.1")
-        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:1.7.22")
+        classpath("com.android.tools.build:gradle:8.2.1")
+        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:1.9.10")
     }
 }
 
@@ -32,12 +32,12 @@ if (isNewArchitectureEnabled()) {
 }
 
 android {
-    compileSdkVersion safeExtGet('compileSdkVersion', 34)
+    compileSdkVersion safeExtGet('compileSdkVersion', 35)
     namespace "com.unistyles"
 
     defaultConfig {
         buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
-        minSdkVersion safeExtGet('minSdkVersion', 23)
+        minSdkVersion safeExtGet('minSdkVersion', 24)
         externalNativeBuild {
             cmake {
                 arguments "-DANDROID_STL=c++_shared"

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

@@ -8,7 +8,6 @@ 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
@@ -23,11 +22,12 @@ 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 val _insets = NativePlatformInsets(reactContext, this::getMiniRuntime) { this.diffMiniRuntime() }
     private var _miniRuntime: UnistylesNativeMiniRuntime = buildMiniRuntime()
-    private val _listener = NativePlatformListener(reactContext) { this.diffMiniRuntime() }
+    private val _listener = NativePlatformListener(reactContext, this::getMiniRuntime) { this.diffMiniRuntime() }
 
     init {
+        checkEdgeToEdge()
         reactContext.addLifecycleEventListener(this)
     }
 
@@ -37,7 +37,6 @@ class NativePlatformAndroid(private val reactContext: ReactApplicationContext):
     }
 
     override fun onHostResume() {
-        enableEdgeToEdge()
         _insets.startInsetsListener()
     }
 
@@ -168,15 +167,6 @@ class NativePlatformAndroid(private val reactContext: ReactApplicationContext):
         }
     }
 
-    @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 {
@@ -231,16 +221,6 @@ class NativePlatformAndroid(private val reactContext: ReactApplicationContext):
         }
     }
 
-    @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)
@@ -279,11 +259,11 @@ class NativePlatformAndroid(private val reactContext: ReactApplicationContext):
         return changedDependencies
     }
 
-    override fun registerPlatformListener(callback: (dependencies: Array<UnistyleDependency>) -> Unit) {
+    override fun registerPlatformListener(callback: (dependencies: Array<UnistyleDependency>, miniRuntime: UnistylesNativeMiniRuntime) -> Unit) {
         this._listener.addPlatformListener(callback)
     }
 
-    override fun registerImeListener(callback: () -> Unit) {
+    override fun registerImeListener(callback: (miniRuntime: UnistylesNativeMiniRuntime) -> Unit) {
         this._insets.addImeListener(callback)
     }
 
@@ -292,11 +272,14 @@ class NativePlatformAndroid(private val reactContext: ReactApplicationContext):
         this._insets.removeImeListeners()
     }
 
-    private fun enableEdgeToEdge() {
-        reactContext.currentActivity?.let { activity ->
-            activity.runOnUiThread {
-                WindowCompat.setDecorFitsSystemWindows(activity.window, false)
-            }
+    private fun checkEdgeToEdge() {
+        // react-native-edge-to-edge will set setDecorFitsSystemWindows automatically
+        // if it's present we assume that edge-to-edge is enabled
+
+        try {
+            Class.forName("com.zoontek.rnedgetoedge.EdgeToEdgePackage")
+        } catch (exception: ClassNotFoundException) {
+            throw IllegalStateException("Unistyles: react-native-edge-to-edge is not installed.")
         }
     }
 }

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

@@ -11,10 +11,15 @@ import androidx.core.view.WindowInsetsCompat
 import com.facebook.react.bridge.ReactApplicationContext
 import com.margelo.nitro.unistyles.Insets
 import com.margelo.nitro.unistyles.UnistyleDependency
+import com.margelo.nitro.unistyles.UnistylesNativeMiniRuntime
 
-typealias CxxImeListener = () -> Unit
+typealias CxxImeListener = (miniRuntime: UnistylesNativeMiniRuntime) -> Unit
 
-class NativePlatformInsets(private val reactContext: ReactApplicationContext, private val diffMiniRuntime: () -> Array<UnistyleDependency>) {
+class NativePlatformInsets(
+    private val reactContext: ReactApplicationContext,
+    private val getMiniRuntime: () -> UnistylesNativeMiniRuntime,
+    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)
 
@@ -58,30 +63,30 @@ class NativePlatformInsets(private val reactContext: ReactApplicationContext, pr
 
         // 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
+        val imeInsets = when {
+            animatedBottomInsets != null && Build.VERSION.SDK_INT >= 30 -> animatedBottomInsets
+            Build.VERSION.SDK_INT < 30 -> {
+                val nextBottomInset = insetsCompat.getInsets(WindowInsetsCompat.Type.ime()).bottom - insets.bottom
+                maxOf(nextBottomInset, 0).toDouble()
             }
+            else -> 0.0
         }
 
+        val shouldEmitImeEvent = Build.VERSION.SDK_INT < 30 && imeInsets != this._insets.ime || animatedBottomInsets != null && Build.VERSION.SDK_INT >= 30
+
         this._insets = Insets(
             statusBarTopInset.toDouble(),
             insets.bottom.toDouble(),
             insets.left.toDouble(),
             insets.right.toDouble(),
-            imeInsets.toDouble()
+            imeInsets
         )
 
         diffMiniRuntime()
+
+        if (shouldEmitImeEvent) {
+            this@NativePlatformInsets.emitImeEvent(this.getMiniRuntime())
+        }
     }
 
     fun startInsetsListener() {
@@ -111,7 +116,6 @@ class NativePlatformInsets(private val reactContext: ReactApplicationContext, pr
                                     }
 
                                     this@NativePlatformInsets.setInsets(insets, activity.window, nextBottomInset)
-                                    this@NativePlatformInsets.emitImeEvent()
                                 }
 
                                 return insets
@@ -123,9 +127,9 @@ class NativePlatformInsets(private val reactContext: ReactApplicationContext, pr
         }
     }
 
-    fun emitImeEvent() {
+    fun emitImeEvent(miniRuntime: UnistylesNativeMiniRuntime) {
         _imeListeners.forEach { listener ->
-            listener()
+            listener(miniRuntime)
         }
     }
 

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

@@ -8,10 +8,15 @@ import android.os.Handler
 import android.os.Looper
 import com.facebook.react.bridge.ReactApplicationContext
 import com.margelo.nitro.unistyles.UnistyleDependency
+import com.margelo.nitro.unistyles.UnistylesNativeMiniRuntime
 
-typealias CxxDependencyListener = (dependencies: Array<UnistyleDependency>) -> Unit
+typealias CxxDependencyListener = (dependencies: Array<UnistyleDependency>, miniRuntime: UnistylesNativeMiniRuntime) -> Unit
 
-class NativePlatformListener(private val reactContext: ReactApplicationContext, private val diffMiniRuntime: () -> Array<UnistyleDependency>) {
+class NativePlatformListener(
+    private val reactContext: ReactApplicationContext,
+    private val getMiniRuntime: () -> UnistylesNativeMiniRuntime,
+    private val diffMiniRuntime: () -> Array<UnistyleDependency>
+) {
     private val _dependencyListeners: MutableList<CxxDependencyListener> = mutableListOf()
 
     private val configurationChangeReceiver = object : BroadcastReceiver() {
@@ -38,9 +43,9 @@ class NativePlatformListener(private val reactContext: ReactApplicationContext,
         this._dependencyListeners.clear()
     }
 
-    private fun emitCxxEvent(dependencies: Array<UnistyleDependency>) {
+    private fun emitCxxEvent(dependencies: Array<UnistyleDependency>, miniRuntime: UnistylesNativeMiniRuntime) {
         this._dependencyListeners.forEach { listener ->
-            listener(dependencies)
+            listener(dependencies, miniRuntime)
         }
     }
 
@@ -48,7 +53,7 @@ class NativePlatformListener(private val reactContext: ReactApplicationContext,
         val changedDependencies = diffMiniRuntime()
 
         if (changedDependencies.isNotEmpty()) {
-            emitCxxEvent(changedDependencies)
+            emitCxxEvent(changedDependencies, getMiniRuntime())
         }
     }
 }

package/cxx/core/UnistyleWrapper.h

@@ -85,18 +85,35 @@ inline static jsi::Object generateUnistylesPrototype(
 }
 
 inline static std::vector<Unistyle::Shared> unistyleFromValue(jsi::Runtime& rt, const jsi::Value& value) {
-    if (value.isNull()) {
+    if (value.isNull() || !value.isObject()) {
         return {};
     }
-
-    auto obj = value.getObject(rt);
-
-    // possible if user used React Native styles or inline styles or did spread styles
-    if (!obj.hasNativeState(rt)) {
-        return unistylesFromNonExistentNativeState(rt, obj);
-    }
-
-    return {value.getObject(rt).getNativeState<UnistyleWrapper>(rt)->unistyle};
+    
+    auto maybeArray = value.asObject(rt);
+    
+    helpers::assertThat(rt, maybeArray.isArray(rt), "Unistyles: can't retrieve Unistyle state from node as it's not an array.");
+    
+    std::vector<Unistyle::Shared> unistyles;
+    jsi::Array unistylesArray = maybeArray.asArray(rt);
+    
+    helpers::iterateJSIArray(rt, unistylesArray, [&rt, &unistyles](size_t index, jsi::Value& value){
+        auto obj = value.getObject(rt);
+
+        // possible if user used React Native styles or inline styles or did spread styles
+        if (!obj.hasNativeState(rt)) {
+            auto exoticUnistyles = unistylesFromNonExistentNativeState(rt, obj);
+            
+            for (auto& exoticUnistyle: exoticUnistyles) {
+                unistyles.emplace_back(exoticUnistyle);
+            }
+            
+            return;
+        }
+
+        unistyles.emplace_back(value.getObject(rt).getNativeState<UnistyleWrapper>(rt)->unistyle);
+    });
+    
+    return unistyles;
 }
 
 inline static jsi::Value valueFromUnistyle(jsi::Runtime& rt, std::shared_ptr<HybridUnistylesRuntime> unistylesRuntime, Unistyle::Shared unistyle, int tag) {

package/cxx/core/UnistylesRegistry.cpp

@@ -73,13 +73,15 @@ void core::UnistylesRegistry::linkShadowNodeWithUnistyle(
     const ShadowNodeFamily* shadowNodeFamily,
     std::vector<core::Unistyle::Shared>& unistyles,
     Variants& variants,
-    std::vector<folly::dynamic>& arguments
+    std::vector<std::vector<folly::dynamic>>& arguments
 ) {
     auto parser = parser::Parser(nullptr);
     shadow::ShadowLeafUpdates updates;
+    
+    for (size_t index = 0; index < unistyles.size(); index++) {
+        Unistyle::Shared unistyle = unistyles[index];
 
-    std::for_each(unistyles.begin(), unistyles.end(), [&, this](Unistyle::Shared unistyle){
-        this->_shadowRegistry[&rt][shadowNodeFamily].emplace_back(std::make_shared<UnistyleData>(unistyle, variants, arguments));
+        this->_shadowRegistry[&rt][shadowNodeFamily].emplace_back(std::make_shared<UnistyleData>(unistyle, variants, arguments[index]));
 
         // add or update node for shadow leaf updates
         // dynamic functions are parsed later
@@ -92,7 +94,7 @@ void core::UnistylesRegistry::linkShadowNodeWithUnistyle(
                 }
             }
         }
-    });
+    }
 
     this->trafficController.setUpdates(updates);
     this->trafficController.resumeUnistylesTraffic();
@@ -153,6 +155,8 @@ 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) {
+                // update state eg. for pressable
+                unistyleData->parsedStyle = jsi::Value(rt, unistyle->parsedStyle.value()).asObject(rt);
                 updates[family] = parser.parseStylesToShadowTreeStyles(rt, { unistyleData });
             }
         }
@@ -161,9 +165,15 @@ void core::UnistylesRegistry::shadowLeafUpdateFromUnistyle(jsi::Runtime& rt, Uni
     this->trafficController.setUpdates(updates);
 }
 
-std::vector<std::shared_ptr<core::StyleSheet>> core::UnistylesRegistry::getStyleSheetsToRefresh(jsi::Runtime& rt, bool themeDidChange, bool runtimeDidChange) {
+std::vector<std::shared_ptr<core::StyleSheet>> core::UnistylesRegistry::getStyleSheetsToRefresh(jsi::Runtime& rt, std::vector<UnistyleDependency>& unistylesDependencies) {
     std::vector<std::shared_ptr<core::StyleSheet>> stylesheetsToRefresh{};
-
+    auto themeDidChangeIt = std::find(unistylesDependencies.begin(),
+                                      unistylesDependencies.end(),
+                                      UnistyleDependency::THEME);
+    auto themeDidChange = themeDidChangeIt != unistylesDependencies.end();
+    auto runtimeDidChange = (themeDidChange && unistylesDependencies.size() > 1) || unistylesDependencies.size() > 0;
+    
+    // if nothing changed, skip further lookup
     if (!themeDidChange && !runtimeDidChange) {
         return stylesheetsToRefresh;
     }
@@ -173,10 +183,24 @@ std::vector<std::shared_ptr<core::StyleSheet>> core::UnistylesRegistry::getStyle
     std::for_each(styleSheets.begin(), styleSheets.end(), [&](std::pair<int, std::shared_ptr<core::StyleSheet>> pair){
         auto& [_, styleSheet] = pair;
 
-        if (styleSheet->type == StyleSheetType::ThemableWithMiniRuntime && (themeDidChange || runtimeDidChange)) {
-            stylesheetsToRefresh.emplace_back(styleSheet);
-
-            return;
+        if (styleSheet->type == StyleSheetType::ThemableWithMiniRuntime) {
+            for (const auto& unistylePair: styleSheet->unistyles) {
+                auto& [_, unistyle] = unistylePair;
+                
+                bool hasAnyOfDependencies = std::any_of(
+                    unistyle->dependencies.begin(),
+                    unistyle->dependencies.end(),
+                    [&unistylesDependencies](UnistyleDependency dep) {
+                        return std::find(unistylesDependencies.begin(), unistylesDependencies.end(), dep) != unistylesDependencies.end();
+                    }
+                );
+                
+                if (hasAnyOfDependencies) {
+                    stylesheetsToRefresh.emplace_back(styleSheet);
+                    
+                    return;
+                }
+            }
         }
 
         if (styleSheet->type == StyleSheetType::Themable && themeDidChange) {

package/cxx/core/UnistylesRegistry.h

@@ -36,8 +36,8 @@ struct UnistylesRegistry: public StyleSheetRegistry {
 
     UnistylesState& getState(jsi::Runtime& rt);
     void createState(jsi::Runtime& rt);
-    std::vector<std::shared_ptr<core::StyleSheet>> getStyleSheetsToRefresh(jsi::Runtime& rt, bool themeDidChange, bool runtimeDidChange);
-    void linkShadowNodeWithUnistyle(jsi::Runtime& rt, const ShadowNodeFamily*, std::vector<core::Unistyle::Shared>& unistyles, Variants& variants, std::vector<folly::dynamic>&);
+    std::vector<std::shared_ptr<core::StyleSheet>> getStyleSheetsToRefresh(jsi::Runtime& rt, std::vector<UnistyleDependency>& unistylesDependencies);
+    void linkShadowNodeWithUnistyle(jsi::Runtime& rt, const ShadowNodeFamily*, std::vector<core::Unistyle::Shared>& unistyles, Variants& variants, std::vector<std::vector<folly::dynamic>>&);
     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);

package/cxx/hybridObjects/HybridNavigationBar.cpp

@@ -1,9 +1,5 @@
 #include "HybridNavigationBar.h"
 
-void HybridNavigationBar::setBackgroundColor(double color) {
-    this->_nativePlatform.setNavigationBarBackgroundColor(color);
-};
-
 void HybridNavigationBar::setHidden(bool isHidden) {
     this->_nativePlatform.setNavigationBarHidden(isHidden);
 };

package/cxx/hybridObjects/HybridNavigationBar.h

@@ -9,7 +9,6 @@ using namespace margelo::nitro::unistyles;
 struct HybridNavigationBar: public HybridUnistylesNavigationBarSpec {
     HybridNavigationBar(Unistyles::HybridNativePlatformSpecCxx nativePlatform): HybridObject(TAG), _nativePlatform{nativePlatform} {}
 
-    void setBackgroundColor(double color) override;
     void setHidden(bool isHidden) override;
     double getWidth() override;
     double getHeight() override;

package/cxx/hybridObjects/HybridShadowRegistry.cpp

@@ -9,10 +9,14 @@ jsi::Value HybridShadowRegistry::link(jsi::Runtime &rt, const jsi::Value &thisVa
     ShadowNode::Shared shadowNodeWrapper = shadowNodeFromValue(rt, args[0]);
     std::vector<core::Unistyle::Shared> unistyleWrappers = core::unistyleFromValue(rt, args[1]);
     core::Variants variants = helpers::variantsToPairs(rt, args[2].asObject(rt));
-    std::vector<folly::dynamic> arguments = helpers::parseDynamicFunctionArguments(rt, args[3].asObject(rt).asArray(rt));
-
+    jsi::Array rawArguments = args[3].asObject(rt).asArray(rt);
+    std::vector<std::vector<folly::dynamic>> arguments;
     auto& registry = core::UnistylesRegistry::get();
-
+    
+    helpers::iterateJSIArray(rt, rawArguments, [&rt, &arguments](size_t index, jsi::Value& value){
+        arguments.push_back(helpers::parseDynamicFunctionArguments(rt, value.asObject(rt).asArray(rt)));
+    });
+    
     registry.linkShadowNodeWithUnistyle(rt, &shadowNodeWrapper->getFamily(), unistyleWrappers, variants, arguments);
 
     return jsi::Value::undefined();

package/cxx/hybridObjects/HybridStatusBar.cpp

@@ -1,9 +1,5 @@
 #include "HybridStatusBar.h"
 
-void HybridStatusBar::setBackgroundColor(double color) {
-    this->_nativePlatform.setStatusBarBackgroundColor(color);
-}
-
 double HybridStatusBar::getWidth() {
     return this->_nativePlatform.getStatusBarDimensions().width;
 }

package/cxx/hybridObjects/HybridStatusBar.h

@@ -9,7 +9,6 @@ using namespace margelo::nitro::unistyles;
 struct HybridStatusBar: public HybridUnistylesStatusBarSpec {
     HybridStatusBar(Unistyles::HybridNativePlatformSpecCxx nativePlatform): HybridObject(TAG), _nativePlatform{nativePlatform} {}
 
-    void setBackgroundColor(double color) override;
     double getWidth() override;
     double getHeight() override;
     void setHidden(bool isHidden) override;

package/cxx/hybridObjects/HybridStyleSheet.cpp

@@ -237,76 +237,107 @@ void HybridStyleSheet::registerHooks(jsi::Runtime& rt) {
     this->_unistylesMountHook = std::make_shared<core::UnistylesMountHook>(this->_uiManager, this->_unistylesRuntime);
 }
 
-void HybridStyleSheet::onPlatformDependenciesChange(std::vector<UnistyleDependency> unistylesDependencies) {
-    if (this->_unistylesRuntime == nullptr) {
+void HybridStyleSheet::onPlatformDependenciesChange(std::vector<UnistyleDependency> dependencies) {
+    // this event listener is triggered from C++ module, and it's only about theme / adaptive theme changes
+    if (dependencies.size() == 0) {
+        return;
+    }
+
+    auto& registry = core::UnistylesRegistry::get();
+    auto& rt = this->_unistylesRuntime->getRuntime();
+    auto parser = parser::Parser(this->_unistylesRuntime);
+    auto dependencyMap = registry.buildDependencyMap(rt, dependencies);
+
+    if (dependencyMap.empty()) {
+        this->notifyJSListeners(dependencies);
+
         return;
     }
 
-    this->_unistylesRuntime->runOnJSThread([this, unistylesDependencies](jsi::Runtime& rt){
+    // 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, dependencies);
+
+    parser.rebuildUnistylesInDependencyMap(rt, dependencyMap, dependentStyleSheets, std::nullopt);
+    parser.rebuildShadowLeafUpdates(rt, dependencyMap);
+
+    this->notifyJSListeners(dependencies);
+    shadow::ShadowTreeManager::updateShadowTree(UIManagerBinding::getBinding(rt)->getUIManager().getShadowTreeRegistry());
+}
+
+void HybridStyleSheet::onPlatformNativeDependenciesChange(std::vector<UnistyleDependency> dependencies, UnistylesNativeMiniRuntime miniRuntime) {
+    // this event listener is triggered from Native platform
+    if (dependencies.size() == 0 || this->_unistylesRuntime == nullptr) {
+        return;
+    }
+
+    this->_unistylesRuntime->runOnJSThread([this, dependencies, miniRuntime](jsi::Runtime& rt){
         auto& registry = core::UnistylesRegistry::get();
         auto parser = parser::Parser(this->_unistylesRuntime);
-        auto dependencies = std::move(unistylesDependencies);
+        auto unistyleDependencies = std::move(dependencies);
 
         // re-compute new breakpoint
-        auto dimensionsIt = std::find(unistylesDependencies.begin(), unistylesDependencies.end(), UnistyleDependency::DIMENSIONS);
+        auto dimensionsIt = std::find(dependencies.begin(), dependencies.end(), UnistyleDependency::DIMENSIONS);
 
-        if (dimensionsIt != unistylesDependencies.end()) {
+        if (dimensionsIt != dependencies.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(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, unistylesDependencies.size() > 1);
+        auto colorSchemeIt = std::find(dependencies.begin(), dependencies.end(), UnistyleDependency::COLORSCHEME);
+        auto hasNewColorScheme = colorSchemeIt != dependencies.end();
 
         if (hasNewColorScheme) {
-            this->_unistylesRuntime->includeDependenciesForColorSchemeChange(dependencies);
+            this->_unistylesRuntime->includeDependenciesForColorSchemeChange(unistyleDependencies);
         }
 
-        auto dependencyMap = registry.buildDependencyMap(rt, dependencies);
+        auto dependencyMap = registry.buildDependencyMap(rt, unistyleDependencies);
 
         if (dependencyMap.empty()) {
-            this->notifyJSListeners(dependencies);
+            this->notifyJSListeners(unistyleDependencies);
 
             return;
         }
 
-        parser.rebuildUnistylesInDependencyMap(rt, dependencyMap, dependentStyleSheets);
+        // 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, unistyleDependencies);
+
+        parser.rebuildUnistylesInDependencyMap(rt, dependencyMap, dependentStyleSheets, miniRuntime);
         parser.rebuildShadowLeafUpdates(rt, dependencyMap);
 
-        this->notifyJSListeners(dependencies);
+        this->notifyJSListeners(unistyleDependencies);
         shadow::ShadowTreeManager::updateShadowTree(UIManagerBinding::getBinding(rt)->getUIManager().getShadowTreeRegistry());
     });
 }
 
-void HybridStyleSheet::onImeChange() {
+void HybridStyleSheet::onImeChange(UnistylesNativeMiniRuntime miniRuntime) {
     if (this->_unistylesRuntime == nullptr) {
         return;
     }
 
-    this->_unistylesRuntime->runOnJSThread([this](jsi::Runtime& rt){
+    this->_unistylesRuntime->runOnJSThread([this, miniRuntime](jsi::Runtime& rt){
+        std::vector<UnistyleDependency> dependencies{UnistyleDependency::IME};
         auto& registry = core::UnistylesRegistry::get();
         auto parser = parser::Parser(this->_unistylesRuntime);
-
-        std::vector<UnistyleDependency> dependencies{UnistyleDependency::IME};
-
-        this->notifyJSListeners(dependencies);
-
         auto dependencyMap = registry.buildDependencyMap(rt, dependencies);
 
         if (dependencyMap.empty()) {
+            this->notifyJSListeners(dependencies);
+
             return;
         }
-        
-        std::vector<std::shared_ptr<core::StyleSheet>> styleSheet;
 
-        parser.rebuildUnistylesInDependencyMap(rt, dependencyMap, styleSheet);
+        // we don't care about other unmounted stylesheets as their not visible
+        // so user won't see any changes
+        std::vector<std::shared_ptr<core::StyleSheet>> dependentStyleSheets;
+
+        parser.rebuildUnistylesInDependencyMap(rt, dependencyMap, dependentStyleSheets, miniRuntime);
         parser.rebuildShadowLeafUpdates(rt, dependencyMap);
 
+        this->notifyJSListeners(dependencies);
         shadow::ShadowTreeManager::updateShadowTree(UIManagerBinding::getBinding(rt)->getUIManager().getShadowTreeRegistry());
     });
 }

package/cxx/hybridObjects/HybridStyleSheet.h

@@ -21,13 +21,16 @@ struct HybridStyleSheet: public HybridUnistylesStyleSheetSpec {
             this->_unistylesRuntime->registerPlatformListener(
                   std::bind(&HybridStyleSheet::onPlatformDependenciesChange, this, std::placeholders::_1)
             );
+            this->_unistylesRuntime->registerNativePlatformListener(
+                  std::bind(&HybridStyleSheet::onPlatformNativeDependenciesChange, this, std::placeholders::_1, std::placeholders::_2)
+            );
             this->_unistylesRuntime->registerImeListener(
-                  std::bind(&HybridStyleSheet::onImeChange, this)
+                  std::bind(&HybridStyleSheet::onImeChange, this, std::placeholders::_1)
             );
       }
 
     ~HybridStyleSheet() {
-        this->_unistylesRuntime->unregisterPlatformListeners();
+        this->_unistylesRuntime->unregisterNativePlatformListeners();
     }
 
     jsi::Value create(jsi::Runtime& rt,
@@ -66,7 +69,8 @@ private:
     void loadExternalMethods(const jsi::Value& thisValue, jsi::Runtime& rt);
     void registerHooks(jsi::Runtime& rt);
     void onPlatformDependenciesChange(std::vector<UnistyleDependency> dependencies);
-    void onImeChange();
+    void onPlatformNativeDependenciesChange(std::vector<UnistyleDependency> dependencies, UnistylesNativeMiniRuntime miniRuntime);
+    void onImeChange(UnistylesNativeMiniRuntime miniRuntime);
     void notifyJSListeners(std::vector<UnistyleDependency>& dependencies);
 
     double __unid = -1;