fix: prevent unneccessarily destroying the styled computed

Author: marklawlor

README.md

@@ -24,28 +24,26 @@ These are the features that are "done", in that they pass basic testing. More co
 - [x] Web
 - [x] Multiple style rules
 - [x] Specificity sorting
-- [x] Transform
-- [ ] Filter
 - [x] Pseudo classes
 - [x] Media query
 - [x] Attribute selectors
 - [x] Container named queries
 - [x] Container media queries
-- [ ] Container attribute queries
 - [x] Dynamic Variables
 - [x] Global variables w/ media queries
+- [x] Transform
+- [ ] Filter
+- [ ] Animations
+- [x] Transitions
+- [x] Important styles
+- [x] Important props
+- [ ] Safe area units
+- [ ] Em
+- [ ] `currentColor`
 - [ ] CSS functions (min, max, platform functions, etc)
-- [ ] Alt style props (e.g `headerStyle`)
 - [ ] Metro
 - [ ] Update compiler to new syntax (switch tuples to objects)
-- [x] Upgrading elements
-- [ ] Animations
-- [x] Transitions
-- [ ] Important styles
-- [ ] Important props
 - [ ] Shorthand runtime styles
 - [ ] Native component wrappers (e.g TextInput, ScrollView, etc)
 - [ ] 3rd party hook (nativeStyleToProp, etc)
-- [ ] Safe area units
-- [ ] Em
-- [ ] `currentColor`
+- [ ] 3rd party Alt style props (e.g `headerStyle`)

cpp/HybridStyleRegistry.cpp

@@ -30,7 +30,7 @@ namespace margelo::nitro::cssnitro {
     // Initialize static members
     std::unique_ptr<ShadowTreeUpdateManager> HybridStyleRegistry::shadowUpdates_ =
             std::make_unique<ShadowTreeUpdateManager>();
-    std::unordered_map<std::string, std::shared_ptr<reactnativecss::Computed<Styled *>>> HybridStyleRegistry::computedMap_;
+    std::unordered_map<std::string, HybridStyleRegistry::ComputedEntry> HybridStyleRegistry::computedMap_;
     std::unordered_map<std::string, std::shared_ptr<reactnativecss::Observable<std::vector<HybridStyleRule>>>> HybridStyleRegistry::styleRuleMap_;
     std::atomic<uint64_t> HybridStyleRegistry::nextStyleRuleId_{1};
 
@@ -186,25 +186,51 @@ namespace margelo::nitro::cssnitro {
                                            const std::string &variableScope,
                                            const std::string &containerScope,
                                            const std::vector<std::string> &validAttributeQueries) {
-        if (auto existing = computedMap_.find(componentId); existing != computedMap_.end()) {
-            if (existing->second) {
-                existing->second->dispose();
+        // Check if an entry exists for this component
+        auto existing = computedMap_.find(componentId);
+
+        // Only recreate computed if parameters have changed or it doesn't exist
+        bool shouldRecreate = false;
+        if (existing == computedMap_.end()) {
+            shouldRecreate = true;
+        } else {
+            // Check if any of the parameters have changed
+            const auto &entry = existing->second;
+            if (entry.classNames != classNames ||
+                entry.variableScope != variableScope ||
+                entry.containerScope != containerScope) {
+                shouldRecreate = true;
             }
-            computedMap_.erase(existing);
         }
 
-        (void) rerender;
+        std::shared_ptr<reactnativecss::Computed<Styled *>> computed;
 
-        // Build computed Styled via factory
-        auto computed = ::margelo::nitro::cssnitro::makeStyledComputed(styleRuleMap_, classNames,
-                                                                       componentId,
-                                                                       rerender,
-                                                                       *shadowUpdates_,
-                                                                       variableScope,
-                                                                       containerScope,
-                                                                       validAttributeQueries);
+        if (shouldRecreate) {
+            // Dispose old computed if it exists
+            if (existing != computedMap_.end() && existing->second.computed) {
+                existing->second.computed->dispose();
+            }
 
-        computedMap_[componentId] = computed;
+            // Build new computed Styled via factory
+            computed = ::margelo::nitro::cssnitro::makeStyledComputed(styleRuleMap_, classNames,
+                                                                      componentId,
+                                                                      rerender,
+                                                                      *shadowUpdates_,
+                                                                      variableScope,
+                                                                      containerScope,
+                                                                      validAttributeQueries);
+
+            // Store the new computed with its parameters
+            computedMap_[componentId] = ComputedEntry{
+                    computed,
+                    classNames,
+                    variableScope,
+                    containerScope
+            };
+        } else {
+            // Reuse existing computed
+            computed = existing->second.computed;
+        }
 
         // Get the value from computed - it's a Styled* that may be nullptr
         Styled *styledPtr = computed->get();
@@ -221,8 +247,8 @@ namespace margelo::nitro::cssnitro {
     void HybridStyleRegistry::deregisterComponent(const std::string &componentId) {
         auto it = computedMap_.find(componentId);
         if (it != computedMap_.end()) {
-            if (it->second) {
-                it->second->dispose();
+            if (it->second.computed) {
+                it->second.computed->dispose();
             }
             computedMap_.erase(it);
         }

cpp/HybridStyleRegistry.hpp

@@ -85,9 +85,17 @@ namespace margelo::nitro::cssnitro {
                                            const jsi::Value &thisValue,
                                            const jsi::Value *args, size_t count);
 
+        // Struct to hold computed with its associated parameters
+        struct ComputedEntry {
+            std::shared_ptr<reactnativecss::Computed<Styled *>> computed;
+            std::string classNames;
+            std::string variableScope;
+            std::string containerScope;
+        };
+
         // Static shared state
         static std::unique_ptr<ShadowTreeUpdateManager> shadowUpdates_;
-        static std::unordered_map<std::string, std::shared_ptr<reactnativecss::Computed<Styled *>>> computedMap_;
+        static std::unordered_map<std::string, ComputedEntry> computedMap_;
         static std::unordered_map<std::string, std::shared_ptr<reactnativecss::Observable<std::vector<HybridStyleRule>>>> styleRuleMap_;
         static std::atomic<uint64_t> nextStyleRuleId_;
     };