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.
LogLevel
Copy from package:logging. LogLevels to control logging output. Logging can be enabled to include all levels above certain LogLevel. The predefined LogLevel constants below are sorted as follows (in descending order): LogLevel.shout, LogLevel.severe, LogLevel.warning, LogLevel.info, LogLevel.config, LogLevel.fine, LogLevel.finer, LogLevel.finest, and LogLevel.all.
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.
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.
RtDependencyObserver
An abstract class that defines the interface for observing dependency changes. Implementations of this class can be used to monitor the lifecycle of dependencies.
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.
RtStateBase<E extends RtStateBase<E>>
A base class that implements the IState interface.
RtStateObserver
An abstract class that defines the interface for observing state changes. Implementations of this class can be used to monitor the lifecycle of states.
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
SignalEvent
This enumeration is used to represent different events that can occur when getting or setting the value of a Signal object.
UseAsyncStateStatus

Properties

Rt → RtInterface
This class represents the interface for the Reactter framework. It provides methods and properties for interacting with the Reactter framework.
final

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 dependency.
LogOutput = void Function(String message, {required int level, required String name, StackTrace? stackTrace})
An function to specify the log output destination.
Reducer<T> = T Function(T state, RtAction action)
to represent a reducer method
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