Chopped Redux

This library is an implementation of @gaearonRedux, which claims to be a "Predictable state container for JavaScript apps".

Redux is based on Facebook's Flux but it's a lot more simple a straightforward. Chopped Redux follows the same principles and ideas but cutting off features, namely all utility methods and ES2015/7 magic. Chopped is practically the same as Redux's 1.0 core, just read the source.

Motivation

In the beginning, Redux was a React thing. So I wanted to have a similar library not tight to any rendering/view-layer library, and I was mainly inspired by this and this, ideas which made the Flux unidirectional data-flow very simple. Redux is free from React and free from classes starting at 1.0, so there's no reason for you to use Chopped instead of the genuine Redux if you don't find any of the key differences useful to you.

Key differences from Redux

There’s no init @@redux/INIT dispatch on createStore(), you need to do that yourself when you know it’s time to initialize your state.

You can pass anything to dispatch(), not only a plain object, it's your responsibility to handle that in the update function.

You can call dispatch() with no arguments (an empty object will get dispatched), useful for initializing.

API

Chopped Redux exports a single factory function that returns an object with four methods:

dispatch

getState

subscribe

The factory has a single mandatory param which is a update function.

createStore(update[, initialState])

updateFunction

initialStateMixed Anything you want to hold your state in

The update function should have the following signature:

function(state,action){

// do something with state depending on the action type,

// ideally generating a fresh new (immutable) value

return state

}

What happens internally on every action dispatch is basically this:

state =update(state, action)

dispatch(action)

Returns undefined

actionObject

getState()

Returns Object The current state

subscribe(listener)

Returns Function A function to remove the listener

listenerFunction A callback that gets fired after every state update

Old replaceState

In previous versions (<=4.0.0) there was a replaceState method, this was a shortcut for an action that can be easily achieved in a pure Redux manner: By dispatching a REPLACE_STATE-typed action and swapping the new state in the update function.

Async and action creators

Handling async stuff in vanilla Flux is a pain. In the beginning of Flux we were making API calls inside our Stores, that turned out to be a bad idea. So they came up with this pompous concept of Action Creators to confuse us all (at least for a while). [If you’re still confused, Action Creators are functions that return Actions, which are simply objects; so Action == plain object; Action Creator == function that creates an Action object.] Apparently no-one knows how to do this right.

In Redux there’s middleware. The thunk middleware allows you to literally dispatch a function, and your Action Creators look like this:

functionfoo(bar){

// do async stuff

returnfunction(dispatch){

dispatch({

type:FOO,

bar: bar

})

}

}

// after binding it and what not, call it

foo()

I prefer a simpler and more explicit approach based only on the necessity of delaying the dispatch, namely this:

functionfoo(dispatch,payload){

// do async stuff

dispatch({

type:FOO,

payload: payload

})

}

foo(store.dispatch,{ foo: ‘bar’ })

a function in which the dispatch callback always gets passed-in as first argument. You could also pass in the very store instance if you need to getState().

I would call this an action dispatcher function, because that’s what it does. There’s no nesting, no type checking, no complexity. You just pass in a callback for dispatching an action with some payload. You’re just delegating dispatching actions to a helper function to do some things before the dispatch.

If you don’t need async, simply dispatch the action directly and you’ve got one less function to care about.