UISheetPresentationController with Detents

[idelfonsog2]

I was writing a SwiftUI viewModifier that could potentially use the UISheetPresentationController based on some of the sample extension the swiftui-navigation and the code Giovanni provided here on his blog

I wanted to ask for help to the viewers of these repot to make that bridge to the SwiftUI version for this viewModifier.
I think this could also be a feature that could be implemented on this package

Let me provide the code below, but one of the things that I'm clueless about is something related with Generics and the View return type depending wether or not the value of the binding Is not nill

import Foundation
import SwiftUI
import ComposableArchitecture

// FIXME: its broken on initializers `self.content = content(value.wrappedValue!)`

  /// UISheetPresentationController that can be used in a SwiftUI interface
struct SheetPresentationForSwiftUI<Value, Content>: UIViewRepresentable where Content: View {
  
  @Binding var value: Value?
  let onDismiss: (() -> Void)?
  let detents: [UISheetPresentationController.Detent]
  let content: Content
  
  
  init(
    _ value: Binding<Value?>,
    onDismiss: (() -> Void)? = nil,
    detents: [UISheetPresentationController.Detent] = [.medium()],
    @ViewBuilder content: (Value) -> Content
  ) {
    self._value = value
    self.onDismiss = onDismiss
    self.detents = detents
    self.content = content(value.wrappedValue!)
  }
  
  func makeUIView(context: Context) -> UIView {
    let view = UIView()
    return view
  }
  
  func updateUIView(_ uiView: UIView, context: Context) {
    
      // Create the UIViewController that will be presented by the UIButton
    let viewController = UIViewController()
    
      // Create the UIHostingController that will embed the SwiftUI View
    let hostingController = UIHostingController(rootView: content)
    
      // Add the UIHostingController to the UIViewController
    viewController.addChild(hostingController)
    viewController.view.addSubview(hostingController.view)
    
      // Set constraints
    hostingController.view.translatesAutoresizingMaskIntoConstraints = false
    hostingController.view.leftAnchor.constraint(equalTo: viewController.view.leftAnchor).isActive = true
    hostingController.view.topAnchor.constraint(equalTo: viewController.view.topAnchor).isActive = true
    hostingController.view.rightAnchor.constraint(equalTo: viewController.view.rightAnchor).isActive = true
    hostingController.view.bottomAnchor.constraint(equalTo: viewController.view.bottomAnchor).isActive = true
    hostingController.didMove(toParent: viewController)
    
      // Set the presentationController as a UISheetPresentationController
    if let sheetController = viewController.presentationController as? UISheetPresentationController {
      sheetController.detents = detents
      sheetController.prefersGrabberVisible = true
      sheetController.prefersScrollingExpandsWhenScrolledToEdge = false
      sheetController.largestUndimmedDetentIdentifier = .medium
    }
    
      // Set the coordinator (delegate)
      // We need the delegate to use the presentationControllerDidDismiss function
    viewController.presentationController?.delegate = context.coordinator
    
    
    if $value.isPresent().wrappedValue {
        // Present the viewController
      uiView.window?.rootViewController?.present(viewController, animated: true)
    } else {
        // Dismiss the viewController
      uiView.window?.rootViewController?.dismiss(animated: true)
    }
    
  }
  
  /* Creates the custom instance that you use to communicate changes
   from your view controller to other parts of your SwiftUI interface.
   */
  func makeCoordinator() -> Coordinator {
    Coordinator(isPresented: $value.isPresent(), onDismiss: onDismiss)
  }
  
  class Coordinator: NSObject, UISheetPresentationControllerDelegate {
    @Binding var isPresented: Bool
    let onDismiss: (() -> Void)?
    
    init(isPresented: Binding<Bool>, onDismiss: (() -> Void)? = nil) {
      self._isPresented = isPresented
      self.onDismiss = onDismiss
    }
    
    func presentationControllerDidDismiss(_ presentationController: UIPresentationController) {
      isPresented = false
      if let onDismiss = onDismiss {
        onDismiss()
      }
    }
  }
}

  /// SwiftUI modifier conforming to the ViewModifier protocol
struct sheetWithDetentsViewModifier<Value, SwiftUIContent>: ViewModifier where SwiftUIContent: View {
  
  @Binding var value: Value?
  let onDismiss: (() -> Void)?
  let detents: [UISheetPresentationController.Detent]
  let swiftUIContent: SwiftUIContent
  
  init(value: Binding<Value?>, detents: [UISheetPresentationController.Detent] = [.medium()] , onDismiss: (() -> Void)? = nil, content: (Value) -> SwiftUIContent) {
    self._value = value
    self.onDismiss = onDismiss
    self.swiftUIContent = content(value.wrappedValue!)
    self.detents = detents
  }
  
  func body(content: Content) -> some View {
    ZStack {
      SheetPresentationForSwiftUI($value, onDismiss: onDismiss, detents: detents) { value in
        swiftUIContent
      }.fixedSize()
      content
    }
  }
}

extension View {
    /// ViewModifier for sheetWithDetents it uses a Binding<Value?> as SwiftUI does
    /// - Parameters:
    ///   - value: Binding<Value?>
    ///   - detents: what sizes you want to show, it has a default of medium()
    ///   - onDismiss: provide closure action
    ///   - content: closure that gets passes the Value in order to show Content: View
  func sheetWithDetents<Value, Content>(
    value: Binding<Value?>,
    detents: [UISheetPresentationController.Detent] = [.medium()],
    onDismiss: (() -> Void)?,
    content: @escaping (Value) -> Content)
  -> some View where Content : View {
    modifier(
      sheetWithDetentsViewModifier(
        value: value,
        detents: detents,
        onDismiss: onDismiss,
        content: content)
    )
  }
}