Fix navigator resolution & @PersistentObject

Author: vmanot

Sources/Intermodular/Helpers/AppKit or UIKit/AppKitOrUIKitViewControllerResolver.swift

@@ -226,7 +226,7 @@ private struct _ResolveAppKitOrUIKitViewController: ViewModifier {
         PassthroughView {
             #if os(iOS) || os(tvOS) || targetEnvironment(macCatalyst)
             content
-                .environment(\.navigator, (_appKitOrUIKitViewControllerBox.value?.navigationController).map(_UINavigationControllerNavigatorAdaptorBox.init))
+                .modifier(ProvideNavigator(_appKitOrUIKitViewControllerBox: _appKitOrUIKitViewControllerBox))
             #elseif os(macOS)
             content
             #endif
@@ -252,6 +252,36 @@ private struct _ResolveAppKitOrUIKitViewController: ViewModifier {
                 .id(_appKitOrUIKitViewControllerBox.value.map(ObjectIdentifier.init))
         }
     }
+
+    #if os(iOS) || os(tvOS) || targetEnvironment(macCatalyst)
+    private struct ProvideNavigator: ViewModifier {
+        struct Navigator: SwiftUIX.Navigator {
+            var base: AppKitOrUIKitViewController?
+
+            private var nearestNavigator: _UINavigationControllerNavigatorAdaptorBox? {
+                base?.nearestNavigationController.map(_UINavigationControllerNavigatorAdaptorBox.init(navigationController:))
+            }
+
+            func push<V: View>(_ view: V, withAnimation animation: Animation?) {
+                nearestNavigator?.push(view, withAnimation: animation)
+            }
+
+            func pop(withAnimation animation: Animation?) {
+                nearestNavigator?.pop(withAnimation: animation)
+            }
+
+            func popToRoot(withAnimation animation: Animation?) {
+                nearestNavigator?.popToRoot(withAnimation: animation)
+            }
+        }
+
+        @ObservedObject var _appKitOrUIKitViewControllerBox: ObservableWeakReferenceBox<AppKitOrUIKitViewController>
+
+        func body(content: Content) -> some View {
+            content.environment(\.navigator, Navigator(base: _appKitOrUIKitViewControllerBox.value))
+        }
+    }
+    #endif
 }
 
 #endif

Sources/Intermodular/Helpers/Combine/_AnyObservableObject.swift

@@ -0,0 +1,29 @@
+//
+// Copyright (c) Vatsal Manot
+//
+
+import Combine
+import Swift
+
+final class _AnyObservableObject: ObservableObject {
+    private class _EmptyObservableObject: ObservableObject {
+        init() {
+            
+        }
+    }
+    
+    static let empty = _AnyObservableObject(_EmptyObservableObject())
+    
+    let base: AnyObject
+    
+    private let objectWillChangeImpl: () -> AnyPublisher<Void, Never>
+    
+    var objectWillChange: AnyPublisher<Void, Never> {
+        objectWillChangeImpl()
+    }
+    
+    init<T: ObservableObject>(_ base: T) {
+        self.base = base
+        self.objectWillChangeImpl = { base.objectWillChange.map({ _ in () }).eraseToAnyPublisher() }
+    }
+}

Sources/Intermodular/Helpers/Combine/_OptionalObservedObjectContainer.swift

@@ -0,0 +1,50 @@
+//
+// Copyright (c) Vatsal Manot
+//
+
+import Combine
+import Swift
+
+final class _OptionalObservedObjectContainer<ObjectType: ObservableObject>: ObservableObject {
+    private var baseSubscription: AnyCancellable?
+    
+    var onObjectWillChange: () -> Void = { }
+    
+    var base: ObjectType? {
+        didSet {
+            if let oldValue = oldValue, let base = base {
+                if oldValue === base, baseSubscription != nil {
+                    return
+                }
+            }
+            
+            subscribe()
+        }
+    }
+    
+    init(base: ObjectType? = nil) {
+        self.base = base
+        
+        subscribe()
+    }
+    
+    private func subscribe() {
+        guard let base = base else {
+            return
+        }
+        
+        baseSubscription = base
+            .objectWillChange
+            .receive(on: DispatchQueue.main)
+            .sink(receiveValue: { [weak self] _ in
+                guard let `self` = self else {
+                    return
+                }
+                
+                DispatchQueue.asyncOnMainIfNecessary {
+                    `self`.objectWillChange.send()
+                    `self`.onObjectWillChange()
+                }
+            })
+    }
+}

Sources/Intramodular/Dynamic Properties/EnvironmentObjectOrObservedObject.swift

@@ -14,16 +14,12 @@ public struct EnvironmentObjectOrObservedObject<Value: ObservableObject>: Dynami
     @OptionalObservedObject private var _wrappedValue1: Value?
 
     public var wrappedValue: Value {
-        get {
-            if let result = _wrappedValue1 ?? _wrappedValue0 {
-                return result
-            } else {
-                assertionFailure()
-                
-                return defaultValue()
-            }
-        } set {
-            _wrappedValue1 = newValue
+        if let result = _wrappedValue1 ?? _wrappedValue0 {
+            return result
+        } else {
+            assertionFailure()
+
+            return defaultValue()
         }
     }
 
@@ -34,7 +30,7 @@ public struct EnvironmentObjectOrObservedObject<Value: ObservableObject>: Dynami
 
     public mutating func update() {
         if _wrappedValue0 == nil {
-            _wrappedValue1 = defaultValue()
+            __wrappedValue1 = .init(wrappedValue: defaultValue())
         }
 
         self.__wrappedValue0.update()

Sources/Intramodular/Dynamic Properties/OptionalObservedObject.swift

@@ -11,139 +11,29 @@ import SwiftUI
 public struct OptionalObservedObject<ObjectType: ObservableObject>: DynamicProperty {
     private typealias Container = _OptionalObservedObjectContainer<ObjectType>
 
-    @State
-    private var dummyStateVariable: Bool = false
-    @ObservedObject
-    private var dummyObservedObject = _DummyObservableObject()
-    @State
-    private var base: ObjectType?
-    @State
-    private var container: Container
-    @ObservedObject
-    private var observedContainer: Container
-    @ObservedObject
-    private var observedObject: _AnyObservableObject
+    private let base: ObjectType?
+    
+    @ObservedObject private var observedContainer = Container(base: nil)
 
     /// The current state value.
     public var wrappedValue: ObjectType? {
-        get {
-            container.base
-        } nonmutating set {
-            base = newValue
-            container.base = newValue
-            observedContainer.base = newValue
-            
-            container.onObjectWillChange = {
-                dummyObservedObject.objectWillChange.send()
-            }
-            
-            dummyStateVariable.toggle()
+        if observedContainer.base !== base {
+            observedContainer.base = base
         }
+        
+        return base
     }
 
     /// Initialize with the provided initial value.
     public init(wrappedValue value: ObjectType?) {
-        let container = Container(base: value)
-        
-        self.container = container
-        self.observedContainer = container
-        self.observedObject = value.map(_AnyObservableObject.init) ?? .empty
+        self.base = value
     }
 
     public init() {
         self.init(wrappedValue: nil)
     }
 
     public mutating func update() {
-        let container = self.container
-        
-        if self.observedContainer !== container {
-            self.observedContainer = container
-        }
-        
-        if let base = container.base, container.isDirty {
-            self.observedContainer = container
-            self.observedObject = _AnyObservableObject(base)
-            
-            container.isDirty = false
-        }
-    }
-}
-
-// MARK: - Auxiliary Implementation -
-
-private class _DummyObservableObject: ObservableObject {
-    init() {
-        
-    }
-}
-
-private final class _OptionalObservedObjectContainer<ObjectType: ObservableObject>: ObservableObject {
-    private var baseSubscription: AnyCancellable?
-    
-    var onObjectWillChange: () -> Void = { }
-    var isDirty: Bool = false
-    
-    var base: ObjectType? {
-        didSet {
-            if let oldValue = oldValue, let base = base {
-                if oldValue === base, baseSubscription != nil {
-                    return
-                }
-            }
-            
-            subscribe()
-            
-            isDirty = true
-        }
-    }
-    
-    init(base: ObjectType?) {
-        self.base = base
-        
-        subscribe()
-    }
-    
-    private func subscribe() {
-        guard let base = base else {
-            return
-        }
-        
-        baseSubscription = base
-            .objectWillChange
-            .receive(on: DispatchQueue.main)
-            .sink(receiveValue: { [weak self] _ in
-                guard let `self` = self else {
-                    return
-                }
-                
-                DispatchQueue.asyncOnMainIfNecessary {
-                    `self`.objectWillChange.send()
-                    `self`.onObjectWillChange()
-                }
-            })
-    }
-}
-
-private final class _AnyObservableObject: ObservableObject {
-    private class _EmptyObservableObject: ObservableObject {
-        init() {
-            
-        }
-    }
-    
-    static let empty = _AnyObservableObject(_EmptyObservableObject())
-    
-    let base: AnyObject
-    
-    private let objectWillChangeImpl: () -> AnyPublisher<Void, Never>
-    
-    var objectWillChange: AnyPublisher<Void, Never> {
-        objectWillChangeImpl()
-    }
-    
-    init<T: ObservableObject>(_ base: T) {
-        self.base = base
-        self.objectWillChangeImpl = { base.objectWillChange.map({ _ in () }).eraseToAnyPublisher() }
+        _observedContainer.update()
     }
 }

Sources/Intramodular/Dynamic Properties/PersistentObject.swift

@@ -11,38 +11,42 @@ import SwiftUI
 public struct PersistentObject<ObjectType: ObservableObject>: DynamicProperty {
     private let thunk: () -> ObjectType
 
-    @OptionalObservedObject
-    private var observedObject: ObjectType?
-    @State
-    private var state = ReferenceBox<ObjectType?>(nil)
+    @State private var objectContainer = _OptionalObservedObjectContainer<ObjectType>()
+    
+    @ObservedObject private var observedObjectContainer = _OptionalObservedObjectContainer<ObjectType>()
 
     public var wrappedValue: ObjectType {
         get {
-            if state.value == nil {
-                state.value = thunk()
+            if let object = objectContainer.base {
+                if observedObjectContainer.base !== object {
+                    observedObjectContainer.base = object
+                }
+                
+                return object
+            } else {
+                let object = thunk()
+                
+                objectContainer.base = object
+                observedObjectContainer.base = object
+                
+                return object
             }
-            
-            return state.value!
         } nonmutating set {
-            state.value = newValue
-            observedObject = newValue
+            objectContainer.base = newValue
+            observedObjectContainer.base = newValue
         }
     }
 
     public var projectedValue: ObservedObject<ObjectType>.Wrapper {
-        ObservedObject(wrappedValue: observedObject!).projectedValue
+        ObservedObject(wrappedValue: wrappedValue).projectedValue
     }
 
     public init(wrappedValue thunk: @autoclosure @escaping () -> ObjectType) {
         self.thunk = thunk
     }
 
     public mutating func update() {
-        if state.value == nil {
-            let object = thunk()
-            
-            state.value = object
-            observedObject = object
-        }
+        _objectContainer.update()
+        _observedObjectContainer.update()
     }
 }