Turbo navigator without session

Demo/Demo/SceneDelegate.swift

@@ -7,20 +7,27 @@ let baseURL = URL(string: "http://localhost:3000")!
 class SceneDelegate: UIResponder, UIWindowSceneDelegate {
     var window: UIWindow?
 
-    private lazy var turboNavigator = TurboNavigator(delegate: self, pathConfiguration: pathConfiguration)
+    private var turboNavigator: TurboNavigator!
+
     private lazy var pathConfiguration = PathConfiguration(sources: [
         .server(baseURL.appendingPathComponent("/configurations/ios_v1.json"))
     ])
 
     func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
         guard let windowScene = scene as? UIWindowScene else { return }
 
+        let mainSession = Session(webView: TurboConfig.shared.makeWebView())
+        mainSession.pathConfiguration = self.pathConfiguration
+
+        let modalSession = Session(webView: TurboConfig.shared.makeWebView())
+        modalSession.pathConfiguration = self.pathConfiguration
+
+        self.turboNavigator = TurboNavigator(session: mainSession, modalSession: modalSession)
+
         self.window = UIWindow(windowScene: windowScene)
         self.window?.makeKeyAndVisible()
 
         self.window?.rootViewController = self.turboNavigator.rootViewController
         self.turboNavigator.route(baseURL)
     }
 }
-
-extension SceneDelegate: TurboNavigationDelegate {}

Sources/TurboConfig.swift → Sources/Helpers/TurboConfig.swift

@@ -17,7 +17,7 @@ public class TurboConfig {
 
     // MARK: - Internal
 
-    func makeWebView() -> WKWebView {
+    public func makeWebView() -> WKWebView {
         makeCustomWebView(makeWebViewConfiguration())
     }
 

Sources/TurboNavigationHierarchyController.swift

@@ -0,0 +1,209 @@
+import SafariServices
+import Turbo
+import UIKit
+import WebKit
+
+/// Handles navigation to new URLs using the following rules:
+/// https://github.com/joemasilotti/TurboNavigator#handled-flows
+class TurboNavigationHierarchyController {
+    let navigationController: UINavigationController
+    let modalNavigationController: UINavigationController
+
+    var rootViewController: UIViewController { navigationController }
+    var activeNavigationController: UINavigationController {
+        navigationController.presentedViewController != nil ? modalNavigationController : navigationController
+    }
+
+    var animationsEnabled: Bool = true
+
+    enum NavigationStackType {
+        case main
+        case modal
+    }
+
+    func navController(for navigationType: NavigationStackType) -> UINavigationController {
+        switch navigationType {
+            case .main: navigationController
+            case .modal: modalNavigationController
+        }
+    }
+
+    /// Default initializer.
+    ///
+    /// - Parameters:
+    ///   - delegate: handles visits and refresh
+    init(delegate: TurboNavigationHierarchyControllerDelegate) {
+        self.delegate = delegate
+        self.navigationController = UINavigationController()
+        self.modalNavigationController = UINavigationController()
+    }
+
+    func route(controller: UIViewController, proposal: VisitProposal) {
+        if let alert = controller as? UIAlertController {
+            presentAlert(alert)
+        } else {
+            switch proposal.presentation {
+            case .default:
+                navigate(with: controller, via: proposal)
+            case .pop:
+                pop()
+            case .replace:
+                replace(with: controller, via: proposal)
+            case .refresh:
+                refresh()
+            case .clearAll:
+                clearAll()
+            case .replaceRoot:
+                replaceRoot(with: controller)
+            case .none:
+                break // Do nothing.
+            }
+        }
+    }
+
+    func openExternal(url: URL, navigationType: NavigationStackType) {
+        if ["http", "https"].contains(url.scheme) {
+            let safariViewController = SFSafariViewController(url: url)
+            safariViewController.modalPresentationStyle = .pageSheet
+            if #available(iOS 15.0, *) {
+                safariViewController.preferredControlTintColor = .tintColor
+            }
+            let navController = navController(for: navigationType)
+            navController.present(safariViewController, animated: animationsEnabled)
+        } else if UIApplication.shared.canOpenURL(url) {
+            UIApplication.shared.open(url)
+        }
+    }
+
+    // MARK: Private
+
+    @available(*, unavailable)
+    required init?(coder aDecoder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+
+    private unowned let delegate: TurboNavigationHierarchyControllerDelegate
+
+    private func presentAlert(_ alert: UIAlertController) {
+        if navigationController.presentedViewController != nil {
+            modalNavigationController.present(alert, animated: animationsEnabled)
+        } else {
+            navigationController.present(alert, animated: animationsEnabled)
+        }
+    }
+
+    private func navigate(with controller: UIViewController, via proposal: VisitProposal) {
+        switch proposal.context {
+        case .default:
+            navigationController.dismiss(animated: animationsEnabled)
+            pushOrReplace(on: navigationController, with: controller, via: proposal)
+            if let visitable = controller as? Visitable {
+                delegate.visit(visitable, on: .main, with: proposal.options)
+            }
+        case .modal:
+            if navigationController.presentedViewController != nil {
+                pushOrReplace(on: modalNavigationController, with: controller, via: proposal)
+            } else {
+                modalNavigationController.setViewControllers([controller], animated: animationsEnabled)
+                navigationController.present(modalNavigationController, animated: animationsEnabled)
+            }
+            if let visitable = controller as? Visitable {
+                delegate.visit(visitable, on: .modal, with: proposal.options)
+            }
+        }
+    }
+
+    private func pushOrReplace(on navigationController: UINavigationController, with controller: UIViewController, via proposal: VisitProposal) {
+        if visitingSamePage(on: navigationController, with: controller, via: proposal.url) {
+            navigationController.replaceLastViewController(with: controller)
+        } else if visitingPreviousPage(on: navigationController, with: controller, via: proposal.url) {
+            navigationController.popViewController(animated: animationsEnabled)
+        } else if proposal.options.action == .advance {
+            navigationController.pushViewController(controller, animated: animationsEnabled)
+        } else {
+            navigationController.replaceLastViewController(with: controller)
+        }
+    }
+
+    private func visitingSamePage(on navigationController: UINavigationController, with controller: UIViewController, via url: URL) -> Bool {
+        if let visitable = navigationController.topViewController as? Visitable {
+            return visitable.visitableURL == url
+        } else if let topViewController = navigationController.topViewController {
+            return topViewController.isMember(of: type(of: controller))
+        }
+        return false
+    }
+
+    private func visitingPreviousPage(on navigationController: UINavigationController, with controller: UIViewController, via url: URL) -> Bool {
+        guard navigationController.viewControllers.count >= 2 else { return false }
+
+        let previousController = navigationController.viewControllers[navigationController.viewControllers.count - 2]
+        if let previousVisitable = previousController as? VisitableViewController {
+            return previousVisitable.visitableURL == url
+        }
+        return type(of: previousController) == type(of: controller)
+    }
+
+    private func pop() {
+        if navigationController.presentedViewController != nil {
+            if modalNavigationController.viewControllers.count == 1 {
+                navigationController.dismiss(animated: animationsEnabled)
+            } else {
+                modalNavigationController.popViewController(animated: animationsEnabled)
+            }
+        } else {
+            navigationController.popViewController(animated: animationsEnabled)
+        }
+    }
+
+    private func replace(with controller: UIViewController, via proposal: VisitProposal) {
+        switch proposal.context {
+        case .default:
+            navigationController.dismiss(animated: animationsEnabled)
+            navigationController.replaceLastViewController(with: controller)
+            if let visitable = controller as? Visitable {
+                delegate.visit(visitable, on: .main, with: proposal.options)
+            }
+        case .modal:
+            if navigationController.presentedViewController != nil {
+                modalNavigationController.replaceLastViewController(with: controller)
+            } else {
+                modalNavigationController.setViewControllers([controller], animated: false)
+                navigationController.present(modalNavigationController, animated: animationsEnabled)
+            }
+            if let visitable = controller as? Visitable {
+                delegate.visit(visitable, on: .modal, with: proposal.options)
+            }
+        }
+    }
+
+    private func refresh() {
+        if navigationController.presentedViewController != nil {
+            if modalNavigationController.viewControllers.count == 1 {
+                navigationController.dismiss(animated: animationsEnabled)
+                delegate.refresh(navigationStack: .main)
+            } else {
+                modalNavigationController.popViewController(animated: animationsEnabled)
+                delegate.refresh(navigationStack: .modal)
+            }
+        } else {
+            navigationController.popViewController(animated: animationsEnabled)
+            delegate.refresh(navigationStack: .main)
+        }
+    }
+
+    private func clearAll() {
+        navigationController.dismiss(animated: animationsEnabled)
+        navigationController.popToRootViewController(animated: animationsEnabled)
+        delegate.refresh(navigationStack: .main)
+    }
+
+    private func replaceRoot(with controller: UIViewController) {
+        navigationController.dismiss(animated: animationsEnabled)
+        navigationController.setViewControllers([controller], animated: animationsEnabled)
+
+        if let visitable = controller as? Visitable {
+            delegate.visit(visitable, on: .main, with: .init(action: .replace))
+        }
+    }
+}

Sources/TurboNavigationHierarchyControllerDelegate.swift

@@ -0,0 +1,11 @@
+import SafariServices
+import Turbo
+import WebKit
+
+/// Implement to be notified when certain navigations are performed
+/// or to render a native controller instead of a Turbo web visit.
+protocol TurboNavigationHierarchyControllerDelegate: AnyObject {
+    func visit(_ : Visitable, on: TurboNavigationHierarchyController.NavigationStackType, with: VisitOptions)
+
+    func refresh(navigationStack: TurboNavigationHierarchyController.NavigationStackType)
+}