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.
AutoDispatchEffect
A mixin to execute the effect on initialization.
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.
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.
MultiMemoInterceptor<T, A>
It allows multiple memoization interceptors to be used together.
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.
RtDependencyLifecycle
It's a mixin that provides a set of methods that can be used to observe the lifecycle of a dependency.
RtDependencyObserver
A class that implements the IDependencyObserver interface. This class can be used to monitor the lifecycle of dependencies.
RtDependencyRef<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.
RtStateObserver
A class that implements the IStateObserver interface.
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