Reactive Repository
This brick is designed to help you to connect your blocs through the domain layer, using the rxdart package in Dart. It provides a reactive repository to keep your blocs' state synchronized. More information about this pattern can be found Connecting Blocs through Domain and Effective Bloc-to-Bloc Communication Strategies in the Domain Layer.
Features 🌟
-
Reactive Stream Management: Utilizes BehaviorSubject from rxdart to manage a stream of bloc states.
-
Current State Access: Easily access the current state of your bloc at any point in time.
-
Update Functionality: Update the state of your bloc with a new one as needed, ideally within the
onChangecallback.
Getting Started 🚀
To use the Reactive Repository brick, you need to have the rxdart package in your environment. If you haven't already, add rxdart to your project's pubspec.yaml:
With Dart:
dart pub add rxdart
With Flutter:
flutter pub add rxdart
Setup 🧑💻
Ensure you have the mason_cli installed.
🎯 Activate from https://pub.dev
dart pub global activate mason_cli
🍺 Or install from https://brew.sh
brew tap felangel/mason && brew install mason
Installation ☁️
Install globally
mason add -g reactive_repository
Usage 🎨
Run the following command in the directory you would like to make the reactive repository.
mason make reactive_repository
Variables ✨
| Variable | Description | Default | Type |
|---|---|---|---|
bloc_state_name | The name of the bloc state | CounterState | string |
includeDispose | Include a dispose method | true | boolean |
seedBehaviorSubject | Seed the BehaviorSubject | true | boolean |
Example Output 📦
counter_state_repository.dart
import 'package:rxdart/rxdart.dart';
/// A repository class for [CounterState].
///
/// This class provides a way to manage and update the state of [CounterState].
class CounterStateRepository {
/// A [BehaviorSubject] to hold and stream the [CounterState].
///
/// It's seeded with an initial state if seedBehaviorSubject is true.
final BehaviorSubject<CounterState> _counterStateSubject =
BehaviorSubject<CounterState>.seeded(const CounterState());
/// A stream of [CounterState] updates for subscription.
Stream<CounterState> get counterStateStream => _counterStateSubject.stream;
/// Provides synchronous access to the current state.
CounterState get currentCounterState => _counterStateSubject.value;
/// Allows for the [CounterState] to be updated, notifying all
/// stream subscribers.
///
/// The [state] is the new state to be added to the stream.
void updateCounterState(CounterState state) =>
_counterStateSubject.add(state);
/// Closes the [BehaviorSubject] stream to prevent memory leaks upon disposal.
void dispose() => _counterStateSubject.close();
}
Update State 🔄
counter_bloc.dart
/// Called when the state of the counter changes.
///
/// This method is called whenever there is a change in the [CounterState].
/// It updates the counter state in the _counterStateRepository with the
/// [change.nextState].
@override
void onChange(Change<CounterState> change) {
super.onChange(change);
_counterStateRepository.updateCounterState(change.nextState);
}
Read State 📖
timer_bloc.dart
/// Handles the stream request event and updates the timer state.
///
/// This method listens to the counter state stream and updates the timer state
/// based on the received data. It emits a new [TimerState] with the updated count.
///
FutureOr<void> _onStreamRequested(
_StreamRequested event,
Emitter<TimerState> emit,
) async {
await emit.forEach<CounterState>(
_counterStateRepository.counterStateStream,
onData: (counterState) {
return state.copyWith(count: counterState.value);
},
);
}