SwiftUI #Published Property Being Updated In DetailView - swiftui

Question

I am trying to understand if I am following the theory of SwiftUI #Published and #ObservedObject.
Theory
I have a Model that is receiving updates from a server. The model publishes any changes to the data in the model.
My main view observes this list from the model and creates a List view with cell views that pushes to a detail view. The cell views are published.
The detail view observes changes to the cell view.
What I Think Should Happen
When the model updates this would update the list view, which is does.
When the model updates the detail view would update if it was loaded. It does not.
Why doesn't the detail view update when the model updates if there is an #Published and #ObservedObject chain?

Answer 1

ObservableObjects don't nest. You have choices to trigger objectWillChange manually. That's actually a great thing because you can use an EnvironmentObject factory to wire up your app without exposing anything to views and not force everything to update all at once.
If you know it has changed from a callback you can fire it yourself objectWillChange.send().
You can also subscribe to a Publisher (e.g., another ObservableObjects ObjectWillChangePublisher, or some networking pipeline) and trigger the recipient ObservableObject's publisher on value receipt.
Here is a redux-style code example that goes hog wild and ties into every update.
import Foundation
import Combine
open class Republisher: ObservableObject {
public func republish() {
objectWillChange.send()
}
public init () {}
}
class VM: ObservableObject {
private var republishers = Set<AnyCancellable>()
internal var root: RootStore
init(_ root: RootStore, _ repubs: Republisher...) {
self.root = root
root.objectWillChange
.receive(on: DispatchQueue.main)
.sink(receiveValue: { [weak self] _ in
guard let self = self else { return }
self.objectWillChange.send()
})
.store(in: &republishers)
repubs.forEach { repubs in
repubs.objectWillChange
.receive(on: DispatchQueue.main)
.sink(receiveValue: { [weak self] _ in
guard let self = self else { return }
self.objectWillChange.send()
})
.store(in: &republishers)
}
}
deinit { republishers = [] }
}
import Foundation
import Combine
public final class RootStore: Republisher {
private var middlewareCancellables: Set<AnyCancellable> = []
public init(state: RootState,
reducer: #escaping Reducer<RootState, RootAction>,
middleware: Middlewares = []) {
self.state = state
self.reducer = reducer
self.middleware = RootStore.mandatoryWares(and: middleware)
}
public private(set) var state: RootState {
didSet { republish() }
}
...
}