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

package/cxx/parser/Parser.cpp

@@ -62,10 +62,10 @@ jsi::Value parser::Parser::getParsedStyleSheetForScopedTheme(jsi::Runtime& rt, c
         .asObject(rt);
 }
 
-void parser::Parser::rebuildUnistyleWithScopedTheme(jsi::Runtime& rt, jsi::Value& jsScopedTheme, std::shared_ptr<core::UnistyleData> unistyleData) {
-    auto parsedStyleSheet = jsScopedTheme.isUndefined()
+void parser::Parser::rebuildUnistyleWithScopedTheme(jsi::Runtime& rt, jsi::Value& scopedStyleSheet, std::shared_ptr<core::UnistyleData> unistyleData) {
+    auto parsedStyleSheet = scopedStyleSheet.isUndefined()
         ? this->getParsedStyleSheetForScopedTheme(rt, unistyleData->unistyle, unistyleData->scopedTheme.value())
-        : jsScopedTheme.asObject(rt);
+        : scopedStyleSheet.asObject(rt);
 
     if (parsedStyleSheet.isUndefined()) {
         return;
@@ -213,112 +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;
             }
         }
@@ -369,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);
 
-    registry.trafficController.setUpdates(updates);
-    registry.trafficController.resumeUnistylesTraffic();
+            updates.emplace(shadowNode, std::move(rawProps));
+        }
+
+        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) {
@@ -880,21 +888,43 @@ jsi::Value parser::Parser::parseSecondLevel(jsi::Runtime &rt, Unistyle::Shared u
 
             return;
         }
-
+        
+        auto isArray = nestedObjectStyle.isArray(rt);
+        
+        if (!isArray) {
+            parsedStyle.setProperty(rt, propertyName.c_str(), this->getValueFromBreakpoints(rt, unistyle, nestedObjectStyle));
+        }
+        
         // possible with variants and compoundVariants
-        if (nestedObjectStyle.isArray(rt) && propertyName == "transform") {
+        if (propertyName == "transform") {
             parsedStyle.setProperty(rt, propertyName.c_str(), parseTransforms(rt, unistyle, nestedObjectStyle));
 
             return;
         }
 
-        if (nestedObjectStyle.isArray(rt) && propertyName == "fontVariant") {
+        if (propertyName == "boxShadow") {
+            parsedStyle.setProperty(rt, propertyName.c_str(), parseBoxShadow(rt, unistyle, nestedObjectStyle));
+
+            return;
+        }
+
+        if (propertyName == "filter") {
+            parsedStyle.setProperty(rt, propertyName.c_str(), parseFilters(rt, unistyle, nestedObjectStyle));
+
+            return;
+        }
+
+        if (propertyName == "fontVariant") {
             parsedStyle.setProperty(rt, propertyName.c_str(), propertyValue);
 
             return;
         }
 
-        parsedStyle.setProperty(rt, propertyName.c_str(), this->getValueFromBreakpoints(rt, unistyle, nestedObjectStyle));
+        if (propertyName == "shadowOffset" || propertyName == "textShadowOffset") {
+            parsedStyle.setProperty(rt, propertyName.c_str(), this->parseSecondLevel(rt, unistyle, propertyValue));
+
+            return;
+        }
     });
 
     return parsedStyle;
@@ -902,27 +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()) {
-            return nullptr;
+            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)));
-            }
+        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;
+                }
 
-            convertedStyles.setProperty(rt, propertyName.c_str(), propertyValue);
-        });
+                if (!propertyValue.isObject()) {
+                    convertedStyles.setProperty(
+                        rt,
+                        propertyName.c_str(),
+                        propertyValue
+                    );
+                    
+                    return;
+                }
+
+                jsi::Object objValue = propertyValue.asObject(rt);
+
+                if (!objValue.isArray(rt)) {
+                    convertedStyles.setProperty(
+                        rt,
+                        propertyName.c_str(),
+                        propertyValue
+                    );
+                    
+                    return;
+                }
+
+                // parse nested arrays like boxShadow
+                jsi::Array arrValue = objValue.asArray(rt);
+                size_t arrLen = arrValue.length(rt);
+                jsi::Array parsedArray(rt, arrLen);
+
+                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

@@ -21,14 +21,12 @@ struct ShadowTrafficController {
     }
 
     inline shadow::ShadowLeafUpdates& getUpdates() {
-        std::lock_guard<std::mutex> lock(_mutex);
- 
+        // 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,22 +41,28 @@ struct ShadowTrafficController {
             targetUpdates.emplace(pair.first, std::move(pair.second));
         });
     }
-    
+
     inline void removeShadowNode(const ShadowNodeFamily* shadowNodeFamily) {
-        std::lock_guard<std::mutex> lock(_mutex);
-        
+        // call it only within withLock!
         if (_unistylesUpdates.contains(shadowNodeFamily)) {
             _unistylesUpdates.erase(shadowNodeFamily);
         }
     }
 
     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

@@ -8,43 +8,40 @@ using AffectedNodes = std::unordered_map<const ShadowNodeFamily*, std::unordered
 
 void shadow::ShadowTreeManager::updateShadowTree(const ShadowTreeRegistry& shadowTreeRegistry) {
     auto& registry = core::UnistylesRegistry::get();
-    auto updates = registry.trafficController.getUpdates();
-
-    if (updates.empty()) {
-        return;
-    }
-
-    shadowTreeRegistry.enumerate([&updates](const ShadowTree& shadowTree, bool& stop){
-        // 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 affectedNodes = shadow::ShadowTreeManager::findAffectedNodes(oldRootShadowNode, updates);
-            auto newRootNode = 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!
-        // CommitOptions:
-        // enableStateReconciliation: https://reactnative.dev/architecture/render-pipeline#react-native-renderer-state-updates
-        // mountSynchronously: must be true as this is update from C++ not React
-        shadowTree.commit(transaction, {false, true});
+    
+    registry.trafficController.withLock([&](){
+        auto updates = registry.trafficController.getUpdates();
 
+        if (updates.empty()) {
+            return;
+        }
 
-        // for now we're assuming single surface, can be improved in the future
-        // stop = true means stop enumerating next shadow tree
-        // so in other words first shadow tree is our desired tree
-        stop = true;
+        shadowTreeRegistry.enumerate([&updates](const ShadowTree& shadowTree, bool& stop){
+            // 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 = [&updates](const RootShadowNode& oldRootShadowNode) {
+                auto affectedNodes = shadow::ShadowTreeManager::findAffectedNodes(oldRootShadowNode, updates);
+                
+                return  std::static_pointer_cast<RootShadowNode>(shadow::ShadowTreeManager::cloneShadowTree(
+                    oldRootShadowNode,
+                    updates,
+                    affectedNodes
+                ));
+            };
+
+            // commit once!
+            // CommitOptions:
+            // enableStateReconciliation: https://reactnative.dev/architecture/render-pipeline#react-native-renderer-state-updates
+            // mountSynchronously: must be true as this is update from C++ not React
+            shadowTree.commit(transaction, {false, true});
+
+
+            // for now we're assuming single surface, can be improved in the future
+            // stop = true means stop enumerating next shadow tree
+            // so in other words first shadow tree is our desired tree
+            stop = true;
+        });
     });
 }
 
@@ -68,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;
 }
@@ -90,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