reducers.md

Reducers

Reducer Utilities

• multireducer
  https://github.com/erikras/multireducer
  A utility to wrap many copies of a single Redux reducer into a single key-based reducer.

• reduce-reducers
  https://github.com/acdlite/reduce-reducers
  Reduce multiple reducers into a single reducer from left to right.

• redux-delegator
  https://github.com/lapanoid/redux-delegator
  Compose reducers in a structured way

• create-reducer
  https://github.com/nrn/create-reducer
  Create a redux reducer from an object of action handling functions, keyed by the actions they handle. Has createReducer.compose(fns) helper function to combine multiple action handlers into a single action.

• reduxr-obj-reducer
  https://github.com/chrisdavies/reduxr-obj-reducer
  A utility to create Redux reducers from simple objects.

• reduxr-scoped-reducer
  https://github.com/chrisdavies/reduxr-scoped-reducer
  A utility to create Redux reducers which only respond to prefixed actions.

• reducer-chain
  https://github.com/bydooweedoo/reducer-chain
  reducer-chain helps you to chain redux reducers with given state and action, then keep last updated state.

• reducer-pipe
  https://github.com/bydooweedoo/reducer-pipe
  reducer-pipe helps you to pipe redux reducers with given state and action, passing previously returned state to next reducer, then keep last updated state.

• reducer-sandbox
  https://github.com/bydooweedoo/reducer-sandbox
  reducer-sandbox helps you to reuse your redux reducers in different place without conflict them.

• redux-create-reducer
  https://github.com/kolodny/redux-create-reducer
  Publishing createReducer from Redux's Reducing Boilerplate page.

• redux-action-reducer
  https://github.com/troch/redux-action-reducer
  Remove redux reducer boilerplate

• Redux Reducer
  https://github.com/chetanism/redux-reducer
  This library is intended to provide a little more object-oriented approach to write reducers. All it does is provide Reducer and CombineReducers classes to get rid of switch-case. Additionally it also lets you modify reducers dynamically.

• redux-reducer
  https://github.com/nathanial/redux-reducer
  A small library for writing redux actions with less boilerplate using classes.

• redux-switch-action
  https://github.com/qwtel/redux-switch-action
  Slightly more concise reducer switching for Flux Standard Actions.

• make-reducer
  https://github.com/reactbits/make-reducer
  Functions to easily build redux reducers without boilerplate code.

• ReduMan
  https://github.com/ajlopez/ReduMan
  Reducer manager, it can be used as a replace for switch in Redux reducers

• create-redux-reducer-from-map
  https://github.com/TehShrike/create-redux-reducer-from-map
  A personal preference for building reducers for Redux.

• redux-polymorphic
  https://github.com/yesmeck/redux-polymorphic
  Another attempt to reuse your reducers, inspired from multireducer

• combined-reduction
  https://github.com/convoyinc/combined-reduction
  Like Redux's combineReducers, but more better! Allows definition of nested reducers and multiple top-level reducers.

• redux-reducer-delegate
  https://github.com/wmira/redux-reducer-delegate
  Create a reducer by delegating types to sub reducers. A way to create reducers by composing sub-reducers. This prevent the switch statements.

• redux-blower
  https://github.com/JiriChara/redux-blower
  Faster and nicer reducers for your Redux applications. Say "NO!" to switch statements!

• redux-modifiers
  https://github.com/calvinfroedge/redux-modifiers
  A collection of generic functions on top of ImmutableJS and Redux Actions for simplifying your reducers. Declare your reducers and state as plain old javascript objects, but take advantage of Immutable guarantees and data structure traversal utilities.

• redux-commons
  https://github.com/KodersLab/redux-commons
  Easily create common reducers by just composing functions

• redux-frr
  https://github.com/e-jigsaw/redux-frr
  Redux Filter and Reduce Reducers.

• Simr
  https://github.com/dalexj/simr
  A library for reducing common functionality in Redux reducers

• fineCombine
  https://github.com/pcarden/fine-combine
  Combines reducer collections, even when they have duplicate keys.

• reduxerit
  https://github.com/jurgob/reduxerit
  reduxerit is strongly influenced from redux-modifiers (https://github.com/calvinfroedge/redux-modifiers), It tries to simplify writing the redux reducer, but without using immutablejs.

• combineSectionReducers
  https://github.com/ryo33/combine-section-reducers
  Section reducers is the same as reducers but it requires the third argument to get the entire state. (sectionState, action, state) => newSectionState

• combineCrossSliceReducers
  https://github.com/visusnet/combine-cross-slice-reducers
  Similar to combineSectionReducers but introduces stages which gives lower-ranking reducers access to the global state that results from higher-ranking reducers.

• Redux Conditional
  https://github.com/ypxing/redux-conditional
  Conditionally apply actions to Redux reducers to make sharing reducers easy.

• redux-concatenate-reducers
  https://github.com/ryo33/redux-concatenate-reducers
  Concatenates reducers and merges states returned by them.

• create-reducer-redux
  https://github.com/johnnyji/create-reducer-redux
  Create simple and functional reducers that can listen to multiple action creators.

• redux-tk
  https://github.com/geowarin/redux-tk
  Utility functions for generating reducers.

• better-combine-reducers
  https://github.com/shinout/better-combine-reducers
  Better redux combineReducers, initial state injectable.

• redux-callback-reducer
  https://github.com/soofty/redux-callback-reducer
  redux-callback-reducer allows any function or class method to make a reducer for your state, without adding any additional actions.

• redux-curried-reducers
  https://github.com/rvikmanis/redux-curried-reducers
  Curried reducer utilities for Redux - create reducers declaratively via function composition. Works really well with functional utilities like lodash-fp and Ramda.

• redux-reducers-hub
  https://github.com/apentle/redux-reducers-hub
  Flexible Redux Reducers

• redux-sword
  https://github.com/somewind/redux-sword
  Redux-Sword is a tool for Redux Reducer, which can make it automatically processed, so you can code less with it.

• redux-reducers
  https://github.com/casparrolfe/redux-reducers
  Unobtrusive reusable redux reducers. Wraps reducers and actions with prefixes for reusability.

• redux-definer
  https://github.com/vvgomes/redux-definer
  A tiny utility to handle lookup tables of reducers in an FP style

• redux-ramda
  https://github.com/davidgtonge/redux-ramda
  Construct reducers using an array of predicate/reducer pairs

• create-reducer-map
  https://github.com/stefanmirck/create-reducers
  A tiny utility to create reducer maps for Redux that follows the principles of Flux Standard Actions

• Redux Compose Reducer
  https://github.com/kimrgrey/redux-compose-reducer
  Reducer composer for Redux. This library simplifies workflow for building namespaced actions and reducers for them in Redux.

• redux-state-mapper
  https://github.com/HikaruYasuda/redux-state-mapper
  Define reducers using a builder pattern instead of switch statements.

• redux-arg
  https://github.com/TheComfyChair/redux-arg
  Redux automated reducer generator

• redux-common-reducers
  https://github.com/try-again-apps/redux-common-reducers
  Prebuilt reducers for types like booleans and strings

• redux-resolver
  https://github.com/sslotsky/redux-resolver
  Love Redux but hate switch statements? ReduxResolver provides functions that allow you to write your reducers as dictionaries.

• reswitch
  https://github.com/chiefGui/reswitch
  A small utility to help write reducers without switch statements.

• redux-unitary-reducer
  https://github.com/rotaryden/redux-unitary-reducer
  Implements a reducers aggregator for Redux, where we have only one root reducer with additional management sugar, and simpler sub-handlers for action types. Aimed to be faster alternative then redux.combineReducers()

• redux-leaf
  https://github.com/awayisblue/redux-shape
  A simple util for generating redux action & reducer by a state shape definition.

• redux-merge-reducers
  https://github.com/kuy/redux-merge-reducers
  A utility to chain reducers instead of combining them by slice. Similar to reduce-reducers, but takes initial state into account.

• rezz
  https://github.com/EugeneZ/rezz
  Composable, chainable reducer toolkit for redux

• flat-combine-reducers
  https://github.com/SanCoder-Q/flat-combine-reducers
  Turns multiple reducer functions, into a single reducer function, with the support of declaring the initial states as default parameters.

• reducer-matching
  https://github.com/IsTheJack/reducer-matching
  A functional redux util to replace the switch case statement.

• redux-tree
  https://github.com/shakacode/redux-tree
  An alternate way to combine Redux reducers, by specifying "branches" and "leaves", then declaring all updates that should apply across the tree for a given action.

• combine-nested-reducers
  https://github.com/rohozhnikoff/combine-nested-reducers
  The original combineReducers from redux, with the ability to create deep scheme of reducers

• action-u
  https://github.com/KevinAst/action-u
  Several redux reducer composition utilities, which blend multiple reducers together forming a richer abstraction through functional decomposition (i.e. higher-order functions).

• redux-scoped-reducer
  https://github.com/ganemone/redux-scoped-reducer
  A small library for creating reducers scoped to a certain part of state.

• redux-reducer-dsl
  https://github.com/ryanaghdam/redux-reducer-dsl
  Define Redux reducers with a doman-specific language.

• mixn
  https://github.com/jeremija/mixn
  Mixes reducers in order. Allows easy extension of redux reducer functions. Tries each one until the state changes

• reducio
  https://github.com/asn007/reducio
  Functional reducers for everybody

• redux-dynamics
  https://github.com/kettanaito/redux-dynamics
  A createReducer utility that simplifies declaration of initialState, helps inforce immutability, and scopes variables and logic.

• redux-composers
  https://github.com/shoutem/redux-composers
  Introduces additional reducer composers besides combineReducers from redux, which enable to compose hierarchy in different ways. Includes 3 additional composer reducers: chainReducers, mergeReducers and mapReducers.

• redux-pipe
  https://github.com/giftofjehovah/redux-pipe
  Utilities for running reducers in a sequence and branching based on a predicate.

• reducer-redux
  https://github.com/b-gran/reducer-redux
  A Ramda-based utility for reducers based on an object tree to define the shape of the state

• redux-strategic-reducer
  https://github.com/davidjbeveridge/redux-strategic-reducer
  Another lookup-table reducer builder, with built-in "set" and "clear" handlers

• recombine
  https://github.com/aikoven/recombine
  Utilities for combining Redux reducers, including a combineReducers alternative with extra arguments, and reducers that manage key-value dictionaries.

• redux-dependent-reducers
  https://github.com/shura-v/redux-dependent-reducers
  Combine reducers dependent on evaluation order

• typescript-fsa-reducers
  https://github.com/dphilipson/typescript-fsa-reducers
  Fluent syntax for defining typesafe reducers on top of typescript-fsa.

• redux-reducers
  https://github.com/casparrolfe/redux-reducers
  Unobtrusive Redux utils for composing reducers and targeting them based on an ID.

• redux-ramda-reducer
  https://github.com/kudorori/redux-ramda-reducer
  Assorted utilities for creating reducer functions using Ramda

• redux-reducer-async
  https://github.com/AndersDJohnson/redux-reducer-async
  Create redux reducers for async behaviors of multiple actions.

• redeuceur
  https://github.com/maxhallinan/redeuceur
  A utility for creating terse Redux reducers.

• redux-autoreducers
  https://github.com/oxyno-zeta/redux-autoreducers
  Utilities for generating reducers that handle async progress actions.

• redux-dependent-reducers
  https://github.com/shura-v/redux-dependent-reducers
  Combine reducers dependent on evaluation order

• redux-reducers
  https://github.com/zimmed/redux-reducers
  Utility library for modular redux reducers.

• redux-reducer-toolkit
  https://github.com/RocketPuppy/redux-reducer-toolkit
  This library implements several functions that are useful for combining, composing, and altering reducers. Each of this functions returns a memoized reducer, similar to reselect, so data isn't re-computed unnecessarily. The inspiration for this library was fantasyland-redux, only instead of basing it off of the fantasyland specification it is based off of the static-land specification. This made it simple to build this as a library instead of pinning it to a specific redux version.

• vitruvius
  https://github.com/americanexpress/vitruvius
  Vitruvius extends redux's combineReducers to allow developers to include a buildInitialState method on their reducer. This allows for the passing of locals to build the initial state that wouldn't normally be available to a reducer when setting its initial state. For instance, one could pass some data from the request object.

• redux-chains
  https://github.com/hector-del-rio/redux-chains
  Nested reducers made easy. A small helper function that allows you to call several reducers in chain and keep the state object reference intact if the state is not modified by any of them.

• Redux-standard-reducer
  https://github.com/magicdawn/redux-standard-reducer
  A redux reducer for standard actions that just need to merge data to state

• redux-keto
  https://github.com/Airbitz/redux-keto
  A tool for building "fat reducers", which take an extra props argument in addition to the normal state and action arguments. Fat reducers use this extra parameter to pass values between each other in a fully-reactive, auto-updating way.

• redux-creators
  https://github.com/MattHsiung/redux-creators
  An opinionated set of helpers for defining reducers via lookup tables

• redux-describe
  https://github.com/jspengeman/redux-describe
  A boilerplate free way to build self documenting reducers with a simple API, using the builder pattern

• redux-create-fsa-reducer
  https://github.com/jurca/redux-create-fsa-reducer
  Redux reducer factory that is designed for use with Flux Standard Actions (FSA)

• composite-tree-reducer
  https://github.com/wdjunaidi/composite-tree-reducer
  Simple composite tree reducer which allow custom root level reducer along with regular combinedReducers from redux.

• redux-nestprops-reducer
  https://github.com/sndyuk/redux-nestprops-reducer
  Simplifies reducer logic by allowing you to specify a reducer to handle an individual piece of nested state, and callbacks to look up which piece of the state it should apply to.

• dumb-reducer
  https://github.com/quentinvernot/dumb-reducer
  A reducer factory function that creates redux action handlers for any action beginning with a set prefix, these handlers will simply put the action payloads into the state.

• redux-recompose
  https://github.com/Wolox/redux-recompose
  A Redux utility belt for reducers and actions. Inspired by acdlite/recompose.

• redux-exr
  https://github.com/paska27/redux-exr
  A set of combineReducers alternatives that allow specifying dependencies between branches.

• redux-combiner
  https://github.com/rmdm/redux-combiner
  Convenient reducers combiner for Redux.

• redux-reducer-functions
  https://github.com/vitsy/redux-reducer-functions
  A reducer combination utility that uses function names as action names

• redux-split-reducer
  https://github.com/jbradle/redux-split-reducer
  Library for more redux friendly configuration of reducers, based on Ramda. It allows splitting reducers on the same state branch.

Higher-Order Reducers

Related topics: Use Cases - Undo-Redo

• redux-ignore
  https://github.com/omnidan/redux-ignore
  Higher-order reducer to ignore redux actions

• redux-recycle
  https://github.com/omnidan/redux-recycle
  Higher-order reducer to reset the redux state on certain actions

• redux-optimist
  https://github.com/ForbesLindesay/redux-optimist
  Optimistically apply actions that can be later commited or reverted.

• redux-optimistic-ui
  https://github.com/mattkrick/redux-optimistic-ui
  A reducer enhancer to enable type-agnostic optimistic updates

• redux-cache
  https://github.com/simplesmiler/redux-cache
  Higher order cache reducer

• redux-multiplex
  https://github.com/reducks/redux-multiplex
  Provides a higher-order reducer for managing multiple instances of the same redux state subtree.

• redux-meta-reducer
  https://github.com/DerekCuevas/redux-meta-reducer
  A redux higher order reducer to simplify the state of fetched data.

• Indexed List Reducer Generator
  https://gist.github.com/elado/95484b754f31fcd6846c7e75de4aafe4
  A high-order-reducer that manages dynamic indexed lists (by ID)

• redux-reset
  https://github.com/abhiaiyer91/redux-reset
  Higher Order Reducer for resetting multiple parts of your state tree

• path-reducer
  https://github.com/appfeel/path-reducer
  This is a reducer function to modify the app state via path (100% compatible with redux). At this development stage, it only works with immutable-js state objects.

• initializable-reducer
  https://github.com/oreshinya/initializable-reducer
  Initializing reducers action and associated higher order reducer for redux.

• Redux-Queue
  https://github.com/JBlaak/Redux-Queue
  Higher order reducer to easily cope with async actions.

• redux-schema-sanitizing-reducer
  https://github.com/kjessec/redux-schema-sanitizing-reducer
  Returns a reducer that immutably sanitizes input state. Easily composable with your existing reducer.

• redux-reset-reducer
  https://github.com/CyberInt/redux-reset-reducer
  Higher-order Redux reducer which resets state to original reducer's initial state

• redux-reuse
  https://github.com/CyberInt/redux-reuse
  Helper utility to create higher-order reducers to reuse your action handlers in existing Redux reducers

• redux-payload
  https://github.com/CyberInt/redux-payload
  Higher-order Redux reducer which returns payload for specific actions

• redux-map-state
  https://github.com/CyberInt/redux-map-state
  Higher-order Redux reducer which helps apply your existent reducers on any format of state

• redux-pipeline
  https://github.com/gtg092x/redux-pipeline
  Redux Pipeline combines reducers into a single, manageable sequence.

• redux-composers
  https://github.com/shoutem/redux-composers
  Utilities to combine reducers in various ways beyond combineReducers, including chaining, merging, and mapping.

• redux-higher-order
  https://github.com/brianneisler/redux-higher-orders
  Redux enhancer for composing higher order reducers. Wrap the reducer with functionality ensuring that the higher order reducers run before the primary reducer.

• redux-rereducers
  https://github.com/brianneisler/redux-rereducers
  A higher order reducer for performing state calculations after the initial reduction has completed.

• higher-order-reducers
  https://github.com/Nehle/higher-order-reducers
  A simple utility belt library for building and composing redux reducers using higher order functions.

• redux-compose-hors
  https://github.com/l2silver/redux-compose-hors
  Compose higher-order-reducers in the correct order, with nesting.

• redux-xforms
  https://github.com/mhelmer/redux-xforms
  redux-xforms is a collection of reducer transformers (higher-order reducers). They can be used to define reducers by direct composition of simpler transformers. Much like the Recompose library, but for reducers instead of React components.

• radhoc
  https://github.com/kyleshevlin/radhoc
  Radhoc is a higher-order reducer. It listens for a particular action.type and then returns the next state (more details below). If the action.type is anything else, it simply returns the reducer it takes as an argument, passing state and action to it.

• redux-buffered-reducer
  https://github.com/bspaulding/redux-buffered-reducer
  A simple reducer enhancer to buffer changes

• initializable-reducer
  https://github.com/oreshinya/initializable-reducer
  Initializing reducers action and associated higher order reducer for redux.

• horux
  https://github.com/Nehle/horux
  A simple utility belt library for building and composing redux reducers using higher order functions.

• reducer-redux
  https://github.com/b-gran/reducer-redux
  Create functional, reusable redux reducers. Liberate yourself from switch. Composable: reducers are just plain functions. Nest and compose them with other reducers and libraries. Reusable: designed for redux but flexible enough to use elsewhere. Create building blocks and reuse them. Powerful: comes with a utility belt for working with redux actions.

• dextrous
  https://github.com/aakashns/dextrous
  A tiny library with utilities for Redux reducer composition.

• redux-reorder
  https://github.com/nonnontrivial/redux-reorder
  Higher-order reducer that tracks order fluctuation within iterable state. Appends a given reducer with a representation of how its new order has changed from a previous order.

• redux-reset-state
  https://github.com/cadleo/redux-reset-state
  A redux plugin to reset the redux state you specify

Prebuilt Use Case Reducers

• redux-data-structures
  https://github.com/adrienjt/redux-data-structures
  Redux Data Structures is a library of higher-order functions ("reducer makers"). Reducer makers help create common reducers like counters, maps, lists (queues, stacks), sets, etc. Most application states can be built by combining a handful of these standardized building blocks.

• common-reducers
  https://github.com/luispablo/common-reducers
  Prebuilt reducers for managing "applications", "messages", and JWT/"security"

• redux-reducer-maker
  https://github.com/grifo/redux-reducer-maker
  Prebuilt reducers for toggle values and request status

• redux-flag-reducer
  https://github.com/DannyDelott/redux-flag-reducer
  Create a reducer that returns true or false, "on" or "off", "loaded" or "loading", etc. Makes it convenient to implement flags as reducers in your redux state tree. This can be handy for tracking all kinds of things from toggle-based UIs to the loading/loaded state of an external resource.

• redux-diet
  https://github.com/AlexMouton/redux-diet
  Simple pre-built reducers to handle updating objects, simple values, arrays, and request status

• easydux
  https://github.com/gtg092x/easydux
  Out of the box reducer creators for objects, arrays, and values, with customizable action types for triggering behavior.

Advanced Reducer Use Cases

• redux-operations
  https://github.com/mattkrick/redux-operations
  https://medium.com/@matt.krick/solving-redux-s-shortcoming-in-150-locs-540979ce6cf9
  https://medium.com/@matt.krick/introducing-redux-operations-332ab56e468b
  Adds additional logic to reducers to handle ordering of reducer handling, dynamic state creation, and display of reducer behavior in the Redux DevTools.

• redux-components
  https://github.com/wcjohnson/redux-components
  A component model for Redux state trees based on the React.js component model and other familiar design patterns from the React ecosystem. Allows creation of "reducer components" that can be dynamically added and removed, and targeted with scoped actions.

• redux-reducer-factory
  https://github.com/mclauia/redux-reducer-factory
  A configurable createReducer factory (i.e. it is a factory for making a createReducer function) that essentially allows projects to insert extra generic reducers (enhancers) before and after individual domain reducers are invoked, without muddying those individual domains.

• redux-reducers-meld
  https://github.com/mclauia/redux-reducer-meld
  A beforeReduce enhancer for use with redux-reducer-factory that can meld previous and initial state to flesh out default state of partial state hydration (for example, when persisting only specific parts of your state tree to local storage)

• redux-reset
  https://github.com/wwayne/redux-reset
  A store enhancer to allow resetting the state based on a specific action

• redux-list-reducer
  https://github.com/mattikl/redux-list-reducer
  redux-list-reducer is a factory function for creating Redux reducers that operate on lists.

• rereduce
  https://github.com/slorber/rereduce
  Simple reducer library for Redux. It's like Reselect but for reducers. By using aggressive memoization, reducers can depend on each others in an efficient way, without having to query Redux store. It works fine with time-travel debugging and server-side rendering, because reducers remains totally stateless pure functions. It permits to replace the imperative waitFor of original Flux implementation by a purely functional approach.

• redux-waitfor
  https://github.com/dtinth/redux-waitfor
  Reducer combinator that allows reducers to wait upon each other.

• topologically-combine-reducers
  https://github.com/KodersLab/topologically-combine-reducers
  A way to combine reducers by their dependencies and access at their ancestor's values.

• incremental-redux-reducers
  https://github.com/tazsingh/incremental-redux-reducers
  Incrementally load Redux reducers into a single store

• redux-register
  https://github.com/dexbol/redux-register
  An Redux enhancer for registering reducer by namespace

• reducify
  https://github.com/gtg092x/reducify
  Generate redux reducers with less effort

• redux-property-graph
  https://github.com/telepathtech/redux-property-graph
  Basic property graph for redux

• redux-reducer-factory
  https://github.com/mclauia/redux-reducer-factory
  https://github.com/mclauia/redux-reducer-meld
  A configurable createReducer factory for adding common reducer enhancers.

• redux-store-validator
  https://github.com/alixander/redux-store-validator
  Wrapper to add validation to your Redux reducers.

• redux-reducer-builder
  https://github.com/anyx/redux-reducer-builder
  A Redux root reducer builder exactly like combineReducers, but with opportunity to create root modules who have access to other modules

• redux-tween
  https://github.com/devgru/redux-tween
  Redux Tween provides a way to tween state in Redux store smoothly, interpolating states in between.

• reducer-generator
  https://github.com/Dash-OS/reducer-generator-array-map
  https://github.com/Dash-OS/reducer-generator-object-map
  https://github.com/Dash-OS/reducer-generator-wildcard
  Utilities to generate reducers based on arrays, objects, or wildcard action type matching

• redux-arrows
  https://github.com/foxnewsnetwork/redux-arrows
  Extension of redux reducers from basic functions to haskell arrows

• nested-reducer
  https://github.com/twop/nested-reducer
  Helper library to deal with deeply nested state in redux

• rewpa
  https://github.com/yi-bai/rewpa
  Redux REducers With json PAth

• redux-runtypes-schema
  https://github.com/mobify/redux-runtypes-schema
  Provides a reducer that enables full Redux store validation against a known schema defined using the runtypes library.

• redux-regeneration
  https://github.com/Phationmationion/redux-regeneration
  Utility to allow just returning the object structure representing a new state, rather than doing all the nested copying in your own code.

• redux-data-components
  https://github.com/pixellyte/redux-data-components
  Redux Data Components are React-like components that exist entirely within the Redux store. The components support lifecycle methods so that data events within the store can trigger subsequent actions without running afoul of the "don't dispatch while reducing" rule.

Dynamic Reducer Injection

• redux-react-dynamic-store
  https://github.com/kravchenkodev/redux-react-dynamic-store
  Allows to register reducers dynamically through react container components to help solve code-splitting and complex state in large applications.

• redux-injector
  https://github.com/randallknutson/redux-injector
  Allows dynamically injecting reducers into a redux store at runtime

• redux-injectable-reducer
  https://github.com/jomaxx/redux-injectable-reducer
  Redux store reducer capable of lazily injecting parts of the state tree. Useful for large single page applications that utilize bundle splitting.

• Paradux
  https://github.com/asteridux/paradux
  A small library to enable dynamic registering of reducers.

• redux-rack
  https://github.com/evanrs/redux-rack
  Treat Redux like a rack � mount reducers like components

• redux-inject-reducer-and-saga
  https://github.com/marcelmokos/redux-inject-reducer-and-saga
  Inject reducer and saga anywhere in the application after store initialization, inspired by react-boilerplate.

• redux-reducers-injector
  https://github.com/GuillaumeCisco/redux-reducers-injector
  https://github.com/GuillaumeCisco/redux-sagas-injector
  Allows dynamically injecting reducers into a redux store at runtime. Compatible with HMR and SSR.

• redux-async-injector
  https://github.com/webliving/redux-async-injector
  A store creation wrapper function that makes an injectReducer function available.

• redux-cake
  https://github.com/jmar777/redux-cake
  A store enhancer and small set of related APIs that facilitate the adding and removing of slices of state on the fly.

• redux-dynamic-reducer
  https://github.com/ioof-holdings/redux-dynamic-reducer
  Allows you to attach new reducer functions after the store is initialised. This is helpful if you want to use a single global store across a lazily loaded application where not all reducers are available at store creation. It also provides a convenience functionality that pairs with redux-subspace and allows combining a React component with a reducer that automatically attaches to the store when the component is mounted.

• redux-contexts
  https://github.com/Vinnovera/redux-contexts
  A utility for adding redux reducers with separated states during runtime. The library is forked from redux-injector and built upon multireducer.

• reedux
  https://github.com/Silviu-Marian/reedux
  Another implementation of dynamic reducer loading. Arguably the simplest solution, supports HMR, and only 70 lines of code.

• inducer
  https://github.com/tanhauhau/inducer
  Injects Redux reducers using a React Higher-Order Component

• react-component-chunk
  https://github.com/Droeftoeter/react-component-chunk
  Library for making dynamic imports easy, with added support to make dynamically loaded Redux Reducers and Redux-Saga Sagas easy.

• redux-extensible-store
  https://github.com/lundegaard/redux-extensible-store
  Redux extension that allows you to dynamically inject new reducers and sagas into you running application.

State Machines

• redux-machine
  https://github.com/mheiber/redux-machine
  A tiny library for creating state machines in Redux apps. Provide an object of reducers to handle different states, and return a special key with the next state name to have the lib swap the active state reducer and include the current state name.

• xstate
  https://github.com/davidkpiano/xstate
  Simple, stateless JavaScript finite state machines and statecharts. Like reducers on steroids, and can be integrated into Redux.

• redux-dsm
  https://github.com/ericelliott/redux-dsm
  Declarative State Machines for Redux: An async state boilerplate reducer.

• redux-state-machine
  https://github.com/realb0t/redux-state-machine
  Wraps the javascript-state-machine library for use as a Redux reducer.

• easy-redux-fsm
  https://github.com/andrewosh/easy-redux-fsm
  Specify action creators as a state/transition graph

• redux-automata
  https://github.com/mocoding-software/redux-automata
  redux-automata - is a finite state machine based on Redux store. It allows developer to generate reducer automatically based on current state. The library was developed to support the following scenarios: Provide different behavoiur for the same action and avoid massive if-then-else; Ignore specific actions while in specific states (or better saying - process actions only in specific states).

• redux-fsm
  https://github.com/quadreex/fsm-redux
  Lightweight library for Finite State Machine support in Redux applications. This library implements FSM pattern as swappable redux reducers. In a configuration object you specify which reducer should be used for each state of FSM and actions which trigger state change.