store.md

Store

Store Persistence

• redux-persist
  https://github.com/rt2zz/redux-persist
  Persist and rehydrate a redux store. The core idea behind redux-persist is to provide performant persistence and rehydration methods. At the same time redux-persist is designed to minimize complexity by knowing as little about your application as possible.

• redux-localstorage
  https://github.com/elgerlambert/redux-localstorage
  Store enhancer that syncs (a subset) of your Redux store state to localstorage.

• redux-localstorage-slicer
  https://github.com/ngokevin/redux-localstorage-slicer
  Custom slicer for redux-localstorage that allows reducers to define their own persistence configuration.

• redux-localstorage-immutable
  https://github.com/jakelazaroff/redux-localstorage-immutable
  Enhancer for redux-localstorage that allows you to persist an immutable store

• redux-storage
  https://github.com/michaelcontento/redux-storage
  Persistence layer for redux with flexible backends. Save and load the Redux state with ease.

• redux-storage-decorator-engines
  https://github.com/allegro/redux-storage-decorator-engines
  Composing decorator for redux-storage to use different storage types like redux-storage-engine-localstorage or redux-storage-engine-sessionstorage including custom engines (i.e. to load information from cookies) in a single application.

• redux-storage-engine-remoteendpoint
  https://github.com/Bionexo/redux-storage-engine-remoteendpoint
  A remote endpoint storage engine for redux-storage. Everytime the store changes, save it on the server.

• redux-pouchdb
  https://github.com/vicentedealencar/redux-pouchdb
  Sync store state to pouchdb

• redux-owl
  https://github.com/rt2zz/redux-owl
  Redux One Way Linking. This is a simple method for supporting offline sync. The basic concept is, try to execute the action, on failure add it to a retry queue. Every so often process the retry queue until success is achieved.

• redux-action-store
  https://github.com/oakfang/redux-action-store
  Save and load actions to persist state

• redux-session-storage
  https://github.com/conorhastings/redux-session-storage
  Redux middleware for recording redux actions for a particular session to session storage

• redux-persistent-state-snapshot
  https://github.com/Marcoga/redux-persistent-state-snapshot
  Middleware to persist your state in a Redux app.

• redux-simple-localstorage
  https://github.com/MoombaDS/redux-simple-localstorage
  Ridiculously simple implementation for serialising the entire Redux store to local storage and retrieving it on application restart.

• redux-smooth-storage
  https://github.com/dsacramone/redux-smooth-storage
  Small program to store your react redux store or stores in local storage or session storage

• redux-state-archiver
  https://github.com/schwers/redux-state-archiver
  A collection of React components for serializing your redux state.

• redux-async-initial-state
  https://github.com/KELiON/redux-async-initial-state
  Redux middleware for async loading of initial app state.

• persistent-redux
  https://github.com/explorigin/persistent-redux
  Persistent-Redux is a drop-in middleware that will save your Redux state and restore it on the next page load. Previously this tool focused on PouchDB but now it offers an adapter API to use any backend.

• redux-store-sync
  https://github.com/lokhmakov/redux-store-sync
  Redux store sync middleware

• redux-simple-storage-middleware
  https://github.com/BartWaardenburg/redux-simple-storage-middleware
  Simple redux middleware which will store the current state tree in either session- or localstorage

• Redux-Session
  https://github.com/HelpfulHuman/Redux-Session
  Redux middleware for automatic setting and hydration of state data in external storage.

• redux-eventstore
  https://github.com/camjackson/redux-eventstore
  Redux middleware for reading and writing actions to Event Store. Meant for event-based persistence on the server.

• redux-gatorade
  https://github.com/michael-iglesias/redux-gatorade
  Need to hydrate state from URL parameters? Redux-gatorade is a simple solution that allows you to hydrate different parts of your state tree from URL parameters.

• redux-simple-storage-middleware
  https://github.com/BartWaardenburg/redux-simple-storage-middleware
  Simple redux middleware which will store the current state tree in either session- or localstorage. This helps creating an awesome developer experience when combined with hot reloading.

• redux-pouchdb-store-enhancer
  https://github.com/jurassix/redux-pouchdb-store-enhancer
  Redux PouchDB Enhancer to store actions locally, sync with remote CouchDB, and time travel by applying remote actions locally and then compute distributed nextState.

• Redux-State-Sync
  https://github.com/AOHUA/redux-state-sync
  A very light weight middleware to sync your redux state across browser tabs.

• redux-replicate
  https://github.com/loggur/redux-replicate
  Creates a Redux store enhancer designed to replicate actions and states. Declaratively connect application state to data sources and create efficient, scalable, and reliable software with minimal effort.

• redux-store-sessionstorage
  https://github.com/ppallesws/redux-store-sessionstorage
  Store enhancer that syncs (a subset) of your Redux store state to sessionstorage.

• record-redux
  https://github.com/GA-MO/record-redux
  Record your action to local storage

• redux-react-session
  https://github.com/bernabe9/redux-react-session
  Redux React Session provides an API that allows to manage sessions through the app, with authorization function for react-router and a persisted session.

• Redux Phoenix
  https://github.com/brainhub-adam/redux-phoenix
  Restore redux state from previous sessions like a phoenix from ashes.

• session-store
  https://github.com/zipdrug/session-store
  A redux store that manages a session lifecycle

Redux-Persist Addons

• redux-persist-crosstab
  https://github.com/rt2zz/redux-persist-crosstab
  Add cross tab syncing to your redux app with 1 line. This tiny module listens to the window for redux-persist storage events. When an event occurs it will dispatch a rehydrate action.

• redux-persist-transform-compress
  https://github.com/rt2zz/redux-persist-transform-compress
  Uses lz-string to compress state before storing.

• redux-persist-migrate
  https://github.com/wildlifela/redux-persist-migrate
  Migrate redux state between versions

• redux-persist-transform-encrypt
  https://github.com/maxdeviant/redux-persist-transform-encrypt
  Encrypt your Redux store.

• redux-persist-transform-expire
  https://github.com/gabceb/redux-persist-transform-expire
  Add expiration to your persisted store

• redux-persist-migrate-semver
  https://github.com/srtucker22/redux-persist-migrate-semver
  Migrate redux state between versions with redux-persist.

• redux-persist-transform-immutable
  https://github.com/rt2zz/redux-persist-transform-immutable
  Add immutable sub-reducer support to redux-persist.

• redux-persist-immutable
  https://github.com/rt2zz/redux-persist-immutable
  A wrapper around redux-persist that provides ImmutableJS support.

• redux-persist-immutable-state
  https://github.com/rufman/redux-persist-immutable-state
  Implements stateIterator, stateGetter, stateSetter and stateReconciler for an ImmutableJS root state.

• redux-persist-transform-filter
  https://github.com/edy/redux-persist-transform-filter
  Filter transformator for redux-persist

• redux-persist-transform-expire
  https://github.com/gabceb/redux-persist-transform-expire
  Add expiration to your persisted store

• redux-persist-restful-storage
  https://github.com/qwe852/redux-persist-restful-storage
  Restful storage for redux-persist

• redux-persist-cookie-storage
  https://github.com/abersager/redux-persist-cookie-storage
  Redux Persist storage adapter for cookies

• redux-persist-node-storage
  https://github.com/pellejacobs/redux-persist-node-storage
  Redux persist adaptor for Node localStorage

• redux-persist-state-manager
  https://github.com/rt2zz/redux-persist-state-manager
  Replacement for autoRehydrate with state migrations, hard set rehydrated values, helpful log messages, and implemented as a higher order reducer

Synchronization

• redux-live
  https://github.com/eitak/redux-live
  https://github.com/eitak/redux-live-localdb
  https://github.com/eitak/redux-live-socketio
  Redux Live a framework for persisting Redux actions to a database and synchronising them across multiple clients.

• Redux Share
  https://github.com/baptistemanson/redux-share-server
  https://github.com/baptistemanson/redux-share-client
  Share redux state across the network between clients and servers

• redux-sync
  https://github.com/Autarc/redux-sync
  A store enhancer for Redux which allows to mirror one store as a part of another and keeps them in sync.

• redux-swarmlog
  https://github.com/philholden/redux-swarmlog
  A super simple way of writing distributed Redux applications. The Redux action log is persisted in an IndexDB and synced with other peers via a WebRTC Swarm using Swarmlog.

• redux-scuttlebutt
  https://github.com/grrowl/redux-scuttlebutt
  Self-replicating, self-ordering log of actions shared between all clients. Using the power behind redux's hot reloading and time travel, your client dispatches actions itself and so does every other client, they share the state, and it all just works.

• redux-scuttlebutt-signatures
  https://github.com/grrowl/redux-signatures
  Cryptographic signing of your redux (or flux) actions

• redux-ipc
  https://github.com/vutran/redux-ipc
  Log your Redux state and actions to a node backend via WebSockets.

• redux-action-sync
  https://github.com/czak/redux-action-sync
  redux-action-sync is an action persistence middleware for Redux applications. A simple solution for keeping state synchronised across multiple clients. It uses a single-endpoint backend as an alternative to CRUD APIs.

• redux-electron-store
  https://github.com/samiskin/redux-electron-store/
  A redux store enhancer that allows automatic synchronization between electron processes

• redux-peerjs-store-enhancer
  https://github.com/jurassix/redux-peerjs-store-enhancer
  Use PeerJS to easily distribute Redux actions to remote peers.

• Redux Websocket Action Transfer
  https://github.com/lttb/redux-wsat
  This package allows to create middleware that transfer redux actions between client and server via websocket. The main point is moving redux actions to the next level of services interactions and use it like messaging protocol between different service components, not only frontend. It can be useful for realtime applications with microservice architecture.

• rehub
  https://github.com/oakfang/rehub
  A Redux middleware to share actions via WebRTC

• redux-peer-connection
  https://github.com/jcblw/redux-peer-connection
  A set of redux tools that enable peer to peer connections between two browsers. It uses simple peer under the hood.

• react-redux-socket
  https://github.com/trouve-antoine/react-redux-socket
  Lightweight library to handle redux actions at server side using sockets. That means that: redux actions can be re-router to a server (instead of the redux reducers); a server can emit a redux action straight to the redux reducers.

• redbone
  https://github.com/ya-kostik/redbone
  Library for client -> server -> client redux dispatching

Store Change Subscriptions

• redux-watch
  https://github.com/jprichardson/redux-watch
  Watch/observe/monitor Redux store state changes. Creates store subscription callbacks that can do comparisons based on object paths or Reselect selectors.

• redux-subscribe
  https://github.com/ashaffer/redux-subscribe
  Subscribe to a path in your redux state atom. Uses a middleware shared path strings for improved performance and dynamic subscription handling.

• redux-changes
  https://github.com/sprightco/redux-changes
  Process changes in redux with path matching. Uses a higher-order reducer that does comparisons, and uses a path string with a matching syntax.

• redux-observers
  https://github.com/xuoe/redux-observers
  Observe Redux state changes and dispatch actions on change.

• redux-observer
  https://github.com/jimf/redux-observer
  Redux middleware for observing state change and taking action when changes of interest occur.

• redux-batched-subscribe
  https://github.com/tappleby/redux-batched-subscribe
  Store enhancer for redux which allows batching of subscribe notifications that occur as a result of dispatches. Semi-similar use case as redux-batched-actions.

• redux-batched-updates
  https://github.com/acdlite/redux-batched-updates
  Batch React updates that occur as a result of Redux dispatches, to prevent cascading renders.

• redux-when
  https://github.com/jameslnewell/redux-when
  Delay dispatching an action until a condition is true.

• redux-skip-by-action
  https://github.com/tshelburne/redux-skip-by-action
  Store enhancer for redux that enables skipping subscriber notifications for individual actions.

• redux-store-observer
  https://github.com/jonnyreeves/redux-store-observer
  redux-store-observer provides a thin wrapper around Redux's store#subscribe() to allow you to respond to state changes.

• redux-spy
  https://github.com/erikras/redux-spy
  A higher order component decorator to read from a Redux store without subscribing to all its changes

• redux-debounce-listener
  https://github.com/nakamura-to/redux-debounce-listener
  Redux Debounce Listener allows you to delay invoking listeners. If you use this with React, rendering cost may be reduced.

• pull-redux
  https://github.com/ahdinosaur/pull-redux
  use redux as a through pull stream

• redux-on-state-change
  https://github.com/franjohn21/redux-on-state-change
  Extremely simple middleware to observe Redux state changes. It's simply to have a place to handle tangentially related logic that doesn't belong in components or reducers but relies on knowing about state or action updates.

• redux-subscriptions
  https://github.com/xaviervia/redux-subscriptions
  Higher-level API for the Redux store.subscribe. redux-subscriptions keeps the previous state for you and gives you the ability of running diffs in the state (using object-difference) so that you can do something when part of the state is updated, much like the React bindings for Redux work.

• redux-batch-enhancer
  https://github.com/abc123s/redux-batch-enhancer
  Batch subscriber notification for an array of actions (including complex actions, e.g. thunks).

• redux-limiter
  https://github.com/joaker/redux-limiter
  Throttle the rate of change notifications from a redux store to stateless components (NOTE: not for use with stateful components)

• redux-add-action-listener
  https://github.com/carnesen/redux-add-action-listener-enhancer
  A store enhancer that adds a second set of subscriptions for dispatched actions

• redux-batch
  https://github.com/manaflair/redux-batch
  Enhance your Redux store to support batched actions. Based on redux-batched-subscribe, but focused on batched actions instead of debouncing notifications.

• redux-subscriber
  https://github.com/ivantsov/redux-subscriber
  Subscribe to changes in any part of redux state

• redux-state-change-listener
  https://github.com/sharingapples/redux-state-change-listener
  Simple library for listening on changes of specific parts of a redux state tree

• redux-detector
  https://github.com/piotr-oles/redux-detector
  Redux Detector enhancer allows you to use state changes detectors with redux. Detector is a simple and pure function which compares two states and returns list of actions for some states configurations. It can be used for reacting on particular state transitions.

• redux-subscribe-reselect
  https://github.com/tswaters/redux-subscribe-reselect
  A tiny utility to subscribe to state changes returned from a reselect selector

• redux-wait-for-state
  https://github.com/karl/redux-wait-for-state
  A small utility to that resolves a promise when a selector predicate returns truthy

• watch-redux
  https://github.com/Wizcorp/watch-redux
  A library that makes observing changes in a Redux store using selectors very easy, and efficient. It provides watching for changes with full granularity.

Integration and Interop

• redux-shared-worker
  https://github.com/burakcan/redux-shared-worker
  A higher order Redux store that runs the actual store in a SharedWorker or WebWorker.

• redux-web-worker
  https://github.com/deebloo/redux-web-worker
  Redux implementation in a web worker (experiment). The entire state is kept in a separate thread. (this also gives the added benefit of immutable objects)

• redux-webext
  https://github.com/ivantsov/redux-webext
  Allows you to use Redux for managing the state of your WebExtension.

• react-chrome-redux
  https://github.com/tshaddix/react-chrome-redux
  A set of utilities for building Redux applications in Google Chrome extensions.

• electron-redux
  https://github.com/hardchor/electron-redux
  Use redux in the main and browser processes in electron

• redux-external-dispatchers
  https://github.com/npr/redux-external-dispatchers
  A Redux store enhancer to let non-Redux pieces of your application dispatch actions into Redux without also having access to Redux state.

• react-native-redux-listener
  https://github.com/line64/react-native-redux-listener
  A Redux store enhancer that automatically hooks to React Native event listeners and dispatches all events as primitive actions that can be handled by the reducers of your app.

Other

• redux-lift
  https://github.com/izaakschroeder/redux-lift
  Store composition for redux. Lifting allows you to "lift" your state, reducers and actions into another context. Lifting is a kind of store enhancer that is a superset of middleware.

• redux-plugins-immutable
  https://github.com/jcoreio/redux-plugins-immutable
  Asynchronously load Redux reducers and middleware, React Components, etc. in app plugins.

• redux-plugins-immutable-react
  https://github.com/jcoreio/redux-plugins-immutable-react
  React helper components for redux-plugins-immutable

• redux-plugins-immutable-hot-loader
  https://github.com/jcoreio/redux-plugins-immutable-hot-loader
  Webpack loader that hot-reloads plugins made with redux-plugins-immutable when you make changes to them.

• redux-mount-store
  https://github.com/RetailMeNotSandbox/redux-mount-store
  Redux store enhancer that makes it possible to mount sub-stores

• redux-online-store-enhancer
  https://github.com/jurassix/redux-online-store-enhancer
  Automatically detect if you are online or offline. Adds a top-level "online" attribute that will dynamically change as the browser goes online and offline.

• epic-linker
  https://github.com/epixode/epic-linker
  This package supports modular applications based on react and redux-saga, by creating generators that yield "bundles" that can be composed together to form the application.

• redux-stack
  https://github.com/jondot/redux-stack
  Redux Stack is a library that helps you build modular, structured, and cleaner redux apps. Redux Stack introduces a concept of initializers. Small pieces of integration code, per library, that "declares" how it integrates. Redux Stack will mesh these together to create your personalized store builder.

• redux-injectable-store
  https://github.com/lelandrichardson/redux-injectable-store
  Redux store with injectable reducers for use with bundle splitting, large apps, and SPAs.