@types/redux-actions

What is @types/redux-actions?

@types/redux-actions provides TypeScript definitions for the redux-actions library, which is used to create and handle actions in Redux applications more efficiently.

What are @types/redux-actions's main functionalities?

createAction

The createAction function allows you to create an action creator for a specific action type. In this example, an action creator for the 'INCREMENT' action type is created, which expects a payload of type number.

const increment = createAction<number>('INCREMENT');

handleAction

The handleAction function allows you to create a reducer for a specific action type. In this example, a reducer is created for the 'INCREMENT' action type, which increments the state by the action's payload.

const counter = handleAction<number, number>(increment, (state, action) => state + action.payload, 0);

combineActions

The combineActions function allows you to handle multiple action types with a single reducer. In this example, the reducer handles both 'INCREMENT' and 'RESET' action types, resetting the state to 0 when the 'RESET' action is dispatched.

const reset = createAction('RESET');
const counter = handleAction<number, number>(combineActions(increment, reset), (state, action) => action.type === 'RESET' ? 0 : state + action.payload, 0);

createActions

The createActions function allows you to create multiple action creators at once. In this example, action creators for 'INCREMENT' and 'DECREMENT' action types are created, both expecting a payload of type number.

const { increment, decrement } = createActions({
  INCREMENT: (amount: number) => amount,
  DECREMENT: (amount: number) => amount
});

handleActions

The handleActions function allows you to create a reducer that handles multiple action types. In this example, a reducer is created that handles both 'INCREMENT' and 'DECREMENT' action types, incrementing or decrementing the state by the action's payload.

const counter = handleActions<number>({
  [increment.toString()]: (state, action) => state + action.payload,
  [decrement.toString()]: (state, action) => state - action.payload
}, 0);

Other packages similar to @types/redux-actions

@types/redux

@types/redux provides TypeScript definitions for the redux library. It is more general than @types/redux-actions and does not include utilities for creating and handling actions, but it provides type definitions for the core Redux functionalities like createStore, combineReducers, and applyMiddleware.

@types/redux-thunk

@types/redux-thunk provides TypeScript definitions for the redux-thunk middleware, which allows you to write action creators that return a function instead of an action. It is useful for handling asynchronous actions in Redux applications, but it does not provide the same action creation and handling utilities as @types/redux-actions.

@types/redux-saga

@types/redux-saga provides TypeScript definitions for the redux-saga library, which is used to manage side effects in Redux applications. It offers a different approach to handling asynchronous actions compared to redux-thunk and does not include the action creation and handling utilities provided by @types/redux-actions.

README

Installation

npm install --save @types/redux-actions

Summary

This package contains type definitions for redux-actions v0.8.0 (https://github.com/acdlite/redux-actions).

Details

Files were exported from https://www.github.com/DefinitelyTyped/DefinitelyTyped/tree/types-2.0/redux-actions

Additional Details

• Last updated: Fri, 08 Jul 2016 19:22:06 GMT
• File structure: ProperModule
• Library Dependencies: none
• Module Dependencies: none
• Global values: ReduxActions

Credits

These definitions were written by Jack Hsu https://github.com/jaysoo.