react-native-unistyles 3.0.0-alpha.8 → 3.0.0-beta.1

package/cxx/common/Helpers.h

@@ -1,6 +1,9 @@
 #pragma once
 
 #include <jsi/jsi.h>
+#include <jsi/JSIDynamic.h>
+#include <folly/dynamic.h>
+#include "NativePlatform.h"
 #include <unordered_set>
 
 using namespace facebook;
@@ -18,11 +21,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);
     }
 }
@@ -30,15 +33,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;
 }
 
@@ -88,6 +91,16 @@ inline bool isPlatformColor(jsi::Runtime& rt, jsi::Object& maybePlatformColor) {
         return true;
     }
 
+    auto isIOSDynamicColor =
+        maybePlatformColor.hasProperty(rt, "dynamic") &&
+        maybePlatformColor.getProperty(rt, "dynamic").isObject() &&
+        maybePlatformColor.getProperty(rt, "dynamic").asObject(rt).hasProperty(rt, "dark") &&
+        maybePlatformColor.getProperty(rt, "dynamic").asObject(rt).hasProperty(rt, "light");
+
+    if (isIOSDynamicColor) {
+        return true;
+    }
+
     // Android
     return maybePlatformColor.hasProperty(rt, "resource_paths") && maybePlatformColor.getProperty(rt, "resource_paths").isObject();
 }
@@ -114,4 +127,102 @@ inline Variants variantsToPairs(jsi::Runtime& rt, jsi::Object&& variants) {
     return pairs;
 }
 
+inline jsi::Object pairsToVariantsValue(jsi::Runtime& rt, Variants& pairs) {
+    auto variantsValue = jsi::Object(rt);
+
+    std::for_each(pairs.begin(), pairs.end(), [&rt, &variantsValue](std::pair<std::string, std::string>& pair){
+        variantsValue.setProperty(rt, jsi::PropNameID::forUtf8(rt, pair.first), jsi::String::createFromUtf8(rt, pair.second));
+    });
+
+    return variantsValue;
+}
+
+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;
+}
+
+inline jsi::Array functionArgumentsToArray(jsi::Runtime& rt, const jsi::Value* args, size_t count) {
+    auto arr = jsi::Array(rt, count);
+
+    for (size_t i = 0; i < count; i++) {
+        const jsi::Value& arg = args[i];
+
+        arr.setValueAtIndex(rt, i, arg);
+    }
+
+    return arr;
+}
+
+inline static jsi::Array dependenciesToJSIArray(jsi::Runtime& rt, const std::vector<UnistyleDependency>& vec) {
+    jsi::Array result(rt, vec.size());
+
+    for (size_t i = 0; i < vec.size(); i++) {
+        result.setValueAtIndex(rt, i, jsi::Value(static_cast<int>(vec[i])));
+    }
+
+    return result;
+}
+
 }

package/cxx/core/HostStyle.cpp

@@ -22,13 +22,17 @@ 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->_unistylesRuntime, this->_styleSheet->unistyles[propertyName], this->_styleSheet->tag);
+    }
+    
+    if (propertyName == helpers::STYLE_VARIANTS) {
+        return helpers::variantsToValue(rt, this->_variants);
     }
 
     return jsi::Value::undefined();
@@ -49,6 +53,7 @@ jsi::Function HostStyle::createAddVariantsProxyFunction(jsi::Runtime& rt) {
         }
 
         this->_variants = pairs;
+
         parser.rebuildUnistylesWithVariants(rt, this->_styleSheet, this->_variants);
 
         return jsi::Value::undefined();

package/cxx/core/HostStyle.h

@@ -4,6 +4,7 @@
 #include "StyleSheet.h"
 #include "Constants.h"
 #include "Parser.h"
+#include "UnistyleWrapper.h"
 #include "HybridUnistylesRuntime.h"
 
 namespace margelo::nitro::unistyles::core {
@@ -23,7 +24,6 @@ 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"
 

package/cxx/core/Unistyle.h

@@ -3,10 +3,12 @@
 #include "string"
 #include <jsi/jsi.h>
 #include <folly/dynamic.h>
-#include "Unistyles-Swift-Cxx-Umbrella.hpp"
+#include "NativePlatform.h"
 
 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

@@ -8,15 +8,17 @@ namespace margelo::nitro::unistyles::core {
 using Variants = std::vector<std::pair<std::string, std::string>>;
 
 struct UnistyleData {
-    UnistyleData(Unistyle::Shared unistyle, const Variants& variants)
-        : unistyle{unistyle}, variants(std::move(variants)) {}
+    UnistyleData(Unistyle::Shared unistyle, const Variants& variants, std::vector<folly::dynamic>& arguments, std::optional<std::string> uniquePressableId)
+        : unistyle{unistyle}, variants(std::move(variants)), dynamicFunctionMetadata{std::move(arguments)}, pressableId{std::move(uniquePressableId)} {}
 
     UnistyleData(const UnistyleData&) = delete;
-    UnistyleData(UnistyleData&& other): unistyle{other.unistyle}, variants(std::move(other.variants)) {}
+    UnistyleData(UnistyleData&& other) = delete;
 
     core::Unistyle::Shared unistyle;
     core::Variants variants;
     std::optional<jsi::Object> parsedStyle = std::nullopt;
+    std::optional<std::vector<folly::dynamic>> dynamicFunctionMetadata = std::nullopt;
+    std::optional<std::string> pressableId = std::nullopt;
 };
 
 }

package/cxx/core/UnistyleWrapper.h

@@ -2,8 +2,11 @@
 
 #include <jsi/jsi.h>
 #include "Unistyle.h"
+#include "UnistylesRegistry.h"
 #include "Helpers.h"
+#include "HybridUnistylesRuntime.h"
 #include "Constants.h"
+#include "Parser.h"
 
 namespace margelo::nitro::unistyles::core {
 
@@ -16,34 +19,126 @@ struct UnistyleWrapper: public jsi::NativeState {
     Unistyle::Shared unistyle;
 };
 
-inline static Unistyle::Shared unistyleFromValue(jsi::Runtime& rt, const jsi::Value& value) {
-    if (value.isNull()) {
-        return nullptr;
+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) {
+    auto hasUnistyleName = value.hasProperty(rt, helpers::NAME_STYLE_KEY.c_str());
+
+    // return wrapped RN/inline style
+    if (!hasUnistyleName) {
+        return {unistyleFromStaticStyleSheet(rt, value)};
     }
 
-    return value.getObject(rt).getNativeState<UnistyleWrapper>(rt)->unistyle;
+    throw jsi::JSError(rt, R"(Unistyles: Style is not bound!
+
+Potential reasons:
+- You likely used the spread operator on a Unistyle style outside of a JSX component
+
+If you need to merge styles, do it within the style prop of your JSX component:
+
+style={{...styles.container, ...styles.otherProp}}
+or
+style={[styles.container, styles.otherProp]}
+
+If you pass computed style prop to component use array syntax:
+
+customStyleProp={[styles.container, styles.otherProp]}
+
+Copying a Unistyle style outside of a JSX element will remove its internal C++ state, leading to unexpected behavior.)");
 }
 
-inline static jsi::Value valueFromUnistyle(jsi::Runtime& rt, Unistyle::Shared unistyle) {
-    auto wrappedUnistyle = std::make_shared<UnistyleWrapper>(unistyle);
+inline static jsi::Object generateUnistylesPrototype(
+    jsi::Runtime& rt,
+    std::shared_ptr<HybridUnistylesRuntime> unistylesRuntime,
+    Unistyle::Shared unistyle,
+    std::optional<Variants> variants,
+    std::optional<jsi::Array> arguments
+) {
+    // add prototype metadata for createUnistylesComponent
+    auto proto = jsi::Object(rt);
+    auto hostFn = jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forUtf8(rt, "getStyle"), 0, [unistyle, unistylesRuntime](jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count){
+        auto variants = helpers::variantsToPairs(rt, thisValue.asObject(rt).getProperty(rt, "variants").asObject(rt));
+        auto arguments = helpers::parseDynamicFunctionArguments(rt, thisValue.asObject(rt).getProperty(rt, "arguments").asObject(rt).asArray(rt));
+
+        parser::Parser(unistylesRuntime).rebuildUnistyle(rt, unistyle->parent, unistyle, variants, std::make_optional<std::vector<folly::dynamic>>(arguments));
+
+        return jsi::Value(rt, unistyle->parsedStyle.value()).asObject(rt);
+    });
+
+    proto.setProperty(rt, "getStyle", std::move(hostFn));
+    proto.setProperty(rt, "arguments", arguments.has_value() ? std::move(arguments.value()) : jsi::Array(rt, 0));
+    proto.setProperty(rt, "variants", variants.has_value() ? helpers::pairsToVariantsValue(rt, variants.value()) : jsi::Object(rt));
+    proto.setProperty(rt, helpers::STYLE_DEPENDENCIES.c_str(), helpers::dependenciesToJSIArray(rt, unistyle->dependencies));
+
+    return proto;
+}
+
+inline static std::vector<Unistyle::Shared> unistyleFromValue(jsi::Runtime& rt, const jsi::Value& value) {
+    if (value.isNull() || !value.isObject()) {
+        return {};
+    }
     
+    auto maybeArray = value.asObject(rt);
+    
+    helpers::assertThat(rt, maybeArray.isArray(rt), "Unistyles: can't retrieve Unistyle state from node as it's not an array.");
+    
+    std::vector<Unistyle::Shared> unistyles;
+    jsi::Array unistylesArray = maybeArray.asArray(rt);
+    
+    helpers::iterateJSIArray(rt, unistylesArray, [&rt, &unistyles](size_t index, jsi::Value& value){
+        auto obj = value.getObject(rt);
+
+        // possible if user used React Native styles or inline styles or did spread styles
+        if (!obj.hasNativeState(rt)) {
+            auto exoticUnistyles = unistylesFromNonExistentNativeState(rt, obj);
+            
+            for (auto& exoticUnistyle: exoticUnistyles) {
+                unistyles.emplace_back(exoticUnistyle);
+            }
+            
+            return;
+        }
+
+        unistyles.emplace_back(value.getObject(rt).getNativeState<UnistyleWrapper>(rt)->unistyle);
+    });
+    
+    return unistyles;
+}
+
+inline static jsi::Value valueFromUnistyle(jsi::Runtime& rt, std::shared_ptr<HybridUnistylesRuntime> unistylesRuntime, 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, helpers::NAME_STYLE_KEY.c_str(), jsi::String::createFromUtf8(rt, unistyle->styleKey));
+
+        helpers::defineHiddenProperty(rt, obj, helpers::STYLE_DEPENDENCIES.c_str(), helpers::dependenciesToJSIArray(rt, unistyle->dependencies));
         helpers::mergeJSIObjects(rt, obj, unistyle->parsedStyle.value());
-        
+
+        obj.setProperty(rt, "__proto__", generateUnistylesPrototype(rt, unistylesRuntime, unistyle, std::nullopt, std::nullopt));
+
         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, helpers::NAME_STYLE_KEY.c_str(), jsi::String::createFromUtf8(rt, unistyleFn->styleKey));
+
     return std::move(hostFn);
 }
 

package/cxx/core/UnistylesCommitHook.cpp

@@ -17,37 +17,33 @@ RootShadowNode::Unshared core::UnistylesCommitHook::shadowTreeWillCommit(
 ) noexcept {
     RootShadowNode::Unshared rootNode = newRootShadowNode;
     auto unistylesRootNode = std::reinterpret_pointer_cast<core::UnistylesCommitShadowNode>(newRootShadowNode);
-    
-    // skip only unistyles commits
+
+    // this is Unistyles commit, we don't need to override it
     if (unistylesRootNode->hasUnistylesCommitTrait()) {
         unistylesRootNode->removeUnistylesCommitTrait();
-        
+        unistylesRootNode->addUnistylesMountTrait();
+
         return newRootShadowNode;
     }
 
-    auto shadowLeafUpdates = this->getUnistylesUpdates();
-    
+    // this is React Native / Reanimated commit
+    // merge Unistyles updates before it completes
+    auto& registry = core::UnistylesRegistry::get();
+    auto& shadowLeafUpdates = registry.trafficController.getUpdates();
+
+    // oops, no updates from Unistyles yet, skip it!
     if (shadowLeafUpdates.size() == 0) {
         return newRootShadowNode;
     }
-    
+
     auto affectedNodes = shadow::ShadowTreeManager::findAffectedNodes(*rootNode, shadowLeafUpdates);
 
+    registry.trafficController.stopUnistylesTraffic();
+
+    // we have few updates, so merge it
     return std::static_pointer_cast<RootShadowNode>(shadow::ShadowTreeManager::cloneShadowTree(
-        this->_unistylesRuntime->getRuntime(),
         *rootNode,
         shadowLeafUpdates,
         affectedNodes
     ));
 }
-
-shadow::ShadowLeafUpdates core::UnistylesCommitHook::getUnistylesUpdates() {
-    auto& registry = core::UnistylesRegistry::get();
-    auto& rt = this->_unistylesRuntime->getRuntime();
-    auto parser = parser::Parser(this->_unistylesRuntime);
-    auto dependencyMap = registry.buildDependencyMap(rt);
-    
-    parser.rebuildUnistylesInDependencyMap(rt, dependencyMap);
-    
-    return parser.dependencyMapToShadowLeafUpdates(dependencyMap);
-}

package/cxx/core/UnistylesCommitHook.h

@@ -2,30 +2,25 @@
 
 #include <react/renderer/uimanager/UIManager.h>
 #include <react/renderer/uimanager/UIManagerCommitHook.h>
-#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(std::shared_ptr<UIManager> uiManager, std::shared_ptr<HybridUnistylesRuntime> unistylesRuntime)
-        : _unistylesRuntime{unistylesRuntime}, _uiManager{uiManager} {
-            _uiManager->registerCommitHook(*this);
-        }
-    
+    UnistylesCommitHook(std::shared_ptr<UIManager> uiManager) : _uiManager{uiManager} {
+        _uiManager->registerCommitHook(*this);
+    }
+
     ~UnistylesCommitHook() noexcept override;
 
     void commitHookWasRegistered(const UIManager &uiManager) noexcept override;
     void commitHookWasUnregistered(const UIManager &uiManager) noexcept override;
     RootShadowNode::Unshared shadowTreeWillCommit(const ShadowTree &shadowTree, const RootShadowNode::Shared &oldRootShadowNode, const RootShadowNode::Unshared &newRootShadowNode) noexcept override;
-    
-    shadow::ShadowLeafUpdates getUnistylesUpdates();
-    
+
 private:
-    std::shared_ptr<HybridUnistylesRuntime> _unistylesRuntime;
     std::shared_ptr<UIManager> _uiManager;
 };
 

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);
+    }
 };
 
 }

package/cxx/core/UnistylesMountHook.cpp

@@ -0,0 +1,28 @@
+#include "UnistylesMountHook.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;
+    }
+
+    // this is React Native or Reanimated commit
+    // one more time merge Unistyles changes
+    auto& registry = core::UnistylesRegistry::get();
+
+    if (!registry.trafficController.shouldStop()) {
+        shadow::ShadowTreeManager::updateShadowTree(this->_uiManager->getShadowTreeRegistry());
+    }
+}

package/cxx/core/UnistylesMountHook.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <react/renderer/uimanager/UIManager.h>
+#include <react/renderer/uimanager/UIManagerMountHook.h>
+#include "ShadowTreeManager.h"
+#include "HybridUnistylesRuntime.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)
+        : _uiManager{uiManager}, _unistylesRuntime{unistylesRuntime} {
+        _uiManager->registerMountHook(*this);
+    }
+
+    ~UnistylesMountHook() noexcept override;
+
+    void shadowTreeDidMount(RootShadowNode::Shared const &rootShadowNode, double mountTime) noexcept override;
+
+private:
+    std::shared_ptr<UIManager> _uiManager;
+    std::shared_ptr<HybridUnistylesRuntime> _unistylesRuntime;
+};
+
+}