react-native-unistyles 3.0.0-beta.8 → 3.0.0-experimental-2025051401

package/cxx/parser/Parser.cpp

@@ -213,113 +213,115 @@ void parser::Parser::rebuildUnistyleWithVariants(jsi::Runtime& rt, std::shared_p
 }
 
 // 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, std::optional<UnistylesNativeMiniRuntime> maybeMiniRuntime) {
-    std::unordered_map<std::shared_ptr<StyleSheet>, jsi::Value> parsedStyleSheetsWithDefaultTheme{};
-    std::unordered_map<std::string, std::unordered_map<std::shared_ptr<StyleSheet>, jsi::Value>> parsedStyleSheetsWithScopedTheme{};
-    std::unordered_map<std::shared_ptr<core::Unistyle>, bool> parsedUnistyles{};
-
-    // parse all stylesheets that depends on changes
-    for (auto styleSheet : styleSheets) {
-        parsedStyleSheetsWithDefaultTheme.emplace(styleSheet, this->unwrapStyleSheet(rt, styleSheet, maybeMiniRuntime));
+void parser::Parser::rebuildUnistylesInDependencyMap(
+    jsi::Runtime& rt,
+    DependencyMap& dependencyMap,
+    std::vector<std::shared_ptr<core::StyleSheet>>& styleSheets,
+    std::optional<UnistylesNativeMiniRuntime> maybeMiniRuntime
+) {
+    std::unordered_map<std::shared_ptr<StyleSheet>, jsi::Value> parsedStyleSheetsWithDefaultTheme;
+    std::unordered_map<std::string, std::unordered_map<std::shared_ptr<StyleSheet>, jsi::Value>> parsedStyleSheetsWithScopedTheme;
+    std::unordered_set<std::shared_ptr<core::Unistyle>> parsedUnistyles;
+
+    // Parse all stylesheets that depend on changes
+    for (const auto& styleSheet : styleSheets) {
+        parsedStyleSheetsWithDefaultTheme.emplace(
+            styleSheet,
+            this->unwrapStyleSheet(rt, styleSheet, maybeMiniRuntime)
+        );
     }
 
-    // then parse all visible Unistyles managed by Unistyle
+    // Parse all visible Unistyles managed by Unistyle
     for (auto& [shadowNode, unistyles] : dependencyMap) {
-        auto styleSheet = unistyles.begin()->get()->unistyle->parent;
+        auto styleSheet = unistyles.front()->unistyle->parent;
 
-        // stylesheet may be optional for exotic unistyles
-        if (styleSheet != nullptr && !parsedStyleSheetsWithDefaultTheme.contains(styleSheet)) {
-            parsedStyleSheetsWithDefaultTheme.emplace(styleSheet, this->unwrapStyleSheet(rt, styleSheet, maybeMiniRuntime));
+        // Stylesheet may be optional for exotic unistyles
+        if (styleSheet && !parsedStyleSheetsWithDefaultTheme.contains(styleSheet)) {
+            parsedStyleSheetsWithDefaultTheme.emplace(
+                styleSheet,
+                this->unwrapStyleSheet(rt, styleSheet, maybeMiniRuntime)
+            );
         }
 
         for (auto& unistyleData : unistyles) {
             auto& unistyle = unistyleData->unistyle;
 
-            // for RN styles or inline styles, compute styles only once
+            // For RN styles or inline styles, compute styles only once
             if (unistyle->styleKey == helpers::EXOTIC_STYLE_KEY) {
                 if (!unistyleData->parsedStyle.has_value()) {
                     unistyleData->parsedStyle = jsi::Value(rt, unistyle->rawValue).asObject(rt);
-
-                    if (!parsedUnistyles.contains(unistyle)) {
-                        parsedUnistyles.emplace(unistyle, true);
-                    }
+                    parsedUnistyles.insert(unistyle);
                 }
-
+                
                 continue;
             }
 
-            // reference Unistyles StyleSheet as we may mix them for one style
+            // Reference Unistyles StyleSheet as we may mix them for one style
             auto unistyleStyleSheet = unistyle->parent;
 
-            // we may hit now other StyleSheets that are referenced from affected nodes
-            if (unistyleStyleSheet != nullptr && !parsedStyleSheetsWithDefaultTheme.contains(unistyleStyleSheet)) {
-                parsedStyleSheetsWithDefaultTheme.emplace(unistyleStyleSheet, this->unwrapStyleSheet(rt, unistyleStyleSheet, maybeMiniRuntime));
+            // We may hit now other StyleSheets that are referenced from affected nodes
+            if (unistyleStyleSheet && !parsedStyleSheetsWithDefaultTheme.contains(unistyleStyleSheet)) {
+                parsedStyleSheetsWithDefaultTheme.emplace(
+                    unistyleStyleSheet,
+                    this->unwrapStyleSheet(rt, unistyleStyleSheet, maybeMiniRuntime)
+                );
             }
 
             // StyleSheet might have styles that are not affected
-            if (!parsedStyleSheetsWithDefaultTheme[unistyleStyleSheet].asObject(rt).hasProperty(rt, unistyle->styleKey.c_str())) {
+            auto& parsedSheetValue = parsedStyleSheetsWithDefaultTheme[unistyleStyleSheet];
+            auto parsedSheetObj = parsedSheetValue.asObject(rt);
+            
+            if (!parsedSheetObj.hasProperty(rt, unistyle->styleKey.c_str())) {
                 continue;
             }
 
-            // for scoped themes we need to parse unistyle exclusively
+            // For scoped themes we need to parse unistyle exclusively
             if (unistyleData->scopedTheme.has_value()) {
-                std::vector<folly::dynamic> arguments = {};
-
-                if (unistyleData->dynamicFunctionMetadata.has_value()) {
-                    arguments = unistyleData->dynamicFunctionMetadata.value();
+                auto& scopedThemeName = unistyleData->scopedTheme.value();
+                auto& scopedThemeMap = parsedStyleSheetsWithScopedTheme[scopedThemeName];
+
+                jsi::Value parsedStyleSheet = jsi::Value::undefined();
+                auto it = scopedThemeMap.find(unistyle->parent);
+                
+                if (it != scopedThemeMap.end()) {
+                    parsedStyleSheet = jsi::Value(rt, it->second);
                 }
 
-                auto parsedStyleSheet = jsi::Value::undefined();
-                auto scopedThemeName = unistyleData->scopedTheme.value();
-
-                // check if we have theme in cache
-                if (parsedStyleSheetsWithScopedTheme.contains(scopedThemeName)) {
-                    if (parsedStyleSheetsWithScopedTheme[scopedThemeName].contains(unistyle->parent)) {
-                        parsedStyleSheet = jsi::Value(rt, parsedStyleSheetsWithScopedTheme[scopedThemeName][unistyle->parent]);
-                    }
-                }
-
-                // if not, let's build it
                 if (parsedStyleSheet.isUndefined()) {
-                    parsedStyleSheet = this->getParsedStyleSheetForScopedTheme(rt, unistyle, unistyleData->scopedTheme.value());
-
-                    if (!parsedStyleSheetsWithScopedTheme.contains(scopedThemeName)) {
-                        parsedStyleSheetsWithScopedTheme.emplace(
-                            scopedThemeName,
-                            std::unordered_map<std::shared_ptr<StyleSheet>, jsi::Value>{}
-                        );
-                    }
-
-                    parsedStyleSheetsWithScopedTheme[scopedThemeName].emplace(
+                    parsedStyleSheet = this->getParsedStyleSheetForScopedTheme(rt, unistyle, scopedThemeName);
+                    scopedThemeMap.emplace(
                         unistyle->parent,
                         jsi::Value(rt, parsedStyleSheet)
                     );
                 }
 
-                this->rebuildUnistyleWithScopedTheme(
-                    rt,
-                    parsedStyleSheet,
-                    unistyleData
-                );
+                this->rebuildUnistyleWithScopedTheme(rt, parsedStyleSheet, unistyleData);
             } else {
-                unistyle->rawValue = parsedStyleSheetsWithDefaultTheme[unistyleStyleSheet].asObject(rt).getProperty(rt, unistyle->styleKey.c_str()).asObject(rt);
-                this->rebuildUnistyle(rt, unistyle, unistyleData->variants, unistyleData->dynamicFunctionMetadata);
+                unistyle->rawValue = parsedSheetObj
+                    .getProperty(rt, unistyle->styleKey.c_str())
+                    .asObject(rt);
+                this->rebuildUnistyle(
+                    rt, unistyle, unistyleData->variants,
+                    unistyleData->dynamicFunctionMetadata
+                );
                 unistyleData->parsedStyle = jsi::Value(rt, unistyle->parsedStyle.value()).asObject(rt);
                 unistyle->isDirty = true;
             }
 
-            if (!parsedUnistyles.contains(unistyle)) {
-                parsedUnistyles.emplace(unistyle, true);
-            }
+            parsedUnistyles.insert(unistyle);
         }
     }
 
-    // parse whatever left in StyleSheets to be later accessible
-    // for createUnistylesComponent
-    for (auto styleSheet : styleSheets) {
+    // Parse whatever left in StyleSheets to be later accessible
+    for (const auto& styleSheet : styleSheets) {
+        auto& parsedSheetValue = parsedStyleSheetsWithDefaultTheme[styleSheet];
+        auto parsedSheetObj = parsedSheetValue.asObject(rt);
+        
         for (auto& [_, unistyle] : styleSheet->unistyles) {
             if (!parsedUnistyles.contains(unistyle)) {
-                unistyle->rawValue = parsedStyleSheetsWithDefaultTheme[styleSheet].asObject(rt).getProperty(rt, unistyle->styleKey.c_str()).asObject(rt);
+                unistyle->rawValue = parsedSheetObj
+                    .getProperty(rt, unistyle->styleKey.c_str())
+                    .asObject(rt);
                 unistyle->isDirty = true;
             }
         }
@@ -370,20 +372,25 @@ void parser::Parser::rebuildUnistyle(jsi::Runtime& rt, Unistyle::Shared unistyle
 
 // convert dependency map to shadow tree updates
 void parser::Parser::rebuildShadowLeafUpdates(jsi::Runtime& rt, core::DependencyMap& dependencyMap) {
-    shadow::ShadowLeafUpdates updates;
     auto& registry = core::UnistylesRegistry::get();
 
-    for (const auto& [shadowNode, unistyles] : dependencyMap) {
-        // this step is required to parse string colors eg. #000000 to int representation
-        auto rawProps = this->parseStylesToShadowTreeStyles(rt, unistyles);
+    registry.trafficController.withLock([this, &rt, &dependencyMap, &registry]() {
+        shadow::ShadowLeafUpdates updates;
+        updates.reserve(dependencyMap.size());
 
-        updates.emplace(shadowNode, std::move(rawProps));
-    }
+        for (const auto& [shadowNode, unistyles] : dependencyMap) {
+            // Parse string colors (e.g., "#000000") to int representation
+            auto rawProps = this->parseStylesToShadowTreeStyles(rt, unistyles);
+
+            updates.emplace(shadowNode, std::move(rawProps));
+        }
 
-    registry.trafficController.setUpdates(updates);
-    registry.trafficController.resumeUnistylesTraffic();
+        registry.trafficController.setUpdates(updates);
+        registry.trafficController.resumeUnistylesTraffic();
+    });
 }
 
+
 // first level of StyleSheet, we can expect here different properties than on second level
 // eg. variants, compoundVariants, mq, breakpoints etc.
 jsi::Object parser::Parser::parseFirstLevel(jsi::Runtime& rt, Unistyle::Shared unistyle, std::optional<Variants> variants) {
@@ -925,69 +932,108 @@ jsi::Value parser::Parser::parseSecondLevel(jsi::Runtime &rt, Unistyle::Shared u
 
 // convert unistyles to folly with int colors
 folly::dynamic parser::Parser::parseStylesToShadowTreeStyles(jsi::Runtime& rt, const std::vector<std::shared_ptr<UnistyleData>>& unistyles) {
-    jsi::Object convertedStyles = jsi::Object(rt);
+    jsi::Object convertedStyles(rt);
     auto& state = core::UnistylesRegistry::get().getState(rt);
 
     for (const auto& unistyleData : unistyles) {
-        // this can happen for exotic stylesheets
         if (!unistyleData->parsedStyle.has_value()) {
             continue;
         }
 
-        helpers::enumerateJSIObject(rt, unistyleData->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)));
-            }
-
-            if (!propertyValue.isObject()) {
-                return convertedStyles.setProperty(rt, propertyName.c_str(), propertyValue);
-            }
-
-            auto objValue = propertyValue.asObject(rt);
-
-            if (!objValue.isArray(rt)) {
-                return convertedStyles.setProperty(rt, propertyName.c_str(), propertyValue);
-            }
-
-            // parse nested arrays like boxShadow
-            auto arrValue = objValue.asArray(rt);
-            auto parsedArray = jsi::Array(rt, arrValue.length(rt));
-
-            helpers::iterateJSIArray(rt, arrValue, [&](size_t i, jsi::Value& nestedValue){
-                if (nestedValue.isObject()) {
-                    jsi::Object obj = jsi::Object(rt);
-
-                    helpers::enumerateJSIObject(rt, nestedValue.asObject(rt), [&](const std::string& propertyName, jsi::Value& propertyValue){
-                        if (this->isColor(propertyName)) {
-                            obj.setProperty(rt, propertyName.c_str(), state.parseColor(propertyValue));
-
-                            return;
-                        }
-
-                        obj.setProperty(rt, propertyName.c_str(), propertyValue);
-                    });
-
-                    parsedArray.setValueAtIndex(rt, i, std::move(obj));
+        helpers::enumerateJSIObject(
+            rt,
+            unistyleData->parsedStyle.value(),
+            [this, &rt, &state, &convertedStyles](const std::string& propertyName, jsi::Value& propertyValue) {
+                if (this->isColor(propertyName)) {
+                    convertedStyles.setProperty(
+                        rt,
+                        propertyName.c_str(),
+                        jsi::Value(state.parseColor(propertyValue))
+                    );
+                    
+                    return;
+                }
 
+                if (!propertyValue.isObject()) {
+                    convertedStyles.setProperty(
+                        rt,
+                        propertyName.c_str(),
+                        propertyValue
+                    );
+                    
                     return;
                 }
 
-                if (this->isColor(propertyName)) {
-                    parsedArray.setValueAtIndex(rt, i, jsi::Value(state.parseColor(nestedValue)));
+                jsi::Object objValue = propertyValue.asObject(rt);
 
+                if (!objValue.isArray(rt)) {
+                    convertedStyles.setProperty(
+                        rt,
+                        propertyName.c_str(),
+                        propertyValue
+                    );
+                    
                     return;
                 }
 
-                parsedArray.setValueAtIndex(rt, i, nestedValue);
-            });
+                // parse nested arrays like boxShadow
+                jsi::Array arrValue = objValue.asArray(rt);
+                size_t arrLen = arrValue.length(rt);
+                jsi::Array parsedArray(rt, arrLen);
 
-            return convertedStyles.setProperty(rt, propertyName.c_str(), parsedArray);
-        });
+                helpers::iterateJSIArray(
+                    rt,
+                    arrValue,
+                    [this, &rt, &state, &propertyName, &parsedArray](size_t i, jsi::Value& nestedValue) {
+                        if (nestedValue.isObject()) {
+                            jsi::Object obj(rt);
+
+                            helpers::enumerateJSIObject(
+                                rt,
+                                nestedValue.asObject(rt),
+                                [this, &rt, &state, &obj](const std::string& nestedPropName, jsi::Value& nestedPropValue) {
+                                    if (this->isColor(nestedPropName)) {
+                                        obj.setProperty(
+                                            rt,
+                                            nestedPropName.c_str(),
+                                            state.parseColor(nestedPropValue)
+                                        );
+                                    } else {
+                                        obj.setProperty(
+                                            rt,
+                                            nestedPropName.c_str(),
+                                            nestedPropValue
+                                        );
+                                    }
+                                }
+                            );
+
+                            parsedArray.setValueAtIndex(rt, i, obj);
+                            
+                            return;
+                        }
+
+                        if (this->isColor(propertyName)) {
+                            parsedArray.setValueAtIndex(
+                                rt,
+                                i,
+                                jsi::Value(state.parseColor(nestedValue))
+                            );
+                        } else {
+                            parsedArray.setValueAtIndex(rt, i, nestedValue);
+                        }
+                    }
+                );
+
+                convertedStyles.setProperty(rt, propertyName.c_str(), parsedArray);
+            }
+        );
     }
 
-    return jsi::dynamicFromValue(rt, std::move(convertedStyles));
+    return jsi::dynamicFromValue(rt, jsi::Value(rt, convertedStyles));
 }
 
+
 // check is styleKey contains color
 bool parser::Parser::isColor(const std::string& propertyName) {
     std::string str = propertyName;

package/cxx/parser/Parser.h

@@ -4,7 +4,7 @@
 #include <folly/dynamic.h>
 #include "Unistyle.h"
 #include "Dimensions.hpp"
-#include "Constants.h"
+#include "UnistylesConstants.h"
 #include "Helpers.h"
 #include "MediaQueries.h"
 #include "HybridUnistylesRuntime.h"

package/cxx/shadowTree/ShadowTrafficController.h

@@ -22,13 +22,11 @@ struct ShadowTrafficController {
 
     inline shadow::ShadowLeafUpdates& getUpdates() {
         // call it only within withLock!
- 
         return _unistylesUpdates;
     }
 
     inline void setUpdates(shadow::ShadowLeafUpdates& newUpdates) {
-        std::lock_guard<std::mutex> lock(_mutex);
-
+        // call it only within withLock!
         auto& targetUpdates = _unistylesUpdates;
 
         // this is important as overriding updates may skip some interim changes
@@ -43,7 +41,7 @@ struct ShadowTrafficController {
             targetUpdates.emplace(pair.first, std::move(pair.second));
         });
     }
-    
+
     inline void removeShadowNode(const ShadowNodeFamily* shadowNodeFamily) {
         // call it only within withLock!
         if (_unistylesUpdates.contains(shadowNodeFamily)) {
@@ -52,19 +50,19 @@ struct ShadowTrafficController {
     }
 
     inline void restore() {
-        std::lock_guard<std::mutex> lock(_mutex);
-        
+        // call it only within withLock!
+
         _unistylesUpdates = {};
         _canCommit = false;
     }
-    
+
     template <typename F>
     inline auto withLock(F&& func) {
         std::lock_guard<std::mutex> lock(_mutex);
-        
+
         return std::forward<F>(func)();
     }
-    
+
 private:
     std::atomic<bool> _canCommit = false;
     shadow::ShadowLeafUpdates _unistylesUpdates{};

package/cxx/shadowTree/ShadowTreeManager.cpp

@@ -20,20 +20,14 @@ void shadow::ShadowTreeManager::updateShadowTree(const ShadowTreeRegistry& shado
             // we could iterate via updates and create multiple commits
             // but it can cause performance issues for hundreds of nodes
             // so let's mutate Shadow Tree in single transaction
-            auto transaction = [&](const RootShadowNode& oldRootShadowNode) {
+            auto transaction = [&updates](const RootShadowNode& oldRootShadowNode) {
                 auto affectedNodes = shadow::ShadowTreeManager::findAffectedNodes(oldRootShadowNode, updates);
-                auto newRootNode = std::static_pointer_cast<RootShadowNode>(shadow::ShadowTreeManager::cloneShadowTree(
+                
+                return  std::static_pointer_cast<RootShadowNode>(shadow::ShadowTreeManager::cloneShadowTree(
                     oldRootShadowNode,
                     updates,
                     affectedNodes
                 ));
-
-                // set unistyles trait
-                auto unistylesRootNode = std::reinterpret_pointer_cast<core::UnistylesCommitShadowNode>(newRootNode);
-
-                unistylesRootNode->addUnistylesCommitTrait();
-
-                return newRootNode;
             };
 
             // commit once!
@@ -71,18 +65,17 @@ void shadow::ShadowTreeManager::updateShadowTree(const ShadowTreeRegistry& shado
 AffectedNodes shadow::ShadowTreeManager::findAffectedNodes(const RootShadowNode& rootNode, ShadowLeafUpdates& updates) {
     AffectedNodes affectedNodes;
 
-    // compute affected nodes (sub tree)
-    std::for_each(updates.begin(), updates.end(), [&](const auto& pair) {
-        const auto& [family, _] = pair;
-        const auto familyAncestors = family->getAncestors(rootNode);
+    for (const auto& [family, _] : updates) {
+        auto familyAncestors = family->getAncestors(rootNode);
 
-        for (const auto& [parentNode, index] : std::ranges::reverse_view(familyAncestors)) {
+        for (auto it = familyAncestors.rbegin(); it != familyAncestors.rend(); ++it) {
+            const auto& [parentNode, index] = *it;
             const auto parentFamily = &parentNode.get().getFamily();
-            std::unordered_set<int>& affectedNode = affectedNodes[parentFamily];
-
-            affectedNode.insert(index);
+            auto [setIt, inserted] = affectedNodes.try_emplace(parentFamily, std::unordered_set<int>{});
+            
+            setIt->second.insert(index);
         }
-    });
+    }
 
     return affectedNodes;
 }
@@ -93,44 +86,53 @@ ShadowNode::Unshared shadow::ShadowTreeManager::cloneShadowTree(const ShadowNode
     const auto family = &shadowNode.getFamily();
     const auto rawPropsIt = updates.find(family);
     const auto childrenIt = affectedNodes.find(family);
-    auto children = shadowNode.getChildren();
 
-    // for each affected node
+    // Only copy children if we need to update them
+    std::shared_ptr<ShadowNode::ListOfShared> childrenPtr;
+    const auto& originalChildren = shadowNode.getChildren();
+
     if (childrenIt != affectedNodes.end()) {
-        // get all indexes of children and clone it recursively
+        auto children = originalChildren;
+        
         for (const auto index : childrenIt->second) {
             children[index] = cloneShadowTree(*children[index], updates, affectedNodes);
         }
+        
+        childrenPtr = std::make_shared<ShadowNode::ListOfShared>(std::move(children));
+    } else {
+        childrenPtr = std::make_shared<ShadowNode::ListOfShared>(originalChildren);
     }
 
     Props::Shared updatedProps = nullptr;
 
-    // clone props for our target shadow node and place fresh RawProps
     if (rawPropsIt != updates.end()) {
+        const auto& componentDescriptor = shadowNode.getComponentDescriptor();
+
         PropsParserContext propsParserContext{
             shadowNode.getSurfaceId(),
             *shadowNode.getContextContainer()
         };
 
-        // this is important and critical
-        // first of all Android doesn't like nullish props (they work perfectly fine on iOS)
-        // second of all Android props MUST be constructed from previous props, otherwise RawProps::~RawProps error occurs
-        // Meta wants to remove shadowNode.getProps()->rawProps, but for now it's the only viable solution
+        folly::dynamic newProps;
         #ifdef ANDROID
-            auto safeProps = rawPropsIt->second == nullptr ? folly::dynamic::object() : rawPropsIt->second;
-            auto newProps = folly::dynamic::merge(shadowNode.getProps()->rawProps, safeProps);
+            auto safeProps = rawPropsIt->second == nullptr
+                ? folly::dynamic::object()
+                : rawPropsIt->second;
+            newProps = folly::dynamic::merge(props->rawProps, safeProps);
         #else
-            auto newProps = rawPropsIt->second;
+            newProps = rawPropsIt->second;
         #endif
 
-        updatedProps = shadowNode
-            .getComponentDescriptor()
-            .cloneProps(propsParserContext, shadowNode.getProps(), RawProps(newProps));
+        updatedProps = componentDescriptor.cloneProps(
+            propsParserContext,
+            shadowNode.getProps(),
+            RawProps(newProps)
+        );
     }
 
     return shadowNode.clone({
         updatedProps ? updatedProps : ShadowNodeFragment::propsPlaceholder(),
-        std::make_shared<ShadowNode::ListOfShared>(children),
+        childrenPtr,
         shadowNode.getState()
     });
 }

package/cxx/shadowTree/ShadowTreeManager.h

@@ -5,7 +5,6 @@
 #include <react/renderer/uimanager/UIManager.h>
 #include <ranges>
 #include "ShadowLeafUpdate.h"
-#include "UnistylesCommitShadowNode.h"
 #include "UnistylesRegistry.h"
 
 namespace margelo::nitro::unistyles::shadow {

package/ios/NativePlatform+ios.swift

@@ -313,7 +313,7 @@ class NativeIOSPlatform: HybridNativePlatformSpec {
     }
 
     func setStatusBarHidden(isHidden: Bool) throws {
-        self.onWindowChange(Notification(name: NSNotification.Name("RCTWindowFrameDidChangeNotification")))
+        self.onNativePlatformChange()
     }
 
     // not implemented for iOS as there are no such APIs

package/ios/NativePlatformListener+ios.swift

@@ -1,12 +1,17 @@
 import Foundation
+import Combine
 
 extension NativeIOSPlatform {
     func setupPlatformListeners() {
-        NotificationCenter.default.publisher(for: NSNotification.Name("RCTWindowFrameDidChangeNotification"))
-            // add small delay (10ms) to make sure all values are up ot date
-            .delay(for: .milliseconds(10), scheduler: RunLoop.current)
-            .sink { [weak self] notification in
-                self?.onWindowChange(notification)
+        let windowPublisher = NotificationCenter.default.publisher(for: NSNotification.Name("RCTWindowFrameDidChangeNotification"))
+        let orientationPublisher = NotificationCenter.default.publisher(for: UIDevice.orientationDidChangeNotification)
+        let colorSchemePublisher = NotificationCenter.default.publisher(for: NSNotification.Name("RCTUserInterfaceStyleDidChangeNotification"))
+
+        Publishers
+            .MergeMany([windowPublisher, orientationPublisher, colorSchemePublisher])
+            .throttle(for: .milliseconds(25), scheduler: RunLoop.main, latest: true)
+            .sink { [weak self] _ in
+                self?.onNativePlatformChange()
             }
             .store(in: &cancellables)
     }
@@ -30,14 +35,14 @@ extension NativeIOSPlatform {
     func emitImeEvent(updatedMiniRuntime: UnistylesNativeMiniRuntime) {
         self.imeListeners.forEach { $0(updatedMiniRuntime) }
     }
-    
+
     func unregisterPlatformListeners() {
         cancellables.removeAll()
         dependencyListeners.removeAll()
         imeListeners.removeAll()
     }
 
-    @objc func onWindowChange(_ notification: Notification) {
+    @objc func onNativePlatformChange() {
         guard let currentMiniRuntime = self.miniRuntime else {
             return
         }

package/ios/UnistylesModuleOnLoad.h

@@ -6,13 +6,9 @@
 
 #import <React/RCTEventEmitter.h>
 #import "TurboUnistyles/TurboUnistyles.h"
-#import <React/RCTSurfacePresenter.h>
-#import <React/RCTScheduler.h>
-#import <React/RCTCallInvoker.h>
-#import <React/RCTCallInvokerModule.h>
 #import <ReactCommon/RCTTurboModuleWithJSIBindings.h>
 
-@interface UnistylesModule: RCTEventEmitter<NativeTurboUnistylesSpec, RCTCallInvokerModule>
+@interface UnistylesModule: RCTEventEmitter<NativeTurboUnistylesSpec>
 @end
 
 @interface UnistylesModule()<RCTTurboModuleWithJSIBindings>