How to work with View methods, for example, dismiss

[arasan01]

swift-navigation has already become one of the indispensable libraries in my app development.
There is an issue I encountered during development: there seemed to be a lack of a way to manipulate methods that have been propagated only by dismiss or View. For example, this is the case.

class MyViewModel: ObservableObject {
  var destination: Destination? = nil

  enum Destination {
    case dismiss
  }
}

struct MyView: View {
  @ObservedObject var model: MyViewModel
  @Environment(\.dismiss) var dismiss

  var body: some View {
    /* <# Where do you link dismiss? #> */
  }
}

So I have taken this action. This seems to work well for our project.

struct MyView: View {
  @ObservedObject var model: MyViewModel
  @Environment(\.dismiss) var dismiss

  var body: some View {
    SomethingView { ... }
    .onMatch(
        unwrapping: $model.destination,
        case: /MyViewModel.Destination.dismiss
    ) {
        dismiss()
    }
  }
}

Implementations that achieve this

extension View {
    public func onMatch<Enum, Value>(
        unwrapping `enum`: Binding<Enum?>,
        case casePath: CasePath<Enum, Value>,
        action: @escaping (Binding<Value>) -> Void
    ) -> some View {
        self.onChange(of: `enum`.isPresent(casePath).wrappedValue == false) { _ in
            if let wrappedBinding = Binding(unwrapping: `enum`.case(casePath)) {
                `enum`.wrappedValue = nil
                action(wrappedBinding)
            }
        }
    }

    public func onMatch<Enum>(
        unwrapping `enum`: Binding<Enum?>,
        case casePath: CasePath<Enum, Void>,
        action: @escaping () -> Void
    ) -> some View {
        self.onMatch(unwrapping: `enum`, case: casePath) { _ in
            action()
        }
    }
}

Does this match the swift-navigation philosophy? Also, I think this is one of the most useful use cases, but does it match the point-free style? We welcome your opinions.

[mbrandonw]

Hi @arasan01, if I am understanding correctly it sounds like you want to be able to have logic inside your ObservableObject that determines when the view should dismiss itself?

If that's the case then I think you can somewhat simplify your code. You can have the feature model just hold onto some boolean state:

class FeatureModel: ObservableObject {
  var isDismissed = false
  // ...
}

And then you can listen for that state to change in the view and dismiss:

struct FeatureView: View {
  @ObservedObject var model: FeatureModel 
  @Environment(\.dismiss) var dismiss

  var body: some View {
    List {
      // ...
    }
    .onChange(of: self.model.isDismissed) {
      if $0 { self.dismiss() }
    }
  }