SUICoordinator

import SwiftUI
import SUICoordinator

enum HomeRoute: RouteType {
    
    case push(viewModel: PushViewModel)
    case sheet(viewModel: SheetViewModel)
    case fullscreen(viewModel: FullscreenViewModel)
    case detents(viewModel: DetentsViewModel)
    case actionListView(viewModel: ActionListViewModel)
    
    var presentationStyle: TransitionPresentationStyle {
        switch self {
            case .push:
                return .push
            case .sheet:
                return .sheet
            case .fullscreen:
                return .fullScreenCover
            case .detents:
                return .detents([.medium])
            case .actionListView:
                return .push
        }
    }
    
    var view: Body {
        switch self {
            case .push(let viewModel):
                return PushView(viewModel: viewModel)
            case .sheet(let viewModel):
                return SheetView(viewModel: viewModel)
            case .fullscreen(let viewModel):
                return FullscreenView(viewModel: viewModel)
            case .detents(let viewModel):
                return DetentsView(viewModel: viewModel)
            case .actionListView(let viewModel):
                return NavigationActionListView(viewModel: viewModel)
        }
    }
}

import SUICoordinator

class HomeCoordinator: Coordinator<HomeRoute> {
    
    override func start(animated: Bool = true) async {
        let viewModel = ActionListViewModel(coordinator: self)
        await startFlow(route: .actionListView(viewModel: viewModel), animated: animated)
    }
    
    func navigateToPushView() async {
        let viewModel = PushViewModel(coordinator: self)
        await router.navigate(to: .push(viewModel: viewModel))
    }
    
    func presentSheet() async {
        let viewModel = SheetViewModel(coordinator: self)
        await router.navigate(to: .sheet(viewModel: viewModel))
    }
    
    func presentFullscreen() async {
        let viewModel = FullscreenViewModel(coordinator: self)
        await router.navigate(to: .fullscreen(viewModel: viewModel))
    }
    
    func presentDetents() async {
        let viewModel = DetentsViewModel(coordinator: self)
        await router.navigate(to: .detents(viewModel: viewModel))
    }
    
    func presentTabbarCoordinator() async {
        let coordinator = TabbarFlowCoordinator()
        await navigate(to: coordinator, presentationStyle: .sheet)
    }
    
    func close() async {
        await router.close()
    }
    
    func finsh() async {
        await finishFlow(animated: true)
    }
}

import Foundation

class ActionListViewModel: ObservableObject {
    
    let coordinator: HomeCoordinator
    
    init(coordinator: HomeCoordinator) {
        self.coordinator = coordinator
    }
    
    func navigateToPushView() async {
        await coordinator.navigateToPushView()
    }
    
    func presentSheet() async {
        await coordinator.presentSheet()
    }
    
    func presentFullscreen() async {
        await coordinator.presentFullscreen()
    }
    
    func presentDetents() async {
        await coordinator.presentDetents()
    }
    
    func presentTabbarCoordinator() async {
        await coordinator.presentTabbarCoordinator()
    }
    
    func finsh() async {
        await coordinator.finsh()
    }
}

import SwiftUI

struct NavigationActionListView: View {
    
    typealias ViewModel = ActionListViewModel
    @StateObject var viewModel: ViewModel
    
    var body: some View {
        List {
            Button("Push NavigationView") {
                Task { await viewModel.navigateToPushView() }
            }
            
            Button("Presents SheetView") {
                Task { await viewModel.presentSheet() }
            }
            
            Button("Presents FullscreenView") {
                Task { await viewModel.presentFullscreen() }
            }
            
            Button("Presents DetentsView") {
                Task { await viewModel.presentDetents() }
            }
            
            Button("Presents Tabbar Coordinator") {
                Task { await viewModel.presentTabbarCoordinator() }
            }
        }
        .navigationTitle("Navigation Action List")
    }
}

import SUICoordinator

class MainCoordinator: Coordinator<MainRoute> {
    
    override init() {
        super.init()
        Task {
            await startFlow(route: .splash, animated: false)
        }
    }
    
    override func start(animated: Bool = true) async {
        let coordinator = HomeCoordinator()
        await navigate(to: coordinator, presentationStyle: .fullScreenCover, animated: animated)
    }
}

import SUICoordinator
import SwiftUI

enum MainRoute: RouteType {
    
    case splash
    
    public var presentationStyle: TransitionPresentationStyle {
        switch self {
            case .splash:
                return .push
        }
    }
    
    @ViewBuilder
    public var view: any View {
        switch self {
            case .splash:
                SplashView()
        }
    }
}

import SwiftUI
import SUICoordinator

class AppDelegate: NSObject, UIApplicationDelegate {
    
    var mainCoodinator: (any CoordinatorType)?
    
    func application(
        _ application: UIApplication,
        didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil
    ) -> Bool {
        mainCoodinator = MainCoordinator()
        return true
    }
}

import SwiftUI

@main
struct SUICoordinatorDemoApp: App {
    
    @UIApplicationDelegateAdaptor private var appDelegate: AppDelegate
    
    var body: some Scene {
        WindowGroup {
            if let view = appDelegate.mainCoodinator?.view {
                AnyView(view)
            }
        }
    }
}