Alert dismiss action not received when using a button that sends another action.

[crayment]

I'm using the new navigation patterns for alerts and I'm seeing a behaviour that was a bit surprising and I want to verify if it is expected or not.

The .alert(.dismiss) action is only received when using an alert button that does not send any other action. Run below example in a preview (setup for Xcode 15) to see what I mean.

The example will either print .alert(.presented(.ok)): OR .alert(.dismiss) but never both. This makes the dismiss action less useful than I expected, and logic for when the alert is dismissed at all (like presenting a next alert in a queue) more painful.

import SwiftUI
import ComposableArchitecture

struct Feature: Reducer {
    struct State: Equatable {
        @PresentationState var alert: AlertState<AlertAction>?
    }
    
    enum Action: Equatable {
        case alertButtonTapped
        case alertWithActionButtonTapped
        case alert(PresentationAction<AlertAction>)
    }
    
    enum AlertAction: Equatable {
        case ok
    }
    
    var body: some Reducer<State, Action> {
        Reduce { state, action in
            switch action {
            case .alertButtonTapped:
                state.alert = .init(title: .init(verbatim: "Alert!"), buttons: [
                    .default(.init(verbatim: "OK"))
                ])
                return .none
                
            case .alertWithActionButtonTapped:
                state.alert = .init(title: .init(verbatim: "Alert!"), buttons: [
                    .default(.init(verbatim: ".send(.ok)"), action: .send(.ok))
                ])
                return .none
                
            case .alert(.presented(.ok)):
                print(".alert(.presented(.ok)): \(state.alert == nil)")
                return .none
                
            case .alert(.dismiss):
                print(".alert(.dismiss): \(state.alert == nil)")
                return .none
            }
        }
        .ifLet(\.$alert, action: /Action.alert)
    }
}
    

struct ContentView: View {
    let store: StoreOf<Feature> = Store(initialState: Feature.State(), reducer: { Feature() })
    var body: some View {
        WithViewStore(store, observe: { $0 }) { viewStore in
            VStack {
                Button(action: {
                    viewStore.send(.alertButtonTapped)
                }, label: {
                    Text("Alert with no action")
                })
                Button(action: {
                    viewStore.send(.alertWithActionButtonTapped)
                }, label: {
                    Text("Alert with action")
                })
            }
        }
        .alert(store: store.scope(state: \.$alert, action: { .alert($0) }))
    }
}

#Preview {
    ContentView()
}

[mbrandonw]

Hi @crayment, yeah this is the intended behavior. We could probably improve the docs here, but PresentationAction.dismiss (and also StackAction.popFrom, .push) are almost always only sent from the UI when the user does something. It is necessary because there are things the user can do that are out of our control, such as hitting ESC on a keyboard to dismiss an alert, or swipe from the edge of the screen to pop a screen of a stack. So these actions allow us to tap into those events without forcing you to model them explicitly in your domain.

But, dismiss is never sent in conjunction with one of your domain's features inside .presented. The .presented case is when the user does something that is under our control, such as tapping on a button in the alert or tapping on a NavigationLink(state:).

If you need to know when the alert is dismissed in all situations, you could try using the .onChange reducer operator to be notified when the state flips from nil to non-nil, or you can call out to a helper method in each of the .presented/.dismiss actions.

[crayment]

Got it 👍
Thank you so much for the quick and thorough reply! ❤️