How to use Checkpoints in my situation. Or maybe not to use Navigator for such scenario ?

[SolodovnykV]

I'm having an issue with Checkpoint. When I press the button, I want to switch to the Trade tab and pass the market as a parameter using the following code:

navigator.perform(.send(RootTabs.trade))
navigator.returnToCheckpoint(KnownCheckpoints.trade, value: market)

I've attached two video examples to show what I'm experiencing. Also, note that I'm trying to use Navigator—even though it might not be necessary—as I really want to integrate it.

The problem is, first of all, that the code for returning to the Trade tab is clearly doing too much. Secondly, if I activate the Trade tab first and then try to navigate from MarketDetail to Trade, the checkpoint exists and the transition happens. However, if the tab hasn’t been activated yet, then the transition does not occur.

One more important detail: my TabView is embedded inside a single ManagedNavigationStack, meaning that there isn’t a separate NavigationStack for each tab. This is how most trading apps work, where the MarketDetail view opens within the main NavigationStack rather than having a separate navigation stack per tab, which is different from what's shown in many examples and Medium articles.

I used the NavigatorDemo and added some simple views and Destinations.

struct RootTabView : View {
    @State private var selectedTab: RootTabs = .markets

    var body: some View {
        ManagedNavigationStack {
            
            TabView(selection: $selectedTab) {
                ForEach(RootTabs.tabs) { tab in
                    tab
                        .tabItem { Label(tab.title, systemImage: tab.image) }
                        .tag(tab)
                }
            }
            .navigationDestination(RootDestinations.self)
            .onNavigationReceive { (tab: RootTabs) in
                if tab == selectedTab {
                    return .immediately
                }
                selectedTab = tab
                return .auto
            }
        }
    }
}

enum RootTabs: Int, Codable {
    case markets
    case trade
}

extension RootTabs: Identifiable {

    static var tabs: [RootTabs] {
        [.markets, .trade]
    }

    var id: String {
        "\(self)"
    }

    var title: String {
        switch self {
        case .markets:
            "Markets"
        case .trade:
            "Trade"
        }
    }

    var image: String {
        switch self {
        case .markets:
            "house"
        case .trade:
            "gear"
        }
    }

}

extension RootTabs: NavigationDestination {
    var body: some View {
        RootTabsViewBuilder(destination: self)
    }
}

private struct RootTabsViewBuilder: View {
    let destination: RootTabs
    var body: some View {
        switch destination {
        case .markets:
            MarketsView()
        case .trade:
            TradeView()
        }
    }
}
struct KnownCheckpoints: NavigationCheckpoints {
    public static var trade: NavigationCheckpoint<String> { checkpoint() }
    public static var markets: NavigationCheckpoint<Void> { checkpoint() }
}

struct MarketDetailView: View {
    let market: String
    @Environment(\.navigator) private var navigator
    var body: some View {
        VStack {
            Text(market)
            Button {
                navigator.perform(.send(RootTabs.trade))
                navigator.returnToCheckpoint(KnownCheckpoints.trade, value: market)
            } label: {
                Text("trade")
            }

        }
    }
}

struct MarketsView: View {
    private var markets: [String] = ["Market 1", "Market 2"]
    @Environment(\.navigator) private var navigator
    var body: some View {
        List {
            ForEach(markets, id: \.self) { market in
                Button {
                    navigator.navigate(to: RootDestinations.marketDetail(market))
                } label: {
                    Text(market)
                }

            }
        }
    }
}

public enum RootDestinations: Codable {
    case marketDetail(String)
}

extension RootDestinations: NavigationDestination {
    public var body: some View {
        switch self {
        case .marketDetail(let market):
            MarketDetailView(market: market)
        }
    }
}

struct TradeView: View {
    @State private var market: String = "Market 3"

    var body: some View {
        Text("Market for trade: \(market)")
            .navigationCheckpoint(KnownCheckpoints.trade) { result in
                debugPrint(result)
                market = result
            }

    }
}

CleanShot.2025-03-10.at.14.52.22.mp4

CleanShot.2025-03-10.at.14.53.18.mp4

[hmlongco]

That's not a use case for checkpoints. Checkpoints return you to a previously visited and named location in the current navigation tree. (A place that you've pushed or presented from.)

If you're wanting to switch tabs and go TO a location, that's more of a deep linking/routing problem, which is what navigation send is designed for.

[SolodovnykV]

So, do I need something like this route?

public struct RootTabViewRouter: NavigationRouteHandling {

    @MainActor public func route(to route: KnownRoutes, with navigator: Navigator) {
        switch route {

        case .trade(let market):
            navigator.perform(
                .send(RootTabs.trade(market: market)),
                .reset
            )
        }
    }
}

I tried to handle this navigation in my TradeView:

struct TradeView: View {
    @State private var market: String = "Market 3"

    var body: some View {
        Text("Market for trade: \(market)")
            .onNavigationReceive { (destination: RootTabs, navigator) in
                switch destination {
                case .trade(let newMarket):
                    market = newMarket
                default:
                    break
                }
                return .auto
            }
    }
}

But surely got an error:

Navigator additional receive handlers ignored for type: RootTabs!!!

I apologize for asking such questions, as they might be trivial for many developers. I haven't been able to figure anything out for the third day already.

[hmlongco]

If you see that you've got more than one handler for RootTabs. There can be only one.