Deox

Edit page

API Reference

createActionCreator(type[, executor])

Creates an action creator.

Arguments

type (string ): the type of action being created. It should typically be defined as string constants and is the only required parameter.
executor (Function ): a function that gives an argument named resolve that gives payload and meta as optional arguments and returns an action.

Returns

(ActionCreator )

Examples

With only type:

xxxxxxxxxx
 
import { createActionCreator } from 'deox'
​
const completeAllTodos = createActionCreator('COMPLETE_ALL_TODOS')
completeAllTodos() //=> { type: 'COMPLETE_ALL_TODOS' }

With type and payload:

xxxxxxxxxx
 
import { createActionCreator } from 'deox'
​
const addTodo = createActionCreator('ADD_TODO', resolve => (text: string) => resolve(text))
addTodo('Read the docs') //=> { type: 'ADD_TODO', payload: 'Read the docs' }

With type and meta:

xxxxxxxxxx
 
import { createActionCreator } from 'deox'
​
const showTodos = createActionCreator('SHOW_TODOS', resolve => (param: number) => resolve(undefined, param))
showTodos(10) //=> { type: 'ADD_TODO', meta: 10 }

With type, payload and meta:

xxxxxxxxxx
 
import { createActionCreator } from 'deox'
​
const getTodo = createActionCreator('GET_TODO', resolve => (id: number, meta: string) => resolve(id, meta))
getTodo(700, 'some-meta') //=> { type: 'GET_TODO', payload: 700, meta: 'some-meta' }

createAction(type[, executor])

Alias of createActionCreator.

createReducer(defaultState, handlerMapsCreator)

Creates a reducer.

Arguments

defaultState (any ): returning state when undefined is passed to the created reducer.
handlerMapsCreator (Function ): a function that gives an argument named handleAction that gives action creator(s) and handler as arguments and returns a HandlerMap.

Returns

(Reduer ).

Examples

Basic:

xxxxxxxxxx
 
import { createActionCreator, createReducer } from 'deox'
​
const increment = createActionCreator('INCREMENT')
const decrement = createActionCreator('DECREMENT')
const reset = createActionCreator('reset', resolve => (count: number) => resolve(count))
​
const defaultState = 0
​
const counterReducer = createReducer(defaultState, handleAction => [
    handleAction(increment, state => state + 1),
    handleAction(decrement, state => state - 1),
    handleAction(reset, (_, { payload }) => payload),
])

Handle multiple actions in one handler:

xxxxxxxxxx
 
import { createActionCreator, createReducer } from 'deox'
​
const fetch = {
  next: createActionCreator('FETCH_NEXT')
  complete: createActionCreator('FETCH_COMPLETE')
  error: createActionCreator('FETCH_ERROR')
  cancel: createActionCreator('FETCH_CANCEL')
}
​
const defaultState = false
​
const isFetchingReducer = createReducer(defaultState, handleAction => [
  handleAction(fetch.next, () => true),
  handleAction([fetch.complete, fetch.error, fetch.cancel], () => false)
])

getType(actionCreator)

Get wrapped action type of an action creator.

Arguments

actionCreator (ActionCreator ): an action creator.

Returns

(string ). The action type that the action creator wraps.

Example

xxxxxxxxxx
 
import { createActionCreator, getType } from 'deox'
​
const increment = createActionCreator('INCREMENT')
​
getType(increment) //=> 'INCREMENT'

ofType(keys)

An RxJS operator that filters input actions according to the given action creator(s) or action(s) or action type(s).

Arguments

keys (ActionCreator[] | Action[] | string[] ):

Examples

With action creator:

xxxxxxxxxx
 
import { createActionCreator, ofType } from 'deox'
import { delay, mapTo } from 'rxjs/operators'
​
const ping = createActionCreator('PING')
​
const pingEpic = action$ => action$.pipe(ofType(ping), delay(1000), mapTo({ type: 'PONG' }))

With multiple action creators:

xxxxxxxxxx
 
import { createActionCreator, ofType } from 'deox'
import { delay, mapTo } from 'rxjs/operators'
​
const ping = createActionCreator('PING')
const pong = createActionCreator('PONG')
​
const pingPongEpic = action$ => action$.pipe(ofType([ping, pong]), delay(1000), mapTo({ type: 'DONE' }))

With action:

xxxxxxxxxx
 
import { createActionCreator, ofType } from 'deox'
import { delay, mapTo } from 'rxjs/operators'
​
const pingEpic = action$ => action$.pipe(ofType({ type: 'PING' }), delay(1000), mapTo({ type: 'PONG' }))

With action type:

xxxxxxxxxx
 
import { createActionCreator, ofType } from 'deox'
import { delay, mapTo } from 'rxjs/operators'
​
const pingEpic = action$ => action$.pipe(ofType('PING'), delay(1000), mapTo({ type: 'PONG' }))

Action<Type, Payload, Meta>

A type that creates Flux-standard compliant action.

AnyAction

(Action<string> ).

ActionType<T>

A type that infers action from (ActionCreator ) or (Reducer ).

DeepImmutable<T>

A type which gives any type as input and return corresponding deeply immutable data structure as output.

DeepImmutableObject<T>

A type which gives an object type as input and return corresponding deeply immutable data structure as output.

DeepImmutableMap<T>

A type which gives a Map type as input and return corresponding deeply immutable data structure as output.

DeepImmutableArray<T>

A type which gives an Array type as input and return corresponding **deeply immutable data structure as output.

Immutable<T>

A type which gives any type as input and return corresponding shallowly immutable data structure as output.