isPresented is showing true for an embedded feature

[Narsail]

Description

I might be stumbled upon a bug with the isPresented utility but I'm unsure whether this actually might be the intended behaviour.

One of my features in my app can be used as a presented view (i.e. a sheet) as well as being embedded into a preexisting view.

I utilize dismiss in combination with 'isPresented' to dismiss this feature through a cancel button.

This view is used a tree navigation hierarchy and thus, even if embedded, can be part of a presented view marked with @Presents higher up in the view hierarchy.

For clarity sake, let's use the following naming and hierarchy:

RootFeature -> @presents FullScreenFeature (fullscreenmodal) -> EmbeddedFeature (as a conditional child view)

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.
• This issue hasn't been addressed in an existing GitHub issue or discussion.

Expected behavior

I expect the isPresented of the EmbeddedFeature to be true, if the feature is utilised behind a @Presents annotation, while it should be false without the annotation. This should also be the case if the FullScreenFeature, that embeds the EmbeddedFeature, is presented via @Presents by the RootFeature.

Actual behavior

Unfortunately, the isPresented within the EmbeddedFeature is true in the aforementioned scenario:

RootFeature -> @presents FullScreenFeature (fullscreenmodal) -> EmbeddedFeature (as a conditional child view)

leading to a dismissal of the Fullscreenfeature upon tapping the cancel button in the EmbeddedFeature.

Steps to reproduce

import SwiftUI
import ComposableArchitecture

@main
struct MyApp: App {
  
  let store = Store(initialState: RootFeature.State(), reducer: { RootFeature() })
  
    var body: some Scene {
        WindowGroup {
            RootView(store: store)
        }
    }
}

@Reducer
struct RootFeature {
  
  @ObservableState
  struct State {
    @Presents var destination: Destination.State?
  }
  
  @Reducer(state: .equatable)
  enum Destination {
    case fullscreen(FullScreenFeature)
  }
  
  enum Action {
    case fullScreenButtonTapped
    case destination(PresentationAction<Destination.Action>)
  }
  
  var body: some Reducer<State, Action> {
    Reduce { state, action in
      switch action {
      case .fullScreenButtonTapped:
        state.destination = .fullscreen(.init())
        return .none
      default: return .none
      }
    }
    .ifLet(\.$destination, action: \.destination)
  }
  
}

struct RootView: View {
  
  @Bindable var store: StoreOf<RootFeature>
  
  var body: some View {
    Button("Full Screen", action: { store.send(.fullScreenButtonTapped) })
    .fullScreenCover(
      item: $store.scope(state: \.destination?.fullscreen, action: \.destination.fullscreen),
      content: { FullScreenView(store: $0) }
    )
  }
}

@Reducer
struct FullScreenFeature {
  
  @ObservableState
  struct State: Equatable {
    var embeddedFeature: EmbeddedFeature.State? = nil
  }
  
  enum Action {
    case embeddedViewButtonTapped
    case embeddedFeature(EmbeddedFeature.Action)
  }
  
  var body: some Reducer<State, Action> {
    Reduce { state, action in
      switch action {
      case .embeddedViewButtonTapped:
        state.embeddedFeature = .init()
        return .none
      case .embeddedFeature(.hideButtonTapped):
        state.embeddedFeature = nil
        return .none
      }
    }
    .ifLet(\.embeddedFeature, action: \.embeddedFeature) { EmbeddedFeature() }
  }
}

struct FullScreenView: View {
  let store: StoreOf<FullScreenFeature>
  
  var body: some View {
    Button("Show Embedded View", action: { store.send(.embeddedViewButtonTapped) })
    
    if let embeddedFeatureStore = store.scope(state: \.embeddedFeature, action: \.embeddedFeature) {
      EmbeddedView(store: embeddedFeatureStore)
    }
  }
}


@Reducer 
struct EmbeddedFeature {
  
  @Dependency(\.dismiss)
  private var dismiss
  
  @Dependency(\.isPresented)
  private var isPresented
  
  @ObservableState
  struct State: Equatable {
  }
  
  enum Action {
    case hideButtonTapped
  }
  
  var body: some Reducer<State, Action> {
    Reduce { state, action in
      switch action {
      case .hideButtonTapped:
        if isPresented {
          return .run { _ in await dismiss() }
        }
        return .none
      }
    }
  }
  
}

struct EmbeddedView: View {
  let store: StoreOf<EmbeddedFeature>
  
  var body: some View {
    VStack(spacing: 10) {
      Text("Embedded View 🎉")
      Button("Hide Embedded View", action: { store.send(.hideButtonTapped) })
    }
    .padding()
    .background(.teal)
  }
}

The Composable Architecture version information

No response

Destination operating system

No response

Xcode version information

No response

Swift Compiler version information

No response

[mbrandonw]

Hi @Narsail, your FullScreenFeature reducer is not using the presentation tools of the library. It needs to use @Presents and PresentationAction in order for \.dismiss to work.

Since this isn't an issue with the library I am going to convert it to a discussion. Please feel free to ask any questions over there!

[Narsail]

I think we have a misunderstanding. I don't want to use @Presents in this particular case, as I'm embedding EmbeddedFeature and don't want to use any of SwiftUIs navigation tools here. So I expect isPresented to be false. But that isn't the case, it is still true and dismiss will dismiss the wrong view (the parent fullscreen modal).

[Narsail]

(The reason why I have isPresented and dismiss in the code is that I use EmbeddedFeature in another part of my codebase with @Presents).

[mbrandonw]

Hi @Narsail, unfortunately this is not how this tool works. It's also not how it works in vanilla SwiftUI with @Environment:

struct RootView_: View {
  @State var isPresented = false
  var body: some View {
    Button("Present") {
      isPresented = true
    }
    .sheet(isPresented: $isPresented) {
      ChildView()
    }
  }
}

struct ChildView: View {
  @State var isPresenting = false
  var body: some View {
    Form {
      Button("Present") {
        isPresenting = true
      }
      if isPresenting {
        GrandchildView()
      }
    }
  }
}

struct GrandchildView: View {
  @Environment(\.dismiss) var dismiss
  @Environment(\.isPresented) var isPresented
  var body: some View {
    VStack {
      Text("Grandchild View")
        .font(.largeTitle)
      Text("Is presented: \(isPresented.description)")
      Button("Dismiss") {
        dismiss()
      }
    }
    .padding(100)
    .background(Color.gray)
  }
}

#Preview {
  RootView_()
}

\.dismiss always looks up the parent feature hierarchy to find a feature presenting and then dismisses it.

If you want to customize EmbeddedFeature to not execute \.dismiss sometimes then you can always customize it by holding onto some isPresented state that is passed from the parent feature.

[Narsail]

Got it. I assumed that but now I have clarity. I do have a workaround so it isn't a big deal. Thanks for the clarification 🙏