Last year @yangmillstheory and I have jumped on this library to maintain and improve it, but since then, our activity has lowered due to other priorities or interests, so we don't work that much on this project anymore like we did in the past.

• Currently we have several open issues and pull requests which need to be handled.
• A new major version could be released that rewrites and improves the library and adds types for Flowtype and Typescript.

It would be great if we can find 2-3 new maintainers. If you are interested in maintaining this library, don't hesitate and give us a sign in this issue. You should also be able to work independently and with others as well. Of course @yangmillstheory and I will try to help as much as possible when needed.

The goal here is to improve documentation. Both the documentation and the user experience around that documentation require changes.

• [x] Use gitbook to keep documentation style consistent across redux projects (redux and redux-saga)
• [x] Add TOCs
• [x] Make the docs less long and unruly
• [x] Close #172 documentation issue
• [x] Close #204 documentation issue
• [x] Add a Beginner Tutorial with Demo and Installation instructions
• [x] Use js.org so that people can access the docs via redux-actions.js.org

New Documentation Demo

Allow the user to create a map of standard actions from a actionType map

example:

file: constants/actionTypes.js

export const MY_FIRST_ACTION_TYPE = 'MY_FIRST_ACTION_TYPE'
export const MY_SECOND_ACTION_TYPE = 'MY_SECOND_ACTION_TYPE'

file: actions/index.js

import { createActions } from 'redux-actions'
import * as actionTypes from '../constants/actionTypes'

const actionCreators = createActions(actionTypes)
// { myFirstActionType: createAction('MY_FIRST_ACTION_TYPE'),  
//   mySecondActionType: createAction('MY_SECOND_ACTION_TYPE'),  }

export default actionCreators

cc @acdlite

Noticed this spec of FSA wasn't yet implemented, and there's an issue for it.

This sets action.error to true if the payload is a direct instance of Error. This is the faintest touch of magic, but if it's documented, it makes sense.

Also fixes a possible error where we're trying to set action.meta even though action is a const.

r? @acdlite

If I wrap a reducer in handleAction I get this error:

"Reducer "selectedReddit" returned undefined during initialization. If the state passed to the reducer is undefined, you must explicitly return the initial state. The initial state may not be undefined."

If I debug I see redux tries to get a initial state by calling the wrapped reducer with undefined state and a specific system action type. Because the type does not match the wrapped one the inner reducer never runs and no state default is created.

If I use handleActions (m) with default state it works fine. Same function with default state in arguments and classic action-type check is also fine.

Anyway,is handleAction usable like this? Readme doesn't really specifiy use case.

@yangmillstheory this might be redundant or overkill so feel free to close - but it might be helpful to folks like me to see a more descriptive error when we forget the action type (with the helpful suggestion to use creatAction or createAction(s))

~~I also took the liberty of adding an .editorconfig and ignoring the JetBrains .idea folder. And removing Node 5 from testing since it's past it's useful life. If any of these bother you I can quickly rebase this and take those changes out.~~

Resolves #145.

Say you want to make a method equal to createAction. Currently this doesn't work very well because this isn't accessible from the payloadCreator or metaCreator.

A simple change will make this work.

First change actionHandler from a lamba to a normal function so it takes on the this of the Class it is assigned to.

Second, bind this to payloadCreator and metaCreator before they are called.

With v1.0.0 we are releasing our first version that comes with breaking changes:

Breaking Changes:

• [x] #115: Only omit payload if undefined
• [x] #127: Make defaultState required when creating reducers
• [x] #145: Fail early for non-FSA actions

A feature request here.

I have a reducer which have cross-cutting concerns, basically an action logger which puts log lines in the store based on different kinds of actions. This logger needs to know about a broader part of the state than the list of log statements its reducing. By sequencing the reducers in the root reducer, the log reducer can get for example the previous and next version of the state and log accordingly.

Having a root reducer similar to the following (using Immutable containers):

export default (state = new Immutable.Map(), action) => (
  state
    .update('someState', s => someState(s, action))
    .update(next => next.update('log', l => log(l, action, state, next)))
);

I'd optimally want to do the following:

const logInitialState = new Immutable.List();
const log = handleActions({
  // Direct logging action
  [logAppend]: (state, action) => state.push(Immutable.fromJS(action.payload)),

  // React to some other non-logging related action, notice the extra args
  [someAction]: (state, action, prev, next) => {
    const value = next.get('someState');
    if (value === prev.get('someState')) return state;
    return state.push(Immutable.fromJS({
      type: 'someAction',
      message: 'someAction happened',
    }));
  },
}, logInitialState);

But since handleActions does not relay the extra arguments, I'm forced to generate the reducers each time and close around the extra arguments like so:

const logInitialState = new Immutable.List();
const log = (state, action, prev, next) => handleActions({
  // Direct logging action
  [logAppend]: () => state.push(Immutable.fromJS(action.payload)),

  // React to some other non-logging related action
  [someAction]: () => {
    const value = next.get('someState');
    if (value === prev.get('someState')) return state;
    return state.push(Immutable.fromJS({
      type: 'someAction',
      message: 'someAction happened',
    }));
  },
}, logInitialState)(state, action);

This is both extra verbose and inefficient. It would be great if both handleAction and handleActions returns reducers that fetch a rest spread and passes it on. I guess reduce-reducers needs to know about this as well.

Something like the following would probably do:

export default function handleActions(handlers, defaultState) {
  // snip
  return (state = defaultState, action, ...args) => reducer(state, action, ...args);
}

The ideas for createActions were discussed in https://github.com/acdlite/redux-actions/pull/83 so this is a result of the discussions in that PR. The ideas had diverged a bit from the original authors work so I started with a fresh slate to implement the functionality.

Basically this is a partner to createAction like handleActions is to handleAction.

It cleans up the code and eliminates a bit of redundant typing that also could be a source of errors.

One change from that #83 was that I went with an array for specifying default actions rather than having a variable set of arguments in the middle of the function. I don't know that typescript can handle that and I wanted the ability to pass an optionMap at the end that might be used to tweak the process. For instance, by passing in a { prefix: 'foo/' } then the createActions will automatically prefix they types with 'foo/'. I can imagine there may be other options that tweak how actions are created so it is nice to have a mechanism in the api to support extensions.

Here is the documentation from the readme with some examples:

createActions(?actionMap, ?arrayDefTypes, ?optionMap)

Create multiple actions and return an object mapping from the type to the actionCreator. This eliminates some of the repetitiveness when creating many actions.

If actionMap is provided as first argument, an action will be created for each item in the map. The key will be used for the type. The value will be treated as follows:

• if value is a function then it will be assumed to be the payloadCreator function
• if value is an object then it will accept as its keys, payload and meta, both of which are functions that will serve as the payloadCreator and/or metaCreator. If payloadCreator is missing the default payloadCreator is used. If metaCreator is missing then it will not use one.
• otherwise create a default actionCreator for the key type

If an array of string is provided as arrayDefTypes it will be used to create default actionCreators using the string for the action type.

If an optionMap object is supplied as last argument then it will adjust the options createActions uses in operation:

• prefix - string, prefix all action types with this prefix, default ''

Example: simple default actions

import { createActions } from 'redux-actions';
const a = createActions(['ONE', 'TWO', 'THREE']);

// is equivalent to
const a = {
  ONE: createAction('ONE'),
  TWO: createAction('TWO'),
  THREE: createAction('THREE')
;}

Example: simple default actions with prefix

import { createActions } from 'redux-actions';
const a = createActions(['ONE', 'TWO', 'THREE'], { prefix: 'ns/');

// is equivalent to
const a = {
  ONE: createAction('ns/ONE'),
  TWO: createAction('ns/TWO'),
  THREE: createAction('ns/THREE')
;}

Example: using actionMap

import { createActions } from 'redux-actions';
const a = createActions({
  ONE: (b, c) => ({ bar: b, cat: c }),  // payload creator
  TWO: {
    payload: (d, e) => [d, e]            // payload creator
    meta: (d, e) => ({ time: Date.now() }) // meta creator
  },
  THREE: {
    meta: f => ({ id: shortid() })
  }
});


// is equivalent to
const a = {
  ONE: createAction('ONE', (b, c) => ({ bar: b, cat: c })),
  TWO: createAction('TWO',
                    (d, e) => [d, e],
                    (d, e) => ({ time: Date.now() })),
  THREE: createAction('THREE',
                      undefined,  // used default payload creator
                      f => ({ id: shortid() }))
});

Example full createActions functionality

import { createActions } from 'redux-actions';
const a = createActions(
  {
    ONE: (b, c) => ({ bar: b, cat: c }),  // payload creator
    TWO: {
      payload: (d, e) => [d, e]            // payload creator
      meta: (d, e) => ({ time: Date.now() }) // meta creator
    },
    THREE: {
      meta: f => ({ id: shortid() })
    }
  }, [ // arrayDefTypes creates defaultActions
    'FOUR',
    'FIVE',
    'SIX'
  ], {  // options
    prefix: 'ns/'
  }
);

// is equivalent to
const a = {
  ONE: createAction('ns/ONE', (b, c) => ({ bar: b, cat: c })),
  TWO: createAction('ns/TWO',
                    (d, e) => [d, e],
                    (d, e) => ({ time: Date.now() })),
  THREE: createAction('ns/THREE',
                      undefined,  // used default payload creator
                      f => ({ id: shortid() })),
  FOUR: createAction('ns/FOUR'),
  FIVE: createAction('ns/FIVE'),
  SIX: createAction('ns/SIX')
};

as mentioned in #87

• added minimal webpack config based on Redux Thunk
• support UMD build
• added note on README

I followed the same pattern in the Makefile, let me know if something else can be improved 😅

First of all I really love this package and it is one of the must have packages for every redux stack I'm working on <3 Since I'm moving most of my projects to Vite I had some troubles with peer dependencies in this project (invariant) so I made some adjustments to make it more ES friendly and internalised the dependency.

I also streamlined some build tooling and added some exports to the build process.

Hi👋 I currently use [email protected]. I want to upgrade the package to the latest version() while it performs differently to @2.6.5 as the way to camelCase. Their differences are shown as below: This confused me a lot. Please show me the way to fix it. Thx😄

Bumps qs from 6.5.2 to 6.5.3.

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.

Bumps decode-uri-component from 0.2.0 to 0.2.2.

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.

Bumps shell-quote from 1.6.1 to 1.7.3.

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.

Title should say jest not recognizing string template reducer.

I have my reducer defined as such (simplified from real world use case to maintain main point)

export const setItem = createAction('@common//setItem');
const reducer = handleActions(
    {
        [`${setItem}`]: (state, action: Action) =>
            !action.error ? action.payload : state,
       //other actions not shown
    },
    null,
);

This is a convenient way of reference the action type in sync with the defined action.

Problem is this seems to not work properly in jest. When defined this way the action is never triggered.

If I rewrite it to statically reference the action type

const reducer = handleActions(
    {
        [`@common/setItem`]: (state, action: Action) =>
            !action.error ? action.payload : state,
       //other actions not shown
    },
    null,
);

This executes properly.

Anyway have any idea how I might fix this?