reactter library

Classes

Args<A>
A class that represents an argument
Args1<A>
A class that represents an argument
Args2<A, A2>
A class that represents a set of two arguments.
Args3<A, A2, A3>
A class that represents a set of three arguments.
AsyncMemoSafe<T, A>
It's a memoization interceptor that prevents saving in cache if the Future calculation function throws an error when executed.
DispatchEffect
Memo<T, A>
A class callable that is used for memoizing values(T) returned by a calcutate function(calculateValue).
MemoInterceptor<T, A>
It allows for intercepting the memoizing function calls.
MemoInterceptors<T, A>
It allows multiple memoization interceptors to be used together.
MemoInterceptorWrapper<T, A>
It´s a wrapper for a memoized function that allows you to define callbacks for initialization, successful completion, error handling, and finishing.
Obj<T>
A base-class that store a value of T.
ObjBase<T>
ReactterAction<T>
A representation of an event that describes something that happened in the application.
ReactterActionCallable<T, P>
A abstract class of ReactterAction that may be called using a call method.
ReactterEventManager
A abstract-class that adds events management features to classes that use it.
ReactterHook
An abstract-class that provides the functionality of ReactterState.
ReactterInstance<T>
A generic class that represents an instance of a Reactter object and provides methods for generating unique keys and retrieving the stored instance.
ReactterInstanceManager
A mixin-class that adds instances management features to classes that use it.
ReactterLogger
ReactterNotifier
ReactterState
A abstract class that represents a stare in Reactter.
ReactterStateImpl
An implementation of the ReactterState.
Signal<T>
A base-class that store a value of T and notify the listeners when the value is updated.
TemporaryCacheMemo<T, A>
It's a memoization interceptor that removes memoized values from the cache after a specified duration.
UseAsyncState<T>
A ReactteHook that manages the state as async way.
UseAsyncStateArg<T, A>
A ReactteHook that manages the state as async way.
UseCompute<T>
A ReactterHook that allows to compute a value using a predetermined compute function and a list of state dependencies, and which automatically updates the computed value if a dependency changes.
UseEffect
A ReactterHook that manages side-effect.
UseEvent<T extends Object?>
A hook that manages events.
UseInstance<T extends Object>
A ReactterHook that allows to manages an instance of T with/without id.
UseReducer<T>
A ReactterHook that manages state using reducer method.
UseState<T>
A ReactterHook that manages a state.

Enums

InstanceManageMode
Represents different ways for managing instances.
Lifecycle
SignalEvent
This enumeration is used to represent different events that can occur when getting or setting the value of a Signal object.
UseAsyncStateStatus

Properties

Reactter → ReactterInterface
final

Functions

defaultLogWriterCallback(String value, {bool isError = false}) → void

Typedefs

ArgsX2<T> = Args2<T, T>
ArgsX3<T> = Args3<T, T, T>
AsyncFunction<T> = FutureOr<T> Function()
to represent an async function without arguments
AsyncFunctionArg<T, A> = Future<T> Function(A arg)
to represent an async function with arguments
CallbackEvent<T extends Object?, P> = dynamic Function(T? inst, P param)
to represent an event callback
FunctionArg<T, A> = T Function(A arg)
to represent a function with arguments
FunctionArgMemo<T, A> = void Function(Memo<T, A> memo, A arg)
FunctionErrorMemo<T, A> = void Function(Memo<T, A> memo, A arg, Object error)
FunctionMemo<T, A> = T Function(A, {bool overrideCache})
FunctionValueMemo<T, A> = void Function(Memo<T, A> memo, A arg, T value, bool fromCache)
InstanceBuilder<T> = T Function()
A function to generate the instance of T
LogWriterCallback = void Function(String text, {bool isError})
Reactter.log type
Reducer<T> = T Function(T state, ReactterAction action)
to represent a reducer method
UseContext<T extends Object> = UseInstance<T>
A ReactterHook that allows to get the T instance with/without id from dependency store when it's ready.
WhenErrorReturn<R> = R Function(Object? value)
UseAsyncState.when's parameter type for representing a error
WhenValueReturn<T, R> = R Function(T value)
UseAsyncState.when's parameter type for representing a value