Pub Bunker

bloc

v8.1.4

A predictable state management library that helps implement the BLoC (Business Logic Component) design pattern.

Package archive: https://pubdev.letsnova.ru/api/archives/bloc/8.1.4.tar.gz

Installdart pub add bloc
Readme Changelog Versions

Readme

build

Bloc

Pub build codecov Star on Github Flutter Website Awesome Flutter Flutter Samples License: MIT Discord Bloc Library

A dart package that helps implement the BLoC pattern.

Learn more at bloclibrary.dev!

This package is built to work with:

Sponsors

Our top sponsors are shown below! [Become a Sponsor]

Overview

The goal of this package is to make it easy to implement the BLoC Design Pattern (Business Logic Component).

This design pattern helps to separate presentation from business logic. Following the BLoC pattern facilitates testability and reusability. This package abstracts reactive aspects of the pattern allowing developers to focus on writing the business logic.

Cubit

Cubit Architecture

A Cubit is class which extends BlocBase and can be extended to manage any type of state. Cubit requires an initial state which will be the state before emit has been called. The current state of a cubit can be accessed via the state getter and the state of the cubit can be updated by calling emit with a new state.

Cubit Flow

State changes in cubit begin with predefined function calls which can use the emit method to output new states. onChange is called right before a state change occurs and contains the current and next state.

Creating a Cubit

/// A `CounterCubit` which manages an `int` as its state.
                class CounterCubit extends Cubit<int> {
                  /// The initial state of the `CounterCubit` is 0.
                  CounterCubit() : super(0);
                
                  /// When increment is called, the current state
                  /// of the cubit is accessed via `state` and
                  /// a new `state` is emitted via `emit`.
                  void increment() => emit(state + 1);
                }

Using a Cubit

void main() {
                  /// Create a `CounterCubit` instance.
                  final cubit = CounterCubit();
                
                  /// Access the state of the `cubit` via `state`.
                  print(cubit.state); // 0
                
                  /// Interact with the `cubit` to trigger `state` changes.
                  cubit.increment();
                
                  /// Access the new `state`.
                  print(cubit.state); // 1
                
                  /// Close the `cubit` when it is no longer needed.
                  cubit.close();
                }

Observing a Cubit

onChange can be overridden to observe state changes for a single cubit.

onError can be overridden to observe errors for a single cubit.

class CounterCubit extends Cubit<int> {
                  CounterCubit() : super(0);
                
                  void increment() => emit(state + 1);
                
                  @override
                  void onChange(Change<int> change) {
                    super.onChange(change);
                    print(change);
                  }
                
                  @override
                  void onError(Object error, StackTrace stackTrace) {
                    print('$error, $stackTrace');
                    super.onError(error, stackTrace);
                  }
                }

BlocObserver can be used to observe all cubits.

class MyBlocObserver extends BlocObserver {
                  @override
                  void onCreate(BlocBase bloc) {
                    super.onCreate(bloc);
                    print('onCreate -- ${bloc.runtimeType}');
                  }
                
                  @override
                  void onChange(BlocBase bloc, Change change) {
                    super.onChange(bloc, change);
                    print('onChange -- ${bloc.runtimeType}, $change');
                  }
                
                  @override
                  void onError(BlocBase bloc, Object error, StackTrace stackTrace) {
                    print('onError -- ${bloc.runtimeType}, $error');
                    super.onError(bloc, error, stackTrace);
                  }
                
                  @override
                  void onClose(BlocBase bloc) {
                    super.onClose(bloc);
                    print('onClose -- ${bloc.runtimeType}');
                  }
                }
                
void main() {
                  Bloc.observer = MyBlocObserver();
                  // Use cubits...
                }

Bloc

Bloc Architecture

A Bloc is a more advanced class which relies on events to trigger state changes rather than functions. Bloc also extends BlocBase which means it has a similar public API as Cubit. However, rather than calling a function on a Bloc and directly emitting a new state, Blocs receive events and convert the incoming events into outgoing states.

Bloc Flow

State changes in bloc begin when events are added which triggers onEvent. The events are then funnelled through an EventTransformer. By default, each event is processed concurrently but a custom EventTransformer can be provided to manipulate the incoming event stream. All registered EventHandlers for that event type are then invoked with the incoming event. Each EventHandler is responsible for emitting zero or more states in response to the event. Lastly, onTransition is called just before the state is updated and contains the current state, event, and next state.

Creating a Bloc

/// The events which `CounterBloc` will react to.
                sealed class CounterEvent {}
                
                /// Notifies bloc to increment state.
                final class CounterIncrementPressed extends CounterEvent {}
                
                /// A `CounterBloc` which handles converting `CounterEvent`s into `int`s.
                class CounterBloc extends Bloc<CounterEvent, int> {
                  /// The initial state of the `CounterBloc` is 0.
                  CounterBloc() : super(0) {
                    /// When a `CounterIncrementPressed` event is added,
                    /// the current `state` of the bloc is accessed via the `state` property
                    /// and a new state is emitted via `emit`.
                    on<CounterIncrementPressed>((event, emit) => emit(state + 1));
                  }
                }

Using a Bloc

Future<void> main() async {
                  /// Create a `CounterBloc` instance.
                  final bloc = CounterBloc();
                
                  /// Access the state of the `bloc` via `state`.
                  print(bloc.state); // 0
                
                  /// Interact with the `bloc` to trigger `state` changes.
                  bloc.add(CounterIncrementPressed());
                
                  /// Wait for next iteration of the event-loop
                  /// to ensure event has been processed.
                  await Future.delayed(Duration.zero);
                
                  /// Access the new `state`.
                  print(bloc.state); // 1
                
                  /// Close the `bloc` when it is no longer needed.
                  await bloc.close();
                }

Observing a Bloc

Since all Blocs extend BlocBase just like Cubit, onChange and onError can be overridden in a Bloc as well.

In addition, Blocs can also override onEvent and onTransition.

onEvent is called any time a new event is added to the Bloc.

onTransition is similar to onChange, however, it contains the event which triggered the state change in addition to the currentState and nextState.

sealed class CounterEvent {}
                
                final class CounterIncrementPressed extends CounterEvent {}
                
                class CounterBloc extends Bloc<CounterEvent, int> {
                  CounterBloc() : super(0) {
                    on<CounterIncrementPressed>((event, emit) => emit(state + 1));
                  }
                
                  @override
                  void onEvent(CounterEvent event) {
                    super.onEvent(event);
                    print(event);
                  }
                
                  @override
                  void onChange(Change<int> change) {
                    super.onChange(change);
                    print(change);
                  }
                
                  @override
                  void onTransition(Transition<CounterEvent, int> transition) {
                    super.onTransition(transition);
                    print(transition);
                  }
                
                  @override
                  void onError(Object error, StackTrace stackTrace) {
                    print('$error, $stackTrace');
                    super.onError(error, stackTrace);
                  }
                }

BlocObserver can be used to observe all blocs as well.

class MyBlocObserver extends BlocObserver {
                  @override
                  void onCreate(BlocBase bloc) {
                    super.onCreate(bloc);
                    print('onCreate -- ${bloc.runtimeType}');
                  }
                
                  @override
                  void onEvent(Bloc bloc, Object? event) {
                    super.onEvent(bloc, event);
                    print('onEvent -- ${bloc.runtimeType}, $event');
                  }
                
                  @override
                  void onChange(BlocBase bloc, Change change) {
                    super.onChange(bloc, change);
                    print('onChange -- ${bloc.runtimeType}, $change');
                  }
                
                  @override
                  void onTransition(Bloc bloc, Transition transition) {
                    super.onTransition(bloc, transition);
                    print('onTransition -- ${bloc.runtimeType}, $transition');
                  }
                
                  @override
                  void onError(BlocBase bloc, Object error, StackTrace stackTrace) {
                    print('onError -- ${bloc.runtimeType}, $error');
                    super.onError(bloc, error, stackTrace);
                  }
                
                  @override
                  void onClose(BlocBase bloc) {
                    super.onClose(bloc);
                    print('onClose -- ${bloc.runtimeType}');
                  }
                }
                
void main() {
                  Bloc.observer = MyBlocObserver();
                  // Use blocs...
                }

Dart Versions

  • Dart 2: >= 2.12

Examples

  • Counter - an example of how to create a CounterBloc in a pure Dart app.

Maintainers

Changelog

8.1.4

  • docs: improve diagrams
  • chore: update copyright year
  • chore: update sponsors

8.1.3

  • chore: update sponsors (#4054)
  • chore: fix require_trailing_commas (#3977)
  • chore(deps): upgrade to package:mocktail v1.0.0 (#3919)
  • chore: add topics to pubspec.yaml (#3914)

8.1.2

  • docs: upgrade README snippets to Dart 3 (#3826)
  • refactor: standardize analysis options and resolve warnings (#3826)
  • docs: remove superfluous word from inline docs (#3734)

8.1.1

  • chore: add screenshots to pubspec.yaml (#3708)
  • refactor: const constructor support for BlocObserver (#3704)
  • refactor: upgrade to Dart 2.19 (#3699)
    • remove deprecated invariant_booleans lint rule

8.1.0

  • feat: reintroduce Bloc.observer and Bloc.transformer (#3469)
    • deprecate: BlocOverrides
  • fix: remove unnecessary async from Emitter.onEach (#3392)
  • chore: upgrade to mocktail ^0.3.0 (#3477)

8.0.3

  • refactor: resolve analysis warnings (#3189)
  • docs: fix inline doc comment (#3167)
  • docs: update GetStream utm tags (#3136)
  • docs: update VGV sponsors logo (#3125)

8.0.2

  • fix: make onChange and addError protected (#3071)
  • refactor: use late keyword for internal state controller (#3100)
  • refactor: add isClosed to Closable (#3066)
  • refactor: add core interfaces (#3012)
  • refactor: internal reorganization (#3011)
  • docs: update example to follow naming conventions (#3029)

8.0.1

  • fix: allow emit usage within tests (#2982)

8.0.0

  • BREAKING: feat: introduce BlocOverrides API (#2932)
    • Bloc.observer removed in favor of BlocOverrides.runZoned and BlocOverrides.current.blocObserver
    • Bloc.transformer removed in favor of BlocOverrides.runZoned and BlocOverrides.current.eventTransformer
  • BREAKING: refactor: make BlocObserver an abstract class
  • BREAKING: feat: add throws StateError when bloc is closed (#2912)
  • BREAKING: feat: emit throws StateError when bloc is closed (#2913)
  • BREAKING: feat: improve error handling/reporting
    • BlocUnhandledErrorException is removed
    • Uncaught exceptions are always reported to onError and rethrown
    • addError reports error to onError but does not propagate as an uncaught exception
  • BREAKING: feat: restrict scope of emit in Bloc and Cubit
    • In Cubit, emit is protected so it can only be used within the Cubit instance.
    • In Bloc, emit is internal so it cannot be used outside of the internal package implementation.
  • BREAKING: refactor: remove deprecated TransitionFunction
  • BREAKING: refactor: remove deprecated transformEvents
  • BREAKING: refactor: remove deprecated mapEventToState
  • BREAKING: refactor: remove deprecated transformTransitions
  • BREAKING: refactor: remove deprecated listen on BlocBase
  • feat: throw StateError if an event is added without a registered event handler

8.0.0-dev.5

  • BREAKING: feat: introduce BlocOverrides API (#2932)
    • Bloc.observer removed in favor of BlocOverrides.runZoned and BlocOverrides.current.blocObserver
    • Bloc.transformer removed in favor of BlocOverrides.runZoned and BlocOverrides.current.eventTransformer
  • BREAKING: refactor: make BlocObserver an abstract class
  • BREAKING: feat: add throws StateError when bloc is closed (#2912)
  • BREAKING: feat: emit throws StateError when bloc is closed (#2913)

8.0.0-dev.4

  • BREAKING: feat: improve error handling/reporting
    • BlocUnhandledErrorException is removed
    • Uncaught exceptions are always reported to onError and rethrown
    • addError reports error to onError but does not propagate as an uncaught exception

8.0.0-dev.3

  • BREAKING: feat: restrict scope of emit in Bloc and Cubit
    • In Cubit, emit is protected so it can only be used within the Cubit instance.
    • In Bloc, emit is internal so it cannot be used outside of the internal package implementation.

8.0.0-dev.2

  • BREAKING: refactor: remove deprecated listen on BlocBase

8.0.0-dev.1

  • BREAKING: refactor: remove deprecated TransitionFunction
  • BREAKING: refactor: remove deprecated transformEvents
  • BREAKING: refactor: remove deprecated mapEventToState
  • BREAKING: refactor: remove deprecated transformTransitions
  • feat: throw StateError if an event is added without a registered event handler

7.2.1

  • fix: on<E extends Event> should have an EventTransformer<E> instead of EventTransformer<Event>

7.2.0

  • feat: introduce on<Event> API to register event handlers
    • by default events are processed concurrently
  • feat: introduce Bloc.transformer API to configure the default EventTransformer
  • feat: introduce Emitter<State> to trigger state changes
    • call to trigger a state change (alignment with Cubit)
    • forEach as an analogue for await for
    • onEach to simplify subscription management
    • isDone to abort expensive async operations
  • feat: throw StateError if mapEventToState is used in conjunction with on<Event>
  • feat: throw StateError if duplicate event handlers are registered
  • feat: throw AssertionError when emit is called in a completed EventHandler
  • feat: throw AssertionError when emit.onEach and emit.forEach are unawaited
  • DEPRECATE: fix: mapEventToState deprecated in favor of on<Event>
  • DEPRECATE: fix: transformEvents deprecated in favor of EventTransformer
    • use a built in EventTransformer or define your own
  • DEPRECATE: fix: transformTransitions deprecated
    • override Stream<State> get stream to modify the outbound stream

7.2.0-dev.3

  • BREAKING: refactor: require emit.forEach onData to be synchronous
  • refactor: minor internal optimizations in on<Event> implementation

7.2.0-dev.2

  • BREAKING: refactor!: make onData callback in emit.onEach and emit.forEach named
  • BREAKING: feat!: rename emit.isCanceled to emit.isDone to encapsulate completion and cancelation
  • feat: introduce optional onError in emit.onEach and emit.forEach
  • feat: throw AssertionError when emit is called in a completed EventHandler
  • feat: throw AssertionError when emit.onEach and emit.forEach are unawaited
  • fix: emit.onEach and emit.forEach error propagation when stream emits an error

7.2.0-dev.1

  • feat: introduce on<Event> API to register event handlers
    • by default events are processed concurrently
  • feat: introduce Bloc.transformer API to configure the default EventTransformer
  • feat: introduce Emitter<State> to trigger state changes
    • call to trigger a state change (alignment with Cubit)
    • forEach as an analogue for await for
    • onEach to simplify subscription management
    • isCanceled to abort expensive async operations
  • feat: throw StateError if mapEventToState is used in conjunction with on<Event>
  • feat: throw StateError if duplicate event handlers are registered
  • DEPRECATE: fix: mapEventToState deprecated in favor of on<Event>
  • DEPRECATE: fix: transformEvents deprecated in favor of EventTransformer
    • use a built in EventTransformer or define your own
  • DEPRECATE: fix: transformTransitions deprecated
    • override Stream<State> get stream to modify the outbound stream

7.1.0

  • feat: expose isClosed getter on BlocBase
  • refactor: simplify internal event controller initialization
  • docs: update onChange description in README
  • docs: update GetStream sponsorship urls

7.0.0

  • BREAKING: refactor: Bloc and Cubit extend BlocBase
    • refactor: void onError(Cubit cubit, Object error, StackTrace stackTrace) -> void onError(BlocBase bloc, Object error, StackTrace stackTrace)
    • refactor: void onCreate(Cubit cubit) -> void onCreate(BlocBase bloc)
    • refactor: void onClose(Cubit cubit) -> void onClose(BlocBase bloc)
  • BREAKING: refactor: Bloc and Cubit do not extend Stream and implement Sink
    • refactor: use bloc.stream or cubit.stream to access Stream<State>
      • myBloc.map(...) -> myBloc.stream.map(...)
    • refactor: deprecate bloc.listen in favor of bloc.stream.listen
  • BREAKING: refactor: CubitUnhandledErrorException -> BlocUnhandledErrorException
  • BREAKING: opt into null safety
    • feat!: upgrade Dart SDK constraints to >=2.12.0-0 <3.0.0
  • fix: transformEvents multiple subscriptions issue
  • test: improve testing for advanced transformEvents behavior
  • chore: bump to meta: ^1.3.0

7.0.0-nullsafety.4

  • BREAKING: refactor: Bloc and Cubit extend BlocBase
    • refactor: void onError(Bloc bloc, Object error, StackTrace stackTrace) -> void onError(BlocBase bloc, Object error, StackTrace stackTrace)
    • refactor: void onCreate(Bloc bloc) -> void onCreate(BlocBase bloc)
    • refactor: void onClose(Bloc bloc) -> void onClose(BlocBase bloc)
  • BREAKING: refactor: Bloc and Cubit do not extend Stream and implement Sink
    • refactor: use bloc.stream or cubit.stream to access Stream<State>
      • myBloc.map(...) -> myBloc.stream.map(...)
    • refactor: deprecate bloc.listen in favor of bloc.stream.listen
  • BREAKING: revert: refactor: Change and onChange removed in favor of Transition and onTransition

7.0.0-nullsafety.3

  • fix: transformEvents multiple subscriptions issue
  • test: improve testing for advanced transformEvents behavior

7.0.0-nullsafety.2

  • chore: bump to meta: ^1.3.0

7.0.0-nullsafety.1

  • BREAKING: refactor: Cubit extends Bloc
    • refactor: Change and onChange removed in favor of Transition and onTransition
    • refactor: void onError(Cubit cubit, Object error, StackTrace stackTrace) -> void onError(Bloc bloc, Object error, StackTrace stackTrace)
    • refactor: void onCreate(Cubit cubit) -> void onCreate(Bloc bloc)
    • refactor: void onClose(Cubit cubit) -> void onClose(Bloc bloc)
    • refactor: CubitUnhandledErrorException -> BlocUnhandledErrorException

7.0.0-nullsafety.0

  • BREAKING: opt into null safety
  • feat!: upgrade Dart SDK constraints to >=2.12.0-0 <3.0.0

6.1.3

  • fix: transformEvents multiple subscriptions issue due to v6.1.2

6.1.2

  • fix: bloc memory leak due to internal event stream being a broadcast stream

6.1.1

  • fix: close should always emit done

6.1.0

  • feat: add onCreate and onClose to BlocObserver

6.0.3

  • docs: README updates to include flow diagrams for Bloc and Cubit.

6.0.2

  • refactor: cubit internal memory and performance optimizations

6.0.1

  • docs: minor documentation fixes and improvements

6.0.0

  • BREAKING: do not emit current state on subscription
  • BREAKING: onError in BlocObserver takes a Cubit as first parameter
  • BREAKING: allow blocs and cubits to emit the initial state
  • feat: include cubit and remove external dependency on package:cubit
    • exports class Cubit
    • exports class Change (Transition for Cubit)
  • feat: onChange added to BlocObserver
  • refactor: apply additional lint rules
  • fix: add @visibleForTesting to emit on class Cubit
  • docs: fix inline documentation references

6.0.0-dev.2

  • fix: add @visibleForTesting to emit on class Cubit

6.0.0-dev.1

  • BREAKING: do not emit current state on subscription
  • BREAKING: onError in BlocObserver takes a Cubit as first parameter
  • BREAKING: allow blocs and cubits to emit the initial state
  • feat: include cubit and remove external dependency on package:cubit
    • exports class Cubit
    • exports class Change (Transition for Cubit)
  • feat: onChange added to BlocObserver
  • refactor: apply additional lint rules
  • docs: fix inline documentation references

5.0.1

  • fix: upgrade to cubit ^0.1.2
  • docs: minor documentation updates

5.0.0

  • BREAKING: remove initialState override in favor of providing the initial state via super (#1304).
  • BREAKING: Remove BlocSupervisor and rename BlocDelegate to BlocObserver.
  • feat: support null states (#1312).
  • refactor: bloc to extend cubit rather than Stream.
  • feat: ignore newly added events after bloc is closed (#1236).
  • feat: add addError to conform to EventSink interface.
  • feat: mark onError, onTransition, onEvent as protected.
  • docs: documentation improvements
  • docs: logo updates

5.0.0-dev.11

  • feat: add addError to conform to EventSink interface.
  • feat: mark onError, onTransition, onEvent as protected.

5.0.0-dev.10

  • docs: additional minor improvement to bloc logo alignment

5.0.0-dev.9

  • docs: minor improvement to bloc logo alignment

5.0.0-dev.8

  • BREAKING: Remove BlocSupervisor and rename BlocDelegate to BlocObserver.

5.0.0-dev.7

  • Ignore newly added events after bloc is closed (#1236).

5.0.0-dev.6

  • Additional documentation optimizations.

5.0.0-dev.5

  • Optimize documentation assets for smaller viewports.

5.0.0-dev.4

  • Update to cubit ^0.0.13
  • Update documentation and static assets.

5.0.0-dev.3

  • Update documentation and static assets.

5.0.0-dev.2

  • BREAKING: update initialState to be a required positional parameter (related issue).

5.0.0-dev.1

  • BREAKING: remove initialState override in favor of providing the initial state via super (#1304).
  • feat: support null states (#1312).
  • refactor: bloc to extend cubit rather than Stream.

4.0.0

  • Remove rxdart dependency (#821)
  • Replace transformStates with transformTransitions (#840)
  • Fix null stackTrace in onError (#963)
  • Fix remove duplicate terminating state
  • Add mustCallSuper to onEvent, onTransition, and onError
  • Surface Unhandled Bloc Errors in Debug Mode
  • Internal testing improvements

4.0.0-dev.4

  • Surface Unhandled Bloc Errors in Debug Mode
  • Internal testing improvements

4.0.0-dev.3

  • Add mustCallSuper to onEvent, onTransition, and onError

4.0.0-dev.2

  • Fix remove duplicate terminating state

4.0.0-dev.1

  • Remove rxdart dependency (#821)
  • Replace transformStates with transformTransitions (#840)
  • Fix null stackTrace in onError (#963)

3.0.0

  • Upgrade to rxdart ^0.23.0
  • Upgrade to Dart >= 2.6.0

3.0.0-dev.1

  • Upgrade to rxdart ^0.23.0

2.0.0

  • Allow blocs to finish processing pending events on close (#639)
  • Documentation Updates

1.0.1

  • Bugfix: Exceptions thrown in onTransition are passed to onError and should not break bloc functionality (#641)
  • Adhere to effective dart (#561)
  • Documentation and Example Updates

1.0.0

  • dispatch and dispose removed
  • Documentation Updates

0.16.1

  • Minor Documentation Updates

0.16.0

  • Bloc extends Stream<State> (#558)
    • bloc.state.listen -> bloc.listen
    • bloc.currentState -> bloc.state
  • Bloc implements Sink<Event> (#558)
    • dispatch deprecated in favor of add
    • dispose deprecated in favor of close
  • Documentation and Example Updates

0.15.0

  • Removed Bloc event Stream (#326)
  • Renamed transform to transformEvents
  • Added transformStates (#382)

0.14.4

Additional Dependency and Documentation Updates.

0.14.3

Dependency and Documentation Updates.

0.14.2

  • Deprecated Bloc event Stream (#326)
  • Documentation Updates

0.14.1

Internal BlocDelegate update and Documentation Updates.

0.14.0

BlocDelegate initialization improvements and Documentation Updates.

  • BlocSupervisor().delegate = ... is now BlocSupervisor.delegate = ... (#304).

0.13.0

Bloc and BlocDelegate Improvements, new Features, and Documentation Updates.

  • Improved dispose to ignore pending events (#257).
  • Exposed event stream on Bloc similar to state stream to expose a Stream of dispatched events (#259).
  • Update to use rxdart version ^0.22.0 (#265).
  • BlocDelegate methods include a reference to the Bloc instance (#259).
  • Added onEvent to Bloc and BlocDelegate (#259).

0.12.0

Updated transform to enable advanced event filtering and processing and Documentation Updates.

0.11.2

Added BlocDelegate onError and onTransition mustCallSuper and Documentation Updates

0.11.1

Added dispose mustCallSuper and Documentation Updates

0.11.0

Update mapEventToState to remove unnecessary argument for currentState

  • Stream<S> mapEventToState(S currentState, E event) -> Stream<S> mapEventToState(E event)
  • Documentation Updates
  • Example Updates

0.10.0

Updated to rxdart ^0.21.0 and Documentation Updates

0.9.5

Minor Enhancements to Code Style and Documentation.

0.9.4

Calls to dispatch after dispose has been called trigger onError in the Bloc and BlocDelegate.

0.9.3

Restrict rxdart to ">=0.18.1 <0.21.0" due to breaking changes.

0.9.2

Additional Minor Updates to Documentation

0.9.1

Minor Updates to Documentation

0.9.0

Bloc and BlocDelegate Error Handling

  • Added onError to Bloc for local error handling.
  • Added onError to BlocDelegate for global error handling.

0.8.4

Blocs handle exceptions thrown in mapEventToState and documentation updates.

0.8.3

Minor Internal Improvements and Documentation Updates

0.8.2

Additional Minor Updates to Documentation

0.8.1

Minor Updates to Documentation

0.8.0

Blocs ignore duplicate states

0.7.8

Additional Minor Updates to Documentation

0.7.7

Additional Minor Updates to Documentation

0.7.6

Minor Updates to Documentation

0.7.5

Exposed currentState in Bloc

  • Updates to Documentation.

0.7.4

Updated mapEventToState parameter name

  • Stream<S> mapEventToState(S state, E event) -> Stream<S> mapEventToState(S currentState, E event)
  • Updates to Documentation.
  • Updates to Example.

0.7.3

Minor Updates to Documentation

0.7.2

Transition Fix

  • Bloc with mapEventToState which returns multiple states per event will now correctly report the Transitions.

0.7.1

Improvements to Bloc usage in pure Dart applications.

  • Bloc state is seeded with initialState automatically

0.7.0

Added BlocSupervisor and BlocDelegate.

  • BlocSupervisor notifies BlocDelegate of Transitions
  • BlocDelegate exposes onTransition which is invoked for all Bloc Transitions.

0.6.0

Transitions and initialState updates.

  • Added Transitions and onTransition
  • Made initialState required

0.5.2

Additional minor Updates to Documentation.

0.5.1

Minor Updates to Documentation

0.5.0

Moved Flutter Widgets to flutter_bloc package

0.4.2

Additional minor Updates to Documentation.

0.4.1

Minor Updates to Documentation.

0.4.0

Added BlocProvider.

  • BlocProvider.of(context)
  • Updates to Documentation.
  • Updates to Example.

0.3.0

Updated mapEventToState to take current state as an argument.

  • Stream<S> mapEventToState(E event) -> Stream<S> mapEventToState(S state, E event)
  • Updates to Documentation.
  • Updates to Example.

0.2.5

Additional Minor Updates to Documentation.

0.2.4

Additional Minor Updates to Documentation.

0.2.3

Additional Minor Updates to Documentation.

0.2.2

Additional Minor Updates to Documentation.

0.2.1

Minor Updates to Documentation.

0.2.0

Added Support for Stream Transformation

  • Includes Stream<E> transform(Stream<E> events)
  • Updates to Documentation

0.1.2

Additional Minor Updates to Documentation.

0.1.1

Minor Updates to Documentation.

0.1.0

Initial Version of the library.

  • Includes the ability to create a custom Bloc by extending Bloc class.
  • Includes the ability to connect presentation layer to Bloc by using the BlocBuilder Widget.