Get support for Djeg/ramduck-redux
If you're new to LTH, please see our FAQ for more information on what it is we do.
Support Options
Unfortunately, there are currently no active helpers for this repository on the platform. Until they become available, we reccomend the following actions:
View Open IssuesTake a look to see if anyone else has experienced the same issue as you and if they managed to solve it.
Open an IssueMake sure to read any relevant guidelines for opening issues on this repo before posting a new issue.
Sponsor directlyCheck out the page and see if there are any options to sponsor this project or it's developers directly.
Djeg/ramduck-redux
Ramduck Redux
Tired of creating reducers that aren't curried. Interested in partial application with Ramdajs ?
This little project brings the power of curry and composition (thanks to Ramda) into your redux project.
Previously
// reducer/user.js
export const INITIAL_STATE = {
name: '',
email: '',
};
// Actions types
export const CHANGE_NAME = 'change user name';
export const CHANGE_EMAIL = 'change user email';
export const CHANGE_USER = 'change user';
// Actions creator
export const changeName = name => ({ type: CHANGE_NAME, name });
export const changeEmail = email => ({ type: CHANGE_EMAIL, email });
export const changeUser = (name, email) => ({ type: CHANGE_USER, name, email });
// Reducer:
export default function (state = INITIAL_STATE, action) {
switch(action.type) {
case CHANGE_NAME:
return {
...state,
name: action.name,
};
case CHANGE_EMAIL:
return {
...state,
email: action.email,
};
case CHANGE_USER:
return {
...state,
name: action.name,
email: action.email,
};
default:
return state;
}
}
With Ramduck Redux
// reducer/user.js
import { action1, action2, createReducer, init, when, mergeAction } from 'ramduck-redux'
import { objOf, always, evolve, o, merge } from 'ramda'
export const initialState = {
name: '',
email: '',
};
// Actions creator
export const changeName = action1('change user name', name => { name });
// with obj of
export const changeEmail = action1('change user email', objOf('email'));
// with 2 arguments
export const changeUser = action2('change user', name => email => ({ name, email }))
// no need of action type, use your function as a string in order
// to retrieve the type:
// `${changeName}` === 'change user name'
// Reducer:
export default createReducer('user', [ // you must name it (handy with ramduck-react-redux)
init(initialState),
when(changeName, ({ name }) => state => ({
...state,
name,
})),
// with evolve:
when(changeEmail, ({ email }) => evolve({
email: always(email),
})),
// with omit, merge and composition:
when(changeUser, ({ name, email }) => state => ({
..state,
name,
email,
})),
// or with mergeAction (same behavior, it merge the action payload by removing
// the type properties):
// when(changeUser, mergeAction),
])
// In your main state file: reducer/index.js
import User from './user'
import { createRootReducer } from 'ramduck-redux'
// you can combine
// your reducers easily with:
const rootReducer = createRootReducer([ User ])
// your state will take the reducer name declare above and put it into a global
// state object of the shape:
// { user: <the user state> }
Installation
With npm:
npm i --save ramduck-redux
Or with yarn:
yarn add ramduck-redux
Usage
Actions
You can easily create curried action creator with
the function action, action1, action2, action3, action4, actionN
:
import { action, action1, action2, action3, action4 } from 'ramduck-redux'
import { objOf } from 'ramda'
// action with no parameter, only a type
const initialize = action('INITIALIZE');
// action with 1 parameter
const changeName = action1('CHANGE_NAME', objOf('name'))
// action with 2 parameter
const changeUser = action2('CHANGE_USER', name => email => ({ name, email }))
// same thing for action2, action3, action4 :)
// you can also create actions of N arguments with actionN
// const veryHugeAction = actionN(8, 'some type', a => b => c => e => f => g => h => i => ...)
// and then:
myAction() // { type: 'MY_TYPE' }
changeName('John') // { type: 'CHANGE_NAME', name: 'John' }
changeUser('John', 'john@mail.com') // { type: 'CHANGE_USER', name: 'John', email: 'john@mail.com' }
// action creators are curried:
const changeJohnEmail = changeUser('John'); // [Function]
const action = changeJohnEmail('john@doe.com'); // { type: 'CHANGE_USER', name: 'John', email: 'john@mail.com' }
// no need of action types. You can access to the type be converting your
// action creator to string
`${changeUser}` === 'CHANGE_USER' // true
Reducer
You can create reducers much more easily with combine, init, when
:
import { createReducer, createRootReducer, init, when } from 'ramduck-redux'
const simpleReducer = init({ name: 'John' });
simpleReducer(null, { type: 'some action' }); // { name: 'John' }
simpleReducer({ name: 'Jane' }, { type: 'some action' }); // { name: 'Jane' }
const changeNameReducer = when(
'changeName',
action => state => ({
...state,
name: action.name,
})
)
changeNameReducer({}, { type: 'changeName', name: 'john' }); // { name: 'john' }
// you can easily combine those methods to create much more complex
// reducers:
const reducer = createReducer('myReducerName', [
init(myInitialState),
when('SOME_TYPE', someTypeReducer),
when('SOME_OTHER_TYPE', someOtherTypeReducer),
when(['A', 'B'], somePluralActionReducer),
])
API Reference
data EmptyAction ::
{ type :: String
}
data Action a ::
{ type :: String
| a
}
--| Actions helpers
action :: String -> () -> EmptyAction
actionN :: Number -> String -> (* -> a) -> * -> Action a
action1 :: String -> (a -> b) -> a -> Action b
action2 :: String -> (a -> b -> c) -> a -> b -> Action c
action3 :: String -> (a -> b -> c -> d) -> a -> b -> c -> Action d
action4 :: String -> (a -> b -> c -> d -> e) -> a -> b -> c -> d -> Action e
mergeAction :: Action a -> Object b -> Action { | a | b }
--| Reducers helpers
init :: a -> (Action b, a) -> a
whenAction :: String -> (Action a -> b -> b) -> (b, Action a) -> b
whenActions :: [String] -> (Action a -> b -> b) -> (b, Action a) -> b
when :: String|[String] -> (Action a -> b -> b) -> (b, Action a) -> b
createReducer :: String -> [((b -> Action a) -> b)] -> b -> Action a -> b
createRootReducer :: [((b -> Action a) -> b)] -> b -> Action a -> b
Our Mission
We want to make open source more sustainable. The entire platform was born from this and everything we do is in aid of this.
From the Blog
Interesting Articles
-
Generating income from open source
Jun 23 • 8 min read
-
2023 State of OSS
Apr 23 • 45 min read ★
-
A funding experiment...
Aug 19 • 10 min read
-
But You Said I could
Aug 19 • 2 min read
Thank you for checking out LiveTechHelper |
2025 © lth-dev incorporated
p-e622a1a2