Deep-linking issues with the pre-release 1.0 branch and the new navigation tools

[ghost]

Hello :)

I've been giving the pre-release 1.0 branch and the new navigation tools a spin and I found a few problems relating to deep-linking:

• deep-linking from the start appears to work only up to at most 3 levels deep (AppFeature -> SceneA -> SceneB -> SceneC)
• programmatically attempting to deep-link causes the runtime warning "A "ifLet" at ... received a presentation action when destination state was absent."

Interestingly, tests pass for both scenarios.

I'm attaching to this post a very simple toy project that you can use to verify those issues. Before I describe the two problems in more detail, here's a brief walk-through of the toy app's code. The app has an AppFeature module and the AppFeature scene can present SceneA:

public struct AppFeature: Reducer {

    public struct State: Equatable {

        @PresentationState var destination: Destination.State?

        public init(destination: Destination.State? = nil) {
            self.destination = destination
        }

        var title: String {
            "AppFeature"
        }

    }

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

    public init() {}

    public var body: some ReducerOf<Self> {

        Reduce { state, action in
            switch action {

                case .presentSceneA:
                    state.destination = .sceneA(.init())
                    return .none

                // We're deep-linked into F (AppFeature -> A -> B -> C -> D -> E -> F) and we want to
                // simulate getting an action to deep link elsewhere (say, AppFeature -> A -> B -> C -> D)
                case .destination(.presented(.sceneA(
                    .destination(.presented(.sceneB(
                        .destination(.presented(.sceneC(
                            .destination(.presented(.sceneD(
                                .destination(.presented(.sceneE(
                                    .destination(.presented(.sceneF(.simulateDeepLink)))
                                ))))))))))))))):
                    state.destination = .sceneA(.init(
                        destination: .sceneB(.init(
                            destination: .sceneC(.init(
                                destination: .sceneD(.init())
                            ))))))
                    return .none

                case let .destination(action):
                    return .none

            }
        }
        .ifLet(\.$destination, action: /Action.destination) {
            Destination()
        }

    }

    public struct Destination: Reducer {

        public enum State: Equatable, Identifiable {

            case sceneA(SceneA.State)

            public var id: AnyHashable {
                switch self {
                    case let .sceneA(state):
                        return state.id
                }
            }

        }

        public enum Action: Equatable {
            case sceneA(SceneA.Action)
        }

        public init() {}

        public var body: some ReducerOf<Self> {
            Scope(state: /State.sceneA, action: /Action.sceneA) {
                SceneA()
            }
        }

    }

}

Then there are modules for various scenes, A through F, with each scene able to present the next, except for SceneF, which is a leaf scene. So, all scenes A through E look identical in structure:

public struct SceneA: Reducer {

    public struct State: Equatable, Identifiable {

        public typealias Id = String
        public internal(set) var id: Id

        @PresentationState var destination: Destination.State?

        public init(
            id: Id = "SceneA",
            destination: Destination.State? = nil
        ) {
            self.id = id
            self.destination = destination
        }

        var title: String {
            "SceneA"
        }

    }

    public enum Action: Equatable {

        case presentSceneB
        case destination(PresentationAction<Destination.Action>)

    }

    public init() {}

    public var body: some ReducerOf<Self> {

        Reduce { state, action in
            switch action {

                case .presentSceneB:
                    state.destination = .sceneB(.init())
                    return .none
                    
                case let .destination(action):
                    return .none

            }
        }
        .ifLet(\.$destination, action: /Action.destination) {
            Destination()
        }

    }

    public struct Destination: Reducer {

        public enum State: Equatable, Identifiable {

            case sceneB(SceneB.State)

            public var id: AnyHashable {
                switch self {
                    case let .sceneB(state):
                        return state.id
                }
            }

        }

        public enum Action: Equatable {
            case sceneB(SceneB.Action)
        }

        public init() {}

        public var body: some ReducerOf<Self> {
            Scope(state: /State.sceneB, action: /Action.sceneB) {
                SceneB()
            }
        }

    }

}

Finally, there's the leaf scene, SceneF:

public struct SceneF: Reducer {

    public struct State: Equatable, Identifiable {

        public typealias Id = String
        public internal(set) var id: Id

        public init(id: Id = "SceneF") {
            self.id = id
        }

        var title: String {
            "SceneF"
        }

    }

    public enum Action: Equatable {

        // Simulate an ancestor scene dismissing the current deep link then deep-linking elsewhere.
        // Is it sufficient just to dismiss the root scene of the current deep link (and then
        // present the new one) or do we need to traverse the collection of presented scenes and
        // explicitly dismiss them (in their reverse order) before establishing the new deep link?
        case simulateDeepLink

    }

    public init() {}

    public var body: some ReducerOf<Self> {

        Reduce { state, action in
            switch action {
                case .simulateDeepLink:
                    // let the root ancestor handle it
                    return .none
            }
        }

    }

}

As for the views, they just show buttons to present the next scene and to dismiss the current scene:

Now, for the two issues.

• deep-linking from the start appears to work only up to at most 3 levels deep (AppFeature -> SceneA -> SceneB -> SceneC)

  If you start the app with the deep-linked state (AppFeature -> SceneA -> SceneB -> SceneC -> SceneD -> SceneE -> SceneF)

  var appState = AppFeature.State(
      destination: .sceneA(.init(
          destination: .sceneB(.init(
              destination: .sceneC(.init(
                  destination: .sceneD(.init(
                      destination: .sceneE(.init(
                          destination: .sceneF(.init())
                      ))
                  ))
              ))
          ))
      ))
  )

  you'll see that it shows SceneC, not SceneF:

  

  The same is true if you deep link into any scene beyond SceneC. Yet, no errors or runtime warnings happen. Moreover, if you attempt to present SceneD from this point, it does not work (no scene transition happens) and you do get a runtime warning

  A "ifLet" at "SceneB/SceneB.swift:64" received a presentation action when destination state was absent. …
  Action:
  SceneB.Action.destination(.presented(.sceneC(.presentSceneD)))

• programmatically attempting to deep-link causes the runtime warning "A "ifLet" at ... received a presentation action when destination state was absent."

  If you start the app with no deep links,

  var appState = AppFeature.State()

  then navigate to SceneF,

  

  and from there try to simulate the app receiving a deep-link to another scene, it does appear to work (the scenes transition correctly) but you also get a runtime warning

  A "ifLet" at "SceneD/SceneA.swift:64" received a presentation action when destination state was absent. …
  Action:
  SceneD.Action.destination(.presented(.sceneE(.destination(.dismiss))))

Can anyone please shed some light on what may be happening?

Many thanks in advance.

NewTCANav-forum.zip

[mbrandonw]

Hi @wtruppel, this is unfortunately just yet another a SwiftUI navigation bug. TCA's navigation tools are just a light layer on top of SwiftUI's native tools and do not try to fix any of their bugs, so you still have to be mindful of their limitations.

Here is a vanilla SwiftUI application that reproduces the same problem:

class Model: ObservableObject, Identifiable {
  @Published var child: Model?
  init(child: Model? = nil) { self.child = child }
  var id: ObjectIdentifier { ObjectIdentifier(self) }
}
struct ModelView: View {
  @ObservedObject var model: Model
  var body: some View {
    Button("Tap") {
      self.model.child = Model()
    }
    .navigationDestination(
      isPresented: Binding(
        get: { self.model.child != nil },
        set: {
          if !$0 { self.model.child = nil }
        }
      )
    ) {
      if let child = self.model.child {
        ModelView(model: child)
      }
    }
  }
}
struct ContentView: View {
  @ObservedObject var model: Model
  var body: some View {
    NavigationStack {
      ModelView(model: self.model)
    }
  }
}

[mbrandonw]

Huh, when I run my demo with many child models populated it does not deep link more than 3 levels:

You are seeing different behavior?

[ghost]

@mbrandonw

I wonder if there's a workaround whereby a nested state is "unrolled" behind the curtains and scenes are then navigated into one at a time, rather than "all at once".

To elaborate a little. I suppose TCA could take a nested navigation state, un-nest it, then navigate to each state in succession, all transparently behind the curtains, ie, as far as we TCA users are concerned, it's business as usual: we set a nested navigation state and don't think twice about it.

Or maybe the solution lies in the other navigation API that Apple introduced in iOS 16, the one with the binding to an array of states. Maybe it's possible to transparently un-nest the nested navigation states into a plain array of navigation states and use that API instead.

Unfortunately, I don't think I understand the internals of TCA well enough to implement either of these ideas myself and open a PR for them. Perhaps someone else (or you or Stephen) might give it a go. If that's possible, I think it would solve a major outstanding problem with navigation.

[ghost]

@mbrandonw

You are seeing different behavior?

I am indeed. Xcode version 14.3 (14E222b).

[ghost]

Oh, wait... I see what you mean. Deep-linking from the start. Let me give that a go.

[ghost]

Ah, yes, I get the same (incorrect) behavior when deep-linking.