Riverpod

Riverpod

Riverpod is a reactive state management framework for Dart that manages application state through providers which automatically track dependencies and rebuild dependents when values change. It functions as an asynchronous data caching library, caching results of async operations and exposing loading, error, and data states to widgets without manual future handling. The framework includes a provider composition system that combines multiple providers into derived values that recompute automatically when any dependency changes, along with code generation for state providers that reduces boilerplate and ensures type safety.

The framework distinguishes itself through compile-time code generation that produces provider declarations from annotated Dart code, a signals-based reactivity model where providers automatically track dependencies and propagate changes without manual subscription management, and a dependency graph invalidation system that clears cached values and triggers recomputation when upstream providers change. Riverpod provides provider container scoping that creates isolated containers which can be nested for per-subtree overrides and state isolation, family provider parameterization that associates a single provider with multiple independent states keyed by unique parameter combinations, and disposal lifecycle management that automatically destroys provider state when no listeners remain with opt-in keep-alive for persistent resources.

Riverpod supports async data handling with automatic retry of failed providers using configurable delay and count, state persistence and restoration to local storage with schema migration support, and testing utilities that create isolated provider containers for unit tests without a widget tree. The framework includes a command-line migration tool that rewrites existing provider syntax to the new code-generation format automatically, lint rules that enforce best practices, and IDE refactorings for wrapping widgets in consumers. It also provides monitoring and observability through DevTools inspection of provider values and lifecycle events, along with performance optimizations including debouncing network requests, automatic disposal of unused state, and selective rebuilds based on property changes.

Features

Reactive State Management Libraries - Provides a reactive state management framework for Dart with automatic dependency tracking and UI rebuilds.

State Mutations - Exposes modifiable providers that widgets can call to update state and trigger rebuilds.

Computational Result Caching - Caches computed values from providers and returns them on subsequent reads without re-execution.

Parameterized Provider Caching - Associates a single provider with multiple independent states keyed by unique parameter combinations for per-parameter caching.

Provider Parameterized Arguments - Provides parameterized provider arguments that enable per-input caching and retrieval.

State Mutation Providers - Defines class-based providers with public methods that external objects can call to mutate the provider's state.

UI State Change Notifications - Watches a provider from a widget and rebuilds only the parts of the UI that depend on that provider.

Async Operation Initiators - Initiates an asynchronous callback via a mutation object and tracks its execution state for UI feedback.

Compile-Time Code Generation - Generates provider declarations from annotated Dart code during build, reducing boilerplate and ensuring type safety.

Incremental Recomputations - Rebuilds derived data and triggers network requests only when their dependencies change, avoiding unnecessary work.

Provider Parameterized Arguments - Supports named, optional, and default parameters in provider definitions for flexible state configuration.

Dependency Injection Providers - Provides a provider-based dependency injection system with scoped overrides and lifecycle management for widget trees.

Derived Provider Composers - Combines multiple providers into derived values that recompute automatically when dependencies change.

Reactive Provider Composition - Combines multiple providers into derived values that recompute automatically when any dependency changes.

Widget Tree Providers - Watches a provider inside a widget's build method and rebuilds the widget whenever the provider's value changes.

Provider State Disposals - Registers callbacks via ref.onDispose that run when a provider's state is destroyed, enabling cleanup of resources.

Reactive Value Declarations - Declares a piece of state as a provider so widgets can read and react to its changes.

Source Generation Providers - Uses a code generator to produce provider declarations from annotated classes, reducing boilerplate and ensuring type safety.

Provider Code Generators - Generates provider declarations from annotated classes, reducing boilerplate and ensuring type safety.

Shared State Management - Places shared state code in any file or package and makes it accessible to multiple widgets.

Declarative State Managers - Declares providers that expose values and automatically rebuild dependents when values change.

Scoped State Containers - Creates isolated provider containers that can be nested for per-subtree overrides and state isolation.

State Controllers - Provides direct access to provider state and underlying controller for advanced state manipulation.

Signal-Based Reactivity - Providers automatically track dependencies and propagate changes to watchers without manual subscription management.

Scoped Provider Resolution - Enables dependent providers to correctly resolve scoped values through explicit dependency declarations.

Lifecycle State Tracking - Monitors the progress of an asynchronous operation through pending, success, error, and idle states.

Asynchronous State Managers - Handles loading, error, and data states automatically through AsyncNotifier without manual boolean flags.

Asynchronous Data Handling - Handles asynchronous operations with loading, error, and success states including automatic retry and cancellation.

Dependency-Based Cache Invalidation - Automatically clears cached results when dependencies change, keeping derived data up to date.

Reactive Dependency Invalidators - Automatically clears cached values and triggers recomputation when upstream providers change.

Asynchronous Data Caching - Caches async operation results and exposes loading, error, and data states to widgets without manual future handling.

Async Loading State Handlers - Provides a typed async value that forces pattern matching on loading, data, and error states.

Typed Async State Unions - Provides a typed async state union that forces exhaustive handling of loading, data, and error states.

Reactive State Management - Watches multiple providers and produces a single combined reactive value without nesting.

Flat Provider Compositions - Combines values from multiple providers by calling ref.watch directly, removing the need for ProxyProvider wrappers.

Provider Compositions - Reads the output of one provider inside another to derive new state without manual wiring.

Unified Provider Reads - Ships a single watch call that replaces multiple older reading patterns with one consistent approach.

Provider Resource Disposals - Disposes provider resources when no listeners remain, preventing memory leaks from unused state.

In-Memory Storage Mocks - Uses an in-memory database in place of a real device database to verify persistence behavior in tests.

Refresh State Distinctions - Provides a built-in mechanism to differentiate initial loading spinners from refresh indicators that preserve stale data.

Mutation State Resets - Returns a mutation to its idle state either automatically when listeners detach or manually through a dedicated method.

Provider Syntax Migration Tools - Riverpod converts existing provider declarations to the code-generation syntax by replacing manual type selection with annotations.

Provider Implementation Overrides - Changes a provider's behavior for testing, debugging, or scoping by supplying an alternative implementation.

Automatic Retry Clients - Automatically re-executes failed providers with configurable delay and retry count.

Provider Scoping Overrides - Riverpod changes a provider's behavior for a specific widget subtree by supplying an override in a non-root ProviderContainer or ProviderScope.

Parameterized Provider Instances - Associates a single provider with multiple independent states keyed by unique parameter combinations.

Parameterized Provider Overrides - Replaces the state of a family provider for a specific parameter combination or for all combinations during testing.

Provider Testing Containers - Creates isolated provider containers for unit tests with mock overrides and state inspection.

Provider Future Awaiters - Reads the .future property of a provider to wait for asynchronous operations to complete before making assertions.

Provider State Persistence - Implements state persistence and restoration for providers with schema migration support.

Parameterized Mutation Instances - Creates distinct instances of the same mutation by passing unique parameters, allowing parallel operations.

Test Isolation - Creates a ProviderContainer to read and listen to providers within unit tests, ensuring no shared state between tests.

Logic Isolation Utilities - Creates isolated provider containers for testing state management logic without a widget tree.

Business Logic Isolation - Creates a provider's state outside the widget tree so unit tests can verify business logic without a UI framework.

Mock Client Testing - Replaces a provider's implementation with a mock during tests or previews to isolate behavior.

Mocking and Spying Libraries - Listens to a provider's value changes in tests, enabling assertions on state transitions.

Reusable Widget Logic - Extracts widget logic into reusable functions that can be shared across different widgets without code duplication.

rrousselGitriverpod

Features

Star history