Payments Module with different Architectures

Payments(MVC).swift

public class Payments: Controller<PaymentsRoute> {
    public override func prepareTransition(for route: PaymentsRoute) -> Transition {
        switch route {
        case let .payments(d):
            let m = PaymentsViewItem(d)
            let v = PaymentsView()
            return .show(v)
        case let .payment(d):
            let m = PaymentViewItem(d)
            let v = PaymentView()
            return .show(v)
        case let .approve(d):
            let m = ApproveViewItem(d)
            let v = ApproveView()
            return .show(v)
        case let .success(d):
            let m  = SuccessViewItem(d)
            let v  = SuccessView()
            return .present(v)
        }
    }
}

Payments(MVP).swift

public class Payments: Presenter<PaymentsRoute> {
    public override func prepareTransition(for route: PaymentsRoute) -> Transition {
        switch route {
        case let .payments(d):
            let m = PaymentsViewItem(d)
            let v = PaymentsView()
            return .show(v)
        case let .payment(d):
            let m = PaymentViewItem(d)
            let v = PaymentView()
            return .show(v)
        case let .approve(d):
            let m = ApproveViewItem(d)
            let v = ApproveView()
            return .show(v)
        case let .success(d):
            let m  = SuccessViewItem(d)
            let v  = SuccessView()
            return .present(v)
        }
    }
}

Payments(MVVM-C).swift

public class Payments: Coordinator<PaymentsRoute> {
    public override func prepareTransition(for route: PaymentsRoute) -> Transition {
        switch route {
        case let .payments(d):
            let m  = PaymentsViewItem(d)
            let v  = PaymentsView()
            let vm = PaymentsViewModel(m)
                .subscribe(v: v)
                .move(by: self)
            return .show(v)
        case let .payment(d):
            let m  = PaymentViewItem(d)
            let v  = PaymentView()
            let vm = PaymentViewModel(m)
                .subscribe(v: v)
                .move(by: self)
            return .show(v)
        case let .approve(d):
            let m  = ApproveViewItem(d)
            let v  = ApproveView()
            let vm = ApproveViewModel(m)
                .subscribe(v: v)
                .move(by: self)
            return .show(v)
        case let .success(d):
            let m  = SuccessViewItem(d)
            let v  = SuccessView()
            let vm = SuccessViewModel(m)
                .subscribe(v: v)
                .move(by: self)
            return .present(v)
        }
    }
}

Payments(VIPER).swift

public class Payments: Router<PaymentsRoute> {
    public override func prepareTransition(for route: PaymentsRoute) -> Transition {
        switch route {
        case let .payments(e):
            let v  = PaymentsView()
            let i  = PaymentsViewInteractor(e)
            let p  = PaymentsViewPresenter(i)
            p.router = self
            p.view = v
            return .show(v)
        case let .payment(e):
            let v  = PaymentView()
            let i  = PaymentViewInteractor(e)
            let p  = PaymentViewPresenter(i)
            p.router = self
            p.view = v
            return .show(v)
        case let .approve(e):
            let v  = ApproveView()
            let i  = ApproveViewInteractor(e)
            let p  = ApproveViewPresenter(m)
            p.router = self
            p.view = v
            return .show(v)
        case let .success(e):
            let v  = SuccessView(d)
            let i  = SuccessViewInteractor()
            let p  = SuccessViewPresenter(m)
            p.router = self
            p.view = v
            return .present(v)
        }
    }
}