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
LifecycleObserver
It's a mixin that provides a set of methods that can be used to observe the lifecycle of an instance.
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.
ReactterHook
An abstract-class that provides the functionality of ReactterState.
ReactterInstance<T>
Represents an instance of the Reactter framework.
ReactterInterface
A class that represents the interface for Reactter.
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.
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
This class represents the interface for the Reactter framework. It provides methods and properties for interacting with the Reactter framework. ignore: non_constant_identifier_names
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
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, {Object error, LogLevel level})
Reactter.log type
Reducer<T> = T Function(T state, ReactterAction 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