fix(store): prevent stale state listeners from crashing apps (#119)

* fix(store): prevent stale state listeners from crashing apps

* fix(store): improve code maintenance

Author: mhamann

Sources/Rownd/Models/Context/ReSwiftObserver.swift

@@ -10,6 +10,17 @@ import Foundation
 import ReSwift
 import SwiftUI
 
+// MARK: - Main Thread Dispatch Helper
+
+/// Helper to centralize main-thread dispatch with weak self handling.
+/// Reduces duplication and ensures consistent patterns across observable state types.
+private func dispatchOnMain<T: AnyObject>(_ instance: T, execute work: @escaping (T) -> Void) {
+    DispatchQueue.main.async { [weak instance] in
+        guard let instance = instance else { return }
+        work(instance)
+    }
+}
+
 public class ObservableState<T: Hashable>: ObservableObject, StoreSubscriber, ObservableSubscription
 {
 
@@ -31,22 +42,22 @@ public class ObservableState<T: Hashable>: ObservableObject, StoreSubscriber, Ob
 
     public func subscribe() {
         guard !isSubscribed else { return }
-        DispatchQueue.main.async { [weak self] in
-            guard let self = self else { return }
-            guard !self.isSubscribed else { return }
+        // Capture selector directly to avoid retaining self in the transform closure
+        let selector = self.selector
+        dispatchOnMain(self) { instance in
+            guard !instance.isSubscribed else { return }
             Context.currentContext.store.subscribe(
-                self, transform: { [self] in $0.select(self.selector) })
-            self.isSubscribed = true
+                instance, transform: { $0.select(selector) })
+            instance.isSubscribed = true
         }
     }
 
     func unsubscribe() {
         guard isSubscribed else { return }
-        DispatchQueue.main.async { [weak self] in
-            guard let self = self else { return }
-            guard self.isSubscribed else { return }
-            Context.currentContext.store.unsubscribe(self)
-            self.isSubscribed = false
+        dispatchOnMain(self) { instance in
+            guard instance.isSubscribed else { return }
+            Context.currentContext.store.unsubscribe(instance)
+            instance.isSubscribed = false
         }
     }
 
@@ -55,17 +66,18 @@ public class ObservableState<T: Hashable>: ObservableObject, StoreSubscriber, Ob
     }
 
     public func newState(state: T) {
-        guard self.current != state else { return }
-        DispatchQueue.main.async {
-            let old = self.current
-            if let animation = self.animation {
+        // All @Published property access must happen on main thread
+        dispatchOnMain(self) { instance in
+            guard instance.current != state else { return }
+            let old = instance.current
+            if let animation = instance.animation {
                 withAnimation(animation) {
-                    self.current = state
+                    instance.current = state
                 }
             } else {
-                self.current = state
+                instance.current = state
             }
-            self.objectDidChange.send(DidChangeSubject(old: old, new: self.current))
+            instance.objectDidChange.send(DidChangeSubject(old: old, new: instance.current))
         }
     }
 
@@ -94,17 +106,19 @@ public class ObservableThrottledState<T: Hashable>: ObservableState<T> {
     }
 
     override public func newState(state: T) {
-        guard self.current != state else { return }
-        DispatchQueue.main.async {
-            let old = self.current
-            if let animation = self.animation {
+        // All @Published property access must happen on main thread to avoid crashes
+        // in swift_retain when accessing Combine's Published wrapper from background threads
+        dispatchOnMain(self) { instance in
+            guard instance.current != state else { return }
+            let old = instance.current
+            if let animation = instance.animation {
                 withAnimation(animation) {
-                    self.objectThrottled.send(state)
+                    instance.objectThrottled.send(state)
                 }
             } else {
-                self.objectThrottled.send(state)
+                instance.objectThrottled.send(state)
             }
-            self.objectDidChange.send(DidChangeSubject(old: old, new: self.current))
+            instance.objectDidChange.send(DidChangeSubject(old: old, new: instance.current))
         }
     }
 
@@ -137,22 +151,22 @@ public class ObservableDerivedState<Original: Hashable, Derived: Hashable>: Obse
 
     func subscribe() {
         guard !isSubscribed else { return }
-        DispatchQueue.main.async { [weak self] in
-            guard let self = self else { return }
-            guard !self.isSubscribed else { return }
+        // Capture selector directly to avoid retaining self in the transform closure
+        let selector = self.selector
+        dispatchOnMain(self) { instance in
+            guard !instance.isSubscribed else { return }
             Context.currentContext.store.subscribe(
-                self, transform: { [self] in $0.select(self.selector) })
-            self.isSubscribed = true
+                instance, transform: { $0.select(selector) })
+            instance.isSubscribed = true
         }
     }
 
     func unsubscribe() {
         guard isSubscribed else { return }
-        DispatchQueue.main.async { [weak self] in
-            guard let self = self else { return }
-            guard self.isSubscribed else { return }
-            Context.currentContext.store.unsubscribe(self)
-            self.isSubscribed = false
+        dispatchOnMain(self) { instance in
+            guard instance.isSubscribed else { return }
+            Context.currentContext.store.unsubscribe(instance)
+            instance.isSubscribed = false
         }
     }
 
@@ -161,18 +175,18 @@ public class ObservableDerivedState<Original: Hashable, Derived: Hashable>: Obse
     }
 
     public func newState(state original: Original) {
-        DispatchQueue.main.async {
-            let old = self.current
-            self.objectWillChange.send(ChangeSubject(old: old, new: self.current))
+        dispatchOnMain(self) { instance in
+            let old = instance.current
+            instance.objectWillChange.send(ChangeSubject(old: old, new: instance.current))
 
-            if let animation = self.animation {
+            if let animation = instance.animation {
                 withAnimation(animation) {
-                    self.current = self.transform(original)
+                    instance.current = instance.transform(original)
                 }
             } else {
-                self.current = self.transform(original)
+                instance.current = instance.transform(original)
             }
-            self.objectDidChange.send(ChangeSubject(old: old, new: self.current))
+            instance.objectDidChange.send(ChangeSubject(old: old, new: instance.current))
         }
     }
 
@@ -207,17 +221,16 @@ public class ObservableDerivedThrottledState<Original: Hashable, Derived: Hashab
     }
 
     override public func newState(state original: Original) {
-        let old = current
-        if let animation = animation {
-            withAnimation(animation) {
-                objectThrottled.send(original)
+        dispatchOnMain(self) { instance in
+            let old = instance.current
+            if let animation = instance.animation {
+                withAnimation(animation) {
+                    instance.objectThrottled.send(original)
+                }
+            } else {
+                instance.objectThrottled.send(original)
             }
-        } else {
-            objectThrottled.send(original)
-        }
-
-        DispatchQueue.main.async {
-            self.objectDidChange.send(ChangeSubject(old: old, new: self.current))
+            instance.objectDidChange.send(ChangeSubject(old: old, new: instance.current))
         }
     }