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

package/cxx/core/UnistylesCommitShadowNode.h

@@ -8,32 +8,11 @@ namespace margelo::nitro::unistyles::core {
 // React Native uses 0-10
 // Reanimated uses 27-28
 constexpr shadow::ShadowNodeTraits::Trait UnistylesCommitTrait{1 << 30};
-constexpr shadow::ShadowNodeTraits::Trait UnistylesMountTrait{1 << 31};
 
 struct UnistylesCommitShadowNode: public shadow::ShadowNode {
     inline void addUnistylesCommitTrait() {
         traits_.set(UnistylesCommitTrait);
     }
-    
-    inline void removeUnistylesCommitTrait() {
-        traits_.unset(UnistylesCommitTrait);
-    }
-    
-    inline bool hasUnistylesCommitTrait() {
-        return traits_.check(UnistylesCommitTrait);
-    }
-    
-    inline void addUnistylesMountTrait() {
-        traits_.set(UnistylesMountTrait);
-    }
-    
-    inline void removeUnistylesMountTrait() {
-        traits_.unset(UnistylesMountTrait);
-    }
-    
-    inline bool hasUnistylesMountTrait() {
-        return traits_.check(UnistylesMountTrait);
-    }
 };
 
 }

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);
+
+        std::for_each(unistylesData.begin(), unistylesData.end(), [this, &rt, shadowNodeFamily](std::shared_ptr<UnistyleData> unistyleData){
+            this->_shadowRegistry[&rt][shadowNodeFamily].emplace_back(unistyleData);
+        });
+
+        updates[shadowNodeFamily] = parser.parseStylesToShadowTreeStyles(rt, unistylesData);
+        
+        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) {
@@ -108,12 +110,14 @@ void core::UnistylesRegistry::removeDuplicatedUnistyles(jsi::Runtime& rt, const
 }
 
 void core::UnistylesRegistry::unlinkShadowNodeWithUnistyles(jsi::Runtime& rt, const ShadowNodeFamily* shadowNodeFamily) {
-    this->_shadowRegistry[&rt].erase(shadowNodeFamily);
-    this->trafficController.removeShadowNode(shadowNodeFamily);
+    this->trafficController.withLock([this, &rt, shadowNodeFamily](){
+        this->_shadowRegistry[&rt].erase(shadowNodeFamily);
+        this->trafficController.removeShadowNode(shadowNodeFamily);
 
-    if (this->_shadowRegistry[&rt].empty()) {
-        this->_shadowRegistry.erase(&rt);
-    }
+        if (this->_shadowRegistry[&rt].empty()) {
+            this->_shadowRegistry.erase(&rt);
+        }
+    });
 }
 
 std::shared_ptr<core::StyleSheet> core::UnistylesRegistry::addStyleSheet(jsi::Runtime& rt, int unid, core::StyleSheetType type, jsi::Object&& rawValue) {
@@ -123,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;
@@ -157,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;
                 }
             }
         }
@@ -214,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/HybridShadowRegistry.cpp

@@ -49,7 +49,6 @@ jsi::Value HybridShadowRegistry::link(jsi::Runtime &rt, const jsi::Value &thisVa
     }
 
     auto parser = parser::Parser(this->_unistylesRuntime);
-    auto parsedStyleSheet = jsi::Value::undefined();
     std::vector<std::shared_ptr<core::UnistyleData>> unistylesData{};
 
     // create unistyleData based on wrappers
@@ -77,10 +76,8 @@ jsi::Value HybridShadowRegistry::link(jsi::Runtime &rt, const jsi::Value &thisVa
         );
 
         // before linking we need to check if given unistyle is affected by scoped theme
-        if (scopedTheme.has_value()) {
-            if (parsedStyleSheet.isUndefined()) {
-                parsedStyleSheet = parser.getParsedStyleSheetForScopedTheme(rt, unistyle, scopedTheme.value());
-            }
+        if (scopedTheme.has_value() && unistyle->styleKey != helpers::EXOTIC_STYLE_KEY) {
+            auto parsedStyleSheet = parser.getParsedStyleSheetForScopedTheme(rt, unistyle, scopedTheme.value());
 
             // if so we need to force update
             parser.rebuildUnistyleWithScopedTheme(rt, parsedStyleSheet, unistyleData);

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, this->_unistylesRuntime);
-}
-
 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;
 };
 

package/cxx/hybridObjects/HybridUnistylesRuntime.cpp

@@ -73,9 +73,13 @@ void HybridUnistylesRuntime::setTheme(const std::string &themeName) {
     helpers::assertThat(*_rt, !this->getHasAdaptiveThemes(), "Unistyles: You're trying to set theme to: '" + themeName + "', but adaptiveThemes are enabled.");
 
     auto& state = core::UnistylesRegistry::get().getState(*_rt);
+    auto currentThemeName = state.getCurrentThemeName();
 
     state.setTheme(themeName);
-    this->_onDependenciesChange({UnistyleDependency::THEME, UnistyleDependency::THEMENAME});
+
+    if (currentThemeName.value() != themeName) {
+        this->_onDependenciesChange({UnistyleDependency::THEME, UnistyleDependency::THEMENAME});
+    }
 };
 
 void HybridUnistylesRuntime::setAdaptiveThemes(bool isEnabled) {