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

package/Unistyles.podspec

@@ -10,7 +10,7 @@ Pod::Spec.new do |s|
   s.license      = package["license"]
   s.authors      = package["author"]
 
-  s.platforms    = { :ios => min_ios_version_supported, :osx => "10.14", :tvos => "9.0", :visionos => "1.0" }
+  s.platforms    = { :ios => min_ios_version_supported }
   s.source       = { :git => package["repository"], :tag => "#{s.version}" }
 
   s.source_files = [
@@ -18,7 +18,8 @@ Pod::Spec.new do |s|
     "cxx/**/*.{h,cpp,hpp}"
   ]
   s.pod_target_xcconfig = {
-    "CLANG_CXX_LANGUAGE_STANDARD" => "c++20"
+    "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
+    "GCC_PREPROCESSOR_DEFINITIONS" => "$(inherited) FOLLY_NO_CONFIG FOLLY_CFG_NO_COROUTINES"
   }
 
   s.public_header_files = [

package/cxx/common/Constants.h

@@ -5,6 +5,8 @@ namespace margelo::nitro::unistyles::helpers {
 static const std::string UNISTYLES_ID = "__unid";
 static const std::string ADD_VARIANTS_FN = "useVariants";
 static const std::string STYLE_DEPENDENCIES = "uni__dependencies";
+static const std::string STYLE_VARIANTS = "uni__variants";
 static const std::string WEB_STYLE_KEY = "_web";
+static const std::string EXOTIC_STYLE_KEY = "_exotic";
 
 }

package/cxx/common/Helpers.h

@@ -1,12 +1,16 @@
 #pragma once
 
 #include <jsi/jsi.h>
+#include <jsi/JSIDynamic.h>
+#include <folly/dynamic.h>
 #include <unordered_set>
 
 using namespace facebook;
 
 namespace margelo::nitro::unistyles::helpers {
 
+using Variants = std::vector<std::pair<std::string, std::string>>;
+
 inline void assertThat(jsi::Runtime& rt, bool condition, const std::string& message) {
     if (!condition) {
         throw jsi::JSError(rt, message);
@@ -16,11 +20,11 @@ inline void assertThat(jsi::Runtime& rt, bool condition, const std::string& mess
 inline void enumerateJSIObject(jsi::Runtime& rt, const jsi::Object& obj, std::function<void(const std::string& propertyName, jsi::Value& propertyValue)> callback) {
     jsi::Array propertyNames = obj.getPropertyNames(rt);
     size_t length = propertyNames.size(rt);
-    
+
     for (size_t i = 0; i < length; i++) {
         auto propertyName = propertyNames.getValueAtIndex(rt, i).asString(rt).utf8(rt);
         auto propertyValue = obj.getProperty(rt, propertyName.c_str());
-        
+
         callback(propertyName, propertyValue);
     }
 }
@@ -28,15 +32,15 @@ inline void enumerateJSIObject(jsi::Runtime& rt, const jsi::Object& obj, std::fu
 template<typename PropertyType>
 inline bool vecContainsKeys(std::vector<PropertyType>& vec, std::vector<PropertyType>&& keys) {
     std::unordered_set<PropertyType> availableKeys(keys.begin(), keys.end());
-    
+
     for (const auto& key : vec) {
         availableKeys.erase(key);
-        
+
         if (availableKeys.empty()) {
             return true;
         }
     }
-    
+
     return false;
 }
 
@@ -90,4 +94,92 @@ inline bool isPlatformColor(jsi::Runtime& rt, jsi::Object& maybePlatformColor) {
     return maybePlatformColor.hasProperty(rt, "resource_paths") && maybePlatformColor.getProperty(rt, "resource_paths").isObject();
 }
 
+inline Variants variantsToPairs(jsi::Runtime& rt, jsi::Object&& variants) {
+    Variants pairs{};
+
+    helpers::enumerateJSIObject(rt, variants, [&](const std::string& variantName, jsi::Value& variantValue){
+        if (variantValue.isUndefined() || variantValue.isNull()) {
+            return;
+        }
+
+        if (variantValue.isBool()) {
+            pairs.emplace_back(std::make_pair(variantName, variantValue.asBool() ? "true" : "false"));
+
+            return;
+        }
+
+        if (variantValue.isString()) {
+            pairs.emplace_back(std::make_pair(variantName, variantValue.asString(rt).utf8(rt)));
+        }
+    });
+
+    return pairs;
+}
+
+inline jsi::Object variantsToValue(jsi::Runtime& rt, Variants& variants) {
+    jsi::Object rawVariants = jsi::Object(rt);
+
+    std::for_each(variants.begin(), variants.end(), [&](std::pair<std::string, std::string>& pair){
+        rawVariants.setProperty(rt, pair.first.c_str(), jsi::String::createFromUtf8(rt, pair.second));
+    });
+
+    return rawVariants;
+}
+
+inline std::vector<folly::dynamic> parseDynamicFunctionArguments(jsi::Runtime& rt, jsi::Array& arguments) {
+    std::vector<folly::dynamic> parsedArgument{};
+    size_t count = arguments.size(rt);
+
+    parsedArgument.reserve(count);
+
+    for (size_t i = 0; i < count; i++) {
+        jsi::Value arg = arguments.getValueAtIndex(rt, i);
+
+        if (arg.isBool()) {
+            parsedArgument.push_back(folly::dynamic(arg.asBool()));
+
+            continue;
+        }
+
+        if (arg.isNumber()) {
+            parsedArgument.push_back(folly::dynamic(arg.asNumber()));
+
+            continue;
+        }
+
+        if (arg.isString()) {
+            parsedArgument.push_back(folly::dynamic(arg.asString(rt).utf8(rt)));
+
+            continue;
+        }
+
+        if (arg.isUndefined()) {
+            parsedArgument.push_back(folly::dynamic());
+
+            continue;
+        }
+
+        if (arg.isNull()) {
+            parsedArgument.push_back(folly::dynamic(nullptr));
+
+            continue;
+        }
+
+        if (!arg.isObject()) {
+            continue;;
+        }
+
+        auto argObj = arg.asObject(rt);
+
+        // allow arrays and objects too
+        if (!argObj.isFunction(rt) && !argObj.isArrayBuffer(rt)) {
+            parsedArgument.push_back(jsi::dynamicFromValue(rt, arg));
+
+            continue;
+        }
+    }
+
+    return parsedArgument;
+}
+
 }

package/cxx/core/HostStyle.cpp

@@ -7,10 +7,12 @@ using namespace facebook;
 std::vector<jsi::PropNameID> HostStyle::getPropertyNames(jsi::Runtime& rt) {
     auto propertyNames = std::vector<jsi::PropNameID> {};
 
+    propertyNames.reserve(8);
+
     for (const auto& pair : this->_styleSheet->unistyles) {
         propertyNames.emplace_back(jsi::PropNameID::forUtf8(rt, pair.first));
     }
-    
+
     return propertyNames;
 }
 
@@ -20,15 +22,19 @@ jsi::Value HostStyle::get(jsi::Runtime& rt, const jsi::PropNameID& propNameId) {
     if (propertyName == helpers::UNISTYLES_ID) {
         return jsi::Value(this->_styleSheet->tag);
     }
-    
+
     if (propertyName == helpers::ADD_VARIANTS_FN) {
         return this->createAddVariantsProxyFunction(rt);
     }
 
     if (this->_styleSheet->unistyles.contains(propertyName)) {
-        return valueFromUnistyle(rt, this->_styleSheet->unistyles[propertyName]);
+        return valueFromUnistyle(rt, this->_styleSheet->unistyles[propertyName], this->_styleSheet->tag);
     }
     
+    if (propertyName == helpers::STYLE_VARIANTS) {
+        return helpers::variantsToValue(rt, this->_variants);
+    }
+
     return jsi::Value::undefined();
 }
 
@@ -36,20 +42,20 @@ jsi::Function HostStyle::createAddVariantsProxyFunction(jsi::Runtime& rt) {
     auto useVariantsFnName = jsi::PropNameID::forUtf8(rt, helpers::ADD_VARIANTS_FN);
 
     return jsi::Function::createFromHostFunction(rt, useVariantsFnName, 1, [&](jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *arguments, size_t count){
-        helpers::assertThat(rt, count == 1, "useVariants expected to be called with one argument.");
-        helpers::assertThat(rt, arguments[0].isObject(), "useVariants expected to be called with object.");
+        helpers::assertThat(rt, count == 1, "Unistyles: useVariants expected to be called with one argument.");
+        helpers::assertThat(rt, arguments[0].isObject(), "Unistyles: useVariants expected to be called with object.");
 
         auto parser = parser::Parser(this->_unistylesRuntime);
-        auto pairs = parser.variantsToPairs(rt, arguments[0].asObject(rt));
-        
-        if (pairs == this->_styleSheet->variants) {
+        auto pairs = helpers::variantsToPairs(rt, arguments[0].asObject(rt));
+
+        if (pairs == this->_variants) {
             return jsi::Value::undefined();
         }
-        
-        this->_styleSheet->variants = pairs;
-        
-        parser.rebuildUnistylesWithVariants(rt, this->_styleSheet);
-        
+
+        this->_variants = pairs;
+
+        parser.rebuildUnistylesWithVariants(rt, this->_styleSheet, this->_variants);
+
         return jsi::Value::undefined();
     });
 }

package/cxx/core/HostStyle.h

@@ -4,10 +4,13 @@
 #include "StyleSheet.h"
 #include "Constants.h"
 #include "Parser.h"
+#include "UnistyleWrapper.h"
 #include "HybridUnistylesRuntime.h"
 
 namespace margelo::nitro::unistyles::core {
 
+using Variants = std::vector<std::pair<std::string, std::string>>;
+
 struct JSI_EXPORT HostStyle : public jsi::HostObject {
     HostStyle(std::shared_ptr<StyleSheet> styleSheet, std::shared_ptr<HybridUnistylesRuntime> unistylesRuntime)
         : _styleSheet{styleSheet}, _unistylesRuntime{unistylesRuntime} {};
@@ -20,6 +23,7 @@ struct JSI_EXPORT HostStyle : public jsi::HostObject {
 private:
     std::shared_ptr<StyleSheet> _styleSheet;
     std::shared_ptr<HybridUnistylesRuntime> _unistylesRuntime;
+    std::vector<std::pair<std::string, std::string>> _variants{};
 };
 
 }

package/cxx/core/StyleSheet.h

@@ -2,7 +2,6 @@
 
 #include <jsi/jsi.h>
 #include "Unistyle.h"
-#include "UnistyleWrapper.h"
 #include "Helpers.h"
 #include "Constants.h"
 
@@ -26,7 +25,6 @@ struct StyleSheet {
     StyleSheetType type;
     jsi::Object rawValue;
     std::unordered_map<std::string, Unistyle::Shared> unistyles{};
-    std::vector<std::pair<std::string, std::string>> variants{};
 };
 
 }

package/cxx/core/StyleSheetRegistry.cpp

@@ -4,20 +4,18 @@
 using namespace margelo::nitro::unistyles::core;
 using namespace facebook;
 
-std::shared_ptr<StyleSheet> StyleSheetRegistry::addStyleSheetFromValue(jsi::Runtime& rt, jsi::Object rawStyleSheet) {
-    static unsigned int tag = 0;
-
+std::shared_ptr<StyleSheet> StyleSheetRegistry::addStyleSheetFromValue(jsi::Runtime& rt, jsi::Object rawStyleSheet, int unid) {
     if (rawStyleSheet.isFunction(rt)) {
-        return this->addFromFunction(rt, ++tag, rawStyleSheet.asFunction(rt));
+        return this->addFromFunction(rt, unid, rawStyleSheet.asFunction(rt));
     }
 
-    return this->addFromObject(rt, ++tag, std::move(rawStyleSheet));
+    return this->addFromObject(rt, unid, std::move(rawStyleSheet));
 }
 
-std::shared_ptr<StyleSheet> StyleSheetRegistry::addFromFunction(jsi::Runtime& rt, unsigned int tag, jsi::Function styleSheetFn) {
+std::shared_ptr<StyleSheet> StyleSheetRegistry::addFromFunction(jsi::Runtime& rt, int unid, jsi::Function styleSheetFn) {
     auto numberOfArgs = styleSheetFn.getProperty(rt, "length").getNumber();
 
-    helpers::assertThat(rt, numberOfArgs <= 2, "expected up to 2 arguments.");
+    helpers::assertThat(rt, numberOfArgs <= 2, "StyleSheet.create expected up to 2 arguments.");
     
     auto& registry = UnistylesRegistry::get();
 
@@ -25,21 +23,20 @@ std::shared_ptr<StyleSheet> StyleSheetRegistry::addFromFunction(jsi::Runtime& rt
     if (numberOfArgs == 0) {
         auto staticStyleSheet = styleSheetFn.call(rt).asObject(rt);
 
-        return registry.addStyleSheet(tag, core::StyleSheetType::Static, std::move(staticStyleSheet));
+        return registry.addStyleSheet(rt, unid, core::StyleSheetType::Static, std::move(staticStyleSheet));
     }
 
     // stylesheet depends only on theme
     if (numberOfArgs == 1) {
-        return registry.addStyleSheet(tag, core::StyleSheetType::Themable, std::move(styleSheetFn));
+        return registry.addStyleSheet(rt, unid, core::StyleSheetType::Themable, std::move(styleSheetFn));
     }
 
     // stylesheet depends on theme and mini runtime
-    return registry.addStyleSheet(tag, core::StyleSheetType::ThemableWithMiniRuntime, std::move(styleSheetFn));
+    return registry.addStyleSheet(rt, unid, core::StyleSheetType::ThemableWithMiniRuntime, std::move(styleSheetFn));
 }
 
-std::shared_ptr<StyleSheet> StyleSheetRegistry::addFromObject(jsi::Runtime& rt, unsigned int tag, jsi::Object rawStyleSheet) {
+std::shared_ptr<StyleSheet> StyleSheetRegistry::addFromObject(jsi::Runtime& rt, int tag, jsi::Object rawStyleSheet) {
     auto& registry = UnistylesRegistry::get();
     
-    return registry.addStyleSheet(tag, core::StyleSheetType::Static, std::move(rawStyleSheet));
+    return registry.addStyleSheet(rt, tag, core::StyleSheetType::Static, std::move(rawStyleSheet));
 }
-

package/cxx/core/StyleSheetRegistry.h

@@ -16,11 +16,11 @@ struct StyleSheetRegistry {
     StyleSheetRegistry(const StyleSheetRegistry&) = delete;
     StyleSheetRegistry(StyleSheetRegistry&&) = delete;
 
-    virtual std::shared_ptr<StyleSheet> addStyleSheetFromValue(jsi::Runtime& rt, jsi::Object rawStyleSheet);
-
+    virtual std::shared_ptr<StyleSheet> addStyleSheetFromValue(jsi::Runtime& rt, jsi::Object rawStyleSheet, int unid);
+    
 private:
-    virtual std::shared_ptr<StyleSheet> addFromFunction(jsi::Runtime& rt, unsigned int tag, jsi::Function styleSheetFn);
-    virtual std::shared_ptr<StyleSheet> addFromObject(jsi::Runtime& rt, unsigned int tag, jsi::Object rawStyleSheet);
+    virtual std::shared_ptr<StyleSheet> addFromFunction(jsi::Runtime& rt, int unid, jsi::Function styleSheetFn);
+    virtual std::shared_ptr<StyleSheet> addFromObject(jsi::Runtime& rt, int unid, jsi::Object rawStyleSheet);
 };
 
 }

package/cxx/core/Unistyle.h

@@ -7,6 +7,8 @@
 
 namespace margelo::nitro::unistyles::core {
 
+class StyleSheet;
+
 using namespace facebook;
 
 enum class UnistyleType {
@@ -14,16 +16,11 @@ enum class UnistyleType {
     DynamicFunction
 };
 
-struct DynamicFunctionMetadata {
-    size_t count;
-    std::vector<folly::dynamic> arguments;
-};
-
 struct Unistyle {
     using Shared = std::shared_ptr<Unistyle>;
 
-    Unistyle(UnistyleType type, std::string styleKey, jsi::Object& rawObject)
-        : styleKey{styleKey}, type{type}, rawValue{std::move(rawObject)} {}
+    Unistyle(UnistyleType type, std::string styleKey, jsi::Object& rawObject, std::shared_ptr<StyleSheet> styleSheet)
+        : styleKey{styleKey}, type{type}, rawValue{std::move(rawObject)}, parent{styleSheet} {}
     virtual ~Unistyle() = default;
 
     Unistyle(const Unistyle&) = delete;
@@ -34,6 +31,7 @@ struct Unistyle {
     jsi::Object rawValue;
     std::optional<jsi::Object> parsedStyle;
     std::vector<UnistyleDependency> dependencies{};
+    std::shared_ptr<StyleSheet> parent;
 
     inline void addDependency(UnistyleDependency dependency) {
         // we can't add dependencies if unistyle is sealed
@@ -67,15 +65,14 @@ struct UnistyleDynamicFunction: public Unistyle {
     // unprocessedValue <- object generated after calling proxy and user's original function
     // parsedStyle <- parsed with Unistyle's parser
 
-    UnistyleDynamicFunction(UnistyleType type, std::string styleKey, jsi::Object& rawObject)
-        : Unistyle(type, styleKey, rawObject) {}
+    UnistyleDynamicFunction(UnistyleType type, std::string styleKey, jsi::Object& rawObject, std::shared_ptr<StyleSheet> styleSheet)
+        : Unistyle(type, styleKey, rawObject, styleSheet) {}
 
     UnistyleDynamicFunction(const UnistyleDynamicFunction&) = delete;
     UnistyleDynamicFunction(UnistyleDynamicFunction&& other) = delete;
 
     std::optional<jsi::Object> unprocessedValue;
     std::optional<jsi::Function> proxiedFunction = std::nullopt;
-    std::optional<DynamicFunctionMetadata> dynamicFunctionMetadata = std::nullopt;
 };
 
 }

package/cxx/core/UnistyleData.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include "Unistyle.h"
+
+namespace margelo::nitro::unistyles::core {
+
+using Variants = std::vector<std::pair<std::string, std::string>>;
+
+struct UnistyleData {
+    UnistyleData(Unistyle::Shared unistyle, const Variants& variants, std::vector<folly::dynamic>& arguments)
+        : unistyle{unistyle}, variants(std::move(variants)), dynamicFunctionMetadata{std::move(arguments)} {}
+
+    UnistyleData(const UnistyleData&) = delete;
+    UnistyleData(UnistyleData&& other): unistyle{other.unistyle}, variants(std::move(other.variants)) {}
+
+    core::Unistyle::Shared unistyle;
+    core::Variants variants;
+    std::optional<jsi::Object> parsedStyle = std::nullopt;
+    std::optional<std::vector<folly::dynamic>> dynamicFunctionMetadata = std::nullopt;
+};
+
+}

package/cxx/core/UnistyleWrapper.h

@@ -2,6 +2,7 @@
 
 #include <jsi/jsi.h>
 #include "Unistyle.h"
+#include "UnistylesRegistry.h"
 #include "Helpers.h"
 #include "Constants.h"
 
@@ -16,33 +17,100 @@ struct UnistyleWrapper: public jsi::NativeState {
     Unistyle::Shared unistyle;
 };
 
-inline static Unistyle::Shared unistyleFromValue(jsi::Runtime& rt, const jsi::Value& value) {
-    if (value.isNull()) {
+inline static std::string generateStyleKey(std::string& key, int tag) {
+    return std::string("__unid_").append(std::to_string(tag)).append("_").append(key).c_str();
+}
+
+inline static Unistyle::Shared unistyleFromKey(jsi::Runtime& rt, const std::string& key) {
+    std::string prefix = "__unid_";
+
+    if (key.substr(0, prefix.length()) != prefix) {
+        return nullptr;
+    }
+
+    std::string remaining = key.substr(prefix.length());
+
+    size_t underscorePos = remaining.find('_');
+
+    if (underscorePos == std::string::npos) {
         return nullptr;
     }
 
-    return value.getObject(rt).getNativeState<UnistyleWrapper>(rt)->unistyle;
+    std::string tagStr = remaining.substr(0, underscorePos);
+
+    auto& registry = UnistylesRegistry::get();
+    auto tag = std::stoi(tagStr);
+    auto styleKey = remaining.substr(underscorePos + 1);
+
+    return registry.findUnistyleFromKey(rt, styleKey, tag);
+}
+
+inline static Unistyle::Shared unistyleFromStaticStyleSheet(jsi::Runtime& rt, jsi::Object& value) {
+    auto exoticUnistyle = std::make_shared<Unistyle>(
+        UnistyleType::Object,
+        helpers::EXOTIC_STYLE_KEY,
+        value,
+        nullptr
+    );
+
+    exoticUnistyle->seal();
+
+    return exoticUnistyle;
+}
+
+
+inline static std::vector<Unistyle::Shared> unistylesFromNonExistentNativeState(jsi::Runtime& rt, jsi::Object& value) {
+    std::vector<Unistyle::Shared> foundUnistyles{};
+
+    helpers::enumerateJSIObject(rt, value, [&](const std::string& key, jsi::Value& value){
+        auto maybeUnistyle = unistyleFromKey(rt, key);
+
+        if (maybeUnistyle != nullptr) {
+            foundUnistyles.emplace_back(maybeUnistyle);
+        }
+    });
+
+    if (foundUnistyles.size() == 0) {
+        return {unistyleFromStaticStyleSheet(rt, value)};
+    }
+
+    return foundUnistyles;
 }
 
-inline static jsi::Value valueFromUnistyle(jsi::Runtime& rt, Unistyle::Shared unistyle) {
+inline static std::vector<Unistyle::Shared> unistyleFromValue(jsi::Runtime& rt, const jsi::Value& value) {
+    if (value.isNull()) {
+        return {};
+    }
+
+    auto obj = value.getObject(rt);
+
+    // possible if user used React Native styles or inline styles or did spread styles
+    if (!obj.hasNativeState(rt)) {
+        return unistylesFromNonExistentNativeState(rt, obj);
+    }
+
+    return {value.getObject(rt).getNativeState<UnistyleWrapper>(rt)->unistyle};
+}
+
+inline static jsi::Value valueFromUnistyle(jsi::Runtime& rt, Unistyle::Shared unistyle, int tag) {
     auto wrappedUnistyle = std::make_shared<UnistyleWrapper>(unistyle);
-    
+
     if (unistyle->type == UnistyleType::Object) {
         jsi::Object obj = jsi::Object(rt);
-        
+       
         obj.setNativeState(rt, std::move(wrappedUnistyle));
-        helpers::defineHiddenProperty(rt, obj, helpers::UNISTYLES_ID.c_str(), unistyle->styleKey);
+        obj.setProperty(rt, std::string("__unid_").append(std::to_string(tag)).append("_").append(unistyle->styleKey).c_str(), jsi::Value::undefined());
         
         helpers::mergeJSIObjects(rt, obj, unistyle->parsedStyle.value());
-        
+
         return obj;
     }
-    
+
     auto unistyleFn = std::dynamic_pointer_cast<UnistyleDynamicFunction>(unistyle);
     auto hostFn = jsi::Value(rt, unistyleFn->proxiedFunction.value()).asObject(rt).asFunction(rt);
 
     hostFn.setNativeState(rt, std::move(wrappedUnistyle));
-    hostFn.setProperty(rt, helpers::UNISTYLES_ID.c_str(), unistyleFn->styleKey);
+    hostFn.setProperty(rt, std::string("__unid_").append(std::to_string(tag)).append("_").append(unistyleFn->styleKey).c_str(), jsi::Value::undefined());
     
     return std::move(hostFn);
 }

package/cxx/core/UnistylesCommitHook.cpp

@@ -3,12 +3,9 @@
 using namespace margelo::nitro::unistyles;
 using namespace facebook::react;
 
-core::UnistylesCommitHook::UnistylesCommitHook(UIManager& uiManager, std::shared_ptr<HybridUnistylesRuntime> unistylesRuntime)
-    : _unistylesRuntime{unistylesRuntime} {
-        uiManager.registerCommitHook(*this);
-    };
-
-core::UnistylesCommitHook::~UnistylesCommitHook() noexcept {}
+core::UnistylesCommitHook::~UnistylesCommitHook() noexcept {
+    _uiManager->unregisterCommitHook(*this);
+}
 
 void core::UnistylesCommitHook::commitHookWasRegistered(const UIManager &uiManager) noexcept {}
 void core::UnistylesCommitHook::commitHookWasUnregistered(const UIManager &uiManager) noexcept {}
@@ -20,24 +17,34 @@ RootShadowNode::Unshared core::UnistylesCommitHook::shadowTreeWillCommit(
 ) noexcept {
     RootShadowNode::Unshared rootNode = newRootShadowNode;
     auto unistylesRootNode = std::reinterpret_pointer_cast<core::UnistylesCommitShadowNode>(newRootShadowNode);
-    
+
     // skip only unistyles commits
     if (unistylesRootNode->hasUnistylesCommitTrait()) {
         unistylesRootNode->removeUnistylesCommitTrait();
-        
+        unistylesRootNode->addUnistylesMountTrait();
+
+        return newRootShadowNode;
+    }
+
+    auto& registry = core::UnistylesRegistry::get();
+
+    if (!registry.trafficController.hasUnistylesCommit()) {
         return newRootShadowNode;
     }
 
     auto shadowLeafUpdates = this->getUnistylesUpdates();
-    
+
     if (shadowLeafUpdates.size() == 0) {
         return newRootShadowNode;
     }
-    
+
+    // this is required, otherwise we end up with old shadow tree in mount hook
+    registry.trafficController.stopUnistylesTraffic();
+
     auto affectedNodes = shadow::ShadowTreeManager::findAffectedNodes(*rootNode, shadowLeafUpdates);
 
     return std::static_pointer_cast<RootShadowNode>(shadow::ShadowTreeManager::cloneShadowTree(
-        this->_unistylesRuntime->getRuntime(),
+        *this->_rt,
         *rootNode,
         shadowLeafUpdates,
         affectedNodes
@@ -47,7 +54,9 @@ RootShadowNode::Unshared core::UnistylesCommitHook::shadowTreeWillCommit(
 shadow::ShadowLeafUpdates core::UnistylesCommitHook::getUnistylesUpdates() {
     auto& registry = core::UnistylesRegistry::get();
     auto parser = parser::Parser(this->_unistylesRuntime);
-    auto dependencyMap = registry.buildDependencyMap();
-    
+    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/UnistylesCommitHook.h

@@ -5,13 +5,18 @@
 #include "HybridUnistylesRuntime.h"
 #include "Parser.h"
 #include "ShadowTreeManager.h"
+#include "ShadowTrafficController.h"
 
 namespace margelo::nitro::unistyles::core {
 
 using namespace facebook::react;
 
 struct UnistylesCommitHook : public UIManagerCommitHook {
-    UnistylesCommitHook(UIManager& uiManager, std::shared_ptr<HybridUnistylesRuntime> unistylesRuntime);
+    UnistylesCommitHook(std::shared_ptr<UIManager> uiManager, std::shared_ptr<HybridUnistylesRuntime> unistylesRuntime, jsi::Runtime& rt)
+        : _unistylesRuntime{unistylesRuntime}, _uiManager{uiManager}, _rt{&rt} {
+            _uiManager->registerCommitHook(*this);
+        }
+    
     ~UnistylesCommitHook() noexcept override;
 
     void commitHookWasRegistered(const UIManager &uiManager) noexcept override;
@@ -22,6 +27,8 @@ struct UnistylesCommitHook : public UIManagerCommitHook {
     
 private:
     std::shared_ptr<HybridUnistylesRuntime> _unistylesRuntime;
+    std::shared_ptr<UIManager> _uiManager;
+    jsi::Runtime* _rt;
 };
 
 }

package/cxx/core/UnistylesCommitShadowNode.h

@@ -8,6 +8,7 @@ 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() {
@@ -21,6 +22,18 @@ struct UnistylesCommitShadowNode: public shadow::ShadowNode {
     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);
+    }
 };
 
 }