@@ -14,28 +14,37 @@ import RxCocoa
1414/// Internally, Reducers come from registered Mutator defines a Reducer.
1515public final class Store < State: Equatable > {
1616
17- /// A Middleware acts like a valve in which a dispatched Action passes through.
18- /// It cannot mutate the State. Middlewares can be used for logging purposes for instance
19- public typealias Middleware = ( _ state: State , _ action: Action ) -> Void
17+ /// Reducer correspond to the apply func of a Mutator
2018 private typealias Reducer = ( State , Action ) -> State
2119
22- private var state : State
20+ private let stateSubject : BehaviorRelay < State >
2321 private var neededReducersPerSubState = [ String: Int] ( )
2422 private var reducers = ContiguousArray < Reducer > ( )
25- private var middlewares = ContiguousArray < Middleware > ( )
23+ private let serialDispatchScheduler : SerialDispatchQueueScheduler = {
24+ let serialQueue = DispatchQueue ( label: " com.rxswiftcommunity.rxreduce.serialqueue " )
25+ return SerialDispatchQueueScheduler . init ( queue: serialQueue, internalSerialQueueName: " com.rxswiftcommunity.rxreduce.serialscheduler " )
26+ } ( )
27+
28+ /// The global State is exposed via an Observable, just like some kind of "middleware".
29+ /// This global State will trigger a new value after a dispatch(action) has triggered a "onNext" event.
30+ public lazy var state : Observable < State > = {
31+ return self . stateSubject. asObservable ( )
32+ } ( )
2633
2734 /// Inits a Store with an initial State
2835 ///
2936 /// - Parameter state: the initial State
3037 public init ( withState state: State ) {
31- self . state = state
38+
39+ // Sets the initial State value
40+ self . stateSubject = BehaviorRelay < State > ( value: state)
3241
3342 // We analyze the State children (aka SubState)
3443 // to be able to check that each of them will be handled
3544 // by a reducer function (it allows to be sure that if we
3645 // add a new SubState to the State, there is a reducer in charge
3746 // of its mutation)
38- let stateMirror = Mirror ( reflecting: self . state)
47+ let stateMirror = Mirror ( reflecting: state)
3948 stateMirror
4049 . children
4150 . map { Mirror ( reflecting: $0. value) }
@@ -75,14 +84,6 @@ public final class Store<State: Equatable> {
7584 self . neededReducersPerSubState [ subStateType] = neededReducerForSubState - 1
7685 }
7786
78- /// Registers a Middleware. Middlewares will be applied in sequence
79- /// in the same order than their addition
80- ///
81- /// - Parameter middleware: The Middleware to add
82- public func register ( middleware: @escaping Middleware ) {
83- self . middlewares. append ( middleware)
84- }
85-
8687 /// Dispatches an Action to the registered Reducers.
8788 /// The Action will first go through the Middlewares and
8889 /// then through the Reducers producing a mutated State.
@@ -100,18 +101,16 @@ public final class Store<State: Equatable> {
100101 // every received action is converted to an async action
101102 return action
102103 . toAsync ( )
103- . do ( onNext: { [ unowned self] ( action) in
104- self . middlewares. forEach ( { [ unowned self] ( middleware) in
105- middleware ( self . state, action)
106- } )
107- } )
108104 . map { [ unowned self] ( action) -> State in
109- return self . reducers. reduce ( self . state , { ( currentState, reducer) -> State in
105+ return self . reducers. reduce ( self . stateSubject . value , { ( currentState, reducer) -> State in
110106 return reducer ( currentState, action)
111107 } )
112- } . do ( onNext: { [ unowned self] ( newState) in
113- self . state = newState
114- } ) . distinctUntilChanged ( )
108+ }
109+ . do ( onNext: { [ unowned self] ( newState) in
110+ self . stateSubject. accept ( newState)
111+ } )
112+ . distinctUntilChanged ( )
113+ . subscribeOn ( self . serialDispatchScheduler)
115114 }
116115
117116 /// Dispatches an Action to the registered Mutators but instead of
0 commit comments