Why are objects still in memory after emptying NavigationStack path?

Question

I'm trying to implement a Coordinator for managing a flow. The state is stored inside the CoordinatorStore. There are 2 @Published properties for managing the flow. The screen property controls which View is currently shown and path controls the navigation stack of the stack view. Details of the implementation can be found below.

With the current implementation and after the following actions: showA -> showB -> showInitial -> Go to Stack

I would expect that StoreA and StoreB would be deallocated from memory since path, which holds StoreA and StoreB via enum associated values, gets emptied.

But that doesn't happen, and if I repeat the actions again there would be 2 StoreA and 2 StoreB in memory and so on. Am I missing something?

I will also attach a screenshot of the memory debugger snapshot after doing the initial set of actions.

enum Path: Hashable {
    case a(StoreA)
    case b(StoreB)
}

enum Screen {
    case initial
    case stack
}

final class CoordinatorStore: ObservableObject {
    @Published var path: [Path] = []
    @Published var screen: Screen = .stack
    
    func showA() {
        let store = StoreA()
        path.append(.a(store))
    }
    
    func showB() {
        let store = StoreB()
        path.append(.b(store))
    }
    
    func showInitial() {
        path = []
        screen = .initial
    }
    
    func showStack() {
        screen = .stack
    }
}

struct Coordinator: View {
    @ObservedObject var store: CoordinatorStore
    
    var body: some View {
        switch store.screen {
        case .initial: initial
        case .stack: stack
        }
    }
    
    var stack: some View {
        NavigationStack(path: $store.path) {
            VStack {
                Text("Root")
            }
            .toolbar {
                Button(action: self.store.showA) {
                    Text("Push A")
                }
            }
            .navigationDestination(for: Path.self) { path in
                switch path {
                case .a(let store):
                    ViewA(store: store)
                        .toolbar {
                            Button(action: self.store.showB) {
                                Text("Push B")
                            }
                        }
                case .b(let store):
                    ViewB(store: store)
                        .toolbar {
                            Button(action: self.store.showInitial) {
                                Text("Show Initial")
                            }
                        }
                }
            }
        }
    }
    
    var initial: some View {
        VStack {
            Text("Initial")
            Button(action: store.showStack) {
                Text("Go to Stack")
            }
        }
    }
}

struct ViewA: View {
    @ObservedObject var store: StoreA
    
    var body: some View {
        Text("View A")
    }
}

final class StoreA: NSObject, ObservableObject {
    deinit {
        print("Deinit: \(String(describing: self))")
    }
}

struct ViewB: View {
    @ObservedObject var store: StoreB
    
    var body: some View {
        Text("View B")
    }
}

final class StoreB: NSObject, ObservableObject {
    deinit {
        print("Deinit: \(String(describing: self))")
    }
}

Answer 1

I believe this is related but not identical to:

• Found a strange behaviour of @State when combined to the new Navigation Stack - Is it a bug or am I doing it wrong?

The Navigation api seems to be prioritizing efficiency (inits are expensive) and that SOMETHING must always be on screen. It doesn't seem to de-initialize views that have been disappeared until it has a replacement initialized and appeared.

That can lead to a memory leak (I believe) if you try to manage Navigation framework views with something outside of the Navigation framework, but it appears as long as the Navigation framework stays in charge things will be de-inted eventually, but not until the new view is init-ed.

NEWER VERSION

This version uses one coordinator, but preserves the separate enums and views for the initial vs main app pathways.

import Foundation
import SwiftUI

enum AppSceneTvTe:Hashable {
    case setup
    case app
}

enum PathTvTeOptions: Hashable {
    case optionA(OptionAVM)
    case optionB(OptionBVM)
}

struct SplashTVTEView: View {
    @StateObject var oneCoordinator = CoordinatorTvTe()
    
    var body: some View {
        NavigationStack(path: $oneCoordinator.path) {
            splash
                .navigationDestination(for: AppSceneTvTe.self) { scene in
                switch scene {
                case .app:
                    SplashTvTeAppRootView().environmentObject(oneCoordinator)
                    
                default:
                    splash
                }
                
            }
        }
    }
    
    var splash: some View {
        VStack {
            Text("Splash Page")
            Button(action:navigateToApp) {
                Text("Go App Root")
            }
        }.navigationBarBackButtonHidden(true)
    }
    
    func navigateToApp() {
        oneCoordinator.showStack()
    }
}

final class CoordinatorTvTe: ObservableObject {
    @Published var path = NavigationPath()

    
    func showA() {
        path.append(PathTvTeOptions.optionA(OptionAVM()))
    }
    
    func showB() {
        path.append(PathTvTeOptions.optionB(OptionBVM()))
    }
    
    func showInitial() {
        unwindAll()
        //path = NavigationPath()
    }
    
    func showStack() {
        path = NavigationPath()
        path.append(AppSceneTvTe.app)
    }
    
    func unwindAll() {
        while !path.isEmpty {
            path.removeLast()
        }
    }
}

struct SplashTvTeAppRootView: View {
    @EnvironmentObject var navigation: CoordinatorTvTe

    
    var body: some View {
      
            VStack {
                Text("Real Root")
            }
            .navigationBarBackButtonHidden(true)
            .toolbar {
                Button(action: self.navigation.showA) {
                    Text("Push A")
                }
            }
            .navigationDestination(for: PathTvTeOptions.self) { path in
                switch path {
                case .optionA(let vm):
                    OptionAView(vm: vm)
                        .toolbar {
                            Button(action: self.navigation.showB) {
                                Text("Push B")
                            }
                        }
                case .optionB(let vm):
                    OptionBView(vm: vm)
                        .toolbar {
                            Button(action: self.navigation.showInitial) {
                                Text("Show Initial")
                            }
                        }
                }
            }

    }
    
}

OLDER VERSION

Currently the way out of this is to keep it all in the Navigation Stack so no separate Scene vs. Path.

This code uses a boolean to control the Initial screen, but it could be one of the path options - which is the commented out code.

EDITED TO ADD: Tuns out the boolean solution gets weird when you try to make the initial state true. The Stack keeps winning, so I've taken it out.

enum Path: Hashable {
    case initial
    case a(StoreA)
    case b(StoreB)
}

final class CoordinatorStore: ObservableObject {
    @Published var path: [Path] = [.initial]
    
    func showA() {
        let store = StoreA()
        path.append(.a(store))
    }
    
    func showB() {
        let store = StoreB()
        path.append(.b(store))
    }
    
    func showInitial() {
        path = []
        path.append(.inital)

    }
    
    func showStack() { 
        path = []
    }
}

struct Coordinator: View {
    @ObservedObject var store: CoordinatorStore

    
    var body: some View {
        NavigationStack(path: $store.path) {
            VStack {
                Text("Real Root")
            }
            .toolbar {
                Button(action: self.store.showA) {
                    Text("Push A")
                }
            }
            .navigationDestination(for: Path.self) { path in
                switch path {
                case .a(let store):
                    ViewA(store: store)
                        .toolbar {
                            Button(action: self.store.showB) {
                                Text("Push B")
                            }
                        }
                case .b(let store):
                    ViewB(store: store)
                        .toolbar {
                            Button(action: self.store.showInitial) {
                                Text("Show Initial")
                            }
                        }
                case .initial:
                    initial
                }

            }
        }
    }
    
    var initial: some View {
        VStack {
            Text("Initial")
            Button(action: store.showStack) {
                Text("Go to Stack")
            }
        }.navigationBarBackButtonHidden(true)
    }
}