react-native-unistyles 3.4.0 → 3.5.0

package/cxx/hybridObjects/HybridShadowRegistry.cpp

@@ -6,6 +6,11 @@ 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 == 2, "Unistyles: Invalid babel transform 'ShadowRegistry link' expected 2 arguments.");
 
+    // runtime was replaced, registry belongs to the next one
+    if (!this->_unistylesRuntime->ownsRegistry()) {
+        return jsi::Value::undefined();
+    }
+
     auto shadowNodeWrapper = getShadowNodeFromRef(rt, args[0]);
 
     std::vector<core::Unistyle::Shared> unistyleWrappers = core::unistyleFromValue(rt, args[1]);
@@ -97,28 +102,69 @@ jsi::Value HybridShadowRegistry::link(jsi::Runtime &rt, const jsi::Value &thisVa
     }
 
     std::optional<folly::dynamic> initialScopedUpdate;
+    bool shouldCommit = false;
 
-    if (scopedTheme.has_value() || wasSuspended) {
-        initialScopedUpdate = parser.parseStylesToShadowTreeStyles(rt, unistylesData);
+    if (scopedTheme.has_value()) {
+        initialScopedUpdate = parser.parseStylesToShadowTreeUpdates(rt, unistylesData);
+        shouldCommit = shadow::hasNativeProps(&shadowNodeWrapper->getFamily());
+    } else if (shadow::hasNativeProps(&shadowNodeWrapper->getFamily())) {
+        auto update = parser.parseStylesToShadowTreeUpdates(rt, unistylesData);
+
+        if (shadow::hasOutdatedNativeProps(&shadowNodeWrapper->getFamily(), update)) {
+            initialScopedUpdate = std::move(update);
+            shouldCommit = true;
+        }
     }
 
     registry.linkShadowNodeWithUnistyle(
         rt,
+        this->_unistylesRuntime->generation,
         shadowNodeWrapper->getFamilyShared(),
         unistylesData,
         std::move(initialScopedUpdate)
     );
 
-    if (wasSuspended) {
-        shadow::ShadowTreeManager::updateShadowTree(rt);
+    if (shouldCommit) {
+        this->scheduleShadowTreeUpdate(rt);
     }
 
     return jsi::Value::undefined();
 }
 
+void HybridShadowRegistry::scheduleShadowTreeUpdate(jsi::Runtime& rt) {
+    if (this->_isShadowTreeUpdateScheduled->exchange(true)) {
+        return;
+    }
+
+    auto isShadowTreeUpdateScheduled = this->_isShadowTreeUpdateScheduled;
+    auto unistylesRuntime = this->_unistylesRuntime;
+
+    rt.queueMicrotask(jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "unistylesUpdateShadowTree"),
+        0,
+        [isShadowTreeUpdateScheduled, unistylesRuntime](jsi::Runtime& rt, const jsi::Value&, const jsi::Value*, size_t) {
+            isShadowTreeUpdateScheduled->store(false);
+
+            // pending updates belong to the runtime that replaced this one
+            if (!unistylesRuntime->ownsRegistry()) {
+                return jsi::Value::undefined();
+            }
+
+            shadow::ShadowTreeManager::updateShadowTree(rt);
+
+            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 argument.");
 
+    if (!this->_unistylesRuntime->ownsRegistry()) {
+        return jsi::Value::undefined();
+    }
+
     auto shadowNodeWrapper = getShadowNodeFromRef(rt, args[0]);
 
     auto& registry = core::UnistylesRegistry::get();
@@ -131,6 +177,10 @@ jsi::Value HybridShadowRegistry::unlink(jsi::Runtime &rt, const jsi::Value &this
 jsi::Value HybridShadowRegistry::suspend(jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) {
     helpers::assertThat(rt, count == 1, "Unistyles: Invalid babel transform 'ShadowRegistry suspend' expected 1 argument.");
 
+    if (!this->_unistylesRuntime->ownsRegistry()) {
+        return jsi::Value::undefined();
+    }
+
     auto shadowNodeWrapper = getShadowNodeFromRef(rt, args[0]);
     auto& registry = core::UnistylesRegistry::get();
 
@@ -140,6 +190,10 @@ jsi::Value HybridShadowRegistry::suspend(jsi::Runtime &rt, const jsi::Value &thi
 }
 
 jsi::Value HybridShadowRegistry::flush(jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) {
+    if (!this->_unistylesRuntime->ownsRegistry()) {
+        return jsi::Value::undefined();
+    }
+
     shadow::ShadowTreeManager::updateShadowTree(rt);
 
     return jsi::Value::undefined();
@@ -148,6 +202,10 @@ jsi::Value HybridShadowRegistry::flush(jsi::Runtime &rt, const jsi::Value &thisV
 jsi::Value HybridShadowRegistry::setScopedTheme(jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) {
     helpers::assertThat(rt, count == 1, "Unistyles: setScopedTheme expected 1 argument.");
 
+    if (!this->_unistylesRuntime->ownsRegistry()) {
+        return jsi::Value::undefined();
+    }
+
     auto& registry = core::UnistylesRegistry::get();
 
     if (args[0].isUndefined()) {
@@ -170,6 +228,68 @@ jsi::Value HybridShadowRegistry::getScopedTheme(jsi::Runtime &rt, const jsi::Val
         : jsi::Value::undefined();
 }
 
+jsi::Value HybridShadowRegistry::verify(jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) {
+    return shadow::ShadowTreeDiagnostics::verify(rt, this->_unistylesRuntime);
+}
+
+jsi::Value HybridShadowRegistry::takeCommittedTags(jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) {
+    auto tags = core::UnistylesRegistry::get().takeCommittedTags();
+    auto result = jsi::Array(rt, tags.size());
+
+    for (size_t i = 0; i < tags.size(); i++) {
+        result.setValueAtIndex(rt, i, jsi::Value(static_cast<double>(tags[i])));
+    }
+
+    return result;
+}
+
+jsi::Value HybridShadowRegistry::refreshReactNodes(jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) {
+    helpers::assertThat(rt, count == 1 && args[0].isObject(), "Unistyles: refreshReactNodes expected to be called with an array of shadow nodes.");
+
+    auto nodes = args[0].asObject(rt).asArray(rt);
+    std::unordered_map<SurfaceId, std::shared_ptr<const RootShadowNode>> roots;
+
+    UIManagerBinding::getBinding(rt)->getUIManager().getShadowTreeRegistry().enumerate([&roots](const ShadowTree& shadowTree, bool&) {
+        roots.emplace(shadowTree.getSurfaceId(), shadowTree.getCurrentRevision().rootShadowNode);
+    });
+
+    for (size_t i = 0; i < nodes.size(rt); i++) {
+        auto node = nodes.getValueAtIndex(rt, i);
+
+        if (!node.isObject() || !node.asObject(rt).hasNativeState<ShadowNodeWrapper>(rt)) {
+            continue;
+        }
+
+        auto wrapper = node.asObject(rt).getNativeState<ShadowNodeWrapper>(rt);
+
+        // never committed, React cloned it in a render that isn't committed yet (eg. a transition that yielded)
+        // it holds what React rendered since, pointing it at the committed node would drop that
+        if (!wrapper->shadowNode->getHasBeenPromoted()) {
+            continue;
+        }
+
+        const auto& family = wrapper->shadowNode->getFamily();
+        auto rootIt = roots.find(family.getSurfaceId());
+
+        if (rootIt == roots.end()) {
+            continue;
+        }
+
+        auto ancestors = family.getAncestors(*rootIt->second);
+
+        // frozen nodes are not in the committed tree, nativeProps_DEPRECATED covers them
+        if (ancestors.empty()) {
+            continue;
+        }
+
+        const auto& [parent, index] = ancestors.back();
+
+        wrapper->shadowNode = parent.get().getChildren().at(index);
+    }
+
+    return jsi::Value::undefined();
+}
+
 std::shared_ptr<const core::ShadowNode> HybridShadowRegistry::getShadowNodeFromRef(jsi::Runtime& rt, const jsi::Value& maybeRef) {
     return Bridging<std::shared_ptr<const ShadowNode>>::fromJs(rt, maybeRef);
 }

package/cxx/hybridObjects/HybridShadowRegistry.h

@@ -6,7 +6,9 @@
 #include "UnistylesState.h"
 #include "UnistylesRegistry.h"
 #include "ShadowTreeManager.h"
+#include "ShadowTreeDiagnostics.h"
 #include <cxxreact/ReactNativeVersion.h>
+#include <atomic>
 
 namespace margelo::nitro::unistyles {
 
@@ -38,6 +40,18 @@ struct HybridShadowRegistry: public HybridUnistylesShadowRegistrySpec {
                             const jsi::Value& thisValue,
                             const jsi::Value* args,
                             size_t count);
+    jsi::Value verify(jsi::Runtime& rt,
+                            const jsi::Value& thisValue,
+                            const jsi::Value* args,
+                            size_t count);
+    jsi::Value takeCommittedTags(jsi::Runtime& rt,
+                            const jsi::Value& thisValue,
+                            const jsi::Value* args,
+                            size_t count);
+    jsi::Value refreshReactNodes(jsi::Runtime& rt,
+                            const jsi::Value& thisValue,
+                            const jsi::Value* args,
+                            size_t count);
 
     void loadHybridMethods() override {
         HybridUnistylesShadowRegistrySpec::loadHybridMethods();
@@ -49,13 +63,19 @@ struct HybridShadowRegistry: public HybridUnistylesShadowRegistrySpec {
             prototype.registerRawHybridMethod("flush", 0, &HybridShadowRegistry::flush);
             prototype.registerRawHybridMethod("setScopedTheme", 1, &HybridShadowRegistry::setScopedTheme);
             prototype.registerRawHybridMethod("getScopedTheme", 0, &HybridShadowRegistry::getScopedTheme);
+            prototype.registerRawHybridMethod("verify", 0, &HybridShadowRegistry::verify);
+            prototype.registerRawHybridMethod("takeCommittedTags", 0, &HybridShadowRegistry::takeCommittedTags);
+            prototype.registerRawHybridMethod("refreshReactNodes", 1, &HybridShadowRegistry::refreshReactNodes);
         });
     };
     
     std::shared_ptr<const core::ShadowNode> getShadowNodeFromRef(jsi::Runtime& rt, const jsi::Value& maybeRef);
 
 private:
+    void scheduleShadowTreeUpdate(jsi::Runtime& rt);
+
     std::shared_ptr<HybridUnistylesRuntime> _unistylesRuntime;
+    std::shared_ptr<std::atomic<bool>> _isShadowTreeUpdateScheduled = std::make_shared<std::atomic<bool>>(false);
 };
 
 }

package/cxx/hybridObjects/HybridStyleSheet.cpp

@@ -16,12 +16,13 @@ double HybridStyleSheet::getHairlineWidth() {
 jsi::Value HybridStyleSheet::create(jsi::Runtime& rt, const jsi::Value &thisVal, const jsi::Value *arguments, size_t count) {
     helpers::assertThat(rt, count == 1, "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.");
+    helpers::assertThat(rt, this->_unistylesRuntime->ownsRegistry(), helpers::RUNTIME_REPLACED_ERROR);
 
     auto thisStyleSheet = thisVal.asObject(rt);
     auto& registry = core::UnistylesRegistry::get();
 
     jsi::Object rawStyleSheet = arguments[0].asObject(rt);
-    auto registeredStyleSheet = registry.addStyleSheetFromValue(rt, std::move(rawStyleSheet));
+    auto registeredStyleSheet = registry.addStyleSheetFromValue(rt, this->_unistylesRuntime->generation, std::move(rawStyleSheet));
 
     auto parser = parser::Parser(this->_unistylesRuntime);
 
@@ -34,6 +35,7 @@ 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, 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.");
+    helpers::assertThat(rt, this->_unistylesRuntime->ownsRegistry(), helpers::RUNTIME_REPLACED_ERROR);
 
     auto config = arguments[0].asObject(rt);
 
@@ -73,6 +75,8 @@ jsi::Value HybridStyleSheet::init(jsi::Runtime &rt, const jsi::Value &thisVal, c
         return jsi::Value::undefined();
     }
 
+    helpers::assertThat(rt, this->_unistylesRuntime->ownsRegistry(), helpers::RUNTIME_REPLACED_ERROR);
+
     // create new state
     auto& registry = core::UnistylesRegistry::get();
 
@@ -165,7 +169,7 @@ void HybridStyleSheet::parseThemes(jsi::Runtime &rt, jsi::Object themes) {
     helpers::enumerateJSIObject(rt, themes, [&](const std::string& propertyName, jsi::Value& propertyValue){
         helpers::assertThat(rt, propertyValue.isObject(), "StyleSheet.configure's registered theme '" + propertyName + "' must be an object.");
 
-        registry.registerTheme(rt, propertyName, propertyValue);
+        registry.registerTheme(rt, this->_unistylesRuntime->generation, propertyName, propertyValue);
     });
 }
 
@@ -267,7 +271,8 @@ void HybridStyleSheet::onPlatformDependenciesChange(std::vector<UnistyleDependen
     this->_unistylesRuntime->runOnJSThread([weakSelf, dependencies](jsi::Runtime& rt) {
         auto self = std::dynamic_pointer_cast<HybridStyleSheet>(weakSelf.lock());
 
-        if (!self) {
+        // runtime was replaced in the meantime, registry belongs to the next one
+        if (!self || !self->_unistylesRuntime->ownsRegistry()) {
             return;
         }
 
@@ -288,7 +293,7 @@ void HybridStyleSheet::onPlatformNativeDependenciesChange(std::vector<UnistyleDe
     this->_unistylesRuntime->runOnJSThread([weakSelf, dependencies, miniRuntime](jsi::Runtime& rt){
         auto self = std::dynamic_pointer_cast<HybridStyleSheet>(weakSelf.lock());
 
-        if (!self) {
+        if (!self || !self->_unistylesRuntime->ownsRegistry()) {
             return;
         }
 
@@ -329,7 +334,7 @@ void HybridStyleSheet::onImeChange(UnistylesNativeMiniRuntime miniRuntime) {
     this->_unistylesRuntime->runOnJSThread([weakSelf, miniRuntime](jsi::Runtime& rt){
         auto self = std::dynamic_pointer_cast<HybridStyleSheet>(weakSelf.lock());
 
-        if (!self) {
+        if (!self || !self->_unistylesRuntime->ownsRegistry()) {
             return;
         }
 
@@ -348,22 +353,25 @@ void HybridStyleSheet::applyDependencyChanges(jsi::Runtime& rt, std::vector<Unis
     // but their rawValue must still be refreshed so rerenders read fresh closures
     auto dependentStyleSheets = registry.getStyleSheetsToRefresh(dependencies);
 
-    if (dependencyMap.empty() && dependentStyleSheets.empty()) {
-        return;
-    }
-
     // rebuild rawValue BEFORE notifying listeners so JS rerenders read fresh closures
-    parser.rebuildUnistylesInDependencyMap(rt, dependencyMap, dependentStyleSheets, maybeMiniRuntime);
+    if (!dependencyMap.empty() || !dependentStyleSheets.empty()) {
+        parser.rebuildUnistylesInDependencyMap(rt, dependencyMap, dependentStyleSheets, maybeMiniRuntime);
+    }
 
     if (!dependencyMap.empty()) {
         parser.rebuildShadowLeafUpdates(rt, dependencyMap);
     }
 
-    this->notifyJSListeners(dependencies);
+    std::vector<Tag> committedTags;
 
     if (!dependencyMap.empty()) {
-        shadow::ShadowTreeManager::updateShadowTree(rt);
+        committedTags = shadow::ShadowTreeManager::updateShadowTree(rt);
     }
+
+    // after the commit, so listeners can point React at the committed nodes
+    registry.setCommittedTags(std::move(committedTags));
+    // also when no StyleSheet depends on the change, hooks (useUnistyles, withUnistyles, Display, Hide) may
+    this->notifyJSListeners(dependencies);
 }
 
 void HybridStyleSheet::notifyJSListeners(std::vector<UnistyleDependency>& dependencies) {

package/cxx/hybridObjects/HybridUnistylesRuntime.cpp

@@ -4,9 +4,18 @@
 using namespace margelo::nitro::unistyles;
 
 core::UnistylesState& HybridUnistylesRuntime::getState() {
+    // state belongs to the runtime that replaced this one
+    if (!this->ownsRegistry()) {
+        throw std::runtime_error(helpers::RUNTIME_REPLACED_ERROR);
+    }
+
     return core::UnistylesRegistry::get().getState();
 }
 
+bool HybridUnistylesRuntime::ownsRegistry() const {
+    return core::UnistylesRegistry::get().isCurrent(this->generation);
+}
+
 ColorScheme HybridUnistylesRuntime::getColorScheme() {
     auto colorScheme = this->_nativePlatform->getColorScheme();
 
@@ -166,13 +175,14 @@ jsi::Value HybridUnistylesRuntime::updateTheme(jsi::Runtime &rt, const jsi::Valu
     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.");
+    helpers::assertThat(rt, this->ownsRegistry(), helpers::RUNTIME_REPLACED_ERROR);
 
     auto& registry = core::UnistylesRegistry::get();
     auto themeName = args[0].asString(rt).utf8(rt);
 
     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));
+    registry.updateTheme(rt, this->generation, themeName, args[1].asObject(rt).asFunction(rt));
 
     this->_onDependenciesChange({UnistyleDependency::THEME});
 

package/cxx/hybridObjects/HybridUnistylesRuntime.h

@@ -13,8 +13,8 @@
 namespace margelo::nitro::unistyles {
 
 struct HybridUnistylesRuntime: public HybridUnistylesRuntimeSpec {
-    HybridUnistylesRuntime(std::shared_ptr<HybridNativePlatformSpec> nativePlatform, std::function<void(std::function<void(jsi::Runtime&)>&&)> runOnJSThread)
-        : HybridObject(TAG), _nativePlatform{nativePlatform}, runOnJSThread(std::move(runOnJSThread)) {}
+    HybridUnistylesRuntime(std::shared_ptr<HybridNativePlatformSpec> nativePlatform, std::function<void(std::function<void(jsi::Runtime&)>&&)> runOnJSThread, uint64_t generation)
+        : HybridObject(TAG), _nativePlatform{nativePlatform}, runOnJSThread(std::move(runOnJSThread)), generation{generation} {}
 
     jsi::Value getTheme(jsi::Runtime& rt,
                             const jsi::Value& thisValue,
@@ -70,11 +70,13 @@ struct HybridUnistylesRuntime: public HybridUnistylesRuntimeSpec {
     std::unordered_map<std::string, double> getBreakpoints() override;
 
     core::UnistylesState& getState();
+    bool ownsRegistry() const;
     UnistylesCxxMiniRuntime buildMiniRuntimeFromNativeRuntime(UnistylesNativeMiniRuntime& nativeMiniRuntime);
     jsi::Value getMiniRuntimeAsValue(jsi::Runtime& rt, std::optional<UnistylesNativeMiniRuntime> maybeMiniRuntime);
     void includeDependenciesForColorSchemeChange(std::vector<UnistyleDependency>& deps);
     void calculateNewThemeAndDependencies(std::vector<UnistyleDependency>& deps);
     std::function<void(std::function<void(jsi::Runtime&)>&&)> runOnJSThread;
+    const uint64_t generation;
 
 private:
     std::shared_ptr<HybridNavigationBar> _navigationBar;

package/cxx/parser/Parser.cpp

@@ -439,7 +439,7 @@ void parser::Parser::rebuildShadowLeafUpdates(jsi::Runtime& rt, core::Dependency
 
         for (const auto& [shadowNode, unistyles] : dependencyMap) {
             // Parse string colors (e.g., "#000000") to int representation
-            auto rawProps = this->parseStylesToShadowTreeStyles(rt, unistyles);
+            auto rawProps = this->parseStylesToShadowTreeUpdates(rt, unistyles);
 
             updates.emplace(shadowNode, std::move(rawProps));
         }
@@ -1268,6 +1268,34 @@ folly::dynamic parser::Parser::parseStylesToShadowTreeStyles(jsi::Runtime& rt, c
     return jsi::dynamicFromValue(rt, jsi::Value(rt, convertedStyles));
 }
 
+// shadow tree updates skip the props an inline style sets last, React (or an animation) owns them
+// writing them would also leave them in nativeProps_DEPRECATED, which React Native applies to every later clone,
+// so a value captured at link time would undo what React rendered since
+folly::dynamic parser::Parser::parseStylesToShadowTreeUpdates(jsi::Runtime& rt, const std::vector<std::shared_ptr<UnistyleData>>& unistyles) {
+    auto props = this->parseStylesToShadowTreeStyles(rt, unistyles);
+    std::unordered_map<std::string, bool> isOwnedByInlineStyle;
+
+    for (const auto& unistyleData : unistyles) {
+        if (!unistyleData->parsedStyle.has_value()) {
+            continue;
+        }
+
+        bool isInlineStyle = unistyleData->unistyle->styleKey == helpers::EXOTIC_STYLE_KEY;
+
+        helpers::enumerateJSIObject(rt, unistyleData->parsedStyle.value(), [&isOwnedByInlineStyle, isInlineStyle](const std::string& propName, jsi::Value&) {
+            isOwnedByInlineStyle[propName] = isInlineStyle;
+        });
+    }
+
+    for (const auto& [propName, isInline] : isOwnedByInlineStyle) {
+        if (isInline) {
+            props.erase(propName);
+        }
+    }
+
+    return props;
+}
+
 
 // check is styleKey contains color
 bool parser::Parser::isColor(const std::string& propertyName) {

package/cxx/parser/Parser.h

@@ -28,6 +28,7 @@ struct Parser {
     void rebuildUnistylesInDependencyMap(jsi::Runtime& rt, core::DependencyMap& dependencyMap, std::vector<std::shared_ptr<core::StyleSheet>>& styleSheets, std::optional<UnistylesNativeMiniRuntime> maybeMiniRuntime);
     void rebuildShadowLeafUpdates(jsi::Runtime& rt, core::DependencyMap& dependencyMap);
     folly::dynamic parseStylesToShadowTreeStyles(jsi::Runtime& rt, const std::vector<std::shared_ptr<UnistyleData>>& unistyles);
+    folly::dynamic parseStylesToShadowTreeUpdates(jsi::Runtime& rt, const std::vector<std::shared_ptr<UnistyleData>>& unistyles);
     void rebuildUnistyle(jsi::Runtime& rt, Unistyle::Shared unistyle, const Variants& variants, std::optional<std::vector<folly::dynamic>>);
     void rebuildUnistyleWithScopedTheme(jsi::Runtime& rt, jsi::Value& jsScopedTheme, std::shared_ptr<core::UnistyleData> unistyleData);
     jsi::Value getParsedStyleSheetForScopedTheme(jsi::Runtime& rt, core::Unistyle::Shared unistyle, std::string& scopedTheme);

package/cxx/shadowTree/NativeProps.h

@@ -3,8 +3,11 @@
 #include <folly/dynamic.h>
 #include <react/renderer/core/ShadowNodeFamily.h>
 #include <cxxreact/ReactNativeVersion.h>
+#include <algorithm>
+#include <cstdint>
 #include <memory>
 #include <mutex>
+#include <string>
 
 // React Native reads ShadowNodeFamily::nativeProps_DEPRECATED from any thread
 // (eg. ShadowNode::clone during main thread layout) and since 0.86.1 guards every access with nativePropsMutex
@@ -33,12 +36,53 @@ inline void mergeNativeProps(const ShadowNodeFamily* family, const folly::dynami
     family->nativeProps_DEPRECATED = std::make_unique<folly::dynamic>(props);
 }
 
-inline void resetNativeProps(const ShadowNodeFamily* family) {
+inline bool hasNativeProps(const ShadowNodeFamily* family) {
 #if UNISTYLES_HAS_NATIVE_PROPS_MUTEX
     std::lock_guard<std::mutex> lock(family->nativePropsMutex);
 #endif
 
-    family->nativeProps_DEPRECATED.reset();
+    return family->nativeProps_DEPRECATED && family->nativeProps_DEPRECATED->isObject();
+}
+
+inline bool isSamePropValue(const std::string& propName, const folly::dynamic& value, const folly::dynamic& otherValue) {
+    if (value == otherValue) {
+        return true;
+    }
+
+    if (!value.isNumber() || !otherValue.isNumber()) {
+        return false;
+    }
+
+    std::string lowercasePropName = propName;
+    std::transform(lowercasePropName.begin(), lowercasePropName.end(), lowercasePropName.begin(), ::tolower);
+
+    if (lowercasePropName.find("color") == std::string::npos) {
+        return false;
+    }
+
+    return static_cast<uint32_t>(static_cast<int64_t>(value.asDouble())) == static_cast<uint32_t>(static_cast<int64_t>(otherValue.asDouble()));
+}
+
+inline bool hasOutdatedNativeProps(const ShadowNodeFamily* family, const folly::dynamic& props) {
+#if UNISTYLES_HAS_NATIVE_PROPS_MUTEX
+    std::lock_guard<std::mutex> lock(family->nativePropsMutex);
+#endif
+
+    if (!family->nativeProps_DEPRECATED || !family->nativeProps_DEPRECATED->isObject() || !props.isObject()) {
+        return false;
+    }
+
+    auto& nativeProps = *family->nativeProps_DEPRECATED;
+
+    for (const auto& [propName, propValue] : props.items()) {
+        auto it = nativeProps.find(propName);
+
+        if (it != nativeProps.items().end() && !isSamePropValue(propName.asString(), it->second, propValue)) {
+            return true;
+        }
+    }
+
+    return false;
 }
 
 }

package/cxx/shadowTree/ShadowTrafficController.h

@@ -36,6 +36,10 @@ struct ShadowTrafficController {
         return family;
     }
 
+    inline size_t getUpdatesCount() const {
+        return _unistylesUpdates.size();
+    }
+
     template <typename F>
     inline auto withLock(F&& func) {
         std::lock_guard<std::mutex> lock(_mutex);