concentric-sheet 0.0.2

package/ios/SheetModalController.swift

@@ -0,0 +1,912 @@
+import Foundation
+import ObjectiveC.runtime
+import UIKit
+
+public final class SheetModalController: HybridSheetModalControllerSpec {
+    
+  private static var didInstallModalHostHooks = false
+  private static weak var sharedInstance: SheetModalController?
+  private static var cachedPresentedModalConfigs: [PresentedModalConfig] = []
+  private static var modalHostViewWillAppearSwizzleKey: UInt8 = 0
+  private static var viewControllerPresentSwizzleKey: UInt8 = 0
+  private static var modalHostInstanceIdKey: UInt8 = 0
+
+  public override init() {
+    super.init()
+    Self.sharedInstance = self
+    // JS reload can recreate this controller while static state remains in-process.
+    // Drop stale config entries so fresh modal mounts don't consume old configs.
+    Self.cachedPresentedModalConfigs.removeAll()
+    Self.installModalHostHooksIfNeeded()
+  }
+
+  public func cachePresentedModalConfig(config: PresentedModalConfig) throws -> Bool {
+    return try onMainThread {
+      Self.cachedPresentedModalConfigs.append(config)
+      Self.debugLog(
+        "cachePresentedModalConfig queued config=\(Self.describe(config)) queueCount=\(Self.cachedPresentedModalConfigs.count)"
+      )
+      return true
+    }
+  }
+
+  public func applyPresentedModalConfig(config: PresentedModalConfig) throws -> Bool {
+    return try onMainThread {
+      let modalInstanceId = Self.modalInstanceId(from: config)
+      guard let controller = targetPresentedViewController(forModalInstanceId: modalInstanceId)
+      else {
+        Self.debugLog(
+          "applyPresentedModalConfig no target controller modalInstanceId=\(modalInstanceId.map(String.init) ?? "nil") config=\(Self.describe(config))"
+        )
+        return false
+      }
+
+      let didApply = applyConfig(config, to: controller)
+      Self.disableBackgroundModalHostInterceptionIfNeeded()
+      Self.debugLog(
+        "applyPresentedModalConfig controller=\(Self.describe(controller)) modalInstanceId=\(modalInstanceId.map(String.init) ?? "nil") didApply=\(didApply) config=\(Self.describe(config))"
+      )
+      return didApply
+    }
+  }
+
+  public func getPresentedModalDetent(modalInstanceId: Double) throws -> Variant_NullType_PresentedModalDetent {
+    return try onMainThread {
+      guard #available(iOS 15.0, *) else {
+          return .first(.null)
+      }
+
+      guard
+        let controller = targetPresentedViewController(
+          forModalInstanceId: Int(modalInstanceId)
+        ),
+        let sheet = controller.sheetPresentationController,
+        let selectedDetentIdentifier = sheet.selectedDetentIdentifier
+      else {
+          return .first(.null)
+      }
+
+      let rawDetentIdentifier = selectedDetentIdentifier.rawValue
+      let detentIdentifier: SheetDetentIdentifier?
+      switch selectedDetentIdentifier {
+      case .medium:
+        detentIdentifier = .medium
+      case .large:
+        detentIdentifier = .large
+      default:
+        detentIdentifier = nil
+      }
+
+      let customDetentHeight = Self.customDetentHeight(from: rawDetentIdentifier)
+        return .second(PresentedModalDetent(
+        detentIdentifier: detentIdentifier,
+        customDetentHeight: customDetentHeight,
+        rawDetentIdentifier: rawDetentIdentifier
+      ))
+    }
+  }
+
+  public func dismissPresentedModal(animated: Bool) throws -> Bool {
+    return try onMainThread {
+      guard let topController = topPresentedViewController(),
+        topController.presentingViewController != nil
+      else {
+        Self.debugLog("dismissPresentedModal no presented controller")
+        return false
+      }
+
+      Self.debugLog("dismissPresentedModal controller=\(Self.describe(topController)) animated=\(animated)")
+      topController.dismiss(animated: animated)
+      return true
+    }
+  }
+
+  private func applyConfig(_ config: PresentedModalConfig, to controller: UIViewController) -> Bool {
+    var didApply = false
+    if let isModalInPresentation = config.isModalInPresentation {
+      controller.isModalInPresentation = isModalInPresentation
+      didApply = true
+    }
+    if config.preferredContentWidth != nil || config.preferredContentHeight != nil {
+      var preferredContentSize = controller.preferredContentSize
+      if let width = config.preferredContentWidth {
+        preferredContentSize.width = CGFloat(width)
+      }
+      if let height = config.preferredContentHeight {
+        preferredContentSize.height = CGFloat(height)
+      }
+      controller.preferredContentSize = preferredContentSize
+      didApply = true
+    }
+    if let modalViewBackground = config.modalViewBackground {
+      applyModalViewBackground(modalViewBackground, to: controller)
+      didApply = true
+    }
+    if let cornerConfiguration = config.cornerConfiguration {
+      if #available(iOS 26.0, *) {
+        let didFullyApply = applyCornerConfiguration(cornerConfiguration, to: controller)
+        didApply = didApply || didFullyApply
+      } else {
+        didApply = true
+      }
+    }
+
+    if let sheetConfig = config.sheet {
+      if #available(iOS 15.0, *), let sheet = controller.sheetPresentationController {
+        applySheetConfig(sheetConfig, to: sheet)
+        if #available(iOS 26.0, *),
+          let cornerConfiguration = config.cornerConfiguration
+        {
+          sheet.preferredCornerRadius = derivedSheetCornerRadius(from: cornerConfiguration)
+        } else if sheetConfig.preferredCornerRadius == nil {
+          sheet.preferredCornerRadius = nil
+        }
+        didApply = true
+
+        // wantsFullScreen and child modal presentations can cause UIKit to
+        // force isModalInPresentation=true on this controller. Re-apply the
+        // caller's explicit intent after all sheet config is applied.
+        let resolvedIsModalInPresentation = config.isModalInPresentation ?? false
+        let beforeFix = controller.isModalInPresentation
+        if sheetConfig.wantsFullScreen == true {
+          controller.isModalInPresentation = resolvedIsModalInPresentation
+        }
+        let afterFix = controller.isModalInPresentation
+
+        #if DEBUG
+        let instanceId = Self.modalInstanceId(from: config).map(String.init) ?? "?"
+        let isModalInPres = controller.isModalInPresentation
+        Self.debugLog(
+          "wantsFullScreen fix id=\(instanceId) wantsFS=\(sheetConfig.wantsFullScreen as Any) before=\(beforeFix) after=\(afterFix) configValue=\(config.isModalInPresentation as Any)"
+        )
+        Self.debugLog(
+          "sheetState id=\(instanceId) isModalInPresentation=\(isModalInPres) detentCount=\(sheet.detents.count) prefersGrabber=\(sheet.prefersGrabberVisible) presentingVC=\(controller.presentingViewController.map { NSStringFromClass(type(of: $0)) } ?? "nil")"
+        )
+        #endif
+      } else {
+        return false
+      }
+    }
+
+    return didApply || config.sheet == nil
+  }
+
+  @available(iOS 15.0, *)
+  private func applySheetConfig(
+    _ config: SheetPresentationConfig,
+    to sheet: UISheetPresentationController
+  ) {
+    var resolvedDetents: [UISheetPresentationController.Detent] = []
+
+    if let detents = config.detents, !detents.isEmpty {
+      resolvedDetents.append(contentsOf: detents.map(detent(for:)))
+    }
+    if #available(iOS 16.0, *),
+      let customDetentHeights = config.customDetentHeights,
+      !customDetentHeights.isEmpty
+    {
+      for height in customDetentHeights {
+        let clampedHeight = max(0, height)
+        guard clampedHeight > 0 else { continue }
+        let customIdentifier = customDetentIdentifier(forHeight: clampedHeight)
+        let customDetent = UISheetPresentationController.Detent.custom(
+          identifier: customIdentifier
+        ) { _ in
+          return CGFloat(clampedHeight)
+        }
+        resolvedDetents.append(customDetent)
+      }
+    }
+    if !resolvedDetents.isEmpty {
+      sheet.detents = resolvedDetents
+    }
+
+    if #available(iOS 16.0, *),
+      let selectedCustomDetentHeight = config.selectedCustomDetentHeight,
+      selectedCustomDetentHeight > 0
+    {
+      sheet.selectedDetentIdentifier = customDetentIdentifier(forHeight: selectedCustomDetentHeight)
+    } else if let selectedDetentIdentifier = config.selectedDetentIdentifier {
+      sheet.selectedDetentIdentifier = detentIdentifier(for: selectedDetentIdentifier)
+    }
+
+    if #available(iOS 16.0, *),
+      let largestUndimmedCustomDetentHeight = config.largestUndimmedCustomDetentHeight,
+      largestUndimmedCustomDetentHeight > 0
+    {
+      sheet.largestUndimmedDetentIdentifier = customDetentIdentifier(
+        forHeight: largestUndimmedCustomDetentHeight
+      )
+    } else if let largestUndimmedDetentIdentifier = config.largestUndimmedDetentIdentifier {
+      sheet.largestUndimmedDetentIdentifier = detentIdentifier(for: largestUndimmedDetentIdentifier)
+    }
+    if let prefersGrabberVisible = config.prefersGrabberVisible {
+      sheet.prefersGrabberVisible = prefersGrabberVisible
+    }
+    if let preferredCornerRadius = config.preferredCornerRadius {
+      sheet.preferredCornerRadius = CGFloat(preferredCornerRadius)
+    }
+    if let prefersScrollingExpandsWhenScrolledToEdge =
+      config.prefersScrollingExpandsWhenScrolledToEdge
+    {
+      sheet.prefersScrollingExpandsWhenScrolledToEdge = prefersScrollingExpandsWhenScrolledToEdge
+    }
+    if let prefersEdgeAttachedInCompactHeight = config.prefersEdgeAttachedInCompactHeight {
+      sheet.prefersEdgeAttachedInCompactHeight = prefersEdgeAttachedInCompactHeight
+    }
+    if let widthFollowsPreferredContentSizeWhenEdgeAttached =
+      config.widthFollowsPreferredContentSizeWhenEdgeAttached
+    {
+      sheet.widthFollowsPreferredContentSizeWhenEdgeAttached =
+        widthFollowsPreferredContentSizeWhenEdgeAttached
+    }
+    if let wantsFullScreen = config.wantsFullScreen {
+      let dyn = Dynamic(sheet)
+      dyn.wantsFullScreen = wantsFullScreen
+      dyn.allowsInteractiveDismissWhenFullScreen = wantsFullScreen
+
+      if let prefersGrabberVisible = config.prefersGrabberVisible, prefersGrabberVisible {
+        // UIKit's internal _grabberAlpha fighting is unreliable in wantsFullScreen mode.
+        // Add our own overlay grabber pill directly to the drop shadow view instead.
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) { [weak sheet] in
+          guard let sheet = sheet else { return }
+          guard let dropShadowView = (sheet as NSObject).value(forKey: "dropShadowView") as? UIView else { return }
+
+          // Remove any previously attached overlay grabber before adding a new one.
+          Self.removeOverlayGrabber(from: dropShadowView)
+
+          let topInset = UIApplication.shared.connectedScenes
+            .compactMap { $0 as? UIWindowScene }
+            .flatMap { $0.windows }
+            .first(where: { $0.isKeyWindow })
+            .map { $0.safeAreaInsets.top } ?? 0
+
+          let pillWidth: CGFloat = 36
+          let pillHeight: CGFloat = 5
+          let pillX = (dropShadowView.bounds.width - pillWidth) / 2
+          let pillY = topInset + 8
+
+          let pill = UIView(frame: CGRect(x: pillX, y: pillY, width: pillWidth, height: pillHeight))
+          pill.backgroundColor = UIColor(white: 0.55, alpha: 0.45)
+          pill.layer.cornerRadius = pillHeight / 2
+          pill.autoresizingMask = [.flexibleLeftMargin, .flexibleRightMargin]
+          pill.tag = Self.overlayGrabberTag
+
+          dropShadowView.addSubview(pill)
+
+          #if DEBUG
+          Self.logPresentationStack(from: sheet)
+          Self.logGestureRecognizers(on: sheet)
+          #endif
+        }
+      }
+    }
+  }
+
+  #if DEBUG
+  private static func logPresentationStack(from sheet: UISheetPresentationController) {
+    let presented = sheet.presentedViewController
+    var vc: UIViewController? = presented
+    var depth = 0
+    var stack: [String] = []
+    while let current = vc {
+      let isModal = isReactNativeModalHostController(current)
+      let instanceId = isModal ? modalHostInstanceId(for: current).map(String.init) ?? "?" : "-"
+      let hasSheet = current.sheetPresentationController != nil
+      let presentedChild = current.presentedViewController.map { NSStringFromClass(type(of: $0)) } ?? "none"
+      stack.append("  [\(depth)] \(NSStringFromClass(type(of: current))) id=\(instanceId) hasSheet=\(hasSheet) presentedChild=\(presentedChild)")
+      vc = current.presentedViewController
+      depth += 1
+    }
+    debugLog("presentationStack:\n\(stack.joined(separator: "\n"))")
+  }
+
+  private static func logGestureRecognizers(on sheet: UISheetPresentationController) {
+    guard let containerView = sheet.containerView else { return }
+    var gestures: [String] = []
+    func walkGestures(view: UIView, depth: Int) {
+      let prefix = String(repeating: "  ", count: depth)
+      let viewName = NSStringFromClass(type(of: view))
+      for gr in view.gestureRecognizers ?? [] {
+        let grName = NSStringFromClass(type(of: gr))
+        gestures.append("\(prefix)\(viewName) → \(grName) enabled=\(gr.isEnabled) state=\(gr.state.rawValue)")
+      }
+      for sub in view.subviews {
+        walkGestures(view: sub, depth: depth + 1)
+      }
+    }
+    walkGestures(view: containerView, depth: 0)
+    if !gestures.isEmpty {
+      debugLog("gestureRecognizers on parent sheet:\n\(gestures.joined(separator: "\n"))")
+    }
+  }
+  #endif
+
+  private static let overlayGrabberTag = 0x4E435347 // "NCSG"
+
+  private static func removeOverlayGrabber(from view: UIView) {
+    view.subviews
+      .filter { $0.tag == overlayGrabberTag }
+      .forEach { $0.removeFromSuperview() }
+  }
+
+  @available(iOS 15.0, *)
+  private func detent(for identifier: SheetDetentIdentifier)
+    -> UISheetPresentationController.Detent
+  {
+    switch identifier {
+    case .medium:
+      return .medium()
+    case .large:
+      return .large()
+    @unknown default:
+      return .large()
+    }
+  }
+
+  @available(iOS 15.0, *)
+  private func detentIdentifier(
+    for identifier: SheetDetentIdentifier
+  ) -> UISheetPresentationController.Detent.Identifier {
+    switch identifier {
+    case .medium:
+      return .medium
+    case .large:
+      return .large
+    @unknown default:
+      return .large
+    }
+  }
+
+  @available(iOS 16.0, *)
+  private func customDetentIdentifier(
+    forHeight height: Double
+  ) -> UISheetPresentationController.Detent.Identifier {
+    let normalizedHeight = max(0, height)
+    let rawValue = String(format: "ncs.customHeight.%.3f", normalizedHeight)
+    return UISheetPresentationController.Detent.Identifier(rawValue: rawValue)
+  }
+
+  private func applyModalViewBackground(
+    _ modalViewBackground: ModalViewBackground,
+    to controller: UIViewController
+  ) {
+    let color: UIColor
+    switch modalViewBackground {
+    case .clear:
+      color = .clear
+    case .systembackground:
+      color = .systemBackground
+    @unknown default:
+      color = .systemBackground
+    }
+
+    controller.view.backgroundColor = color
+    controller.view.isOpaque = color != .clear
+
+    // React Native mounts its modal content as a subview of the presented controller's root view.
+    // Keep those roots aligned with the requested background mode to avoid accidental opaque fills.
+    for subview in controller.view.subviews {
+      subview.backgroundColor = color
+      subview.isOpaque = color != .clear
+    }
+  }
+
+  @available(iOS 26.0, *)
+  private func applyCornerConfiguration(
+    _ configuration: ModalCornerConfiguration,
+    to controller: UIViewController
+  ) -> Bool {
+    let appliedConfiguration: UICornerConfiguration
+
+    switch configuration.type {
+    case .none:
+      appliedConfiguration = .corners(radius: .fixed(0))
+    case .fixed:
+      let radius = max(0, configuration.radius ?? 0)
+      appliedConfiguration = .corners(radius: .fixed(radius))
+    case .containerconcentric:
+      if let minimumRadius = configuration.minimumRadius {
+        appliedConfiguration = .corners(
+          radius: .containerConcentric(minimum: max(0, minimumRadius))
+        )
+      } else {
+        appliedConfiguration = .corners(radius: .containerConcentric())
+      }
+    case .capsule:
+      if let maximumRadius = configuration.maximumRadius {
+        appliedConfiguration = .capsule(maximumRadius: max(0, maximumRadius))
+      } else {
+        appliedConfiguration = .capsule()
+      }
+    @unknown default:
+      appliedConfiguration = .corners(radius: .fixed(0))
+    }
+
+    return applyCornerConfigurationNow(
+      appliedConfiguration,
+      cornerType: configuration.type,
+      to: controller
+    )
+  }
+
+  @available(iOS 26.0, *)
+  private func applyCornerConfigurationNow(
+    _ cornerConfiguration: UICornerConfiguration,
+    cornerType: ModalCornerConfigurationType,
+    to controller: UIViewController
+  ) -> Bool {
+    let contentView = controller.view!
+    let reactRootSubview = contentView.subviews.first
+
+    CATransaction.begin()
+    CATransaction.setDisableActions(true)
+    contentView.cornerConfiguration = cornerConfiguration
+    reactRootSubview?.cornerConfiguration = cornerConfiguration
+
+    let shouldClipContents = cornerType != .none
+    contentView.clipsToBounds = shouldClipContents
+    contentView.layer.masksToBounds = shouldClipContents
+    reactRootSubview?.clipsToBounds = shouldClipContents
+    reactRootSubview?.layer.masksToBounds = shouldClipContents
+    CATransaction.commit()
+
+    // React content can mount after present; return false to trigger JS retry until mounted.
+    return reactRootSubview != nil
+  }
+
+  private func derivedSheetCornerRadius(
+    from configuration: ModalCornerConfiguration
+  ) -> CGFloat? {
+    switch configuration.type {
+    case .none:
+      return 0
+    case .fixed:
+      return CGFloat(max(0, configuration.radius ?? 0))
+    case .containerconcentric, .capsule:
+      return nil
+    @unknown default:
+      return nil
+    }
+  }
+
+  private func onMainThread<T>(_ block: () throws -> T) throws -> T {
+    if Thread.isMainThread {
+      return try block()
+    }
+
+    var result: Result<T, Error>?
+    DispatchQueue.main.sync {
+      result = Result(catching: block)
+    }
+    return try result!.get()
+  }
+
+  private func topPresentedViewController() -> UIViewController? {
+    guard let rootViewController = activeRootViewController() else { return nil }
+    let topController = Self.topMostPresentedController(startingFrom: rootViewController)
+    return topController === rootViewController ? nil : topController
+  }
+
+  private func targetPresentedViewController(forModalInstanceId modalInstanceId: Int?)
+    -> UIViewController?
+  {
+    guard let modalInstanceId else {
+      return topPresentedViewController()
+    }
+
+    guard let rootViewController = activeRootViewController() else { return nil }
+
+    var controller: UIViewController? = rootViewController
+    while let current = controller {
+      if Self.isReactNativeModalHostController(current),
+        Self.modalHostInstanceId(for: current) == modalInstanceId
+      {
+        return current
+      }
+      controller = current.presentedViewController
+    }
+
+    return nil
+  }
+
+  private func activeRootViewController() -> UIViewController? {
+    let connectedScenes = UIApplication.shared.connectedScenes.compactMap {
+      $0 as? UIWindowScene
+    }
+
+    let activeScenes = connectedScenes.filter {
+      $0.activationState == .foregroundActive || $0.activationState == .foregroundInactive
+    }
+
+    for scene in activeScenes {
+      if let keyWindow = scene.windows.first(where: \.isKeyWindow),
+        let rootViewController = keyWindow.rootViewController
+      {
+        return rootViewController
+      }
+      if let rootViewController = scene.windows.first?.rootViewController {
+        return rootViewController
+      }
+    }
+
+    return nil
+  }
+
+    // TODO: super hacky find better solution 🤷‍♂️
+  @MainActor
+  fileprivate static func preconfigurePresentedControllerIfNeeded(_ controller: UIViewController) {
+    guard isReactNativeModalHostController(controller) else { return }
+    guard !cachedPresentedModalConfigs.isEmpty else {
+      debugLog("preconfigure skip empty queue controller=\(describe(controller))")
+      return
+    }
+    let queueSnapshot = cachedPresentedModalConfigs.compactMap { Self.modalInstanceId(from: $0) }.map(String.init)
+    debugLog(
+      "preconfigure queueBefore=[\(queueSnapshot.joined(separator: ","))] controller=\(describe(controller))"
+    )
+    // React child effects run before parent effects, so inner modals cache first.
+    // UIKit fires viewWillAppear outer-first. Using removeLast() (LIFO) corrects
+    // the mismatch so outer controllers get outer configs and inner get inner.
+    let config = cachedPresentedModalConfigs.removeLast()
+    let modalInstanceId = modalInstanceId(from: config)
+    if let modalInstanceId {
+      setModalHostInstanceId(modalInstanceId, on: controller)
+    }
+    debugLog(
+      "preconfigure consume controller=\(describe(controller)) modalInstanceId=\(modalInstanceId.map(String.init) ?? "nil") config=\(describe(config)) remainingQueueCount=\(cachedPresentedModalConfigs.count)"
+    )
+    _ = sharedInstance?.applyConfig(config, to: controller)
+    disableBackgroundModalHostInterceptionIfNeeded()
+  }
+
+    // TODO: super hacky find better solution 🤷‍♂️
+  private static func isReactNativeModalHostController(_ controller: UIViewController) -> Bool {
+    let className = NSStringFromClass(type(of: controller))
+    return className.contains("ModalHostViewController")
+  }
+
+    // TODO: super hacky find better solution 🤷‍♂️
+  private static func installModalHostHooksIfNeeded() {
+    guard !didInstallModalHostHooks else { return }
+    didInstallModalHostHooks = true
+    debugLog("installModalHostHooksIfNeeded")
+    swizzleUIViewControllerPresentIfNeeded()
+
+    let classNames = ["RCTFabricModalHostViewController", "RCTModalHostViewController"]
+    for className in classNames {
+      guard let cls = NSClassFromString(className) else { continue }
+      swizzleViewWillAppear(on: cls)
+    }
+  }
+
+    // TODO: super hacky find better solution 🤷‍♂️
+  private static func swizzleViewWillAppear(on cls: AnyClass) {
+    if let isSwizzled = objc_getAssociatedObject(
+      cls,
+      &Self.modalHostViewWillAppearSwizzleKey
+    ) as? Bool, isSwizzled {
+      debugLog("swizzleViewWillAppear already swizzled class=\(NSStringFromClass(cls))")
+      return
+    }
+
+    let originalSelector = #selector(UIViewController.viewWillAppear(_:))
+    let swizzledSelector = #selector(UIViewController.ncs_modalHost_viewWillAppear(_:))
+
+    guard
+      let originalMethod = class_getInstanceMethod(cls, originalSelector),
+      let swizzledMethod = class_getInstanceMethod(UIViewController.self, swizzledSelector)
+    else {
+      debugLog("swizzleViewWillAppear failed missing methods class=\(NSStringFromClass(cls))")
+      return
+    }
+
+    // Canonical safe swizzle pattern:
+    // 1) Try adding swizzled impl under original selector on this class.
+    // 2) If added, wire original impl under swizzled selector.
+    // 3) Otherwise exchange class-local method impls.
+    let didAddOriginalMethod = class_addMethod(
+      cls,
+      originalSelector,
+      method_getImplementation(swizzledMethod),
+      method_getTypeEncoding(swizzledMethod)
+    )
+
+    if didAddOriginalMethod {
+      class_replaceMethod(
+        cls,
+        swizzledSelector,
+        method_getImplementation(originalMethod),
+        method_getTypeEncoding(originalMethod)
+      )
+    } else if
+      let classOriginalMethod = class_getInstanceMethod(cls, originalSelector),
+      let classSwizzledMethod = class_getInstanceMethod(cls, swizzledSelector)
+    {
+      method_exchangeImplementations(classOriginalMethod, classSwizzledMethod)
+    } else {
+      debugLog("swizzleViewWillAppear failed class-local methods class=\(NSStringFromClass(cls))")
+      return
+    }
+
+    objc_setAssociatedObject(
+      cls,
+      &Self.modalHostViewWillAppearSwizzleKey,
+      true,
+      .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+    )
+    debugLog("swizzleViewWillAppear success class=\(NSStringFromClass(cls))")
+  }
+
+  private static func swizzleUIViewControllerPresentIfNeeded() {
+    if let isSwizzled = objc_getAssociatedObject(
+      UIViewController.self,
+      &Self.viewControllerPresentSwizzleKey
+    ) as? Bool, isSwizzled {
+      debugLog("swizzleUIViewControllerPresentIfNeeded already swizzled")
+      return
+    }
+
+    let originalSelector = #selector(
+      UIViewController.present(_:animated:completion:)
+    )
+    let swizzledSelector = #selector(
+      UIViewController.ncs_modalHost_present(_:animated:completion:)
+    )
+
+    guard
+      let originalMethod = class_getInstanceMethod(UIViewController.self, originalSelector),
+      let swizzledMethod = class_getInstanceMethod(UIViewController.self, swizzledSelector)
+    else {
+      debugLog("swizzleUIViewControllerPresentIfNeeded failed missing methods")
+      return
+    }
+
+    method_exchangeImplementations(originalMethod, swizzledMethod)
+    objc_setAssociatedObject(
+      UIViewController.self,
+      &Self.viewControllerPresentSwizzleKey,
+      true,
+      .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+    )
+    debugLog("swizzleUIViewControllerPresentIfNeeded success")
+  }
+
+  fileprivate static func preferredPresenter(
+    for presenter: UIViewController,
+    viewControllerToPresent: UIViewController
+  ) -> UIViewController {
+    guard isReactNativeModalHostController(viewControllerToPresent),
+      let currentlyPresented = presenter.presentedViewController
+    else {
+      return presenter
+    }
+
+    let top = topMostPresentedController(startingFrom: currentlyPresented)
+    guard isReactNativeModalHostController(top) else {
+      return presenter
+    }
+
+    return top
+  }
+
+  fileprivate static func topMostPresentedController(startingFrom root: UIViewController)
+    -> UIViewController
+  {
+    var controller = root
+    while let next = controller.presentedViewController {
+      controller = next
+    }
+    return controller
+  }
+
+  fileprivate static func modalInstanceId(from config: PresentedModalConfig) -> Int? {
+    guard let modalInstanceId = config.modalInstanceId else { return nil }
+    return Int(modalInstanceId)
+  }
+
+  fileprivate static func setModalHostInstanceId(_ id: Int, on controller: UIViewController) {
+    objc_setAssociatedObject(
+      controller,
+      &Self.modalHostInstanceIdKey,
+      NSNumber(value: id),
+      .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+    )
+  }
+
+  fileprivate static func modalHostInstanceId(for controller: UIViewController) -> Int? {
+    guard
+      let number = objc_getAssociatedObject(
+        controller,
+        &Self.modalHostInstanceIdKey
+      ) as? NSNumber
+    else {
+      return nil
+    }
+    return number.intValue
+  }
+
+  fileprivate static func customDetentHeight(from rawDetentIdentifier: String) -> Double? {
+    let prefix = "ncs.customHeight."
+    guard rawDetentIdentifier.hasPrefix(prefix) else { return nil }
+    let rawValue = String(rawDetentIdentifier.dropFirst(prefix.count))
+    return Double(rawValue)
+  }
+
+  fileprivate static func disableBackgroundModalHostInterceptionIfNeeded() {
+    guard let rootViewController = sharedInstance?.activeRootViewController() else { return }
+    disableModalHostComponentInteraction(in: rootViewController.view)
+  }
+
+  fileprivate static func disableModalHostComponentInteraction(in rootView: UIView) {
+    var disabledCount = 0
+
+    func walk(_ view: UIView) {
+      let className = NSStringFromClass(type(of: view))
+      if className.contains("RCTModalHostViewComponentView")
+        || className.contains("RCTModalHostView")
+      {
+        if view.isUserInteractionEnabled {
+          view.isUserInteractionEnabled = false
+          disabledCount += 1
+        }
+      }
+
+      for subview in view.subviews {
+        walk(subview)
+      }
+    }
+
+    walk(rootView)
+    if disabledCount > 0 {
+      debugLog(
+        "disabled modal host interception views count=\(disabledCount)"
+      )
+    }
+  }
+
+  fileprivate static func describe(_ controller: UIViewController) -> String {
+    let className = NSStringFromClass(type(of: controller))
+    let pointer = Unmanaged.passUnretained(controller).toOpaque()
+    return "\(className)@\(pointer)"
+  }
+
+  fileprivate static func describe(_ config: PresentedModalConfig) -> String {
+    let modalInstanceId = modalInstanceId(from: config).map(String.init) ?? "nil"
+    let isModalInPresentation = config.isModalInPresentation.map(String.init) ?? "nil"
+    let bg = config.modalViewBackground.map { "\($0)" } ?? "nil"
+    let corner = config.cornerConfiguration.map { "\($0.type)" } ?? "nil"
+    let selectedCustom = config.sheet?.selectedCustomDetentHeight.map {
+      String(format: "%.3f", $0)
+    } ?? "nil"
+    let largestCustom = config.sheet?.largestUndimmedCustomDetentHeight.map {
+      String(format: "%.3f", $0)
+    } ?? "nil"
+    let customHeights = (config.sheet?.customDetentHeights ?? []).map {
+      String(format: "%.3f", $0)
+    }.joined(separator: ",")
+
+    return "modalInstanceId=\(modalInstanceId) sheetCustom=[\(customHeights)] selectedCustom=\(selectedCustom) largestCustom=\(largestCustom) bg=\(bg) corner=\(corner) modalInPresentation=\(isModalInPresentation)"
+  }
+
+  fileprivate static func debugLog(_ message: String) {
+    #if DEBUG
+      NSLog("[SheetModalController] %@", message)
+    #endif
+  }
+}
+
+private extension UIViewController {
+  @objc
+  func ncs_modalHost_present(
+    _ viewControllerToPresent: UIViewController,
+    animated flag: Bool,
+    completion: (() -> Void)? = nil
+  ) {
+    let preferredPresenter = SheetModalController.preferredPresenter(
+      for: self,
+      viewControllerToPresent: viewControllerToPresent
+    )
+
+    if preferredPresenter !== self {
+      SheetModalController.debugLog(
+        "redirect present from=\(SheetModalController.describe(self)) to=\(SheetModalController.describe(preferredPresenter)) target=\(SheetModalController.describe(viewControllerToPresent))"
+      )
+      preferredPresenter.ncs_modalHost_present(
+        viewControllerToPresent,
+        animated: flag,
+        completion: completion
+      )
+      return
+    }
+
+    ncs_modalHost_present(viewControllerToPresent, animated: flag, completion: completion)
+  }
+
+  @objc
+  func ncs_modalHost_viewWillAppear(_ animated: Bool) {
+    SheetModalController.debugLog(
+      "modalHost viewWillAppear controller=\(SheetModalController.describe(self)) animated=\(animated)"
+    )
+    if Thread.isMainThread {
+      SheetModalController.preconfigurePresentedControllerIfNeeded(self)
+    } else {
+      DispatchQueue.main.sync {
+        SheetModalController.preconfigurePresentedControllerIfNeeded(self)
+      }
+    }
+    ncs_modalHost_viewWillAppear(animated)
+  }
+}
+
+// MARK: - Debug helpers
+
+#if DEBUG
+extension SheetModalController {
+  static func dumpSheetProperties(_ sheet: UISheetPresentationController) {
+    let obj = sheet as NSObject
+    var cls: AnyClass? = type(of: sheet)
+
+    print("──── UISheetPresentationController ivars ────")
+    while let current = cls {
+      var ivarCount: UInt32 = 0
+      if let ivars = class_copyIvarList(current, &ivarCount) {
+        for i in 0..<Int(ivarCount) {
+          guard let ivarName = ivar_getName(ivars[i]) else { continue }
+          let rawKey = String(cString: ivarName)
+          let kvcKey = String(rawKey.drop(while: { $0 == "_" }))
+          guard !kvcKey.isEmpty else {
+            print("  \(rawKey) = ⚠️ inaccessible (empty key)")
+            continue
+          }
+          let getter = NSSelectorFromString(kvcKey)
+          let boolGetter = NSSelectorFromString(
+            "is" + kvcKey.prefix(1).uppercased() + kvcKey.dropFirst()
+          )
+          if obj.responds(to: getter) || obj.responds(to: boolGetter) {
+            let value = obj.value(forKey: kvcKey)
+            print("  \(rawKey) = \(value ?? "nil")")
+          } else {
+            print("  \(rawKey) = ⚠️ inaccessible")
+          }
+        }
+        free(ivars)
+      }
+      cls = class_getSuperclass(current)
+      if current == NSObject.self { break }
+    }
+
+    print("──── Methods matching grabber/fullScreen ────")
+    cls = type(of: sheet)
+    while let current = cls {
+      var methodCount: UInt32 = 0
+      if let methods = class_copyMethodList(current, &methodCount) {
+        for i in 0..<Int(methodCount) {
+          let selName = NSStringFromSelector(method_getName(methods[i]))
+          if selName.localizedCaseInsensitiveContains("grabber") ||
+            selName.localizedCaseInsensitiveContains("fullScreen") ||
+            selName.localizedCaseInsensitiveContains("fullscreen")
+          {
+            print("  \(selName)")
+          }
+        }
+        free(methods)
+      }
+      cls = class_getSuperclass(current)
+      if current == NSObject.self { break }
+    }
+    print("─────────────────────────────────────────────")
+  }
+}
+#endif
+
+// MARK: - KVC access for private UISheetPresentationController properties
+@dynamicMemberLookup
+private final class Dynamic {
+  private let base: NSObject
+  init(_ base: NSObject) { self.base = base }
+  subscript(dynamicMember member: String) -> Any? {
+    get { base.value(forKey: member) }
+    set { base.setValue(newValue, forKey: member) }
+  }
+}