Redux

Redux is a tiny (~2kB) JavaScript library for predictable and maintainable global state management. It centralizes your application’s state in a single store, where the only way to change state is by dispatching plain-object actions that flow through pure reducer functions, making state transitions explicit, traceable, and easy to test.

Because the core is view-layer agnostic, Redux works with React, Vue, Angular, vanilla JS, or any other UI library, and runs the same way on the client, server, and native. Its strict unidirectional data flow enables powerful developer tooling like time-travel debugging, and a rich middleware ecosystem extends it for async logic, logging, and persistence.

What You Get

• A single, centralized store holding the entire application state tree
• Pure reducer functions for predictable, testable state transitions
• A middleware pipeline (via applyMiddleware) for async logic, logging, and side effects
• Store enhancers and the compose helper for composing store behavior
• Framework-agnostic core that works with React, Vue, Angular, or vanilla JS
• First-class TypeScript types for actions, reducers, middleware, and the store

Common Use Cases

• Managing complex, shared UI state across many components in a single-page app
• Providing a single source of truth for state that must stay consistent
• Enabling time-travel debugging and action replay during development
• Coordinating async data flows through middleware like thunks or sagas

Under The Hood

Architecture Redux’s core is a handful of small, single-responsibility modules under src/. createStore.ts is the heart: it holds the current state in a closure, exposes getState, dispatch, subscribe, and replaceReducer, and runs each dispatched action through the root reducer to produce the next state, then notifies subscribers. combineReducers.ts composes a map of slice reducers into one root reducer; applyMiddleware.ts wraps dispatch in a chain of middleware built with the tiny compose.ts right-to-left function composer; bindActionCreators.ts is a convenience wrapper. The src/utils/ helpers (isPlainObject, isAction, actionTypes, kindOf, symbol-observable) guard invariants and provide the interop $$observable symbol.

Tech Stack The library is written in TypeScript (85% of the codebase) with a small amount of JavaScript, targeting both ESM and CJS consumers via a dual-export package.json. It is built with tsup, type-checked and tested with Vitest (vitest --run --typecheck), and linted with ESLint and Prettier. The published core has essentially no runtime dependencies, keeping the bundle around 2kB.

Code Quality The source is exceptionally clean and heavily typed, with extensive JSDoc on public APIs (including deprecation guidance steering users toward Redux Toolkit’s configureStore). Reducers and helpers are pure functions with explicit invariant checks that throw descriptive, production-minified error codes via formatProdErrorMessage. There is a thorough test suite — 22 spec files under test/ covering createStore, combineReducers, applyMiddleware, compose, and TypeScript type tests — exercising edge cases and error paths.

API Design The public surface is deliberately minimal and consistent: createStore, combineReducers, bindActionCreators, applyMiddleware, and compose, all exported from a single entry point with rich TypeScript generics for inferring state and action types. The conceptual model (store, action, reducer, middleware) is small and well documented at redux.js.org, though the surrounding patterns for async logic and immutability historically required boilerplate — which is why the team now points developers to Redux Toolkit for day-to-day use.