react-native-unistyles 3.3.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]);
@@ -87,37 +92,79 @@ jsi::Value HybridShadowRegistry::link(jsi::Runtime &rt, const jsi::Value &thisVa
             parser.rebuildUnistyleWithScopedTheme(rt, parsedStyleSheet, unistyleData);
         }
 
-        // Initialize parsedStyle from the unistyle's current computed style from withUnistyles
+        // The shared cache can belong to another view by the time React attaches refs.
+        // Restore this view's arguments and variants before saving its native styles.
         if (!unistyleData->parsedStyle.has_value() && unistyle->parsedStyle.has_value()) {
-            unistyleData->parsedStyle = jsi::Value(rt, unistyle->parsedStyle.value()).asObject(rt);
+            parser.rebuildUnistyleWithVariants(rt, unistyleData);
         }
 
         unistylesData.emplace_back(unistyleData);
     }
 
     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,
-        &shadowNodeWrapper->getFamily(),
+        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();
@@ -130,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();
 
@@ -139,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();
@@ -147,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()) {
@@ -169,10 +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) {
-#if REACT_NATIVE_VERSION_MINOR >= 81
     return Bridging<std::shared_ptr<const ShadowNode>>::fromJs(rt, maybeRef);
-#else
-    return shadowNodeFromValue(rt, maybeRef);
-#endif
 }

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,13 +439,12 @@ 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));
         }
 
-        registry.trafficController.setUpdates(updates);
-        registry.trafficController.resumeUnistylesTraffic();
+        registry.queueShadowLeafUpdatesUnsafe(updates);
     });
 }
 
@@ -1269,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

@@ -0,0 +1,88 @@
+#pragma once
+
+#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
+// we need to hold the same lock, otherwise mutating / replacing the folly::dynamic races with RN copying it
+#if REACT_NATIVE_VERSION_MINOR > 86 || (REACT_NATIVE_VERSION_MINOR == 86 && REACT_NATIVE_VERSION_PATCH >= 1)
+#define UNISTYLES_HAS_NATIVE_PROPS_MUTEX 1
+#else
+#define UNISTYLES_HAS_NATIVE_PROPS_MUTEX 0
+#endif
+
+namespace margelo::nitro::unistyles::shadow {
+
+using namespace facebook::react;
+
+inline void mergeNativeProps(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()) {
+        family->nativeProps_DEPRECATED->update(props);
+
+        return;
+    }
+
+    family->nativeProps_DEPRECATED = std::make_unique<folly::dynamic>(props);
+}
+
+inline bool hasNativeProps(const ShadowNodeFamily* family) {
+#if UNISTYLES_HAS_NATIVE_PROPS_MUTEX
+    std::lock_guard<std::mutex> lock(family->nativePropsMutex);
+#endif
+
+    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/ShadowLeafUpdate.h

@@ -2,6 +2,7 @@
 
 #include <jsi/jsi.h>
 #include <folly/dynamic.h>
+#include <memory>
 #include <react/renderer/uimanager/UIManager.h>
 
 namespace margelo::nitro::unistyles::shadow {
@@ -12,4 +13,11 @@ using namespace facebook::react;
 // translates Unistyles changes to unified shadow tree changes
 using ShadowLeafUpdates = std::unordered_map<const ShadowNodeFamily*, folly::dynamic>;
 
+struct PinnedShadowLeafUpdate {
+    std::shared_ptr<const ShadowNodeFamily> family;
+    folly::dynamic props;
+};
+
+using PinnedShadowLeafUpdates = std::unordered_map<const ShadowNodeFamily*, PinnedShadowLeafUpdate>;
+
 }

package/cxx/shadowTree/ShadowTrafficController.h

@@ -8,52 +8,36 @@ namespace margelo::nitro::unistyles::shadow {
 // Like a traffic officer managing a jam, this struct ensures everything
 // is synchronized within a set timeframe, controlling flow and preventing chaos.
 struct ShadowTrafficController {
-    inline bool shouldStop() {
-        return !_canCommit;
-    }
-
-    inline void stopUnistylesTraffic() {
-        this->_canCommit = false;
-    }
+    inline void setUpdate(std::shared_ptr<const ShadowNodeFamily> family, folly::dynamic props) {
+        // call it only within withLock!
+        auto key = family.get();
 
-    inline void resumeUnistylesTraffic() {
-        this->_canCommit = true;
+        _unistylesUpdates.insert_or_assign(key, PinnedShadowLeafUpdate{std::move(family), std::move(props)});
     }
 
-    inline shadow::ShadowLeafUpdates& getUpdates() {
+    inline PinnedShadowLeafUpdates takeUpdates() {
         // call it only within withLock!
-        return _unistylesUpdates;
+        return std::exchange(_unistylesUpdates, {});
     }
 
-    inline void setUpdates(shadow::ShadowLeafUpdates& newUpdates) {
+    inline std::shared_ptr<const ShadowNodeFamily> removeShadowNode(const ShadowNodeFamily* shadowNodeFamily) {
         // call it only within withLock!
-        auto& targetUpdates = _unistylesUpdates;
+        // returns the pin, so the caller can release it after unlocking
+        auto it = _unistylesUpdates.find(shadowNodeFamily);
 
-        // this is important as overriding updates may skip some interim changes
-        // Unistyles emits different events so this will make sure that everything is synced
-        std::for_each(newUpdates.begin(), newUpdates.end(), [&targetUpdates](auto& pair){
-            if (targetUpdates.contains(pair.first)) {
-                targetUpdates[pair.first] = std::move(pair.second);
+        if (it == _unistylesUpdates.end()) {
+            return nullptr;
+        }
 
-                return;
-            }
+        auto family = std::move(it->second.family);
 
-            targetUpdates.emplace(pair.first, std::move(pair.second));
-        });
-    }
+        _unistylesUpdates.erase(it);
 
-    inline void removeShadowNode(const ShadowNodeFamily* shadowNodeFamily) {
-        // call it only within withLock!
-        if (_unistylesUpdates.contains(shadowNodeFamily)) {
-            _unistylesUpdates.erase(shadowNodeFamily);
-        }
+        return family;
     }
 
-    inline void restore() {
-        // call it only within withLock!
-
-        _unistylesUpdates = {};
-        _canCommit = false;
+    inline size_t getUpdatesCount() const {
+        return _unistylesUpdates.size();
     }
 
     template <typename F>
@@ -64,8 +48,7 @@ struct ShadowTrafficController {
     }
 
 private:
-    std::atomic<bool> _canCommit = false;
-    shadow::ShadowLeafUpdates _unistylesUpdates{};
+    PinnedShadowLeafUpdates _unistylesUpdates{};
 
     // this struct should be accessed in thread-safe manner. Otherwise shadow tree updates
     // from different threads will break it