react-native-unistyles 3.0.0-alpha.2 → 3.0.0-alpha.21

package/cxx/core/UnistylesMountHook.cpp

@@ -0,0 +1,37 @@
+#include "UnistylesMountHook.h"
+#include "ShadowTreeManager.h"
+
+using namespace margelo::nitro::unistyles;
+using namespace facebook::react;
+
+core::UnistylesMountHook::~UnistylesMountHook() noexcept {
+    _uiManager->unregisterMountHook(*this);
+}
+
+void core::UnistylesMountHook::shadowTreeDidMount(RootShadowNode::Shared const &rootShadowNode, double mountTime) noexcept {
+    auto rootNode = std::const_pointer_cast<RootShadowNode>(rootShadowNode);
+    auto unistylesRootNode = std::reinterpret_pointer_cast<core::UnistylesCommitShadowNode>(rootNode);
+
+    // if this is Unistyles commit, do nothing
+    if (unistylesRootNode->hasUnistylesMountTrait()) {
+        unistylesRootNode->removeUnistylesMountTrait();
+
+        return;
+    }
+
+    // React Native commit did mount
+    auto& registry = core::UnistylesRegistry::get();
+
+    // so, resume Unistyles commits
+    registry.trafficController.resumeUnistylesTraffic();
+}
+
+shadow::ShadowLeafUpdates core::UnistylesMountHook::getUnistylesUpdates() {
+    auto& registry = core::UnistylesRegistry::get();
+    auto parser = parser::Parser(this->_unistylesRuntime);
+    auto dependencyMap = registry.buildDependencyMap(*this->_rt);
+
+    // don't rebuild dependency map, at this point it's already done
+
+    return parser.dependencyMapToShadowLeafUpdates(dependencyMap);
+}

package/cxx/core/UnistylesMountHook.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <react/renderer/uimanager/UIManager.h>
+#include <react/renderer/uimanager/UIManagerMountHook.h>
+#include "HybridUnistylesRuntime.h"
+#include "Parser.h"
+#include "ShadowTreeManager.h"
+
+namespace margelo::nitro::unistyles::core {
+
+using namespace facebook::react;
+
+struct UnistylesMountHook : public UIManagerMountHook {
+    UnistylesMountHook(std::shared_ptr<UIManager> uiManager, std::shared_ptr<HybridUnistylesRuntime> unistylesRuntime, jsi::Runtime& rt)
+        : _unistylesRuntime{unistylesRuntime}, _uiManager{uiManager}, _rt{&rt} {
+            _uiManager->registerMountHook(*this);
+        }
+
+    ~UnistylesMountHook() noexcept override;
+
+    void shadowTreeDidMount(RootShadowNode::Shared const &rootShadowNode, double mountTime) noexcept override;
+
+    shadow::ShadowLeafUpdates getUnistylesUpdates();
+
+private:
+    jsi::Runtime* _rt;
+    std::shared_ptr<HybridUnistylesRuntime> _unistylesRuntime;
+    std::shared_ptr<UIManager> _uiManager;
+};
+
+}

package/cxx/core/UnistylesRegistry.cpp

@@ -5,11 +5,6 @@ using namespace margelo::nitro::unistyles;
 using namespace facebook;
 using namespace facebook::react;
 
-using DependencyMap = std::unordered_map<
-    std::shared_ptr<core::StyleSheet>,
-    std::unordered_map<const ShadowNodeFamily*, std::vector<core::Unistyle::Shared>>
->;
-
 void core::UnistylesRegistry::registerTheme(jsi::Runtime& rt, std::string name, jsi::Object&& theme) {
     auto& state = this->getState(rt);
 
@@ -62,113 +57,93 @@ void core::UnistylesRegistry::createState(jsi::Runtime& rt) {
 void core::UnistylesRegistry::updateTheme(jsi::Runtime& rt, std::string& themeName, jsi::Function&& callback) {
     auto& state = this->getState(rt);
     auto it = state._jsThemes.find(themeName);
-    
-    helpers::assertThat(rt, it != state._jsThemes.end(), "you're trying to update theme '" + themeName + "' but it wasn't registered.");
-    
+
+    helpers::assertThat(rt, it != state._jsThemes.end(), "Unistyles: You're trying to update theme '" + themeName + "' but it wasn't registered.");
+
     auto currentThemeValue = it->second.lock(rt);
-    
-    helpers::assertThat(rt, currentThemeValue.isObject(), "unable to update your theme from C++. It was already garbage collected.");
-    
+
+    helpers::assertThat(rt, currentThemeValue.isObject(), "Unistyles: Unable to update your theme from C++. It was already garbage collected.");
+
     auto result = callback.call(rt, currentThemeValue.asObject(rt));
-    
-    helpers::assertThat(rt, result.isObject(), "returned theme is not an object. Please check your updateTheme function.");
+
+    helpers::assertThat(rt, result.isObject(), "Unistyles: Returned theme is not an object. Please check your updateTheme function.");
 
     it->second = jsi::WeakObject(rt, result.asObject(rt));
 }
 
-void core::UnistylesRegistry::linkShadowNodeWithUnistyle(const ShadowNodeFamily* shadowNodeFamily, const core::Unistyle::Shared unistyle) {
-    if (!this->_shadowRegistry.contains(shadowNodeFamily)) {
-        this->_shadowRegistry[shadowNodeFamily] = {};
+void core::UnistylesRegistry::linkShadowNodeWithUnistyle(
+    jsi::Runtime& rt,
+    const ShadowNodeFamily* shadowNodeFamily,
+    std::vector<core::Unistyle::Shared>& unistyles,
+    Variants& variants,
+    std::vector<folly::dynamic>& arguments
+) {
+    if (!this->_shadowRegistry[&rt].contains(shadowNodeFamily)) {
+        this->_shadowRegistry[&rt][shadowNodeFamily] = {};
     }
-    
-    this->_shadowRegistry[shadowNodeFamily].emplace_back(unistyle);
-}
 
-void core::UnistylesRegistry::unlinkShadowNodeWithUnistyle(const ShadowNodeFamily* shadowNodeFamily, const core::Unistyle::Shared unistyle) {
-    auto& unistylesVec = this->_shadowRegistry[shadowNodeFamily];
-    auto it = std::find(unistylesVec.begin(), unistylesVec.end(), unistyle);
-    
-    if (it != unistylesVec.end()) {
-        this->_shadowRegistry[shadowNodeFamily].erase(it);
-    }
+    std::for_each(unistyles.begin(), unistyles.end(), [&, this](Unistyle::Shared unistyle){
+        this->_shadowRegistry[&rt][shadowNodeFamily].emplace_back(std::make_shared<UnistyleData>(unistyle, variants, arguments));
+    });
 }
 
-std::shared_ptr<core::StyleSheet> core::UnistylesRegistry::addStyleSheet(int tag, core::StyleSheetType type, jsi::Object&& rawValue) {
-    this->_styleSheetRegistry.emplace_back(std::make_shared<core::StyleSheet>(tag, type, std::move(rawValue)));
-
-    return this->_styleSheetRegistry.back();
+void core::UnistylesRegistry::unlinkShadowNodeWithUnistyles(jsi::Runtime& rt, const ShadowNodeFamily* shadowNodeFamily) {
+    this->_shadowRegistry[&rt][shadowNodeFamily].clear();
 }
 
-std::shared_ptr<core::StyleSheet> core::UnistylesRegistry::getStyleSheetById(int tag) {
-    auto it = std::find_if(
-        this->_styleSheetRegistry.begin(),
-        this->_styleSheetRegistry.end(),
-        [tag](std::shared_ptr<StyleSheet> styleSheet){
-            return styleSheet->tag == tag;
-        }
-    );
+core::Unistyle::Shared core::UnistylesRegistry::findUnistyleFromKey(jsi::Runtime& rt, std::string styleKey, int tag) {
+    auto targetStyleSheet = this->_styleSheetRegistry[&rt][tag];
     
-    if (it == this->_styleSheetRegistry.cend()) {
-        throw std::runtime_error("stylesheet with tag: " + std::to_string(tag) + " cannot be found.");
+    if (targetStyleSheet == nullptr) {
+        return nullptr;
     }
     
-    return *it;
+    return targetStyleSheet.get()->unistyles[styleKey];
 }
-    
-DependencyMap core::UnistylesRegistry::buildDependencyMap(std::vector<UnistyleDependency>& deps) {
+
+std::shared_ptr<core::StyleSheet> core::UnistylesRegistry::addStyleSheet(jsi::Runtime& rt, int unid, core::StyleSheetType type, jsi::Object&& rawValue) {
+    this->_styleSheetRegistry[&rt][unid] = std::make_shared<core::StyleSheet>(unid, type, std::move(rawValue));
+
+    return this->_styleSheetRegistry[&rt][unid];
+}
+
+core::DependencyMap core::UnistylesRegistry::buildDependencyMap(jsi::Runtime& rt, std::vector<UnistyleDependency>& deps) {
     DependencyMap dependencyMap;
- 
-    for (const auto& styleSheet : this->_styleSheetRegistry) {
-        for (const auto& [_, unistyle] : styleSheet->unistyles) {
-            // check if in the given stylesheet we have unistyle
-            // that depends on something affected
+    std::set<UnistyleDependency> uniqueDependencies(deps.begin(), deps.end());
+
+    for (const auto& [family, unistyles] : this->_shadowRegistry[&rt]) {
+        for (const auto& unistyleData : unistyles) {
             bool hasAnyOfDependencies = std::any_of(
-                unistyle->dependencies.begin(),
-                unistyle->dependencies.end(),
-                [&deps](UnistyleDependency dep) {
-                    return std::find(deps.begin(), deps.end(), dep) != deps.end();
+                unistyleData->unistyle->dependencies.begin(),
+                unistyleData->unistyle->dependencies.end(),
+                [&uniqueDependencies](UnistyleDependency dep) {
+                    return std::find(uniqueDependencies.begin(), uniqueDependencies.end(), dep) != uniqueDependencies.end();
                 }
             );
-            
+
             if (!hasAnyOfDependencies) {
                 continue;
             }
-            
-            // if so, we need to find shadow family too
-            for (const auto& pair : this->_shadowRegistry) {
-                const auto& [family, unistyles] = pair;
-                
-                for (const auto& shadowUnistyle : unistyles) {
-                    if (unistyle != shadowUnistyle) {
-                        continue;
-                    }
-
-                    dependencyMap[styleSheet][family].push_back(shadowUnistyle);
-                }
+
+            // 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);
             }
+
+            break;
         }
     }
 
     return dependencyMap;
 }
 
-DependencyMap core::UnistylesRegistry::buildDependencyMap() {
+core::DependencyMap core::UnistylesRegistry::buildDependencyMap(jsi::Runtime& rt) {
     DependencyMap dependencyMap;
- 
-    for (const auto& styleSheet : this->_styleSheetRegistry) {
-        for (const auto& [_, unistyle] : styleSheet->unistyles) {
-            for (const auto& pair : this->_shadowRegistry) {
-                const auto& [family, unistyles] = pair;
-                
-                for (const auto& shadowUnistyle : unistyles) {
-                    if (unistyle != shadowUnistyle) {
-                        continue;
-                    }
-
-                    // make sure to use base Unistyle class
-                    dependencyMap[styleSheet][family].push_back(shadowUnistyle);
-                }
-            }
+
+    for (const auto& [family, unistyles] : this->_shadowRegistry[&rt]) {
+        for (const auto& unistyleData : unistyles) {
+            dependencyMap[family].emplace_back(unistyleData);
         }
     }
 

package/cxx/core/UnistylesRegistry.h

@@ -1,6 +1,8 @@
 #pragma once
 
+#include "set"
 #include <jsi/jsi.h>
+#include <folly/dynamic.h>
 #include <react/renderer/uimanager/UIManager.h>
 #include <unordered_map>
 #include <unordered_set>
@@ -8,6 +10,8 @@
 #include "StyleSheetRegistry.h"
 #include "StyleSheet.h"
 #include "Unistyle.h"
+#include "UnistyleData.h"
+#include "ShadowTrafficController.h"
 
 namespace margelo::nitro::unistyles::core {
 
@@ -16,10 +20,7 @@ struct UnistylesState;
 using namespace facebook;
 using namespace facebook::react;
 
-using DependencyMap = std::unordered_map<
-    std::shared_ptr<core::StyleSheet>,
-    std::unordered_map<const ShadowNodeFamily*, std::vector<core::Unistyle::Shared>>
->;
+using DependencyMap = std::unordered_map<const ShadowNodeFamily*, std::vector<std::shared_ptr<UnistyleData>>>;
 
 struct UnistylesRegistry: public StyleSheetRegistry {
     static UnistylesRegistry& get();
@@ -35,19 +36,20 @@ struct UnistylesRegistry: public StyleSheetRegistry {
 
     UnistylesState& getState(jsi::Runtime& rt);
     void createState(jsi::Runtime& rt);
-    void linkShadowNodeWithUnistyle(const ShadowNodeFamily*, const core::Unistyle::Shared);
-    void unlinkShadowNodeWithUnistyle(const ShadowNodeFamily*, const core::Unistyle::Shared);
-    std::shared_ptr<core::StyleSheet> addStyleSheet(int tag, core::StyleSheetType type, jsi::Object&& rawValue);
-    std::shared_ptr<core::StyleSheet> getStyleSheetById(int tag);
-    DependencyMap buildDependencyMap(std::vector<UnistyleDependency>& deps);
-    DependencyMap buildDependencyMap();
-
+    void linkShadowNodeWithUnistyle(jsi::Runtime& rt, const ShadowNodeFamily*, std::vector<core::Unistyle::Shared>& unistyles, Variants& variants, std::vector<folly::dynamic>&);
+    void unlinkShadowNodeWithUnistyles(jsi::Runtime& rt, const ShadowNodeFamily*);
+    std::shared_ptr<core::StyleSheet> addStyleSheet(jsi::Runtime& rt, int tag, core::StyleSheetType type, jsi::Object&& rawValue);
+    DependencyMap buildDependencyMap(jsi::Runtime& rt, std::vector<UnistyleDependency>& deps);
+    Unistyle::Shared findUnistyleFromKey(jsi::Runtime& rt, std::string styleKey, int tag);
+    DependencyMap buildDependencyMap(jsi::Runtime& rt);
+    shadow::ShadowTrafficController trafficController{};
+    
 private:
     UnistylesRegistry() = default;
 
     std::unordered_map<jsi::Runtime*, UnistylesState> _states{};
-    std::vector<std::shared_ptr<core::StyleSheet>> _styleSheetRegistry{};
-    std::unordered_map<const ShadowNodeFamily*, std::vector<core::Unistyle::Shared>> _shadowRegistry{};
+    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<std::shared_ptr<UnistyleData>>>> _shadowRegistry{};
 };
 
 UnistylesRegistry& UnistylesRegistry::get() {

package/cxx/core/UnistylesState.cpp

@@ -12,7 +12,7 @@ bool core::UnistylesState::hasAdaptiveThemes() {
 }
 
 void core::UnistylesState::setTheme(std::string themeName) {
-    helpers::assertThat(*_rt, helpers::vecContainsKeys(this->_registeredThemeNames, {themeName}), "You're trying to set theme to: '" + std::string(themeName) + "', but it wasn't registered.");
+    helpers::assertThat(*_rt, helpers::vecContainsKeys(this->_registeredThemeNames, {themeName}), "Unistyles: You're trying to set theme to: '" + std::string(themeName) + "', but it wasn't registered.");
 
     if (themeName != this->_currentThemeName) {
         this->_currentThemeName = themeName;
@@ -31,15 +31,15 @@ jsi::Object core::UnistylesState::getJSTheme() {
         return jsi::Object(*_rt);
     }
 
-    helpers::assertThat(*_rt, _currentThemeName.has_value(), "one of your stylesheets is trying to get the theme, but no theme has been selected yet. Did you forget to select an initial theme?");
+    helpers::assertThat(*_rt, _currentThemeName.has_value(), "Unistyles: One of your stylesheets is trying to get the theme, but no theme has been selected yet. Did you forget to select an initial theme?");
 
     auto it = this->_jsThemes.find(_currentThemeName.value());
 
-    helpers::assertThat(*_rt, it != this->_jsThemes.end(), "you're trying to get theme '" + _currentThemeName.value() + "', but it was not registered. Did you forget to register it with StyleSheet.configure?");
+    helpers::assertThat(*_rt, it != this->_jsThemes.end(), "Unistyles: You're trying to get theme '" + _currentThemeName.value() + "', but it was not registered. Did you forget to register it with StyleSheet.configure?");
 
     auto maybeTheme = it->second.lock(*_rt);
 
-    helpers::assertThat(*_rt, maybeTheme.isObject(), "unable to retrieve your theme from C++ as it has already been garbage collected, likely due to multiple hot reloads. Please live reload the app.");
+    helpers::assertThat(*_rt, maybeTheme.isObject(), "Unistyles: Unable to retrieve your theme from C++ as it has already been garbage collected, likely due to multiple hot reloads. Please live reload the app.");
 
     return maybeTheme.asObject(*_rt);
 }
@@ -88,8 +88,14 @@ int core::UnistylesState::parseColor(jsi::Value& maybeColor) {
         return 0;
     }
     
-    // we must convert it to uint32_t first, otherwise color will be broken
-    uint32_t color = this->_processColorFn.get()->call(*_rt, maybeColor.asString(*_rt)).asNumber();
-
-    return color;
+    auto colorString = maybeColor.asString(*_rt);
+    
+    if (!this->_colorCache.contains(colorString.utf8(*_rt).c_str())) {
+        // we must convert it to uint32_t first, otherwise color will be broken
+        uint32_t color = this->_processColorFn.get()->call(*_rt, colorString).asNumber();
+        
+        this->_colorCache[colorString.utf8(*_rt).c_str()] = color ? color : 0;
+    }
+    
+    return this->_colorCache[colorString.utf8(*_rt).c_str()];
 }

package/cxx/core/UnistylesState.h

@@ -43,6 +43,7 @@ private:
     std::vector<std::string> _registeredThemeNames{};
     std::optional<std::string> _currentThemeName = std::nullopt;
     std::shared_ptr<jsi::Function> _processColorFn;
+    std::unordered_map<std::string, uint32_t> _colorCache{};
 
     friend class UnistylesRegistry;
 };

package/cxx/hybridObjects/HybridShadowRegistry.cpp

@@ -4,23 +4,29 @@ using namespace margelo::nitro::unistyles;
 using namespace facebook::react;
 
 jsi::Value HybridShadowRegistry::link(jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) {
+    helpers::assertThat(rt, count == 4, "Unistyles: Invalid babel transform 'ShadowRegistry link' expected 4 arguments.");
+
     ShadowNode::Shared shadowNodeWrapper = shadowNodeFromValue(rt, args[0]);
-    core::Unistyle::Shared unistyleWrapper = core::unistyleFromValue(rt, args[1]);
-    
+    std::vector<core::Unistyle::Shared> unistyleWrappers = core::unistyleFromValue(rt, args[1]);
+    core::Variants variants = helpers::variantsToPairs(rt, args[2].asObject(rt));
+    auto rawArguments = args[3].asObject(rt).asArray(rt);
+    std::vector<folly::dynamic> arguments = helpers::parseDynamicFunctionArguments(rt, rawArguments);
+
     auto& registry = core::UnistylesRegistry::get();
-    
-    registry.linkShadowNodeWithUnistyle(&shadowNodeWrapper->getFamily(), unistyleWrapper);
-    
+
+    registry.linkShadowNodeWithUnistyle(rt, &shadowNodeWrapper->getFamily(), unistyleWrappers, variants, arguments);
+
     return jsi::Value::undefined();
 }
 
 jsi::Value HybridShadowRegistry::unlink(jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) {
+    helpers::assertThat(rt, count == 1, "Unistyles: Invalid babel transform 'ShadowRegistry unlink' expected 1 arguments.");
+
     ShadowNode::Shared shadowNodeWrapper = shadowNodeFromValue(rt, args[0]);
-    core::Unistyle::Shared unistyleWrapper = core::unistyleFromValue(rt, args[1]);
-    
+
     auto& registry = core::UnistylesRegistry::get();
 
-    registry.unlinkShadowNodeWithUnistyle(&shadowNodeWrapper->getFamily(), unistyleWrapper);
-    
+    registry.unlinkShadowNodeWithUnistyles(rt, &shadowNodeWrapper->getFamily());
+
     return jsi::Value::undefined();
 }

package/cxx/hybridObjects/HybridStyleSheet.cpp

@@ -9,27 +9,21 @@ double HybridStyleSheet::getHairlineWidth() {
     return nearestPixel / pixelRatio;
 }
 
-double HybridStyleSheet::get___unid() {
+double HybridStyleSheet::get__unid() {
     return this->__unid;
 }
 
-jsi::Value HybridStyleSheet::create(jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *arguments, size_t count) {
-    helpers::assertThat(rt, arguments[0].isObject(), "expected to be called with object or function.");
+jsi::Value HybridStyleSheet::create(jsi::Runtime& rt, const jsi::Value &thisVal, const jsi::Value *arguments, size_t count) {
+    // second argument is hidden, so validation is perfectly fine
+    helpers::assertThat(rt, count == 2, "StyleSheet.create expected to be called with one argument.");
+    helpers::assertThat(rt, arguments[0].isObject(), "StyleSheet.create expected to be called with object or function.");
 
     auto thisStyleSheet = thisVal.asObject(rt);
     auto& registry = core::UnistylesRegistry::get();
-
-    // this might happen only when hot reloading
-    if (this->__unid != -1) {
-        auto registeredStyleSheet = registry.getStyleSheetById(this->__unid);
-        auto style = std::make_shared<core::HostStyle>(registeredStyleSheet, this->_unistylesRuntime);
-        auto styleHostObject = jsi::Object::createFromHostObject(rt, style);
-
-        return styleHostObject;
-    }
+    int unid = arguments[1].asNumber();
 
     jsi::Object rawStyleSheet = arguments[0].asObject(rt);
-    auto registeredStyleSheet = registry.addStyleSheetFromValue(rt, std::move(rawStyleSheet));
+    auto registeredStyleSheet = registry.addStyleSheetFromValue(rt, std::move(rawStyleSheet), unid);
 
     this->__unid = registeredStyleSheet->tag;
 
@@ -45,7 +39,8 @@ jsi::Value HybridStyleSheet::create(jsi::Runtime &rt, const jsi::Value &thisVal,
 }
 
 jsi::Value HybridStyleSheet::configure(jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *arguments, size_t count) {
-    helpers::assertThat(rt, arguments[0].isObject(), "expected to be called with object.");
+    helpers::assertThat(rt, count == 1, "StyleSheet.configure expected to be called with one argument.");
+    helpers::assertThat(rt, arguments[0].isObject(), "StyleSheet.configure expected to be called with object.");
 
     // create new state
     auto config = arguments[0].asObject(rt);
@@ -55,29 +50,29 @@ jsi::Value HybridStyleSheet::configure(jsi::Runtime &rt, const jsi::Value &thisV
 
     helpers::enumerateJSIObject(rt, config, [&](const std::string& propertyName, jsi::Value& propertyValue){
         if (propertyName == "settings") {
-            helpers::assertThat(rt, propertyValue.isObject(), "settings must be an object.");
+            helpers::assertThat(rt, propertyValue.isObject(), "StyleSheet.configure's settings must be an object.");
 
             return this->parseSettings(rt, propertyValue.asObject(rt));
         }
 
         if (propertyName == "breakpoints") {
-            helpers::assertThat(rt, propertyValue.isObject(), "breakpoints must be an object.");
+            helpers::assertThat(rt, propertyValue.isObject(), "StyleSheet.configure's breakpoints must be an object.");
 
             return this->parseBreakpoints(rt, propertyValue.asObject(rt));
         }
 
         if (propertyName == "themes") {
-            helpers::assertThat(rt, propertyValue.isObject(), "themes must be an object.");
+            helpers::assertThat(rt, propertyValue.isObject(), "StyleSheet.configure's themes must be an object.");
 
             return this->parseThemes(rt, propertyValue.asObject(rt));
         }
 
-        helpers::assertThat(rt, false, "received unexpected key: '" + std::string(propertyName) + "'.");
+        helpers::assertThat(rt, false, "StyleSheet.configure received unexpected key: '" + std::string(propertyName) + "'.");
     });
 
     verifyAndSelectTheme(rt);
     loadExternalMethods(thisVal, rt);
-    registerCommitHook(rt);
+    registerHooks(rt);
 
     return jsi::Value::undefined();
 }
@@ -87,7 +82,7 @@ void HybridStyleSheet::parseSettings(jsi::Runtime &rt, jsi::Object settings) {
 
     helpers::enumerateJSIObject(rt, settings, [&](const std::string& propertyName, jsi::Value& propertyValue){
         if (propertyName == "adaptiveThemes") {
-            helpers::assertThat(rt, propertyValue.isBool(), "adaptiveThemes configuration must be of boolean type.");
+            helpers::assertThat(rt, propertyValue.isBool(), "StyleSheet.configure's adaptiveThemes must be of boolean type.");
 
             registry.setPrefersAdaptiveThemes(rt, propertyValue.asBool());
 
@@ -96,31 +91,31 @@ void HybridStyleSheet::parseSettings(jsi::Runtime &rt, jsi::Object settings) {
 
         if (propertyName == "initialTheme") {
             if (propertyValue.isObject()) {
-                helpers::assertThat(rt, propertyValue.asObject(rt).isFunction(rt), "initialTheme configuration must be either a string or a function.");
+                helpers::assertThat(rt, propertyValue.asObject(rt).isFunction(rt), "StyleSheet.configure's initialTheme must be either a string or a function.");
 
                 auto result = propertyValue.asObject(rt).asFunction(rt).call(rt);
 
-                helpers::assertThat(rt, result.isString(), "initialTheme resolved from function is not a string. Please check your initialTheme function.");
+                helpers::assertThat(rt, result.isString(), "StyleSheet.configure's initialTheme resolved from function is not a string. Please check your initialTheme function.");
 
                 return registry.setInitialThemeName(rt, result.asString(rt).utf8(rt));
             }
 
-            helpers::assertThat(rt, propertyValue.isString(), "initialTheme configuration must be either a string or a function.");
+            helpers::assertThat(rt, propertyValue.isString(), "StyleSheet.configure's initialTheme must be either a string or a function.");
 
             registry.setInitialThemeName(rt, propertyValue.asString(rt).utf8(rt));
 
             return;
         }
 
-        helpers::assertThat(rt, false, "settings received unexpected key: '" + std::string(propertyName) + "'");
+        helpers::assertThat(rt, false, "StyleSheet.configure's settings received unexpected key: '" + std::string(propertyName) + "'");
     });
 }
 
 void HybridStyleSheet::parseBreakpoints(jsi::Runtime &rt, jsi::Object breakpoints){
     helpers::Breakpoints sortedBreakpoints = helpers::jsiBreakpointsToVecPairs(rt, std::move(breakpoints));
 
-    helpers::assertThat(rt, sortedBreakpoints.size() > 0, "registered breakpoints can't be empty.");
-    helpers::assertThat(rt, sortedBreakpoints.front().second == 0, "first breakpoint must start from 0.");
+    helpers::assertThat(rt, sortedBreakpoints.size() > 0, "StyleSheet.configure's breakpoints can't be empty.");
+    helpers::assertThat(rt, sortedBreakpoints.front().second == 0, "StyleSheet.configure's first breakpoint must start from 0.");
 
     auto& registry = core::UnistylesRegistry::get();
     auto& state = registry.getState(rt);
@@ -133,7 +128,7 @@ void HybridStyleSheet::parseThemes(jsi::Runtime &rt, jsi::Object themes) {
     auto& registry = core::UnistylesRegistry::get();
 
     helpers::enumerateJSIObject(rt, themes, [&](const std::string& propertyName, jsi::Value& propertyValue){
-        helpers::assertThat(rt, propertyValue.isObject(), "registered theme '" + propertyName + "' must be an object.");
+        helpers::assertThat(rt, propertyValue.isObject(), "StyleSheet.configure's registered theme '" + propertyName + "' must be an object.");
 
         registry.registerTheme(rt, propertyName, propertyValue.asObject(rt));
     });
@@ -151,7 +146,7 @@ void HybridStyleSheet::verifyAndSelectTheme(jsi::Runtime &rt) {
 
     // user tries to enable adaptive themes, but didn't register both 'light' and 'dark' themes
     if (prefersAdaptiveThemes && !hasAdaptiveThemes) {
-        helpers::assertThat(rt, false, "you're trying to enable adaptiveThemes, but you didn't register both 'light' and 'dark' themes.");
+        helpers::assertThat(rt, false, "Unistyles: You're trying to enable adaptiveThemes, but you didn't register both 'light' and 'dark' themes.");
     }
 
     // user didn't select initial theme nor can have adaptive themes, and registered more than 1 theme
@@ -175,14 +170,14 @@ void HybridStyleSheet::verifyAndSelectTheme(jsi::Runtime &rt) {
     // user selected both initial theme and adaptive themes
     // we should throw an error as these options are mutually exclusive
     if (hasInitialTheme && hasAdaptiveThemes) {
-        helpers::assertThat(rt, false, "you're trying to set initial theme and enable adaptiveThemes, but these options are mutually exclusive.");
+        helpers::assertThat(rt, false, "Unistyles: You're trying to set initial theme and enable adaptiveThemes, but these options are mutually exclusive.");
     }
 
     // user only selected initial theme
     // validate if following theme exist
     std::string selectedTheme = state.getInitialTheme().value();
 
-    helpers::assertThat(rt, state.hasTheme(selectedTheme), "you're trying to select theme '" + selectedTheme + "' but it wasn't registered.");
+    helpers::assertThat(rt, state.hasTheme(selectedTheme), "Unistyles: You're trying to select theme '" + selectedTheme + "' but it wasn't registered.");
 
     state.setTheme(selectedTheme);
 }
@@ -201,18 +196,18 @@ void HybridStyleSheet::setThemeFromColorScheme(jsi::Runtime& rt) {
 
             return;
         default:
-            throw std::runtime_error("unable to set adaptive theme as your device doesn't support it.");
+            throw std::runtime_error("Unistyles: Unable to set adaptive theme as your device doesn't support it.");
     }
 }
 
 void HybridStyleSheet::loadExternalMethods(const jsi::Value& thisValue, jsi::Runtime& rt) {
     auto jsMethods = thisValue.getObject(rt).getProperty(rt, "jsMethods");
 
-    helpers::assertThat(rt, jsMethods.isObject(), "can't find jsMethods.");
+    helpers::assertThat(rt, jsMethods.isObject(), "Unistyles: Can't find jsMethods.");
 
     auto maybeProcessColorFn = jsMethods.asObject(rt).getProperty(rt, "processColor");
 
-    helpers::assertThat(rt, maybeProcessColorFn.isObject(), "can't load processColor function from JS.");
+    helpers::assertThat(rt, maybeProcessColorFn.isObject(), "Unistyles: Can't load processColor function from JS.");
 
     auto processColorFn = maybeProcessColorFn.asObject(rt).asFunction(rt);
     auto& registry = core::UnistylesRegistry::get();
@@ -224,22 +219,32 @@ void HybridStyleSheet::loadExternalMethods(const jsi::Value& thisValue, jsi::Run
 void HybridStyleSheet::onPlatformDependenciesChange(std::vector<UnistyleDependency> dependencies) {
     auto& registry = core::UnistylesRegistry::get();
     auto parser = parser::Parser(this->_unistylesRuntime);
-    auto dependencyMap = registry.buildDependencyMap(dependencies);
     auto& rt = this->_unistylesRuntime->getRuntime();
 
+    // check if color scheme changed and then if Unistyles state depend on it (adaptive themes)
+    auto colorSchemeIt = std::find(dependencies.begin(), dependencies.end(), UnistyleDependency::COLORSCHEME);
+
+    if (colorSchemeIt != dependencies.end()) {
+        this->_unistylesRuntime->includeDependenciesForColorSchemeChange(dependencies);
+    }
+
+    auto dependencyMap = registry.buildDependencyMap(rt, dependencies);
+
     if (dependencyMap.size() == 0) {
         return;
     }
 
     parser.rebuildUnistylesInDependencyMap(rt, dependencyMap);
 
+    // this is required, otherwise shadow tree will ignore Unistyles commit
+    registry.trafficController.setHasUnistylesCommit(true);
+
     auto shadowLeafUpdates = parser.dependencyMapToShadowLeafUpdates(dependencyMap);
 
     shadow::ShadowTreeManager::updateShadowTree(rt, shadowLeafUpdates);
 }
 
-void HybridStyleSheet::registerCommitHook(jsi::Runtime &rt) {
-    UIManager& uiManager = const_cast<UIManager&>(UIManagerBinding::getBinding(rt)->getUIManager());
-
-    this->_unistylesCommitHook = std::make_shared<core::UnistylesCommitHook>(uiManager, this->_unistylesRuntime);
+void HybridStyleSheet::registerHooks(jsi::Runtime& rt) {
+    this->_unistylesCommitHook = std::make_shared<core::UnistylesCommitHook>(this->_uiManager, this->_unistylesRuntime, rt);
+    this->_unistylesMountHook = std::make_shared<core::UnistylesMountHook>(this->_uiManager, this->_unistylesRuntime, rt);
 }