Open-source alternatives to Reselect

mobx-react is a library that provides state bindings to connect React components to MobX observable state. It functions as a component state synchronizer, ensuring that user interface elements automatically re-render only when the specific observed data they consume changes. The project enables a decoupled state architecture by moving business logic and domain state into standalone stores, separating data management from the React component tree. It facilitates global state distribution across deep component hierarchies using providers and context to avoid manual prop drilling. The library c

This is a foundational project structure for building scalable web applications using React. It provides a standardized directory structure and build tools to accelerate the bootstrapping of new projects, featuring a Redux architecture for predictable state management through unidirectional data flow and an immutable store. The project is distinguished by a command-line interface for generating standardized components, containers, and routes from predefined templates. It implements an offline-first framework using service workers to enable progressive web app functionality, alongside a compon

React is a JavaScript library for building user interfaces based on a component-driven architecture and unidirectional data flow.

React is a JavaScript library for building user interfaces through the composition of modular, self-contained components. It employs a declarative programming model where developers describe the desired visual state, and the library automatically manages the underlying document updates and state synchronization. By utilizing a virtual representation of the document, it calculates and applies minimal changes to the browser, ensuring efficient rendering even in complex applications. The library distinguishes itself through a sophisticated scheduling system that manages rendering work in increme

Vuex is a centralized state management library for Vue.js applications. It provides a single source of truth for application data, ensuring consistent state across a component tree through a reactive data store. The system organizes the global state tree into independent, namespaced modules to prevent naming collisions and maintain code organization. It distinguishes between synchronous mutations for predictable state transitions and asynchronous actions for handling complex operations. The library includes cached getters for derived state, store lifecycle hooks for mutation interception, an

Constate is a global state management tool for React designed to minimize unnecessary component re-renders. It functions as a state manager and optimization tool that utilizes specialized contexts to organize shared data across a component tree. The library distinguishes itself through a state-slicing provider pattern, which splits global state into multiple contexts to isolate data dependencies. It includes a state selector system that allows components to extract specific slices of global state, ensuring interface updates only occur when the selected data dependencies change. The project c

re-frame is a functional framework for building single-page applications in ClojureScript. It provides a centralized, immutable database that serves as the single source of truth for the entire application state, enforcing a strict unidirectional data flow where events trigger state transitions and subsequent view updates. The framework distinguishes itself through a reactive signal graph and an interceptor-based middleware pipeline. By treating application logic as a sequence of data-driven events and declarative side effects, it decouples business logic from the view layer. This architectur

MobX is a reactive state management library and fine-grained reactivity engine. It provides an observable data store that automatically triggers updates in the user interface when data structures change, functioning as a transparent functional reactive store to maintain a consistent source of truth. The system utilizes a dependency-graph mapping and proxy-based object observation to track data dependencies. This ensures that only the specific components dependent on changed data are updated, which reduces unnecessary re-renders and optimizes frontend performance. The library supports decoupl

This repository serves as a comprehensive knowledge base and study guide for developers preparing for technical assessments and job screenings focused on React. It provides a structured collection of common industry inquiries and answers designed to build proficiency in the core concepts and patterns required for modern web interface development. The resource covers the fundamental pillars of the library, including component-based architecture, declarative rendering, and unidirectional data flow. It details essential patterns for managing both local and global application state, as well as te

This project is an ECMAScript proposal to introduce a native reactive state primitive to the JavaScript language. It defines a standard for fine-grained reactivity, providing a mechanism to track value dependencies and automatically propagate updates through a dependency graph. The specification focuses on managing computed values and side effects based on granular changes to state. It enables the synchronization of state updates across a dependency graph and the tracking of relationships between values and their observers without manual subscriptions. The proposal covers efficient value com

This project is a state management framework for Angular applications that provides a predictable state container. It implements a Redux-style architecture using a centralized store, managing global and local application data through an observable-based data flow of actions and reducers. The framework includes a specialized entity management tool for organizing and synchronizing server-side data collections within client-side stores. It also provides a reactive store system that integrates state updates with Angular signals for change detection and includes debugging mechanisms for time-trave

This is the comprehensive documentation website for the Vue 2 progressive JavaScript framework. It serves as a technical reference and development guide for building reactive user interfaces and single-page applications. The site provides a detailed JavaScript API reference and a web component directory. It covers the implementation of component-based architectures, reactive state management, and the use of a virtual DOM to synchronize application state with the browser. The documentation details capabilities including client-side routing, declarative DOM manipulation, and frontend build opt

This project is a comprehensive collection of reusable code snippets, custom hooks, and implementation patterns for building user interfaces with React. It serves as a library of short examples designed to solve common development tasks, ranging from state management to DOM integration. The collection provides a wide array of specialized utilities for interacting with browser APIs, including window dimension tracking, media query evaluation, and online status monitoring. It also includes practical guides and snippets for performance optimization, such as memoization, lazy loading, and state c

Effector is a reactive state management library and data flow orchestrator designed for building complex, event-driven applications. It models application logic as a directed acyclic graph, where state updates and asynchronous side effects propagate automatically through declarative pipelines. By decoupling business logic from user interface layers, it allows developers to maintain state in independent containers that communicate via standard interfaces, ensuring the system remains framework-agnostic. The library distinguishes itself through its robust support for isolated execution scopes, w

Recompose is a suite of toolsets for implementing higher-order component composition, context extraction, render optimization, and external state integration. It provides a library of utilities to wrap components in reusable logic and behavioral layers, allowing developers to chain functional wrappers and reduce nesting within a component tree. The project focuses on the composition of functional wrappers to inject properties and behavior into components. It includes a set of helpers for extracting values from component context and passing them as direct properties, as well as tools for integ

Easy-peasy is a React state management library and typed framework that provides a centralized store for managing global application state. It functions as an immutable state store and an async state orchestrator, ensuring end-to-end type safety for state definitions, actions, and derived values. The library distinguishes itself by converting direct mutation syntax into immutable updates to simplify the management of nested data. It includes a mechanism for persisting the state tree to storage and rehydrating it during the application boot process, with the ability to suspend the user interfa

Jotai is a state management library for React applications that utilizes an atomic model to handle data. It organizes application state into small, independent units called atoms, which automatically track dependencies and trigger granular updates to components. By building state through these composable primitives, the library ensures that only the necessary parts of an application re-render when data changes. The library distinguishes itself through its flexible approach to state composition and asynchronous data handling. It integrates promises directly into the state model, allowing devel

React Redux is a set of official bindings and integration layers that connect a Redux global state container to a React user interface. It functions as a state synchronization library and a communication bridge, allowing components to read state and dispatch actions to a centralized store. The project decouples business logic from the view layer, ensuring that the user interface automatically updates whenever the underlying global state changes. It manages complex data flows by linking the UI to a central state container to share data across different components and screens. The library impl

React Redux is a global state management bridge and a set of bindings that connect React components to a Redux state store. It serves as a communication layer and state store connector, allowing a declarative user interface to synchronize with a centralized source of truth. The library enables the synchronization of shared global state across an application by providing mechanisms to read state and dispatch actions directly from the view layer. It ensures predictable state transitions by bridging the gap between UI components and the Redux state container. The project covers core capabilitie

This project is a reactive, offline-first NoSQL database engine designed for JavaScript applications. It provides a robust framework for managing application state by synchronizing data across browsers, mobile devices, and server-side runtimes. By treating local storage as the primary source of truth, it enables applications to remain functional without network connectivity, automatically reconciling changes with remote backends once a connection is restored. The database distinguishes itself through a modular architecture that supports cross-environment synchronization and high-performance d

`bash npm install redux-orm --save `

simple undo/redo functionality for redux state containers

redux-immutable is used to create an equivalent function of Redux combineReducers that works with Immutable.js state.

higher-order reducer to ignore redux actions

redux-api-middleware

redux-requests ![Versionnpm-image]npm-url

Simple reducer library for Redux. It's like Reselect but for reducers.