flutter_triple library

Classes

Atom<T>
Extension to ValueNotifier by transparently applying functional reactive programming (TFRP).
AtomObserver
Tracker of all atom`s changes;
BaseStore<State>
BaseStore abstract class
DispatchedTriple<State>
DispatchedTriple class
EitherAdapter<Left, Right>
EitherAdapter abstract class
HydratedDelegate
HydratedDelegate abstract class
MemoryHydratedDelegate
MemoryHydratedDelegate class implements HydratedDelegate
Reducer
The layer responsible for making business decisions to perform actions and modify Atoms;
RxBuilder
Listen for Atom changes present in the builder method.
builder: All Atom used in this function will be automatically signed and this function will be called every time the value of an Atom changes. filter: Filter reactions and prevent unwanted effects.
RxCallback
Used to assign effect functions that will react to the reactivity of the declared Atom, similar to the rxObserver function.
RxDisposer
Remove all listeners of rxObserver;
RxFuture<T>
The RxFuture is the reactive wrapper around a Future. You can use it to show the UI under various states of a Future, from pending to fulfilled or rejected.
RxList<T>
An RxList gives you a deeper level of observability on a list of values. It tracks when items are added, removed or modified and notifies the observers.
RxMap<K, V>
An RxMap gives you a deeper level of observability on a map of values. It tracks when keys are added, removed or modified and notifies the observers.
RxRoot
Responsible for propagating Atom values as a dependency of a child Widget.
RxRoot should be one of the first Widgets in the Flutter tree.
RxSet<T>
An RxSet gives you a deeper level of observability on a set of values. It tracks when values are added, removed or modified and notifies the observers.
RxStream<T>
The RxStream is the reactive wrapper around a StreamSubscription. You can use it to show the UI under various states of a Stream, from waiting to active, done or rejected.
RxValueListenable<T>
An interface for subclasses of Listenable that expose a value.
RxVoid
Void return
ScopedBuilder<TStore extends BaseStore<TState>, TState>
ScopedBuilder it's the type <TStore extends Store<TError, TState>, TError extends Object, TState extends Object>
ScopedConsumer<TStore extends BaseStore<TState>, TState>
The typedef TransitionCallback receive Widget Function(BuildContext context, Widget child,) ScopedConsumer it's the type Store
ScopedListener<TStore extends BaseStore<TState>, TState>
ScopedListener it's the type <TStore extends Store<TError, TState>, TError extends Object, TState extends Object>
Selectors<ErrorRx, StateRx, LoadingRx>
Selectors abstract class
Serializable<T>
Serializable abstract class
Store<State>
Store it's an abstract class that implements Selectors<ValueListenable<Error?>, ValueListenable
Triple<State>
Triple class
TripleBuilder<TStore extends BaseStore<TState>, TState>
TripleBuilder class it's the type <TStore extends Store<TError, TState>, TError extends Object, TState extends Object>
TripleConsumer<TStore extends BaseStore<TState>, TError extends Object, TState extends Object>
TripleConsumer class it's the type <TStore extends Store<TError, TState>, TError extends Object, TState extends Object>
TripleListener<TStore extends BaseStore<TState>, TState>
TripleListener class it's the type <TStore extends Store<TError, TState>, TError extends Object, TState extends Object>
TripleObserver
TripleObserver class
ValueListenable<T>
An interface for subclasses of Listenable that expose a value.

Enums

FutureStatus
RxFuture status values.
StreamStatus
RxStream status values.
TripleEvent

Mixins

HydratedMixin<State>
HydratedMixin mixin
MementoMixin<State>

Extensions

ContextSelectionExtension on BuildContext
Propagates the changes of the Atom placed in the body function in this widget.
To use this feature, you need to add RxRoot at the beginning of your application's Widget tree.
ListenableMergeExtension on Listenable
Merge Listenable objects.
RxFutureExtension on Future<T>
Convert a Future to RxFuture.
RxListExtension on List<T>
Convert a List to RxList.
RxMapExtension on Map<K, V>
Convert a Map to RxMap.
RxSetExtension on Set<T>
Convert a Set to RxSet.
RxStreamExtension on Stream<T>
Convert a Stream to RxStream.
ValueNotifierParse on ValueListenable<T>
Convert a ValueListenable to Atom.

Constants

rxVoid → const RxVoid
Void return

Functions

debounceTime<T>([Duration duration = const Duration(milliseconds: 500)]) → PipeCallback<T>
Emits a notification from an Atom only after a specified period of time has passed without another source issuing.
distinct<T>() → PipeCallback<T>
Skips data value if they are equal to the previous data value.
getTripleResolver<TBaseStore extends BaseStore>() → TBaseStore
The function getTripleResolver it's the type TBaseStore
interval<T>([Duration duration = const Duration(milliseconds: 500)]) → PipeCallback<T>
Emits a notification from an Atom after a given duration.
multiPipe<T>(List<PipeCallback<T>> pipes) → PipeCallback<T>
Concat many pipes.
rxNext<T>(RxValueListenable<T> rx, {Duration timeLimit = const Duration(seconds: 10)}) → Future<T>
Wait the next change of a Atom. The timeLimit is 10 seconds by default.
rxObserver<T>(T? body(), {bool filter()?, void effect(T? value)?}) → RxDisposer
Listen for Atom changes present in the body.
body: All Atom used in this function will be automatically signed and this function will be called every time the value of an Atom changes. filter: Filter reactions and prevent unwanted effects.
effect: The body function generates a value that can be retrieved from the effect function.
setTripleHydratedDelegate(HydratedDelegate delegate) → void
The function setTripleHydratedDelegate it's the type void and receive the param delegate it's the type HydratedDelegate
setTripleResolver(TripleResolverCallback tripleResolver) → void
The function setTripleResolver it's the type void and receive the param tripleResolver it's the type TripleResolverCallback
throttleTime<T>([Duration duration = const Duration(milliseconds: 500)]) → PipeCallback<T>
Emits a notification from an Atom, then ignores subsequent source values for duration milliseconds, then repeats this process.

Typedefs

Disposer = Future<void> Function()
The typedef Disposer receive Future
PipeCallback<T> = void Function(T value, void emit(T value))
Used in Atom.pipe propetie
TransitionCallback = Widget Function(BuildContext context, Widget child)
The typedef TransitionCallback receive Widget Function(BuildContext context, Widget child,)
TripleCallback = void Function(DispatchedTriple triple)
The typedef TripleCallback receive void Function(DispatchedTriple triple)
TripleResolverCallback = TStore Function<TStore extends Object>()
The typedef TripleResolverCallback receive TStore Function

Exceptions / Errors

TripleException
TripleException class implements Exception