ReSwift-EpicMiddleware

EpicMiddleware.swift

import RxSwift
import ReSwift

public typealias Epic = (Observable<Action>, @escaping GetState) -> Observable<Action>

public func CombineEpics(epics: [Epic]) -> Epic {
    return { (actions: Observable<Action>, getState: @escaping GetState) -> Observable<Action> in
        return Observable.from(epics)
            .map{ e in e(actions, getState) }
            .merge()
    }
}

class EpicMiddleware {
    
    private let disposeBag = DisposeBag()
    
    private var epic: Epic
    
    init(epic: @escaping Epic) {
        self.epic = epic
    }
    
    func createMiddleware() -> Middleware {
        
        let middleware: Middleware = { dispatch, getState in
            
            return { next in
                
                let epicSubject = PublishSubject<Epic>()
                let actionSubject = PublishSubject<Action>()
                
                epicSubject
                    .map{ e in
                        return e(actionSubject, getState)
                    }
                    .flatMapLatest{ output in
                        return output
                    }
                    .subscribe(onNext: { action in
                        _ = dispatch?(action)
                    })
                    .addDisposableTo(self.disposeBag)
                
                epicSubject.onNext(self.epic)
                
                return { action in
                    let result = next(action)
                    
                    actionSubject.onNext(action)
                    
                    return result
                }
            }
        }
        
        return middleware
    }
}