safe_bloc library

Classes

BaseEffect

General parent effect.

Emitter<State>

An Emitter is a class which is capable of emitting new states.

EmptyTrackableError

Use as "error" without actual exception.

ErrorIdService

GeneralTrackableError

ITrackable

ITrackableError

SafeBloc<EVENT, STATE>

An extended class to SafeBlocWithPresentation that uses BaseEffect class as EFFECT. Additionally, it also emits an UnexpectedErrorEffect if exception occurs during some use action.

SafeBlocBase<STATE, EFFECT>

SafeBlocWithPresentation<EVENT, STATE, EFFECT>

A class that extends Bloc and encapsulates the Emitter with a SafeEmitter that catches all exceptions using a try-catch block and processes them based on specified parameters.

SafeCubit<STATE>

An extended class to SafeCubitWithPresentation that uses BaseEffect class as EFFECT. Additionally, it also emits an UnexpectedErrorEffect if exception occurs during some use action.

SafeCubitWithPresentation<STATE, EFFECT>

A class that extends Cubit for a safeCall method that catches all exceptions using a try-catch block and processes them based on specified parameters.

SafeEmitter<State>

An SafeEmitter is a class which is capable of emitting new states. Also checks if stateController is not closed before each emit.

TrackableError<T>

TrackingIdService

UnexpectedError

Object that stores information about exceptions thrown in Blocs and Cubits.

UnexpectedErrorBase

API that is implemented by Bloc/Cubit's error states and effects.

UnexpectedErrorEffect

Error effect that is emitted by SafeBloc/SafeCubit if exception in its event handler/method occurs.

UnexpectedErrorHandler<BLOC extends SafeBlocBase<STATE, BaseEffect>, STATE>

Widget that listens to the events and states that implement UnexpectedErrorBase in specified the BLOC. Subsequently, it calls onErrorAction in case of error event or displays a errorScreen in case of error state.

Mixins

SafeBlocBaseMixin<STATE, EFFECT>

Extensions

CubitExtensions on Cubit<State>

Calls emit only and only if underlying bloc is not closed.

GeneralTrackableErrorExtensions on Object

Functions

blocPresentationTest<B extends BlocPresentationMixin<State, Event>, State, Event>(String description, {required B build(), AsyncFutureOrVoidCallback? setUp, State seed()?, FutureOr<void> act(B bloc)?, Duration? wait, int skip = 0, List<State> expect()?, FutureOr<void> verify(B bloc)?, Matcher errors()?, AsyncFutureOrVoidCallback? tearDown, Object? tags, List<Event> expectEvents()?}) → void

Typedefs

AsyncFutureOrVoidCallback = FutureOr<void> Function()

Callback = Future<void> Function(String trackingId)

Emit<STATE> = void Function(STATE state)

ErrorEffectGetter<EFFECT> = EFFECT Function(UnexpectedError error)

ErrorMapper<STATE> = STATE? Function(ITrackableError error)

ErrorStateGetter<STATE> = STATE Function(UnexpectedError error)

InvokeEffect<EFFECT> = void Function(EFFECT effect)

OnError = Future<void> Function(ITrackableError error, StackTrace stackTrace, String trackingId)

OnErrorSync = void Function(ITrackableError error, StackTrace stackTrace, String trackingId)

OnIgnoreError = Future<void> Function(ITrackableError error, StackTrace stackTrace)

SafeEventHandler<Event, State> = FutureOr<void> Function(Event event, SafeEmitter<State> emit, {required String trackingId})

An event handler is responsible for reacting to an incoming Event and can emit zero or more states via the SafeEmitter. Contains a unique trackingId that can be passed to emitter for tracking the event.

SyncCallback = void Function(String trackingId)

TrackingId = String

UnexpectedErrorActionCallback = Future<void> Function(BuildContext context, UnexpectedError error)

UnexpectedErrorWidgetBuilder = Widget Function(BuildContext context, UnexpectedError error)