Change destination while child's child is presented #2775

shoplab7 · 2024-02-06T14:42:03Z

shoplab7
Feb 6, 2024

Hi,
I'm trying to change destination of a feature while child's child is presented and get a warning. What is the correct way to do it?

import ComposableArchitecture
import Foundation
import SwiftUI

// MARK: - First Level

@Reducer
struct FirstLevelFeature {
   @ObservableState
   struct State: Equatable {
       @Presents var destination: Destination.State?
   }

   enum Action: Equatable {
       case destination(PresentationAction<Destination.Action>)
       case buttonTapped
       case task
       case updateDestination
   }

   var body: some ReducerOf<Self> {
       Reduce<State, Action> { state, action in
           switch action {
           case .task:
               return .run { send in
                   try? await Task.sleep(for: .seconds(10))
                   await send(.updateDestination)
               }
           case .updateDestination:
               state.destination = .secondLevelB(.init())
               return .none
           case .buttonTapped:
               state.destination = .secondLevelA(.init())
               return .none
           case .destination:
               return .none
           }
       }
       .ifLet(\.$destination, action: \.destination) {
           Destination()
       }
   }
}

extension FirstLevelFeature {
   @Reducer
   struct Destination {
       enum State: Equatable {
           case secondLevelA(SecondLevelFeature.State)
           case secondLevelB(SecondLevelFeature.State)
       }

       enum Action: Equatable {
           case secondLevelA(SecondLevelFeature.Action)
           case secondLevelB(SecondLevelFeature.Action)
       }

       var body: some ReducerOf<Self> {
           Scope(state: \.secondLevelA, action: \.secondLevelA) {
               SecondLevelFeature()
           }
           Scope(state: \.secondLevelB, action: \.secondLevelB) {
               SecondLevelFeature()
           }
       }
   }
}

struct ContentView: View {
   @Bindable var store: StoreOf<FirstLevelFeature>
   var body: some View {
       NavigationStack {
           VStack {
               Button("Open") {
                   store.send(.buttonTapped)
               }
           }
           .padding()
           .task {
               store.send(.task)
           }
           .navigationDestination(
               item: $store.scope(
                   state: \.destination?.secondLevelA,
                   action: \.destination.secondLevelA)
           ) { store in
               SecondLevelView(store: store)
           }
           .navigationDestination(
               item: $store.scope(
                   state: \.destination?.secondLevelB,
                   action: \.destination.secondLevelB)
           ) { store in
               SecondLevelView(store: store)
           }
       }
   }
}

// MARK: - Second Level

@Reducer
struct SecondLevelFeature {
   @ObservableState
   struct State: Equatable {
       @Presents var destination: Destination.State?
   }

   enum Action: Equatable {
       case destination(PresentationAction<Destination.Action>)
       case buttonTapped
   }

   var body: some ReducerOf<Self> {
       Reduce<State, Action> { state, action in
           switch action {
           case .buttonTapped:
               state.destination = .thirdLevel(.init())
               return .none
           case .destination:
               return .none
           }
       }
       .ifLet(\.$destination, action: \.destination) {
           Destination()
       }
   }
}

extension SecondLevelFeature {
   @Reducer
   struct Destination {
       enum State: Equatable {
           case thirdLevel(ThirdLevelFeature.State)
       }

       enum Action: Equatable {
           case thirdLevel(ThirdLevelFeature.Action)
       }

       var body: some ReducerOf<Self> {
           Scope(state: \.thirdLevel, action: \.thirdLevel) {
               ThirdLevelFeature()
           }
       }
   }
}

struct SecondLevelView: View {
   @Bindable var store: StoreOf<SecondLevelFeature>
   var body: some View {
       VStack {
           Text("Second levle")
           Button("Open") {
               store.send(.buttonTapped)
           }
       }
       .padding()
       .navigationDestination(
           item: $store.scope(
               state: \.destination?.thirdLevel,
               action: \.destination.thirdLevel)
       ) { store in
           ThirdLevelView(store: store)
       }
   }
}

// MARK: - Third Level

@Reducer
struct ThirdLevelFeature {
   @ObservableState
   struct State: Equatable {
   }

   enum Action: Equatable {
   }

   var body: some ReducerOf<Self> {
       Reduce<State, Action> { state, action in
           return .none
       }
   }
}

struct ThirdLevelView: View {
   @Bindable var store: StoreOf<ThirdLevelFeature>
   var body: some View {
       VStack {
           Text("Third level")
       }
       .padding()
   }
}

#Preview {
   ContentView(
       store: Store(initialState: FirstLevelFeature.State()) {
           FirstLevelFeature()
       })
}

Warning:

A "Scope" at "TCANavigationTestProj/ContentView.swift:68" received a child action when child state was set to a different case. …

 Action:
  FirstLevelFeature.Destination.Action.secondLevelA(.destination(.dismiss))
 State:
  FirstLevelFeature.Destination.State.secondLevelB

This is generally considered an application logic error, and can happen for a few reasons:

• A parent reducer set "FirstLevelFeature.Destination.State" to a different case before the scoped reducer ran. Child reducers must run before any parent reducer sets child state to a different case. This ensures that child reducers can handle their actions while their state is still available. Consider using "Reducer.ifCaseLet" to embed this child reducer in the parent reducer that change its state to ensure the child reducer runs first.

• An in-flight effect emitted this action when child state was unavailable. While it may be perfectly reasonable to ignore this action, consider canceling the associated effect before child state changes to another case, especially if it is a long-living effect.

• This action was sent to the store while state was another case. Make sure that actions for this reducer can only be sent from a view store when state is set to the appropriate case. In SwiftUI applications, use "SwitchStore".