Action Triggered on Wrong View

[BakrMohamedRBM]

Hello TCA Team
i made a sample project with

App Master View that responsible to show Splash view
and splash view that have multiple destination ( language and home)

but i have an issue when i setup language view to navigated inside splash the action runs on App master view and ignored in splash

here the implmentation

App Master View

// MARK: - Feature
@Reducer
struct AppMasterFeature {
    @ObservableState
    struct State {
        var splashState: SplashFeature.State?
    }
    
    enum Action: BindableAction, Sendable {
        case binding(BindingAction<State>)
        case onAppear
        case splashAction(SplashFeature.Action)
    }
    
    var body: some Reducer<State, Action> {
        BindingReducer()
        Reduce { state, action in
            switch action {
                case .onAppear:
                    state.splashState = .init()
                    return .none
                case .splashAction:
                    return .none
                case .binding:
                    return .none
            }
        }
    }
}

// MARK: - View
struct AppMasterView: View {
    @State var store: StoreOf<AppMasterFeature>
    
    init() {
        self.store = .init(
            initialState: AppMasterFeature.State()
        ) {
            AppMasterFeature()
                ._printChanges()
        }
    }
    
    var body: some View {
        NavigationStack {
            ZStack {
                Unwrap(
                    store.scope(
                        state: \.splashState,
                        action: \.splashAction
                    )
                ) {
                    SplashView(store: $0)
                }
            }
            .onAppear {
                store.send(.onAppear)
            }
        }
        .toolbar(.hidden, for: .navigationBar)
    }
}

Splash View

@Reducer
struct SplashFeature: Sendable {
//    @AppStorage(StorageKeys.kAppRoot)
//    var appRoot: AppRoot = .language
    
    @Reducer(state: .equatable)
    enum Destination {
        case language(LanguageFeature)
    }
    
    @ObservableState
    struct State {
        
        // Stores
        @Presents var destination: Destination.State?
    }
    
    enum Action: BindableAction, Sendable {
        case binding(BindingAction<State>)
        case destination(PresentationAction<Destination.Action>)
        case showLanguage
    }
    
    var body: some Reducer<State, Action> {
        BindingReducer()
        Reduce { state, action in
            switch action {
                case .showLanguage:
                    switch state.destination {
                        case .language:
                            state.destination = .language(LanguageFeature.State())
                        case .none:
                            state.destination = nil
                    }
                    return .none
                case .binding, .destination:
                    return .none
            }
        }
        .ifLet(\.$destination, action: \.destination)
    }
}

struct SplashView: View {
    @Bindable var store: StoreOf<SplashFeature>
    
    var body: some View {
        ZStack {
            Image(.splash)
                .resizable()
                .frame(width: 300, height: 150)
            
            VStack {
                Spacer()
                
                ProgressView()
                    .progressViewStyle(.circular)
                
                Button("show Language") {
                    store.send(.showLanguage)
                }
            }
        }
        .navigationDestination(
            item: $store.scope(
                state: \.destination?.language,
                action: \.destination.language
            )
        ) {
            LanguageView(store: $0)
        }
    }
}

Language View

@Reducer
struct LanguageFeature {
    
    @ObservableState
    struct State: Equatable {
        
    }
    
    enum Action: BindableAction, Sendable {
        case binding(BindingAction<State>)
    }
    
    var body: some Reducer<State, Action> {
        BindingReducer()
    }
}

struct LanguageView: View {
    @Bindable var store: StoreOf<LanguageFeature>
    
    var body: some View {
        ZStack {
           Text("Language Screen")
        }
    }
}

When Splash View initialized

received action:
  AppMasterFeature.Action.onAppear
  AppMasterFeature.State(
-   _splashState: nil
+   _splashState: SplashFeature.State(
+     _destination: nil
+   )
  )

When press show language button on splash view

received action:
  AppMasterFeature.Action.splashAction(.showLanguage)
  (No state changes)
  

I don't understand really why this is happening also I tried without an enum destination and same behavior

[dusiema]

I haven't recreated your example - so I might be wrong.
But just by looking at your code: I think you never really set the destination state. In you .showLanguage action you switch over destination. Shouldn't you instead just set the destination to state.destination = .language(LanguageFeature.State()) ?

So instead of

case .showLanguage:
    switch state.destination {
    case .language:
        state.destination = .language(LanguageFeature.State())
    case .none:
        state.destination = nil
}
return .none

just do:

case .showLanguage:
    state.destination = .language(LanguageFeature.State())
}
return .none

[BakrMohamedRBM]

actually i was experimental also the logic will not navigated with the button later should check what stage language selection or login or home so later will be runs on on appear to check what stage and go so destination with switch case is the right one but while tracking why the action not triggered inside splash i move it to button