Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/briandunnington/Redoku

Redux for Roku
https://github.com/briandunnington/Redoku

Last synced: 2 months ago
JSON representation

Redux for Roku

Awesome Lists containing this project

README 

        
# Redoku - Redux for Roku



## Usage



In your main() function, construct an associative array that represents your app's

state structure and initial values. Pass this to `RedokuSetInitialState()` before

showing your root Scene.



In your root scene, call `RedokuRegisterReducer()` for each reducer in your app.

Note that each reducer should target a 'section' (property) of the overall state,

and that is the only portion of the state that it will be passed when called.

Each 'section' that will be handled by a reducer must be an associative array.



Ex: For a 'todos' reducer (`RedokuRegisterReducer("todos", todosReducer)`, set up

your state like this:



	{

		todos: {

			items: [...]

		},

		config: {

		}

	}



Not this:



	{

		todos: [...],  'this should not be an array

		config: {

		}

	}



After you have registered all of your reducers, call `RedokuInitialize` from your

root scene to set up the dispatch mechanisms and to trigger the initial reduction

pass.



Individual components can call any action creator functions to trigger state updates.

Action creator functions should call `RedokuDispatch()` with a single action parameter.

The action parameter should be an associative array with (at minimum) a `type`

property and also contain any other properties as appropriate. You can also call

`RedokuDispatch()` from a Task node at any point during its execution to report

asynchronous state changes.



Internally, calls to `RedokuDispatch()` will result in a call to `RedokuRunReducers`

which will loop through all registered reducers and provide them with an opportunity

to modify the state. If a given reducer does not respond to the action specified,

simply return the passed-in state parameter. If the reducer needs to modify the state,

make sure to create a copy of the state before mutating it and returning it. You

can use `RedokuClone()` to easily create a copy of the state before modifying it.



If the state changes, `m.global.state` will be updated. Any components can set

up an observer on that field and update their UI as appropriate.



## For Redux Javascript Developers



If you are familiar with Redux in Javascript, most of the concepts have an analog

version in Redoku.



#### store & createStore()

You initialize your 'store' by calling `RedokuSetInitialState()` and

`RedokuInitialize()`. The equivalent of `store.dispatch()` is `RedokuDispatch()`.

State is stored in the global context, so the equivalent of `store.getState()` is

to access `m.global.state`. You can set up an observer on `m.global.state` to be

notified when it changes.



#### reducers

Redoku reducers are pure functions of the type `state => (state, action)` just

like in Redux. There is no `combineReducers()` function, but instead you register

each reducer independently using `RedokuRegisterReducer()`.



#### actions & action creators

Actions and action creators are exactly the same as in Redux. Actions must have

a `type` property along with any other additional data.



#### async actions & thunk

There is no need for `thunk` or middleware in Redoku to handle async actions.

Asynchronous logic is handled by Scene Graph Tasks. There are two ways to trigger

async actions using Tasks:



  1. In the actual Task itself, dispatch your actions directly (when the task is

	  complete or at any point during its execution).

  2. In your components, spin up the Task and watch for its completion using

      `observeField` and when it is complete, dispatch your actions from your

	  component.



In both cases, the actions are just normal synchronous actions fired during/after

any asynchronous activity.