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.
DispatchEffect
LifecycleObserver
It's a mixin that provides a set of methods that can be used to observe the lifecycle of a dependency.
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.
MemoMultiInterceptor<T, A>
It allows multiple memoization interceptors to be used together.
MemoSafeAsyncInterceptor<T, A>
It's a memoization interceptor that prevents saving in cache if the Future calculation function throws an error when executed.
MemoTemporaryCacheInterceptor<T, A>
It's a memoization interceptor that removes memoized values from the cache after a specified duration.
MemoWrapperInterceptor<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>
RtAction<T>
A representation of an event that describes something that happened in the application.
RtActionCallable<T, P>
A abstract class of RtAction that may be called using a call method.
RtDependency<T>
Represents dependency managed by Reactter's dependency injection.
RtHook
An abstract-class that provides the functionality of RtState.
RtInterface
A class that represents the interface for Rt.
RtState
A abstract class that represents a stare in Reactter.
RtStateImpl
An implementation of the RtState.
Signal<T>
A base-class that store a value of T and notify the listeners when the value is updated.
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 RtHook 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.
UseDependency<T extends Object>
A RtHook that allows to manages a dependency of T with/without id.
UseEffect
A RtHook that manages side-effect.
UseReducer<T>
A RtHook that manages state using reducer method.
UseState<T>
A RtHook that manages a state.

Enums

DependencyMode
Represents different ways for managing instances.
Lifecycle
LogLevel
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 → RtInterface
This class represents the interface for the Reactter framework. It provides methods and properties for interacting with the Reactter framework.
final
Rt → RtInterface
final

Functions

defaultLogWriterCallback(String value, {Object? error, LogLevel? level = LogLevel.info}) → 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
AsyncMemoSafe<T, A> = MemoSafeAsyncInterceptor<T, A>
It's a memoization interceptor that prevents saving in cache if the Future calculation function throws an error when executed.
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 dependency.
LogWriterCallback = void Function(String text, {Object error, LogLevel level})
Rt.log type
MemoInterceptors<T, A> = MemoMultiInterceptor<T, A>
It allows multiple memoization interceptors to be used together.
MemoInterceptorWrapper<T, A> = MemoWrapperInterceptor<T, A>
It´s a wrapper for a memoized function that allows you to define callbacks for initialization, successful completion, error handling, and finishing.
ReactterAction<T> = RtAction<T>
A representation of an event that describes something that happened in the application.
ReactterActionCallable = RtActionCallable
A abstract class of RtAction that may be called using a call method.
ReactterDependency<T> = RtDependency<T>
Represents dependency managed by Reactter's dependency injection.
ReactterHook = RtHook
An abstract-class that provides the functionality of RtState.
ReactterInstance<T> = RtDependency<T>
Represents dependency managed by Reactter's dependency injection.
ReactterInterface = RtInterface
A class that represents the interface for Rt.
ReactterState = RtState
A abstract class that represents a stare in Reactter.
ReactterStateImpl = RtStateImpl
An implementation of the RtState.
Reducer<T> = T Function(T state, RtAction action)
to represent a reducer method
TemporaryCacheMemo<T, A> = MemoTemporaryCacheInterceptor<T, A>
It's a memoization interceptor that removes memoized values from the cache after a specified duration.
UseInstance<T extends Object> = UseDependency<T>
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