Possible regression in .navigationDestination(isPresented:) in iOS 17

[tadelv]

deep linking with .navigationDestination(isPresented:) was fixed in iOS 16.4, according to this snippet.

But on iOS 17, it seems the issue has returned (Using Xcode 15 beta8).

I have a demo repo, that demonstrates this issue using both vanilla SwiftUI and swiftui-navigation. If you run it on an iOS 17 device (or simulator), it will present a blank screen even though it should be drilled down 2 levels. And if you run the demo on an iOS 16 device, it deep links as expected.

This issue is handled with the BindWorkaround NavigationDestination for iOS < 16.4 and can be mitigated by using the same workaround in iOS 17, by changing the logic here, to return true for iOS 17 as well.

I also filed a radar: FB13126471

[mbrandonw]

Hi @tadelv, thanks for the repro and investigating this! Were you able to confirm that if we bring back the workaround logic for iOS 17+ that it fixes the issue?

[stephencelis]

@jafienberg We've unfortunately come to the conclusion that we shouldn't be baking workarounds for Apple bugs in our libraries. They make our libraries more complex and prone to failure over time, more difficult to test given (a huge array of platforms and OSes should be tested for regressions, requiring flakey UI tests), and while we thought working around the bugs would reduce the number of folks thinking a bug they experienced was in our library and not Apple's underlying APIs, we haven't seen this to be the case 😉

We'll maintain the workaround in SwiftUI Navigation for now, as folks most likely depend on it, but we'll keep TCA's interactions with SwiftUI rather vanilla by simply invoking the underlying APIs directly. We try to provide tools (View.presentation(store:)) that make it easy to cook around local workarounds in your own projects, though!

[jafienberg]

@stephencelis I totally respect that decision. I just wanted to alert you that the workaround was not comprehensive. Thanks for your response. Based on that I don’t think we need to pursue my issue any further @tadelv. Thanks for your efforts.

[tadelv]

@stephencelis thanks for the info. Are there any more sources about how to use View.presentation(store:), that showcase implementing this kind of a workaround?
We’re going to use TCA in one of our app modules and will be needing this type of functionality.

[stephencelis]

@tadelv You can see how it's used here:

https://github.com/pointfreeco/swift-composable-architecture/blob/main/Sources/ComposableArchitecture/SwiftUI/NavigationDestination.swift#L58-L67

You can @_spi(Presentation) import ComposableArchitecture to get access to the API.

[tadelv]

thanks @stephencelis!

[jafienberg]

@tadelv Here is a workaround for the regression in ComposableArchitecture. Do with it as you please!

`
#if swift(>=5.7)
@_spi(Reflection) import CasePaths
@_spi(Presentation) import ComposableArchitecture
import SwiftUI

extension View {
  /// Associates a destination view with a store that can be used to push the view onto a
  /// `NavigationStack`.
  ///
  /// > This is a Composable Architecture-friendly version of SwiftUI's
  /// > `navigationDestination(isPresented:)` view modifier.
  ///
  /// - Parameters:
  ///   - store: A store that is focused on ``PresentationState`` and ``PresentationAction`` for
  ///     a screen. When `store`'s state is non-`nil`, the system passes a store of unwrapped
  ///     `State` and `Action` to the modifier's closure. You use this store to power the content
  ///     in a view that the system pushes onto the navigation stack. If `store`'s state is
  ///     `nil`-ed out, the system pops the view from the stack.
  ///   - destination: A closure returning the content of the destination view.
  @available(iOS 16, macOS 13, tvOS 16, watchOS 9, *)
  public func _navigationDestination<State, Action, Destination: View>(
    store: Store<PresentationState<State>, PresentationAction<Action>>,
    @ViewBuilder destination: @escaping (_ store: Store<State, Action>) -> Destination
  ) -> some View {
    self._navigationDestination(
      store: store,
      state: { $0 },
      action: { $0 },
      destination: destination
    )
  }
  
  /// Associates a destination view with a store that can be used to push the view onto a
  /// `NavigationStack`.
  ///
  /// > This is a Composable Architecture-friendly version of SwiftUI's
  /// > `navigationDestination(isPresented:)` view modifier.
  ///
  /// - Parameters:
  ///   - store: A store that is focused on ``PresentationState`` and ``PresentationAction`` for
  ///     a screen. When `store`'s state is non-`nil`, the system passes a store of unwrapped
  ///     `State` and `Action` to the modifier's closure. You use this store to power the content
  ///     in a view that the system pushes onto the navigation stack. If `store`'s state is
  ///     `nil`-ed out, the system pops the view from the stack.
  ///   - toDestinationState: A transformation to extract screen state from the presentation
  ///     state.
  ///   - fromDestinationAction: A transformation to embed screen actions into the presentation
  ///     action.
  ///   - destination: A closure returning the content of the destination view.
  @available(iOS 16, macOS 13, tvOS 16, watchOS 9, *)
  public func _navigationDestination<
    State, Action, DestinationState, DestinationAction, Destination: View
  >(
    store: Store<PresentationState<State>, PresentationAction<Action>>,
    state toDestinationState: @escaping (_ state: State) -> DestinationState?,
    action fromDestinationAction: @escaping (_ destinationAction: DestinationAction) -> Action,
    @ViewBuilder destination: @escaping (_ store: Store<DestinationState, DestinationAction>) ->
      Destination
  ) -> some View {
    self.presentation(
      store: store,
      state: toDestinationState,
      id: { $0.wrappedValue.map(NavigationDestinationID.init) },
      action: fromDestinationAction
    ) { `self`, $item, destinationContent in
      if requiresBindWorkaround {
        self.modifier(
          _NavigationDestinationBindWorkaround(
            isPresented: $item.isPresent(),
            destination: destinationContent(destination)
          )
        )
      } else {
        self.navigationDestination(isPresented: $item.isPresent()) {
          destinationContent(destination)
        }
      }
    }
  }
}

private struct NavigationDestinationID: Hashable {
  let objectIdentifier: ObjectIdentifier
  let enumTag: UInt32?

  init<Value>(_ value: Value) {
    self.objectIdentifier = ObjectIdentifier(Value.self)
    self.enumTag = EnumMetadata(Value.self)?.tag(of: value)
  }
}

// NB: This view modifier works around a bug in SwiftUI's built-in modifier:
// https://gist.github.com/mbrandonw/f8b94957031160336cac6898a919cbb7#file-fb11056434-md
@available(iOS 16, macOS 13, tvOS 16, watchOS 9, *)
private struct _NavigationDestinationBindWorkaround<Destination: View>: ViewModifier {
  @Binding var isPresented: Bool
  let destination: Destination

  @State private var isPresentedState = false

  public func body(content: Content) -> some View {
    content
      .navigationDestination(isPresented: self.$isPresentedState) { self.destination }
      .bind(self.$isPresented, to: self.$isPresentedState)
  }
}

private let requiresBindWorkaround = {
  if #available(iOS 17, macOS 14, tvOS 17, watchOS 10, *) {
    return true
  }
  guard #available(iOS 16.4, macOS 13.3, tvOS 16.4, watchOS 9.4, *)
  else { return true }
  return false
}()

extension Binding {
  func isPresent<Wrapped>() -> Binding<Bool> where Value == Wrapped? {
    .init(
      get: { self.wrappedValue != nil },
      set: { isPresent, transaction in
        guard !isPresent else { return }
        self.transaction(transaction).wrappedValue = nil
      }
    )
  }
}

#endif
`

[tadelv]

thanks @jafienberg !