Unexpected dismissal when transitioning between destinations (prerelease/1.0)

[junebash]

Description

When a screen is presented with multiple possible destinations, the view unexpectedly dismisses when transitioning between these views.

Checklist

• I have determined whether this bug is also reproducible in a vanilla SwiftUI project.
• If possible, I've reproduced the issue using the main branch of this package.
  • (n/a)
• This issue hasn't been addressed in an existing GitHub issue or discussion.

Expected behavior

The view will smoothly transition between destinations without dismissing when a single ifLet reducer/fullScreenCover modifier is used.

Actual behavior

The destination view dismisses before transitioning to the new destination.

Steps to reproduce

1. Start a fresh SwiftUI iOS project.
2. Add TCA/prerelease/1.0 to the project dependencies
3. Copy and paste the following code into the ContentView.swift file
4. Run the app and note the dismissal between the first and second presented screens.
5. Change the App file's content view to VanillaContentView to see the expected behavior.

import ComposableArchitecture
import SwiftUI

public struct AppFeature: Reducer {
    public struct Destination: Reducer {
        public enum State: Equatable {
            case first(FirstDestination.State)
            case second(SecondDestination.State)
        }

        public enum Action: Equatable {
            case first(FirstDestination.Action)
            case second(SecondDestination.Action)
        }

        public var body: some ReducerOf<Self> {
            Scope(state: /Destination.State.first, action: /Destination.Action.first) {
                FirstDestination()
            }
            Scope(state: /Destination.State.second, action: /Destination.Action.second) {
                SecondDestination()
            }
        }
    }

    public struct State: Equatable {
        public var text: String = "Press Me"
        @PresentationState public var destination: Destination.State?
    }

    public enum Action {
        case presentButtonTapped
        case destination(PresentationAction<Destination.Action>)
    }

    struct Core: Reducer {
        func reduce(into state: inout State, action: Action) -> Effect<Action> {
            switch action {
            case .presentButtonTapped:
                state.destination = .first(.init())
                return .none

            case .destination(.presented(let destinationAction)):
                switch destinationAction {
                case .first(.nextTapped):
                    state.destination = .second(.init())
                    return .none

                case .second(.dismissTapped):
                    state.destination = nil
                    return .none
                }

            case .destination(.dismiss):
                return .none
            }
        }
    }

    public var body: some ReducerOf<Self> {
        Core()
            .ifLet(\.$destination, action: /Action.destination) {
                Destination()
            }
    }
}

public struct FirstDestination: Reducer {
    public struct State: Equatable {}

    public enum Action: Equatable {
        case nextTapped
    }

    public var body: some ReducerOf<Self> {
        EmptyReducer()
    }
}

public struct SecondDestination: Reducer {
    public struct State: Equatable {}

    public enum Action: Equatable {
        case dismissTapped
    }

    public var body: some ReducerOf<Self> {
        EmptyReducer()
    }
}

public struct ContentView: View {
    let store: StoreOf<AppFeature> = .init(initialState: .init(), reducer: AppFeature())

    public var body: some View {
        WithViewStore(store, observe: \.text) { textViewStore in
            Button(textViewStore.state) {
                textViewStore.send(.presentButtonTapped)
            }
        }
        .fullScreenCover(
            store: store.scope(
                state: \.$destination,
                action: AppFeature.Action.destination
            )
        ) { destinationStore in
            SwitchStore(destinationStore) {
                CaseLet(
                    state: /AppFeature.Destination.State.first,
                    action: AppFeature.Destination.Action.first
                ) { firstStore in
                    WithViewStore(firstStore, observe: { $0 }) { viewStore in
                        Button("Next View") {
                            viewStore.send(.nextTapped)
                        }
                        .tint(.cyan)
                    }
                }

                CaseLet(
                    state: /AppFeature.Destination.State.second,
                    action: AppFeature.Destination.Action.second
                ) { secondStore in
                    WithViewStore(secondStore, observe: { $0 }) { viewStore in
                        Button("Dismiss") {
                            viewStore.send(.dismissTapped)
                        }
                        .tint(.red)
                    }
                }
            }
        }
    }
}

public struct VanillaContentView: View {
    @State var state: AppFeature.State = .init()

    public var body: some View {
        Button("Press Me") {
            state.destination = .first(.init())
        }
        .fullScreenCover(unwrapping: $state.destination, onDismiss: { state.destination = nil }) { $destination in
            if let _ = Binding(unwrapping: $destination, case: /AppFeature.Destination.State.first) {
                Button("Next View") {
                    state.destination = .second(.init())
                }
                .tint(.cyan)
            }
            if let _ = Binding(unwrapping: $destination, case: /AppFeature.Destination.State.second) {
                Button("Dismiss") {
                    state.destination = nil
                }
                .tint(.red)
            }
        }
    }
}

The Composable Architecture version information

prerelease/1.0

Destination operating system

iOS 16.4

Xcode version information

Xcode 14.3

Swift Compiler version information

No response

[tgrapperon]

Hey @junebash! I'm afraid this is the expected behavior in vanilla, where the change of ID triggers a re-presentation. I have a pending PR in swift-navigation that replicates this behaviors for .fullscreenCover(unwrapping:…), but it wasn't reviewed yet. The same idea was directly baked-in TCA.
This is a behavior I personally find counter-intuitive, and I would expect the same as you are, but if we follow vanilla steps, I'm afraid we'll have to replicate it.

[junebash]

So in that case, is there any way using TCA to get the desired behavior of not dismissing and re-presenting when the destination changes?

[mbrandonw]

Hi @junebash, have you seen this version of fullscreenCover(store:state:action:)? It allows you to first specify a store focused on the destination domain, and then further state and action transformations that single out a case in the destination enum.

If you use that version instead of manually doing a SwitchStore inside fullscreenCover you will get the behavior you expect:

.fullScreenCover(
  store: store.scope(
    state: \.$destination,
    action: AppFeature.Action.destination
  ),
  state: /AppFeature.Destination.State.first,
  action: AppFeature.Destination.Action.first
) { firstStore in
  WithViewStore(firstStore, observe: { $0 }) { viewStore in
    Button("Next View") {
      viewStore.send(.nextTapped)
    }
    .tint(.cyan)
  }
}
.fullScreenCover(
  store: store.scope(
    state: \.$destination,
    action: AppFeature.Action.destination
  ),
  state: /AppFeature.Destination.State.second,
  action: AppFeature.Destination.Action.second
) { secondStore in
  WithViewStore(secondStore, observe: { $0 }) { viewStore in
    Button("Dismiss") {
      viewStore.send(.dismissTapped)
    }
    .tint(.red)
  }
}

[junebash]

Interesting! Looking at the APIs, I find that behavior surprising; I would expect two different fullScreenCover modifiers to produce two separate presentations, and one fullScreenCover to produce only one presentation, but it seems that it's the opposite. Is that how vanilla SwiftUI is as well? (I realize now my "vanilla" example really isn't quite "vanilla".)

In any case, even though it feels counterintuitive to me, that does indeed give me a solution. Thanks!

[mbrandonw]

We too were a little surprised by it and we want to look into it more. I'm going to convert this to a discussion, and we this documented in our notes to look at before final release. Also please let us know if you uncover anything else.

[tgrapperon]

This is rather odd, because on both cases, I'm getting a re-presentation in Vanilla when the case changes:

enum Destination: String, Equatable, Identifiable {
  case a
  case b

  var id: String {
    rawValue
  }
}

struct ContentView: View {
  @State var state: Destination?
  var body: some View {
    Button {
      self.state = .a
    } label: {
      Text("Present")
    }

    // Re-presentation on change
    .sheet(item: $state) { state in
      Button {
        self.state = state == .a ? .b : .a
      } label: {
        Text(String(describing: state))
      }
    }

    //      // Re-presentation on change
    //      .sheet(item: Binding(
    //        get: { self.state == .a ? Destination.a : nil },
    //        set: { self.state = $0 })
    //      ) { state in
    //        Button {
    //          self.state = .b
    //        } label: {
    //          Text(String(describing: state))
    //        }
    //      }
    //      .sheet(item: Binding(
    //        get: { self.state == .b ? Destination.b : nil },
    //        set: { self.state = $0 })
    //      ) { state in
    //        Button {
    //          self.state = .a
    //        } label: {
    //          Text(String(describing: state))
    //        }
    //      }
  }
}

[junebash]

For what it's worth, this version seems to work well for me so far, although I haven't tested extensively.

extension View {
  public func persistentFullScreenCover<PresentedState, PresentedAction>(
    store: Store<PresentationState<PresentedState>, PresentationAction<PresentedAction>>,
    content: @escaping (Store<PresentedState, PresentedAction>) -> some View
  ) -> some View {
    WithViewStore(store, observe: { $0.wrappedValue != nil }) { viewStore in
      self.fullScreenCover(isPresented: .constant(viewStore.state)) {
        IfLetStore(
          store.scope(state: \.wrappedValue, action: { .presented($0) })
        ) { presentedStore in
          content(presentedStore)
        }
      }
    }
  }
}

[stephencelis]

@junebash I took a look into this today and the main issue is that presentation was driven by the item's ID, which we derive dynamically under the hood from the value's enum case and any other identifiable identity. The non-state:action: initializer of fullScreenCover was still identifying based on these traits, so they would re-present when they probably shouldn't.

I've relaxed this on navigation-beta and prerelease/1.0, so it should work as expected now, though I think there's still more nuance and cleanup work to do. Thanks again for reporting the behavior!