react-native-unistyles 3.3.0 → 3.4.0

package/README.md

@@ -58,9 +58,6 @@ Then follow [installation guides](https://unistyl.es/v3/start/getting-started) f
 <a href="https://codemask.com">
     <img src="https://avatars.githubusercontent.com/u/51229884?s=200&v=4" height="70px" width="70px" alt="codemask" />
 </a>
-<a href="https://galaxies.dev">
-     <img src="https://avatars.githubusercontent.com/u/118431096?s=200&v=4" height="70px" width="70px" alt="galaxies-dev" />
-</a>
 <a href="https://github.com/ryanlanciaux">
      <img src="https://avatars.githubusercontent.com/u/85041?v=4" height="70px" width="70px" alt="ryanlanciaux" />
 </a>
@@ -155,6 +152,9 @@ Then follow [installation guides](https://unistyl.es/v3/start/getting-started) f
 <a href="https://github.com/AdiRishi">
      <img src="https://avatars.githubusercontent.com/u/8351234?v=4" height="60px" width="60px" alt="AdiRishi" />
 </a>
+<a href="https://galaxies.dev">
+     <img src="https://avatars.githubusercontent.com/u/118431096?s=200&v=4" height="60px" width="60px" alt="galaxies-dev" />
+</a>
 
 ## Sponsor my work
 

package/cxx/core/UnistylesRegistry.cpp

@@ -1,6 +1,7 @@
 #include "UnistylesRegistry.h"
 #include "UnistylesState.h"
 #include "Parser.h"
+#include "NativeProps.h"
 
 using namespace margelo::nitro::unistyles;
 using namespace facebook;
@@ -60,37 +61,85 @@ void core::UnistylesRegistry::updateTheme(jsi::Runtime& rt, std::string& themeNa
 
 void core::UnistylesRegistry::linkShadowNodeWithUnistyle(
     jsi::Runtime& rt,
-    const ShadowNodeFamily* shadowNodeFamily,
+    const std::shared_ptr<const ShadowNodeFamily>& shadowNodeFamily,
     std::vector<std::shared_ptr<UnistyleData>>& unistylesData,
     std::optional<folly::dynamic> initialScopedUpdate
 ) {
-    this->trafficController.withLock([this, &rt, &unistylesData, shadowNodeFamily, &initialScopedUpdate](){
+    // released after unlocking, so a family destructor never runs within the lock
+    ReleasedFamilies releasedFamilies;
+
+    this->trafficController.withLock([this, &unistylesData, &shadowNodeFamily, &initialScopedUpdate, &releasedFamilies](){
+        auto family = shadowNodeFamily.get();
+        auto it = this->_shadowRegistry.find(family);
+
         // Clear suspension state if this family was previously suspended
-        if (_suspendedFamilies.erase(shadowNodeFamily) > 0) {
-            auto* mutableFamily = const_cast<ShadowNodeFamily*>(shadowNodeFamily);
-            mutableFamily->nativeProps_DEPRECATED.reset();
+        if (it != this->_shadowRegistry.end() && it->second.isSuspended) {
+            shadow::resetNativeProps(family);
             // Clear old registry entries to prevent stale UnistyleData accumulation
-            this->_shadowRegistry.erase(shadowNodeFamily);
-            // Remove any stale traffic controller entry (e.g. from a theme change during suspension)
-            this->trafficController.removeShadowNode(shadowNodeFamily);
+            // and any stale traffic controller entry (e.g. from a theme change during suspension)
+            this->forgetFamilyUnsafe(family, releasedFamilies);
         }
 
-        std::for_each(unistylesData.begin(), unistylesData.end(), [this, shadowNodeFamily](std::shared_ptr<UnistyleData> unistyleData){
-            this->_shadowRegistry[shadowNodeFamily].emplace_back(unistyleData);
-        });
+        auto& linkedFamily = this->_shadowRegistry[family];
+
+        linkedFamily.family = shadowNodeFamily;
+        linkedFamily.unistyles.insert(linkedFamily.unistyles.end(), unistylesData.begin(), unistylesData.end());
 
         // Required for scoped themes to apply on initial mount
         if (initialScopedUpdate.has_value()) {
-            shadow::ShadowLeafUpdates updates;
+            this->trafficController.setUpdate(shadowNodeFamily, std::move(*initialScopedUpdate));
+        }
 
-            updates.emplace(shadowNodeFamily, std::move(*initialScopedUpdate));
-            this->trafficController.setUpdates(updates);
+        // families unmounted without unlink (eg. while frozen) are pinned by us only
+        // sweep them once the registry doubles, so it's amortized O(1) per link
+        if (this->_shadowRegistry.size() >= this->_sweepThreshold) {
+            this->sweepUnownedFamiliesUnsafe(releasedFamilies);
+            this->_sweepThreshold = std::max(MIN_SWEEP_THRESHOLD, this->_shadowRegistry.size() * 2);
         }
     });
 }
 
+bool core::UnistylesRegistry::isOwnedOnlyByUnistyles(const LinkedFamily& linkedFamily) noexcept {
+    // shadow nodes own their family, so if nothing but our pin owns it, the family is not part of any
+    // shadow tree anymore. React Native can't get it back, as it only keeps weak references beside shadow nodes
+    return linkedFamily.family.use_count() == 1;
+}
+
+void core::UnistylesRegistry::forgetFamilyUnsafe(const ShadowNodeFamily* shadowNodeFamily, ReleasedFamilies& releasedFamilies) {
+    auto it = this->_shadowRegistry.find(shadowNodeFamily);
+
+    if (it != this->_shadowRegistry.end()) {
+        releasedFamilies.emplace_back(std::move(it->second.family));
+        this->_shadowRegistry.erase(it);
+    }
+
+    if (auto pendingFamily = this->trafficController.removeShadowNode(shadowNodeFamily)) {
+        releasedFamilies.emplace_back(std::move(pendingFamily));
+    }
+}
+
+void core::UnistylesRegistry::sweepUnownedFamiliesUnsafe(ReleasedFamilies& releasedFamilies) {
+    std::vector<const ShadowNodeFamily*> unownedFamilies;
+
+    for (const auto& [family, linkedFamily] : this->_shadowRegistry) {
+        if (isOwnedOnlyByUnistyles(linkedFamily)) {
+            unownedFamilies.emplace_back(family);
+        }
+    }
+
+    for (const auto* family : unownedFamilies) {
+        this->forgetFamilyUnsafe(family, releasedFamilies);
+    }
+}
+
 void core::UnistylesRegistry::removeDuplicatedUnistyles(const ShadowNodeFamily *shadowNodeFamily, std::vector<core::Unistyle::Shared>& unistyles) {
-    auto targetFamilyUnistyles = this->_shadowRegistry[shadowNodeFamily];
+    auto it = this->_shadowRegistry.find(shadowNodeFamily);
+
+    if (it == this->_shadowRegistry.end()) {
+        return;
+    }
+
+    auto& targetFamilyUnistyles = it->second.unistyles;
 
     unistyles.erase(
         std::remove_if(
@@ -111,23 +160,27 @@ void core::UnistylesRegistry::removeDuplicatedUnistyles(const ShadowNodeFamily *
 }
 
 void core::UnistylesRegistry::unlinkShadowNodeWithUnistyles(const ShadowNodeFamily* shadowNodeFamily) {
-    this->trafficController.withLock([this, shadowNodeFamily](){
-        this->_shadowRegistry.erase(shadowNodeFamily);
-        this->_suspendedFamilies.erase(shadowNodeFamily);
-        this->trafficController.removeShadowNode(shadowNodeFamily);
+    ReleasedFamilies releasedFamilies;
+
+    this->trafficController.withLock([this, shadowNodeFamily, &releasedFamilies](){
+        this->forgetFamilyUnsafe(shadowNodeFamily, releasedFamilies);
     });
 }
 
 void core::UnistylesRegistry::suspendShadowNode(const ShadowNodeFamily* shadowNodeFamily) {
     this->trafficController.withLock([this, shadowNodeFamily](){
-        if (this->_shadowRegistry.contains(shadowNodeFamily)) {
-            this->_suspendedFamilies.insert(shadowNodeFamily);
+        auto it = this->_shadowRegistry.find(shadowNodeFamily);
+
+        if (it != this->_shadowRegistry.end()) {
+            it->second.isSuspended = true;
         }
     });
 }
 
 bool core::UnistylesRegistry::isSuspended(const ShadowNodeFamily* family) const noexcept {
-    return _suspendedFamilies.count(family) > 0;
+    auto it = this->_shadowRegistry.find(family);
+
+    return it != this->_shadowRegistry.end() && it->second.isSuspended;
 }
 
 std::shared_ptr<core::StyleSheet> core::UnistylesRegistry::addStyleSheet(jsi::Runtime& rt, core::StyleSheetType type, jsi::Object&& rawValue) {
@@ -143,36 +196,56 @@ core::DependencyMap core::UnistylesRegistry::buildDependencyMap(std::vector<Unis
     core::DependencyMap dependencyMap;
 
     std::unordered_set<UnistyleDependency> uniqueDependencies(deps.begin(), deps.end());
+    ReleasedFamilies releasedFamilies;
+
+    // families stay pinned by the registry until the shadow tree update is committed
+    this->trafficController.withLock([this, &dependencyMap, &uniqueDependencies, &releasedFamilies](){
+        // we iterate whole registry anyway, so it's a free moment to drop families unmounted without unlink
+        this->sweepUnownedFamiliesUnsafe(releasedFamilies);
+
+        for (const auto& [family, linkedFamily] : this->_shadowRegistry) {
+            bool hasAnyOfDependencies = false;
+
+            // Check if any dependency matches
+            for (const auto& unistyleData : linkedFamily.unistyles) {
+                for (const auto& dep : unistyleData->unistyle->dependencies) {
+                    if (uniqueDependencies.count(dep)) {
+                        hasAnyOfDependencies = true;
+                        break;
+                    }
+                }
 
-    for (const auto& [family, unistyles] : this->_shadowRegistry) {
-        bool hasAnyOfDependencies = false;
-
-        // Check if any dependency matches
-        for (const auto& unistyleData : unistyles) {
-            for (const auto& dep : unistyleData->unistyle->dependencies) {
-                if (uniqueDependencies.count(dep)) {
-                    hasAnyOfDependencies = true;
+                if (hasAnyOfDependencies) {
                     break;
-                }
+                };
             }
 
-            if (hasAnyOfDependencies) {
-                break;
-            };
+            if (!hasAnyOfDependencies) {
+                continue;
+            }
+
+            dependencyMap[family].insert(
+                dependencyMap[family].end(),
+                linkedFamily.unistyles.begin(),
+                linkedFamily.unistyles.end()
+            );
         }
+    });
+
+    return dependencyMap;
+}
 
-        if (!hasAnyOfDependencies) {
+void core::UnistylesRegistry::queueShadowLeafUpdatesUnsafe(shadow::ShadowLeafUpdates& updates) {
+    for (auto& [family, props] : updates) {
+        auto it = this->_shadowRegistry.find(family);
+
+        // family was unlinked in the meantime, there is nothing to update
+        if (it == this->_shadowRegistry.end()) {
             continue;
         }
 
-        dependencyMap[family].insert(
-            dependencyMap[family].end(),
-            unistyles.begin(),
-            unistyles.end()
-        );
+        this->trafficController.setUpdate(it->second.family, std::move(props));
     }
-
-    return dependencyMap;
 }
 
 // called from proxied function only, we don't know host
@@ -185,15 +258,15 @@ void core::UnistylesRegistry::shadowLeafUpdateFromUnistyle(jsi::Runtime& rt, Uni
             ? std::make_optional(maybePressableId.asString(rt).utf8(rt))
             : std::nullopt;
 
-        for (const auto& [family, unistyles] : this->_shadowRegistry) {
-            for (const auto& unistyleData : unistyles) {
+        for (const auto& [family, linkedFamily] : this->_shadowRegistry) {
+            for (const auto& unistyleData : linkedFamily.unistyles) {
                 if (unistyleData->unistyle == unistyle) {
                     updates[family] = parser.parseStylesToShadowTreeStyles(rt, { unistyleData });
                 }
             }
         }
 
-        this->trafficController.setUpdates(updates);
+        this->queueShadowLeafUpdatesUnsafe(updates);
     });
 }
 
@@ -263,10 +336,25 @@ void core::UnistylesRegistry::setScopedTheme(std::optional<std::string> themeNam
 }
 
 void core::UnistylesRegistry::destroy() {
+    // called when module is invalidated, before React Native destroys the runtime
+    // pins must be released now, as families hold JS handles that can't outlive the runtime
+    ReleasedFamilies releasedFamilies;
+
+    this->trafficController.withLock([this, &releasedFamilies](){
+        for (auto& [_, linkedFamily] : this->_shadowRegistry) {
+            releasedFamilies.emplace_back(std::move(linkedFamily.family));
+        }
+
+        for (auto& [_, pendingUpdate] : this->trafficController.takeUpdates()) {
+            releasedFamilies.emplace_back(std::move(pendingUpdate.family));
+        }
+
+        this->_shadowRegistry.clear();
+        this->_sweepThreshold = MIN_SWEEP_THRESHOLD;
+    });
+
     this->_state.reset();
     this->_styleSheetRegistry.clear();
-    this->_shadowRegistry.clear();
-    this->_suspendedFamilies.clear();
     this->_scopedTheme = std::nullopt;
     _nextStyleSheetTag.store(0);
 }

package/cxx/core/UnistylesRegistry.h

@@ -23,6 +23,12 @@ using namespace facebook::react;
 
 using DependencyMap = std::unordered_map<const ShadowNodeFamily*, std::vector<std::shared_ptr<UnistyleData>>>;
 
+struct LinkedFamily {
+    std::shared_ptr<const ShadowNodeFamily> family;
+    std::vector<std::shared_ptr<UnistyleData>> unistyles;
+    bool isSuspended = false;
+};
+
 struct UnistylesRegistry: public StyleSheetRegistry {
     static UnistylesRegistry& get();
 
@@ -40,13 +46,15 @@ struct UnistylesRegistry: public StyleSheetRegistry {
     UnistylesState& getState();
     void createState();
     std::vector<std::shared_ptr<core::StyleSheet>> getStyleSheetsToRefresh(std::vector<UnistyleDependency>& unistylesDependencies);
-    void linkShadowNodeWithUnistyle(jsi::Runtime& rt, const ShadowNodeFamily*, std::vector<std::shared_ptr<UnistyleData>>& unistylesData, std::optional<folly::dynamic> initialScopedUpdate = std::nullopt);
+    void linkShadowNodeWithUnistyle(jsi::Runtime& rt, const std::shared_ptr<const ShadowNodeFamily>& shadowNodeFamily, std::vector<std::shared_ptr<UnistyleData>>& unistylesData, std::optional<folly::dynamic> initialScopedUpdate = std::nullopt);
     void unlinkShadowNodeWithUnistyles(const ShadowNodeFamily*);
     void suspendShadowNode(const ShadowNodeFamily*);
     bool isSuspended(const ShadowNodeFamily*) const noexcept;
     std::shared_ptr<core::StyleSheet> addStyleSheet(jsi::Runtime& rt, core::StyleSheetType type, jsi::Object&& rawValue);
     DependencyMap buildDependencyMap(std::vector<UnistyleDependency>& deps);
     void shadowLeafUpdateFromUnistyle(jsi::Runtime& rt, Unistyle::Shared unistyle, jsi::Value& maybePressableId);
+    // call it only within trafficController.withLock!
+    void queueShadowLeafUpdatesUnsafe(shadow::ShadowLeafUpdates& updates);
     shadow::ShadowTrafficController trafficController{};
     const std::optional<std::string> getScopedTheme();
     void removeDuplicatedUnistyles(const ShadowNodeFamily* shadowNodeFamily, std::vector<core::Unistyle::Shared>& unistyles);
@@ -55,14 +63,26 @@ struct UnistylesRegistry: public StyleSheetRegistry {
     void destroy();
 
 private:
+    using ReleasedFamilies = std::vector<std::shared_ptr<const ShadowNodeFamily>>;
+
     UnistylesRegistry() = default;
 
+    // call it only within trafficController.withLock!
+    // pins are moved to releasedFamilies, so they can be released after unlocking
+    void forgetFamilyUnsafe(const ShadowNodeFamily* shadowNodeFamily, ReleasedFamilies& releasedFamilies);
+    void sweepUnownedFamiliesUnsafe(ReleasedFamilies& releasedFamilies);
+
+    // React Native doesn't own the family anymore, it was unmounted without unlink
+    static bool isOwnedOnlyByUnistyles(const LinkedFamily& linkedFamily) noexcept;
+
+    static constexpr size_t MIN_SWEEP_THRESHOLD = 64;
+
     static std::atomic<int> _nextStyleSheetTag;
     std::optional<std::string> _scopedTheme{};
     std::unique_ptr<UnistylesState> _state{};
     std::unordered_map<int, std::shared_ptr<core::StyleSheet>> _styleSheetRegistry{};
-    std::unordered_map<const ShadowNodeFamily*, std::vector<std::shared_ptr<UnistyleData>>> _shadowRegistry{};
-    std::unordered_set<const ShadowNodeFamily*> _suspendedFamilies{};
+    std::unordered_map<const ShadowNodeFamily*, LinkedFamily> _shadowRegistry{};
+    size_t _sweepThreshold = MIN_SWEEP_THRESHOLD;
 };
 
 inline UnistylesRegistry& UnistylesRegistry::get() {

package/cxx/hybridObjects/HybridShadowRegistry.cpp

@@ -87,9 +87,10 @@ 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);
@@ -103,7 +104,7 @@ jsi::Value HybridShadowRegistry::link(jsi::Runtime &rt, const jsi::Value &thisVa
 
     registry.linkShadowNodeWithUnistyle(
         rt,
-        &shadowNodeWrapper->getFamily(),
+        shadowNodeWrapper->getFamilyShared(),
         unistylesData,
         std::move(initialScopedUpdate)
     );
@@ -170,9 +171,5 @@ jsi::Value HybridShadowRegistry::getScopedTheme(jsi::Runtime &rt, const jsi::Val
 }
 
 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/parser/Parser.cpp

@@ -444,8 +444,7 @@ void parser::Parser::rebuildShadowLeafUpdates(jsi::Runtime& rt, core::Dependency
             updates.emplace(shadowNode, std::move(rawProps));
         }
 
-        registry.trafficController.setUpdates(updates);
-        registry.trafficController.resumeUnistylesTraffic();
+        registry.queueShadowLeafUpdatesUnsafe(updates);
     });
 }
 

package/cxx/shadowTree/NativeProps.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <folly/dynamic.h>
+#include <react/renderer/core/ShadowNodeFamily.h>
+#include <cxxreact/ReactNativeVersion.h>
+#include <memory>
+#include <mutex>
+
+// 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 void resetNativeProps(const ShadowNodeFamily* family) {
+#if UNISTYLES_HAS_NATIVE_PROPS_MUTEX
+    std::lock_guard<std::mutex> lock(family->nativePropsMutex);
+#endif
+
+    family->nativeProps_DEPRECATED.reset();
+}
+
+}

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,32 @@ 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;
-
-        // 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);
-
-                return;
-            }
+        // returns the pin, so the caller can release it after unlocking
+        auto it = _unistylesUpdates.find(shadowNodeFamily);
 
-            targetUpdates.emplace(pair.first, std::move(pair.second));
-        });
-    }
-
-    inline void removeShadowNode(const ShadowNodeFamily* shadowNodeFamily) {
-        // call it only within withLock!
-        if (_unistylesUpdates.contains(shadowNodeFamily)) {
-            _unistylesUpdates.erase(shadowNodeFamily);
+        if (it == _unistylesUpdates.end()) {
+            return nullptr;
         }
-    }
 
-    inline void restore() {
-        // call it only within withLock!
+        auto family = std::move(it->second.family);
+
+        _unistylesUpdates.erase(it);
 
-        _unistylesUpdates = {};
-        _canCommit = false;
+        return family;
     }
 
     template <typename F>
@@ -64,8 +44,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