react-native-unistyles 3.0.0-rc.3 → 3.0.0-rc.5

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.find(styleSheet) == parsedStyleSheetsWithDefaultTheme.end()) {
+            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.find(unistyleStyleSheet) == parsedStyleSheetsWithDefaultTheme.end()) {
+                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];
 
-                auto parsedStyleSheet = jsi::Value::undefined();
-                auto scopedThemeName = unistyleData->scopedTheme.value();
+                jsi::Value parsedStyleSheet = jsi::Value::undefined();
+                auto it = scopedThemeMap.find(unistyle->parent);
 
-                // 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 (it != scopedThemeMap.end()) {
+                    parsedStyleSheet = jsi::Value(rt, it->second);
                 }
 
-                // 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;
             }
         }
@@ -372,11 +374,12 @@ void parser::Parser::rebuildUnistyle(jsi::Runtime& rt, Unistyle::Shared unistyle
 void parser::Parser::rebuildShadowLeafUpdates(jsi::Runtime& rt, core::DependencyMap& dependencyMap) {
     auto& registry = core::UnistylesRegistry::get();
 
-    registry.trafficController.withLock([this, &rt, &dependencyMap, &registry](){
+    registry.trafficController.withLock([this, &rt, &dependencyMap, &registry]() {
         shadow::ShadowLeafUpdates updates;
-        
+        updates.reserve(dependencyMap.size());
+
         for (const auto& [shadowNode, unistyles] : dependencyMap) {
-            // this step is required to parse string colors eg. #000000 to int representation
+            // Parse string colors (e.g., "#000000") to int representation
             auto rawProps = this->parseStylesToShadowTreeStyles(rt, unistyles);
 
             updates.emplace(shadowNode, std::move(rawProps));
@@ -387,6 +390,7 @@ void parser::Parser::rebuildShadowLeafUpdates(jsi::Runtime& rt, core::Dependency
     });
 }
 
+
 // 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) {
@@ -420,6 +424,13 @@ jsi::Object parser::Parser::parseFirstLevel(jsi::Runtime& rt, Unistyle::Shared u
             return;
         }
 
+        // special case as we need to convert it to jsi::Array<jsi::Object>
+        if (propertyName == "boxShadow" && propertyValue.isString()) {
+            parsedStyle.setProperty(rt, jsi::PropNameID::forUtf8(rt, propertyName), parseBoxShadowString(rt, propertyValue.asString(rt).utf8(rt)));
+
+            return;
+        }
+
         // primitives
         if (propertyValue.isNumber() || propertyValue.isString() || propertyValue.isUndefined() || propertyValue.isNull()) {
             parsedStyle.setProperty(rt, jsi::PropNameID::forUtf8(rt, propertyName), propertyValue);
@@ -592,7 +603,7 @@ jsi::Value parser::Parser::parseTransforms(jsi::Runtime& rt, Unistyle::Shared un
 jsi::Value parser::Parser::parseBoxShadow(jsi::Runtime &rt, Unistyle::Shared unistyle, jsi::Object &obj) {
     std::vector<jsi::Value> parsedBoxShadows{};
 
-    parsedBoxShadows.reserve(2);
+    parsedBoxShadows.reserve(1);
 
     helpers::iterateJSIArray(rt, obj.asArray(rt), [&](size_t i, jsi::Value& value){
         if (!value.isObject()) {
@@ -614,6 +625,13 @@ jsi::Value parser::Parser::parseBoxShadow(jsi::Runtime &rt, Unistyle::Shared uni
     return result;
 }
 
+jsi::Array parser::Parser::parseBoxShadowString(jsi::Runtime& rt, std::string&& boxShadowString) {
+    auto& registry = core::UnistylesRegistry::get();
+    auto& state = registry.getState(rt);
+
+    return state.parseBoxShadowString(std::move(boxShadowString));
+}
+
 // eg. [{ brightness: 0.5 }, { opacity: 0.25 }]
 jsi::Value parser::Parser::parseFilters(jsi::Runtime &rt, Unistyle::Shared unistyle, jsi::Object &obj) {
     std::vector<jsi::Value> parsedFilters{};
@@ -863,8 +881,16 @@ jsi::Value parser::Parser::parseSecondLevel(jsi::Runtime &rt, Unistyle::Shared u
     jsi::Object parsedStyle = jsi::Object(rt);
 
     helpers::enumerateJSIObject(rt, nestedObjectStyle, [&](const std::string& propertyName, jsi::Value& propertyValue){
-        // primitives
-        if (propertyValue.isString() || propertyValue.isNumber() || propertyValue.isUndefined() || propertyValue.isNull()) {
+        // special case as we need to convert it to jsi::Array<jsi::Object>
+        // possible with variants and compoundVariants
+        if (propertyName == "boxShadow" && propertyValue.isString()) {
+            parsedStyle.setProperty(rt, jsi::PropNameID::forUtf8(rt, propertyName), parseBoxShadowString(rt, propertyValue.asString(rt).utf8(rt)));
+
+            return;
+        }
+
+        // primitives, bool is possible for boxShadow inset
+        if (propertyValue.isString() || propertyValue.isNumber() || propertyValue.isUndefined() || propertyValue.isNull() || propertyValue.isBool()) {
             parsedStyle.setProperty(rt, propertyName.c_str(), propertyValue);
 
             return;
@@ -884,13 +910,13 @@ 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 (propertyName == "transform") {
             parsedStyle.setProperty(rt, propertyName.c_str(), parseTransforms(rt, unistyle, nestedObjectStyle));
@@ -928,69 +954,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::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))
+                    );
 
-            helpers::iterateJSIArray(rt, arrValue, [&](size_t i, jsi::Value& nestedValue){
-                if (nestedValue.isObject()) {
-                    jsi::Object obj = jsi::Object(rt);
+                    return;
+                }
 
-                    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));
+                if (!propertyValue.isObject()) {
+                    convertedStyles.setProperty(
+                        rt,
+                        propertyName.c_str(),
+                        propertyValue
+                    );
 
-                            return;
-                        }
+                    return;
+                }
 
-                        obj.setProperty(rt, propertyName.c_str(), propertyValue);
-                    });
+                jsi::Object objValue = propertyValue.asObject(rt);
 
-                    parsedArray.setValueAtIndex(rt, i, std::move(obj));
+                if (!objValue.isArray(rt)) {
+                    convertedStyles.setProperty(
+                        rt,
+                        propertyName.c_str(),
+                        propertyValue
+                    );
 
                     return;
                 }
 
-                if (this->isColor(propertyName)) {
-                    parsedArray.setValueAtIndex(rt, i, jsi::Value(state.parseColor(nestedValue)));
+                // parse nested arrays like boxShadow
+                jsi::Array arrValue = objValue.asArray(rt);
+                size_t arrLen = arrValue.length(rt);
+                jsi::Array parsedArray(rt, arrLen);
 
-                    return;
-                }
+                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;
+                        }
 
-                parsedArray.setValueAtIndex(rt, i, nestedValue);
-            });
+                        if (this->isColor(propertyName)) {
+                            parsedArray.setValueAtIndex(
+                                rt,
+                                i,
+                                jsi::Value(state.parseColor(nestedValue))
+                            );
+                        } else {
+                            parsedArray.setValueAtIndex(rt, i, nestedValue);
+                        }
+                    }
+                );
 
-            return convertedStyles.setProperty(rt, propertyName.c_str(), parsedArray);
-        });
+                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

@@ -40,6 +40,7 @@ private:
     std::vector<UnistyleDependency> parseDependencies(jsi::Runtime &rt, jsi::Object&& dependencies);
     jsi::Value parseTransforms(jsi::Runtime& rt, Unistyle::Shared unistyle, jsi::Object& obj);
     jsi::Value parseBoxShadow(jsi::Runtime& rt, Unistyle::Shared unistyle, jsi::Object& obj);
+    jsi::Array parseBoxShadowString(jsi::Runtime& rt, std::string&& boxShadowString);
     jsi::Value parseFilters(jsi::Runtime& rt, Unistyle::Shared unistyle, jsi::Object& obj);
     jsi::Value getValueFromBreakpoints(jsi::Runtime& rt, Unistyle::Shared unistyle, jsi::Object& obj);
     jsi::Object parseVariants(jsi::Runtime& rt, Unistyle::Shared unistyle, jsi::Object& obj, Variants& variants);

package/cxx/shadowTree/ShadowTreeManager.cpp

@@ -8,7 +8,7 @@ using AffectedNodes = std::unordered_map<const ShadowNodeFamily*, std::unordered
 
 void shadow::ShadowTreeManager::updateShadowTree(const ShadowTreeRegistry& shadowTreeRegistry) {
     auto& registry = core::UnistylesRegistry::get();
-    
+
     registry.trafficController.withLock([&](){
         auto updates = registry.trafficController.getUpdates();
 
@@ -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];
+            auto [setIt, inserted] = affectedNodes.try_emplace(parentFamily, std::unordered_set<int>{});
 
-            affectedNode.insert(index);
+            setIt->second.insert(index);
         }
-    });
+    }
 
     return affectedNodes;
 }
@@ -93,44 +86,54 @@ 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();
+        const auto& props = shadowNode.getProps();
+
         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,
+            props,
+            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/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>

package/ios/UnistylesModuleOnLoad.mm

@@ -10,18 +10,11 @@ using namespace margelo::nitro;
 
 RCT_EXPORT_MODULE(Unistyles)
 
-__weak RCTSurfacePresenter* _surfacePresenter;
-@synthesize callInvoker = _callInvoker;
-
 + (BOOL)requiresMainQueueSetup {
     return YES;
 }
 
-- (void)setSurfacePresenter:(id<RCTSurfacePresenterStub>)surfacePresenter {
-    _surfacePresenter = surfacePresenter;
-}
-
-- (void)installJSIBindingsWithRuntime:(jsi::Runtime&)rt {
+- (void)installJSIBindingsWithRuntime:(jsi::Runtime&)rt callInvoker:(const std::shared_ptr<facebook::react::CallInvoker> &)callInvoker {
     // function is called on: first init and every live reload
     // check if this is live reload, if so let's replace UnistylesRuntime with new runtime
     auto hasUnistylesRuntime = HybridObjectRegistry::hasHybridObject("UnistylesRuntime");
@@ -32,18 +25,17 @@ __weak RCTSurfacePresenter* _surfacePresenter;
         HybridObjectRegistry::unregisterHybridObjectConstructor("UnistylesShadowRegistry");
     }
 
-    [self createHybrids:rt];
+    [self createHybrids:rt callInvoker:callInvoker];
 }
 
-- (void)createHybrids:(jsi::Runtime&)rt {
-    auto runOnJSThread = [callInvoker = _callInvoker.callInvoker](std::function<void(jsi::Runtime& rt)> &&callback){
+- (void)createHybrids:(jsi::Runtime&)rt callInvoker:(const std::shared_ptr<facebook::react::CallInvoker> &)callInvoker {
+    auto runOnJSThread = [callInvoker](std::function<void(jsi::Runtime& rt)> &&callback){
         callInvoker->invokeAsync(std::move(callback));
     };
 
     auto nativePlatform = Unistyles::NativePlatform::create().getCxxPart();
     auto unistylesRuntime = std::make_shared<HybridUnistylesRuntime>(nativePlatform, rt, runOnJSThread);
-    auto uiManager = [_surfacePresenter scheduler].uiManager;
-    auto styleSheet = std::make_shared<HybridStyleSheet>(unistylesRuntime, uiManager);
+    auto styleSheet = std::make_shared<HybridStyleSheet>(unistylesRuntime);
 
     HybridObjectRegistry::registerHybridObjectConstructor("UnistylesRuntime", [unistylesRuntime]() -> std::shared_ptr<HybridObject>{
         return unistylesRuntime;