Redux with RX

sample.ts

const randomError$ =  Rx.Observable
  .create(observer => {
    if (Math.random() < 0.5) {
      observer.next("success") 
    }
    else {
      observer.error("FAILED REQUEST") 
    }
  })

const severalRequests$ = Rx.Observable.create(observer => {
      let n = 1;

    const intervalId = setInterval(() => {
      if (Math.random() < 0.5) {
              observer.next("success") 

        n += 1;
      } else {
        observer.error("FAILED REQUEST") 
      }
    }, 1000);

    return () => clearInterval(intervalId);

})


var globalState = 0 

const increment = document.createElement('button');
increment.innerHTML = 'increment';
output.prepend(increment);

const decrement = document.createElement('button');
decrement.innerHTML = 'decrement';
output.prepend(decrement);

const request = document.createElement('button');
request.innerHTML = 'request';
output.prepend(request);

const severalRequests = document.createElement('button');
severalRequests.innerHTML = 'severalRequests';
output.prepend(severalRequests);

var action$ = new Rx.Subject();
var asyncAction$ = new Rx.Subject();
const oSync$ = Rx.Observable.from(asyncAction$)
.flatMap((x) => {
   return asyncReduce(x).catch((error, caught) => {  
      return Rx.Observable.empty()

   })
})
  




const random = (items) => {
  return items[Math.floor(Math.random()*items.length)]                
}

const incrementClick$ = Rx.Observable
.fromEvent(increment, 'click')
.subscribe((x) => {
  action$.next("incr") 
})

const decrementClick$ = Rx.Observable
.fromEvent(decrement, 'click')
.subscribe((x) => {
  action$.next("decr") 
})

const requestClick$ = Rx.Observable
.fromEvent(request, 'click')
.subscribe((x) => {
  asyncAction$.next("request") 
})

const severalRequestsClick$ = Rx.Observable
.fromEvent(severalRequests, 'click')
.subscribe((x) => {
  asyncAction$.next("severalRequests") 
})


const state$ = Rx.Observable.merge(oSync$, Rx.Observable.from(action$))

state$
  .scan((state, action) => { return reduce(state, action)  } , globalState)
  .do((x) => {
    globalState = x
})



const reduce = (state, action) => {
      console.log("reduce:" + action)
     switch (action) {
      case "incr": 
         state += 1
         break; 
      case "decr": 
         state -= 1
         break; 
      case "error": 
         state = -10
         break; 
      case "success": 
         state += 5
         break; 

     }

  return state
}

const asyncReduce = (action) => {
     console.log("asyncReduce:" + action)
     var observable = Rx.Observable.empty()
     switch (action) {
       case "severalRequests" : 
				observable = severalRequests$.map((x) => {
            return "success"
         })
         .catch((error, caught) => { 
           return Rx.Observable.of("error") 
         }) 
         break

      case "request": 
         observable = randomError$.map((x) => {
            return "success"
         })
         .catch((error, caught) => { 
           return Rx.Observable.of("error") 
         }) 
         break
     }

  return observable
}