How can I pass information between subviews in Swift

I am using a NavigationStack for my app. In the NavigationStack, I have multiple "sub" views that need to pass information between one another. For example, I have three views in my app. View1 handles all of the navigation between the views (this is the only way I know how to do this due to the SwiftUI update). In view2, I need to pass information to view3 ( I would use a @Binding, however, since the view change in handled in View1, I cannot do this. Is there a better structure I can use?

Here is my code

enum Route {
    case view2
    case view3
}

struct View1: View {
    @State private var navigationPath: [Route] = []
    
    var body: some View {
        NavigationStack(path: $navigationPath) {
            Button("Go to view 2") {
                navigationPath.append(.view2)
            }
            .background(Color.red)
            .navigationDestination(for: Route.self) { route in
                switch route {
                case .view2:
                    View2(navigationPath: $navigationPath)
                case .view3:
                    View3(navigationPath: $navigationPath)
                }
            }
        }
    }
}

struct View2: View {
    @Binding var navigationPath: [Route]
    
    var body: some View {
        Button("Go to view 3") {
            navigationPath.append(.view3)
        }
        .background(Color.orange)
    }
}

struct View3: View {
    @Environment(\.dismiss) private var dismiss
    @Binding var navigationPath: [Route]
    
    var body: some View {
        Button("Pop view") {
            navigationPath.removeLast()
            
            // or - call `dismiss()`
            // dismiss()
        }
        .background(Color.green)
    }
}

I think this is the best struct to use Navigation and @Binding

import SwiftUI

struct View1: View {
    
    @State private var stackOverflow: String = "StackOverflow"

    //MARK: - Body
    var body: some View {
        NavigationStack {
            VStack {
                Text("Hello World!")
                
                NavigationLink(destination: {
                    View2(stackOverflow: $stackOverflow)
                }, label: {
                    Text(stackOverflow + "View 1")
                })
            }
        }
    }//END body
}//END struct

struct View2: View {
    
    @Binding var stackOverflow: String
    
    @State private var showNewView: Bool = false

    //MARK: - Body
    var body: some View {
        NavigationStack {
            VStack {
                Text("Hello World!")
                
                Button(action: {
                    showNewView.toggle()
                }, label: {
                    Text(stackOverflow + "View 2")
                })
            }
            .sheet(isPresented: $showNewView, content: {
                View3(stackOverflow: $stackOverflow)
            })
        }
    }//END body
}//END struct

struct View3: View {
    
    @Binding var stackOverflow: String

    //MARK: - Body
    var body: some View {
        NavigationStack {
            VStack {
                Text("Hello World!")
                
                Text(stackOverflow + "View 3")
            }
        }
    }//END body
}//END struct

For @Bindingyou can view more here

For NavigationLinkyou can view more here

Don't forget to validate my answer if it's right for you

I figured it out myself. I added a AccountChangeSelector class and a @ObservedObject var selection = AccountChangeSelector().

Here is the full code:

class AccountChangeSelector: ObservableObject {
    @Published var selection = ""
}

struct View1: View {
    @State private var path = NavigationPath()
    @ObservedObject var selection = AccountChangeSelector()

    var body: some View {
        NavigationStack(path: $path) {
            Button("Go to view 2") {
                path.append("View2")
            }
            .background(Color.red)
            .navigationDestination(for: String.self) { route in
                switch route {
                case "View2":
                    View2(path: $path)
                case "View3":
                    View3(path: $path, selection: $selection)
                }
            }
        }
    }
}

struct View2: View {
    @Binding var path: NavigationPath
    @ObservedObject var selection: AccountChangeSelector

    var body: some View {
        Button("Go to view 3") {
            selection.selection = "View3 selection"
            path.append("View3")
        }
        .background(Color.orange)
        //...
        //...
    }
}

struct View3: View {
    @Environment(\.dismiss) private var dismiss
    @Binding var path: NavigationPath
    var selection: String

    var body: some View {
        Button("Pop view") {
            navigationPath.removeLast()
            
            // or - call `dismiss()`
            // dismiss()
        }
        .background(Color.green)
    }
}

I hope this helps someone as I had a headache over this for days. As someone who always used NavigationView & NavigationLink, switching to this was supposed to be easy, but turned out to be a pain.

You can use a ViewModel solution or pass variable through the enums.

View Model Solution (A)

This will allow movement of the data back and forth, you can use the viewModel.someView as a State var

ViewModel

final class ViewModel: ObservableObject { 
   @Published var someVa: String = ""

   enum Route {
      case view2
      case view3
   }
}

View1

struct View1: View {
    @State private var navigationPath: [ViewModel.Route] = []
    @StateObject var viewModel = ViewModel()

    var body: some View {
        NavigationStack(path: $navigationPath) {
            Button("Go to view 2") {
                navigationPath.append(.view2)
            }
            .background(Color.red)
            Text(viewModel.someVar)
            .navigationDestination(for: ViewModel.Route.self) { route in
                switch route {
                case .view2:
                    View2(navigationPath: $navigationPath, viewModel: viewModel)
                case .view3:
                    View3(navigationPath: $navigationPath, viewModel: viewModel)
                }
            }
        }
    }
}

View2

struct View2: View {
    @Binding var navigationPath: [ViewModel.Route]
    @ObservedObject var viewModel: ViewModel

    var body: some View {
        VStack {
           Button("Go to view 3") {
              navigationPath.append(.view3)
           }
           .background(Color.orange)

           Text(viewModel.someVar)
        }
    }
}

View3

struct View3: View {
    @Environment(\.dismiss) private var dismiss
    @Binding var navigationPath: [ViewModel.Route]
    @ObservedObject var viewModel: ViewModel

    var body: some View {
        VStack {
           Button("Pop view") {
              navigationPath.removeLast()
            
               // or - call `dismiss()`
               // dismiss()
           }
           .background(Color.green)

           Text(viewModel.someVar)
        }
    }
}

Enum Solution (B)

This will only allow a forward move of data from the parent view

Enum

enum Route {
   case view2(someVar: String)
   case view3(someVar: String)
}