Use State over StateObject where possible

Author: ra1028

Sources/Atoms/AtomRoot.swift

@@ -61,7 +61,7 @@ import SwiftUI
 /// ```
 ///
 public struct AtomRoot<Content: View>: View {
-    private var storeHost: StoreHost
+    private var storage: Storage
     private var overrides = [OverrideKey: any OverrideProtocol]()
     private var observers = [Observer]()
     private let content: Content
@@ -70,7 +70,7 @@ public struct AtomRoot<Content: View>: View {
     ///
     /// - Parameter content: The descendant view content that provides context for atoms.
     public init(@ViewBuilder content: () -> Content) {
-        self.storeHost = .tree
+        self.storage = .managed
         self.content = content()
     }
 
@@ -84,26 +84,26 @@ public struct AtomRoot<Content: View>: View {
         storesIn store: AtomStore,
         @ViewBuilder content: () -> Content
     ) {
-        self.storeHost = .unmanaged(store: store)
+        self.storage = .unmanaged(store: store)
         self.content = content()
     }
 
     /// The content and behavior of the view.
     public var body: some View {
-        switch storeHost {
-        case .tree:
-            TreeManaged(
-                content: content,
+        switch storage {
+        case .managed:
+            Managed(
                 overrides: overrides,
-                observers: observers
+                observers: observers,
+                content: content
             )
 
         case .unmanaged(let store):
             Unmanaged(
-                content: content,
                 store: store,
                 overrides: overrides,
-                observers: observers
+                observers: observers,
+                content: content
             )
         }
     }
@@ -150,31 +150,27 @@ public struct AtomRoot<Content: View>: View {
 }
 
 private extension AtomRoot {
-    enum StoreHost {
-        case tree
+    enum Storage {
+        case managed
         case unmanaged(store: AtomStore)
     }
 
-    struct TreeManaged: View {
-        @MainActor
-        final class State: ObservableObject {
-            let store = AtomStore()
-            let token = ScopeKey.Token()
-        }
-
-        let content: Content
+    struct Managed: View {
         let overrides: [OverrideKey: any OverrideProtocol]
         let observers: [Observer]
+        let content: Content
 
-        @StateObject
-        private var state = State()
+        @State
+        private var store = AtomStore()
+        @State
+        private var token = ScopeKey.Token()
 
         var body: some View {
             content.environment(
                 \.store,
                 StoreContext(
-                    store: state.store,
-                    scopeKey: ScopeKey(token: state.token),
+                    store: store,
+                    scopeKey: ScopeKey(token: token),
                     inheritedScopeKeys: [:],
                     observers: observers,
                     scopedObservers: [],
@@ -186,25 +182,20 @@ private extension AtomRoot {
     }
 
     struct Unmanaged: View {
-        @MainActor
-        final class State: ObservableObject {
-            let token = ScopeKey.Token()
-        }
-
-        let content: Content
         let store: AtomStore
         let overrides: [OverrideKey: any OverrideProtocol]
         let observers: [Observer]
+        let content: Content
 
-        @StateObject
-        private var state = State()
+        @State
+        private var token = ScopeKey.Token()
 
         var body: some View {
             content.environment(
                 \.store,
                 StoreContext(
                     store: store,
-                    scopeKey: ScopeKey(token: state.token),
+                    scopeKey: ScopeKey(token: token),
                     inheritedScopeKeys: [:],
                     observers: observers,
                     scopedObservers: [],

Sources/Atoms/AtomScope.swift

@@ -87,19 +87,19 @@ public struct AtomScope<Content: View>: View {
     public var body: some View {
         switch inheritance {
         case .environment(let id):
-            InheritedEnvironment(
+            WithEnvironment(
                 id: id,
-                content: content,
                 overrides: overrides,
-                observers: observers
+                observers: observers,
+                content: content
             )
 
         case .context(let store):
-            InheritedContext(
-                content: content,
+            WithContext(
                 store: store,
                 overrides: overrides,
-                observers: observers
+                observers: observers,
+                content: content
             )
         }
     }
@@ -158,27 +158,22 @@ private extension AtomScope {
         case context(store: StoreContext)
     }
 
-    struct InheritedEnvironment: View {
-        @MainActor
-        final class State: ObservableObject {
-            let token = ScopeKey.Token()
-        }
-
+    struct WithEnvironment: View {
         let id: ScopeID
-        let content: Content
         let overrides: [OverrideKey: any OverrideProtocol]
         let observers: [Observer]
+        let content: Content
 
-        @StateObject
-        private var state = State()
+        @State
+        private var token = ScopeKey.Token()
         @Environment(\.store)
         private var environmentStore
 
         var body: some View {
             content.environment(
                 \.store,
                 environmentStore?.scoped(
-                    scopeKey: ScopeKey(token: state.token),
+                    scopeKey: ScopeKey(token: token),
                     scopeID: id,
                     observers: observers,
                     overrides: overrides
@@ -187,11 +182,11 @@ private extension AtomScope {
         }
     }
 
-    struct InheritedContext: View {
-        let content: Content
+    struct WithContext: View {
         let store: StoreContext
         let overrides: [OverrideKey: any OverrideProtocol]
         let observers: [Observer]
+        let content: Content
 
         var body: some View {
             content.environment(

Sources/Atoms/PropertyWrapper/ViewContext.swift

@@ -32,9 +32,10 @@ import SwiftUI
 ///
 @propertyWrapper
 public struct ViewContext: DynamicProperty {
-    @StateObject
-    private var state = State()
-
+    @State
+    private var signal = false
+    @State
+    private var subscriberState = SubscriberState()
     @Environment(\.store)
     private var _store
 
@@ -52,29 +53,25 @@ public struct ViewContext: DynamicProperty {
     /// This property provides primary access to the view context. However you don't
     /// access ``wrappedValue`` directly.
     /// Instead, you use the property variable created with the `@ViewContext` attribute.
-    #if compiler(>=6) || hasFeature(DisableOutwardActorInference)
-        @MainActor
-    #endif
+
+    @MainActor
     public var wrappedValue: AtomViewContext {
-        AtomViewContext(
+        let signal = _signal
+
+        // Initializes State and starts observing for updates.
+        _ = signal.wrappedValue
+
+        return AtomViewContext(
             store: store,
-            subscriber: Subscriber(state.subscriberState),
-            subscription: Subscription(
-                location: location,
-                update: { [weak state] in
-                    state?.objectWillChange.send()
-                }
-            )
+            subscriber: Subscriber(subscriberState),
+            subscription: Subscription(location: location) {
+                signal.wrappedValue.toggle()
+            }
         )
     }
 }
 
 private extension ViewContext {
-    @MainActor
-    final class State: ObservableObject {
-        let subscriberState = SubscriberState()
-    }
-
     @MainActor
     var store: StoreContext {
         guard let _store else {