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

package/cxx/core/UnistylesRegistry.cpp

@@ -73,17 +73,19 @@ void core::UnistylesRegistry::linkShadowNodeWithUnistyle(
     const ShadowNodeFamily* shadowNodeFamily,
     std::vector<std::shared_ptr<UnistyleData>>& unistylesData
 ) {
-    shadow::ShadowLeafUpdates updates;
-    auto parser = parser::Parser(nullptr);
-
-    std::for_each(unistylesData.begin(), unistylesData.end(), [this, &rt, shadowNodeFamily](std::shared_ptr<UnistyleData> unistyleData){
-        this->_shadowRegistry[&rt][shadowNodeFamily].emplace_back(unistyleData);
-    });
+    this->trafficController.withLock([this, &rt, &unistylesData, shadowNodeFamily](){
+        shadow::ShadowLeafUpdates updates;
+        auto parser = parser::Parser(nullptr);
 
-    updates[shadowNodeFamily] = parser.parseStylesToShadowTreeStyles(rt, unistylesData);
+        std::for_each(unistylesData.begin(), unistylesData.end(), [this, &rt, shadowNodeFamily](std::shared_ptr<UnistyleData> unistyleData){
+            this->_shadowRegistry[&rt][shadowNodeFamily].emplace_back(unistyleData);
+        });
 
-    this->trafficController.setUpdates(updates);
-    this->trafficController.resumeUnistylesTraffic();
+        updates[shadowNodeFamily] = parser.parseStylesToShadowTreeStyles(rt, unistylesData);
+        
+        this->trafficController.setUpdates(updates);
+        this->trafficController.resumeUnistylesTraffic();
+    });
 }
 
 void core::UnistylesRegistry::removeDuplicatedUnistyles(jsi::Runtime& rt, const ShadowNodeFamily *shadowNodeFamily, std::vector<core::Unistyle::Shared>& unistyles) {
@@ -111,7 +113,7 @@ void core::UnistylesRegistry::unlinkShadowNodeWithUnistyles(jsi::Runtime& rt, co
     this->trafficController.withLock([this, &rt, shadowNodeFamily](){
         this->_shadowRegistry[&rt].erase(shadowNodeFamily);
         this->trafficController.removeShadowNode(shadowNodeFamily);
-        
+
         if (this->_shadowRegistry[&rt].empty()) {
             this->_shadowRegistry.erase(&rt);
         }
@@ -125,31 +127,36 @@ std::shared_ptr<core::StyleSheet> core::UnistylesRegistry::addStyleSheet(jsi::Ru
 }
 
 core::DependencyMap core::UnistylesRegistry::buildDependencyMap(jsi::Runtime& rt, std::vector<UnistyleDependency>& deps) {
-    DependencyMap dependencyMap;
-    std::set<UnistyleDependency> uniqueDependencies(deps.begin(), deps.end());
+    core::DependencyMap dependencyMap;
+
+    std::unordered_set<UnistyleDependency> uniqueDependencies(deps.begin(), deps.end());
 
     for (const auto& [family, unistyles] : this->_shadowRegistry[&rt]) {
+        bool hasAnyOfDependencies = false;
+
+        // Check if any dependency matches
         for (const auto& unistyleData : unistyles) {
-            bool hasAnyOfDependencies = std::any_of(
-                unistyleData->unistyle->dependencies.begin(),
-                unistyleData->unistyle->dependencies.end(),
-                [&uniqueDependencies](UnistyleDependency dep) {
-                    return std::find(uniqueDependencies.begin(), uniqueDependencies.end(), dep) != uniqueDependencies.end();
+            for (const auto& dep : unistyleData->unistyle->dependencies) {
+                if (uniqueDependencies.count(dep)) {
+                    hasAnyOfDependencies = true;
+                    break;
                 }
-            );
-
-            if (!hasAnyOfDependencies) {
-                continue;
-            }
-
-            // we need to take in count all unistyles from the shadowNode
-            // as user might be using spreads and not all of them may have dependencies
-            for (const auto& unistyleData : unistyles) {
-                dependencyMap[family].emplace_back(unistyleData);
             }
+            
+            if (hasAnyOfDependencies) {
+                break;
+            };
+        }
 
-            break;
+        if (!hasAnyOfDependencies) {
+            continue;
         }
+
+        dependencyMap[family].insert(
+            dependencyMap[family].end(),
+            unistyles.begin(),
+            unistyles.end()
+        );
     }
 
     return dependencyMap;
@@ -159,56 +166,49 @@ core::DependencyMap core::UnistylesRegistry::buildDependencyMap(jsi::Runtime& rt
 // so we need to rebuild all instances as they may have different variants
 void core::UnistylesRegistry::shadowLeafUpdateFromUnistyle(jsi::Runtime& rt, Unistyle::Shared unistyle, jsi::Value& maybePressableId) {
     shadow::ShadowLeafUpdates updates;
-    auto parser = parser::Parser(nullptr);
-    std::optional<std::string> pressableId = maybePressableId.isString()
-        ? std::make_optional(maybePressableId.asString(rt).utf8(rt))
-        : std::nullopt;
+    this->trafficController.withLock([this, &rt, &maybePressableId, unistyle, &updates](){
+        auto parser = parser::Parser(nullptr);
+        std::optional<std::string> pressableId = maybePressableId.isString()
+            ? std::make_optional(maybePressableId.asString(rt).utf8(rt))
+            : std::nullopt;
 
-    for (const auto& [family, unistyles] : this->_shadowRegistry[&rt]) {
-        for (const auto& unistyleData : unistyles) {
-            if (unistyleData->unistyle == unistyle) {
-                updates[family] = parser.parseStylesToShadowTreeStyles(rt, { unistyleData });
+        for (const auto& [family, unistyles] : this->_shadowRegistry[&rt]) {
+            for (const auto& unistyleData : unistyles) {
+                if (unistyleData->unistyle == unistyle) {
+                    updates[family] = parser.parseStylesToShadowTreeStyles(rt, { unistyleData });
+                }
             }
         }
-    }
 
-    this->trafficController.setUpdates(updates);
+        this->trafficController.setUpdates(updates);
+    });
 }
 
-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;
+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;
+    std::unordered_set<UnistyleDependency> depSet(
+        unistylesDependencies.begin(),
+        unistylesDependencies.end()
+    );
+
+    bool themeDidChange = depSet.count(UnistyleDependency::THEME) > 0;
+    bool runtimeDidChange = (themeDidChange && depSet.size() > 1) || !depSet.empty();
 
-    // if nothing changed, skip further lookup
     if (!themeDidChange && !runtimeDidChange) {
         return stylesheetsToRefresh;
     }
 
     auto& styleSheets = this->_styleSheetRegistry[&rt];
 
-    std::for_each(styleSheets.begin(), styleSheets.end(), [&](std::pair<int, std::shared_ptr<core::StyleSheet>> pair){
-        auto& [_, styleSheet] = pair;
-
+    for (const auto& [_, styleSheet] : styleSheets) {
         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();
+            for (const auto& [__, unistyle] : styleSheet->unistyles) {
+                for (const auto& dep : unistyle->dependencies) {
+                    if (depSet.count(dep)) {
+                        stylesheetsToRefresh.emplace_back(styleSheet);
+                        
+                        goto nextStyleSheet;
                     }
-                );
-
-                if (hasAnyOfDependencies) {
-                    stylesheetsToRefresh.emplace_back(styleSheet);
-
-                    return;
                 }
             }
         }
@@ -216,11 +216,14 @@ std::vector<std::shared_ptr<core::StyleSheet>> core::UnistylesRegistry::getStyle
         if (styleSheet->type == StyleSheetType::Themable && themeDidChange) {
             stylesheetsToRefresh.emplace_back(styleSheet);
         }
-    });
+
+        nextStyleSheet:;
+    }
 
     return stylesheetsToRefresh;
 }
 
+
 core::Unistyle::Shared core::UnistylesRegistry::getUnistyleById(jsi::Runtime& rt, std::string unistyleID) {
     for (auto& pair: this->_styleSheetRegistry[&rt]) {
         auto [_, stylesheet] = pair;

package/cxx/core/UnistylesRegistry.h

@@ -56,7 +56,7 @@ private:
     std::optional<std::string> _scopedTheme{};
     std::unordered_map<jsi::Runtime*, UnistylesState> _states{};
     std::unordered_map<jsi::Runtime*, std::unordered_map<int, std::shared_ptr<core::StyleSheet>>> _styleSheetRegistry{};
-    std::unordered_map<jsi::Runtime*, std::unordered_map<const ShadowNodeFamily*, std::vector<const std::shared_ptr<UnistyleData>>>> _shadowRegistry{};
+    std::unordered_map<jsi::Runtime*, std::unordered_map<const ShadowNodeFamily*, std::vector<std::shared_ptr<UnistyleData>>>> _shadowRegistry{};
 };
 
 inline UnistylesRegistry& UnistylesRegistry::get() {

package/cxx/hybridObjects/HybridStyleSheet.cpp

@@ -80,15 +80,14 @@ jsi::Value HybridStyleSheet::init(jsi::Runtime &rt, const jsi::Value &thisVal, c
     if (this->isInitialized) {
         return jsi::Value::undefined();
     }
-    
+
     // create new state
     auto& registry = core::UnistylesRegistry::get();
 
     registry.createState(rt);
 
     loadExternalMethods(thisVal, rt);
-    registerHooks(rt);
-    
+
     this->isInitialized = true;
 
     return jsi::Value::undefined();
@@ -127,18 +126,18 @@ void HybridStyleSheet::parseSettings(jsi::Runtime &rt, jsi::Object settings) {
         if (propertyName == "CSSVars") {
             return;
         }
-        
+
         if (propertyName == "nativeBreakpointsMode") {
             helpers::assertThat(rt, propertyValue.isString(), "StyleSheet.configure's nativeBreakpointsMode must be a string");
-            
+
             auto mode = propertyValue.asString(rt).utf8(rt);
-            
+
             helpers::assertThat(rt, mode == "pixels" || mode == "points", "StyleSheet.configure's nativeBreakpointsMode must be one of: pixels or points");
-            
+
             if (mode == "points") {
                 registry.shouldUsePointsForBreakpoints = true;
             }
-            
+
             return;
         }
 
@@ -156,12 +155,12 @@ void HybridStyleSheet::parseBreakpoints(jsi::Runtime &rt, jsi::Object breakpoint
     auto& state = registry.getState(rt);
 
     registry.registerBreakpoints(rt, sortedBreakpoints);
-    
+
     auto rawWidth = this->_unistylesRuntime->getScreen().width;
     auto width = registry.shouldUsePointsForBreakpoints
         ? rawWidth / this->_unistylesRuntime->getPixelRatio()
         : rawWidth;
-    
+
     state.computeCurrentBreakpoint(width);
 }
 
@@ -256,14 +255,6 @@ void HybridStyleSheet::loadExternalMethods(const jsi::Value& thisValue, jsi::Run
     state.registerProcessColorFunction(std::move(processColorFn));
 }
 
-void HybridStyleSheet::registerHooks(jsi::Runtime& rt) {
-    // cleanup Shadow updates
-    core::UnistylesRegistry::get().trafficController.restore();
-
-    this->_unistylesCommitHook = std::make_shared<core::UnistylesCommitHook>(this->_uiManager);
-    this->_unistylesMountHook = std::make_shared<core::UnistylesMountHook>(this->_uiManager);
-}
-
 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) {
@@ -317,7 +308,7 @@ void HybridStyleSheet::onPlatformNativeDependenciesChange(std::vector<UnistyleDe
             auto width = registry.shouldUsePointsForBreakpoints
                 ? rawWidth / this->_unistylesRuntime->getPixelRatio()
                 : rawWidth;
-            
+
             registry.getState(rt).computeCurrentBreakpoint(width);
         }
 

package/cxx/hybridObjects/HybridStyleSheet.h

@@ -6,18 +6,16 @@
 #include "HybridUnistylesStyleSheetSpec.hpp"
 #include "RNStyle.h"
 #include "Helpers.h"
-#include "Constants.h"
+#include "UnistylesConstants.h"
 #include "Breakpoints.h"
 #include "Parser.h"
-#include "UnistylesCommitHook.h"
-#include "UnistylesMountHook.h"
+#include "ShadowTreeManager.h"
 
 using namespace margelo::nitro::unistyles;
 using namespace facebook::react;
 
 struct HybridStyleSheet: public HybridUnistylesStyleSheetSpec {
-    HybridStyleSheet(std::shared_ptr<HybridUnistylesRuntime> unistylesRuntime, std::shared_ptr<UIManager> uiManager)
-        : HybridObject(TAG), _unistylesRuntime{unistylesRuntime}, _uiManager{uiManager} {
+    HybridStyleSheet(std::shared_ptr<HybridUnistylesRuntime> unistylesRuntime): HybridObject(TAG), _unistylesRuntime{unistylesRuntime} {
             this->_unistylesRuntime->registerPlatformListener(
                   std::bind(&HybridStyleSheet::onPlatformDependenciesChange, this, std::placeholders::_1)
             );
@@ -67,7 +65,6 @@ private:
     void verifyAndSelectTheme(jsi::Runtime &rt);
     void setThemeFromColorScheme(jsi::Runtime& rt);
     void loadExternalMethods(const jsi::Value& thisValue, jsi::Runtime& rt);
-    void registerHooks(jsi::Runtime& rt);
     void onPlatformDependenciesChange(std::vector<UnistyleDependency> dependencies);
     void onPlatformNativeDependenciesChange(std::vector<UnistyleDependency> dependencies, UnistylesNativeMiniRuntime miniRuntime);
     void onImeChange(UnistylesNativeMiniRuntime miniRuntime);
@@ -77,8 +74,6 @@ private:
     double __unid = -1;
     std::vector<std::unique_ptr<const std::function<void(std::vector<UnistyleDependency>&)>>> _changeListeners{};
     std::shared_ptr<HybridUnistylesRuntime> _unistylesRuntime;
-    std::shared_ptr<core::UnistylesCommitHook> _unistylesCommitHook;
-    std::shared_ptr<core::UnistylesMountHook> _unistylesMountHook;
     std::shared_ptr<UIManager> _uiManager;
 };