react-native-unistyles 3.0.0-alpha.1 → 3.0.0-alpha.11

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,71 +57,61 @@ 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) {
+void core::UnistylesRegistry::linkShadowNodeWithUnistyle(
+    const ShadowNodeFamily* shadowNodeFamily,
+    const core::Unistyle::Shared unistyle,
+    Variants& variants,
+    std::vector<folly::dynamic>& arguments
+) {
     if (!this->_shadowRegistry.contains(shadowNodeFamily)) {
         this->_shadowRegistry[shadowNodeFamily] = {};
     }
-    
-    this->_shadowRegistry[shadowNodeFamily].emplace_back(unistyle);
+
+    this->_shadowRegistry[shadowNodeFamily].emplace_back(std::make_shared<UnistyleData>(unistyle, variants, arguments));
 }
 
 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);
-    
+    auto it = std::find_if(unistylesVec.begin(), unistylesVec.end(), [unistyle](std::shared_ptr<UnistyleData> unistyleData){
+        return unistyleData->unistyle == unistyle;
+    });
+
     if (it != unistylesVec.end()) {
         this->_shadowRegistry[shadowNodeFamily].erase(it);
     }
 }
 
-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)));
+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.back();
+    return this->_styleSheetRegistry[&rt][unid];
 }
 
-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;
-        }
-    );
-    
-    if (it == this->_styleSheetRegistry.cend()) {
-        throw std::runtime_error("stylesheet with tag: " + std::to_string(tag) + " cannot be found.");
-    }
-    
-    return *it;
-}
-    
-DependencyMap core::UnistylesRegistry::buildDependencyMap(std::vector<UnistyleDependency>& deps) {
+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) {
+        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();
                 }
             );
             
@@ -134,41 +119,25 @@ DependencyMap core::UnistylesRegistry::buildDependencyMap(std::vector<UnistyleDe
                 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) {
+        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,7 @@
 #include "StyleSheetRegistry.h"
 #include "StyleSheet.h"
 #include "Unistyle.h"
+#include "UnistyleData.h"
 
 namespace margelo::nitro::unistyles::core {
 
@@ -16,10 +19,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 +35,18 @@ struct UnistylesRegistry: public StyleSheetRegistry {
 
     UnistylesState& getState(jsi::Runtime& rt);
     void createState(jsi::Runtime& rt);
-    void linkShadowNodeWithUnistyle(const ShadowNodeFamily*, const core::Unistyle::Shared);
+    void linkShadowNodeWithUnistyle(const ShadowNodeFamily*, const core::Unistyle::Shared, Variants& variants, std::vector<folly::dynamic>&);
     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();
+    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);
+    DependencyMap buildDependencyMap(jsi::Runtime& rt);
 
 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<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);
 }

package/cxx/hybridObjects/HybridShadowRegistry.cpp

@@ -4,23 +4,30 @@ 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]);
-    
+    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(&shadowNodeWrapper->getFamily(), unistyleWrapper, 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 == 2, "Unistyles: Invalid babel transform 'ShadowRegistry unlink' expected 2 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);
-    
+
     return jsi::Value::undefined();
 }

package/cxx/hybridObjects/HybridStyleSheet.cpp

@@ -13,23 +13,17 @@ 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,28 @@ 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);
 
     return jsi::Value::undefined();
 }
@@ -87,7 +81,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 +90,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 +127,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 +145,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 +169,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 +195,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,9 +218,17 @@ 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;
     }
@@ -237,9 +239,3 @@ void HybridStyleSheet::onPlatformDependenciesChange(std::vector<UnistyleDependen
 
     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);
-}

package/cxx/hybridObjects/HybridStyleSheet.h

@@ -11,16 +11,19 @@
 #include "Parser.h"
 #include "ShadowTreeManager.h"
 #include "UnistylesCommitHook.h"
+#include "UnistylesMountHook.h"
 
 using namespace margelo::nitro::unistyles;
 using namespace facebook::react;
 
 struct HybridStyleSheet: public HybridUnistylesStyleSheetSpec {
-    HybridStyleSheet(std::shared_ptr<HybridUnistylesRuntime> unistylesRuntime)
-      : HybridObject(TAG), _unistylesRuntime{unistylesRuntime} {
-          this->_unistylesRuntime->registerPlatformListener(
-              std::bind(&HybridStyleSheet::onPlatformDependenciesChange, this, std::placeholders::_1)
-          );
+    HybridStyleSheet(std::shared_ptr<HybridUnistylesRuntime> unistylesRuntime, std::shared_ptr<UIManager> uiManager)
+        : HybridObject(TAG), _unistylesRuntime{unistylesRuntime} {
+            this->_unistylesCommitHook = std::make_shared<core::UnistylesCommitHook>(uiManager, unistylesRuntime);
+            this->_unistylesMountHook = std::make_shared<core::UnistylesMountHook>(uiManager, unistylesRuntime);
+            this->_unistylesRuntime->registerPlatformListener(
+                  std::bind(&HybridStyleSheet::onPlatformDependenciesChange, this, std::placeholders::_1)
+            );
       }
 
     jsi::Value create(jsi::Runtime& rt,
@@ -52,10 +55,10 @@ private:
     void setThemeFromColorScheme(jsi::Runtime& rt);
     void loadExternalMethods(const jsi::Value& thisValue, jsi::Runtime& rt);
     void onPlatformDependenciesChange(std::vector<UnistyleDependency> dependencies);
-    void registerCommitHook(jsi::Runtime& rt);
 
     double __unid = -1;
     std::shared_ptr<HybridUnistylesRuntime> _unistylesRuntime;
     std::shared_ptr<core::UnistylesCommitHook> _unistylesCommitHook;
+    std::shared_ptr<core::UnistylesMountHook> _unistylesMountHook;
 };
 

package/cxx/hybridObjects/HybridUnistylesRuntime.cpp

@@ -45,7 +45,7 @@ Insets HybridUnistylesRuntime::getInsets() {
 
 Orientation HybridUnistylesRuntime::getOrientation() {
     int orientation = this->_nativePlatform.getOrientation();
-    
+
     return static_cast<Orientation>(orientation);
 };
 
@@ -58,7 +58,7 @@ double HybridUnistylesRuntime::getFontScale() {
 };
 
 void HybridUnistylesRuntime::setTheme(const std::string &themeName) {
-    helpers::assertThat(*_rt, !this->getHasAdaptiveThemes(), "You're trying to set theme to: '" + themeName + "', but adaptiveThemes are enabled.");
+    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);
 
@@ -68,14 +68,17 @@ void HybridUnistylesRuntime::setTheme(const std::string &themeName) {
 
 void HybridUnistylesRuntime::setAdaptiveThemes(bool isEnabled) {
     auto& registry = core::UnistylesRegistry::get();
-    
+
     std::vector<UnistyleDependency> changedDependencies{};
+
+    changedDependencies.reserve(3);
+
     bool hadAdaptiveThemes = this->getHasAdaptiveThemes();
 
     registry.setPrefersAdaptiveThemes(*_rt, isEnabled);
-    
+
     bool haveAdaptiveThemes = this->getHasAdaptiveThemes();
-    
+
     if (hadAdaptiveThemes != haveAdaptiveThemes) {
         changedDependencies.push_back(UnistyleDependency::ADAPTIVETHEMES);
     }
@@ -83,12 +86,17 @@ void HybridUnistylesRuntime::setAdaptiveThemes(bool isEnabled) {
     // if user disabled it, or can't have adaptive themes, do nothing
     if (!this->getHasAdaptiveThemes()) {
         this->_onDependenciesChange(changedDependencies);
-        
+
         return;
     }
 
     // if user enabled adaptive themes, then we need to make sure
     // we selected theme based on color scheme
+    this->calculateNewThemeAndDependencies(changedDependencies);
+    this->_onDependenciesChange(changedDependencies);
+};
+
+void HybridUnistylesRuntime::calculateNewThemeAndDependencies(std::vector<UnistyleDependency>& changedDependencies) {
     auto& state = core::UnistylesRegistry::get().getState(*_rt);
     auto colorScheme = this->getColorScheme();
     auto currentThemeName = this->getThemeName();
@@ -99,24 +107,23 @@ void HybridUnistylesRuntime::setAdaptiveThemes(bool isEnabled) {
     if (!currentThemeName.has_value() || nextTheme != currentThemeName.value()) {
         changedDependencies.push_back(UnistyleDependency::THEME);
         changedDependencies.push_back(UnistyleDependency::THEMENAME);
-        
+
         state.setTheme(nextTheme);
     }
-    
-    this->_onDependenciesChange(changedDependencies);
-};
+}
 
 jsi::Value HybridUnistylesRuntime::updateTheme(jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) {
-    helpers::assertThat(rt, args[0].isString(), "first argument expected to be a string.");
-    helpers::assertThat(rt, args[1].isObject(), "second argument expected to be a function.");
+    helpers::assertThat(rt, count == 2, "UnistylesRuntime.updateTheme expected to be called with 2 arguments.");
+    helpers::assertThat(rt, args[0].isString(), "UnistylesRuntime.updateTheme expected first argument to be a string.");
+    helpers::assertThat(rt, args[1].isObject(), "UnistylesRuntime.updateTheme expected first argument to be a function.");
 
     auto& registry = core::UnistylesRegistry::get();
     auto themeName = args[0].asString(rt).utf8(rt);
 
-    helpers::assertThat(rt, args[1].asObject(rt).isFunction(rt), "second argument expected to be a function.");
+    helpers::assertThat(rt, args[1].asObject(rt).isFunction(rt), "UnistylesRuntime.updateTheme expected second argument to be a function.");
 
     registry.updateTheme(rt, themeName, args[1].asObject(rt).asFunction(rt));
-    
+
     this->_onDependenciesChange({UnistyleDependency::THEME});
 
     return jsi::Value::undefined();
@@ -163,7 +170,7 @@ UnistylesCxxMiniRuntime HybridUnistylesRuntime::getMiniRuntime() {
         nativeMiniRuntime.statusBar,
         nativeMiniRuntime.navigationBar
     };
-    
+
     return cxxMiniRuntime;
 }
 
@@ -197,3 +204,15 @@ void HybridUnistylesRuntime::registerPlatformListener(const std::function<void(s
     this->_nativePlatform.registerPlatformListener(listener);
     this->_onDependenciesChange = listener;
 }
+
+void HybridUnistylesRuntime::includeDependenciesForColorSchemeChange(std::vector<UnistyleDependency>& deps) {
+    auto& registry = core::UnistylesRegistry::get();
+    auto& state = registry.getState(*this->_rt);
+
+    // ignore color scheme changes if user has no adaptive themes
+    if (!state.hasAdaptiveThemes()) {
+        return;
+    }
+
+    this->calculateNewThemeAndDependencies(deps);
+}