rrousselGit/riverpod

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.

Star-Verlauf