signals_flutter library

Classes

AsyncData<T>
State for an AsyncState with a value
AsyncDataRefreshing<T>
A loading state with a value. Signals the query conditions that led to the data has remained the same and is being refreshed
AsyncDataReloading<T>
A loading state with a value. Signals the query conditions that led to the data has changed and is being reloaded.
AsyncError<T>
State for an AsyncState with an error
AsyncErrorRefreshing<T>
A loading state with an error. Signal the query conditions that led to the error has remained the same and is being refreshed.
AsyncErrorReloading<T>
A loading state with an error. Signal the query conditions that led to the error has changed and is being reloaded.
AsyncLoading<T>
State for an AsyncState with a loading state
AsyncSignal<T>
The signal function creates a new signal. A signal is a container for a value that can change over time. You can read a signal's value or subscribe to value updates by accessing its .value property.
AsyncState<T>
AsyncState is class commonly used with Future/Stream signals to represent the states the signal can be in.
ChangeStackSignal<T>
Change stack signal that can be used to call undo/redo on a value.
Computed<T>
Data is often derived from other pieces of existing data. The computed function lets you combine the values of multiple signals into a new signal that can be reacted to, or even used by additional computeds. When the signals accessed from within a computed callback change, the computed callback is re-executed and its new return value becomes the computed signal's value.
Connect<T, S extends T>
The idea for connect comes from Anguar Signals with RxJS:
DevToolsSignalsObserver
Signals DevTools observer
Effect
The effect function is the last piece that makes everything reactive. When you access a signal inside its callback function, that signal and every dependency of said signal will be activated and subscribed to. In that regard it is very similar to computed(fn). By default all updates are lazy, so nothing will update until you access a signal inside effect.
ElementWatcher
Helper class to track signals and effects with the lifecycle of an element.
FlutterComputed<T>
A signal based on the value of a computation
FlutterReadonlySignal<T>
Simple writeable single
FlutterSignal<T>
Simple writeable single
FutureSignal<T>
Future signals can be created by extension or method.
IterableSignal<E>
A Signal that holds a Iterable.
ListSignal<E>
A Signal that holds a List.
LoggingSignalsObserver
Logs all signals and computed changes to the console.
MapSignal<K, V>
A Signal that holds a Map.
PersistedBoolSignal
A PersistedSignal that stores a boolean value.
PersistedDoubleSignal
A PersistedSignal that stores an double value.
PersistedEnumSignal<T extends Enum>
A PersistedSignal that stores an enum value.
PersistedIntSignal
A PersistedSignal that stores an integer value.
PersistedNullableDoubleSignal
A PersistedSignal that stores a nullable double value.
PersistedNullableIntSignal
A PersistedSignal that stores a nullable integer value.
PersistedNullableNumSignal
A PersistedSignal that stores a nullable numeric value.
PersistedNullableStringSignal
A PersistedSignal that stores a nullable string value.
PersistedNumSignal
A PersistedSignal that stores a numeric value.
PersistedPersistedBoolSignal
A PersistedSignal that stores a nullable string value.
PersistedPersistedEnumSignal<T extends Enum>
A PersistedSignal that stores a nullable enum value.
PersistedSignal<T>
A signal that persists its value in a key-value store.
PersistedStringSignal
A PersistedSignal that stores a string value.
QueueSignal<T>
A Signal that holds a Queue.
ReadonlySignal<T>
Read only signals can just retrieve a value but not update or cause mutations
SetSignal<E>
A Signal that holds a Set.
Signal<T>
Simple writeable signal
SignalContainer<T, Arg, S extends ReadonlySignalMixin<T>>
Signal container used to create signals based on args
SignalProvider<T extends FlutterReadonlySignal>
Signal notifier widget
SignalsInMemoryKeyValueStore
An in-memory implementation of SignalsKeyValueStore.
SignalsKeyValueStore
An abstract class that defines the contract for a key-value store to be used with PersistedSignal.
SignalsObserver
You can observe all signal values in the dart application by providing an implementation of SignalsObserver:
StreamSignal<T>
Stream signals can be created by extension or method.
TickerSignal
Ticker signal used to drive animations and can create animation controllers
TimerSignal
Emit recurring TimerSignalEvent aka AsyncSignal
TrackedSignal<T>
A signal that stores the initial and previous value
Watch<T extends Widget>
Watch
WatchBuilder<T extends Widget>
Watch

Mixins

ChangeStackSignalMixin<T>
Change stack signal that can be used to call undo/redo on a value.
EventSinkSignalMixin<T>
EventSink implementation for AsyncState
IterableSignalMixin<E, T extends Iterable<E>>
Mixin to upgrade an iterable signal with reactive properties
ListSignalMixin<E, T extends List<E>>
Mixin to upgrade an list signal with reactive properties
MapSignalMixin<K, V, T extends Map<K, V>>
Mixin to upgrade an map signal with reactive properties
PersistedSignalMixin<T>
A mixin that provides the persistence logic for a signal.
QueueSignalMixin<T, S extends Queue<T>>
Mixin to upgrade an queue signal with reactive properties
ReadonlySignalMixin<T>
Readonly signal mixin for adding addition helper methods
SetSignalMixin<E, T extends Set<E>>
Mixin to upgrade an set signal with reactive properties
SignalsAutoDisposeMixin<T>
Mixin to enable autodispose on a signal
SignalsMixin<T extends StatefulWidget>
Signals mixin that will automatically rebuild the widget tree when any of the signals change and dispose of any signals and effects created locally.
SinkSignalMixin<T>
Sink implementation for Signal
StreamSignalMixin<T>
Stream implementation for AsyncState
TrackedSignalMixin<T>
Get the previous and initial values used
ValueListenableSignalMixin<T>
ValueListenable implementation for ReadonlySignal
ValueNotifierSignalMixin<T>
ValueNotifier implementation for Signal

Extensions

AsyncSignalState on Signal<AsyncState<T>>
Extensions for Signal<AsyncState<T>>
BoolSignalExtension on ReadonlySignal<bool>
Helper extensions for ReadonlySignal<bool>
ComparableSignalExtension on ReadonlySignal<T>
Helper extensions for ReadonlySignal<Comparable<T>>
DoubleSignalExtension on ReadonlySignal<double>
Helper extensions for ReadonlySignal<double>
EnumSignalExtension on ReadonlySignal<Enum>
Helper extensions for ReadonlySignal<Enum>
FlutterReadonlySignalUtils on ReadonlySignal<T>
Signal extensions
IntSignalExtension on ReadonlySignal<int>
Helper extensions for ReadonlySignal<int>
ListSignalExtension on Signal<List<E>>
Helper extensions for Signal<List>
MapSignalExtension on Signal<Map<K, V>>
Helper extensions for Signal<Map>
NumSignalExtension on ReadonlySignal<num>
Helper extensions for ReadonlySignal<num>
PatternSignalExtension on ReadonlySignal<Pattern>
Helper extensions for ReadonlySignal<Pattern>
ReadonlyIterableSignalExtension on ReadonlySignal<Iterable<E>>
Helper extensions for ReadonlySignal<Iterable>
ReadonlyListSignalExtension on ReadonlySignal<List<E>>
Helper extensions for ReadonlySignal<List>
ReadonlyMapSignalExtension on ReadonlySignal<Map<K, V>>
Helper extensions for ReadonlySignal<Map>
ReadonlySetSignalExtension on ReadonlySignal<Set<E>>
Helper extensions for ReadonlySignal<Set>
ReadonlySignalUtils on ReadonlySignal<T>
Readonly signal extensions
SetSignalExtension on Signal<Set<E>>
Helper extensions for Signal<Set>
SignalBoolExtensions on bool
Extensions for bool
SignalComparableExtensions on Comparable<T>
Extensions for Comparable<T>
SignalDoubleExtensions on double
Extensions for double
SignalEnumExtensions on T
Extensions for Enum
SignalFunctionExtensions on T Function()
Extensions for T Function()
SignalFutureUtils on Future<T>
Extension on future to provide helpful methods for signals
SignalIntExtensions on int
Extensions for int
SignalIterableExtensions on Iterable<E>
Extensions for Iterable<E>
SignalIterableUtils on Iterable<T>
Extension on future to provide helpful methods for signals
SignalListExtensions on List<E>
Extensions for List<E>
SignalListUtils on List<T>
Extension on future to provide helpful methods for signals
SignalMapExtensions on Map<K, V>
Extensions for Map<E>
SignalMapUtils on Map<K, V>
Extension on future to provide helpful methods for signals
SignalNumExtensions on num
Extensions for num
SignalPatternExtensions on Pattern
Extensions for Pattern
SignalQueueUtils on Queue<T>
Extension on future to provide helpful methods for signals
SignalSetExtensions on Set<E>
Extensions for Set<E>
SignalSetUtils on Set<T>
Extension on future to provide helpful methods for signals
SignalStreamUtils on Stream<T>
Extension on stream to provide helpful methods for signals
SignalStringExtensions on String
Extensions for String
SignalValueListenableUtils on ValueListenable<T>
Extension on ValueListenable to provide helpful methods for signals
SignalValueNotifierUtils on ValueNotifier<T>
Extension on ValueNotifier to provide helpful methods for signals
StringSignalExtension on ReadonlySignal<String>
Helper extensions for ReadonlySignal<String>
TimerSignalDurationUtils on Duration
Expose Duration as a TimerSignal
WriteableSignalUtils on Signal<T>
Writeable signal extensions

Properties

signalsDevToolsEnabled ↔ bool
Check if the signals devtools are enabled
getter/setter pair

Functions

asyncSignal<T>(AsyncState<T> value, {String? debugLabel, bool autoDispose = false}) → AsyncSignal<T>
The signal function creates a new signal. A signal is a container for a value that can change over time. You can read a signal's value or subscribe to value updates by accessing its .value property.
batch<T>(BatchCallback<T> fn) → T
The batch function allows you to combine multiple signal writes into one single update that is triggered at the end when the callback completes.
changeStack<T>(T value, {String? debugLabel, int? limit, bool autoDispose = false}) → ChangeStackSignal<T>
Change stack signal that can be used to call undo/redo on a value.
computed<T>(T compute(), {String? debugLabel, bool autoDispose = false, bool runCallbackOnListen = false}) → FlutterComputed<T>
Create a new signal that is computed based on the values of other signals.
computedAsync<T>(Future<T> fn(), {T? initialValue, String? debugLabel, bool autoDispose = false, List<ReadonlySignal> dependencies = const [], bool lazy = true}) → FutureSignal<T>
Async Computed is syntax sugar around FutureSignal.
computedFrom<T, A>(List<ReadonlySignal<A>> signals, Future<T> fn(List<A> args), {T? initialValue, String? debugLabel, bool autoDispose = false, bool lazy = true}) → FutureSignal<T>
Async Computed is syntax sugar around FutureSignal.
connect<T, S extends T>(Signal<T> signal, [Stream<S>? stream]) → Connect<T, S>
The idea for connect comes from Anguar Signals with RxJS:
disableSignalsDevTools() → void
Disable the devtools
effect(EffectCallback fn, {String? debugLabel, EffectCallback? onDispose}) → EffectCleanup
The effect function is the last piece that makes everything reactive. When you access a signal inside its callback function, that signal and every dependency of said signal will be activated and subscribed to. In that regard it is very similar to computed(fn). By default all updates are lazy, so nothing will update until you access a signal inside effect.
futureSignal<T>(Future<T> fn(), {T? initialValue, String? debugLabel, List<ReadonlySignal> dependencies = const [], bool lazy = true, bool autoDispose = false}) → FutureSignal<T>
Future signals can be created by extension or method.
iterableSignal<T>(Iterable<T> iterable, {String? debugLabel, bool autoDispose = false}) → IterableSignal<T>
Create an IterableSignal from Iterable
lazySignal<T>({String? debugLabel, bool autoDispose = false, bool runCallbackOnListen = false}) → FlutterSignal<T>
Lazy signal that can be created with type T that the value will be assigned later.
listSignal<T>(List<T> list, {String? debugLabel, bool autoDispose = false}) → ListSignal<T>
Create an ListSignal from List
mapSignal<K, V>(Map<K, V> map, {String? debugLabel, bool autoDispose = false}) → MapSignal<K, V>
Create an MapSignal from Map
queueSignal<T>(Queue<T> list, {String? debugLabel, bool autoDispose = false}) → QueueSignal<T>
Create an QueueSignal from Queue
readonly<T>(T value, {String? debugLabel, bool autoDispose = false, bool runCallbackOnListen = false}) → FlutterReadonlySignal<T>
Create a new plain readonly signal
readonlySignalContainer<T, Arg>(ReadonlySignal<T> create(Arg), {bool cache = false}) → SignalContainer<T, Arg, ReadonlySignal<T>>
Create a signal container used to instance signals based on args
reloadSignalsDevTools() → void
Reload the devtools
setSignal<T>(Set<T> list, {String? debugLabel, bool autoDispose = false}) → SetSignal<T>
Create an SetSignal from Set
signal<T>(T value, {String? debugLabel, bool autoDispose = false, bool runCallbackOnListen = false}) → FlutterSignal<T>
Simple signal that can be created with type T that can read and write a value.
signalContainer<T, Arg>(Signal<T> create(Arg), {bool cache = false}) → SignalContainer<T, Arg, Signal<T>>
Create a signal container used to instance signals based on args
streamSignal<T>(Stream<T> callback(), {T? initialValue, String? debugLabel, List<ReadonlySignal> dependencies = const [], void onDone()?, bool? cancelOnError, bool lazy = true, bool autoDispose = false}) → StreamSignal<T>
Stream signals can be created by extension or method.
tickerSignal({Duration? initialDuration, String? debugLabel}) → TickerSignal
Ticker signal used to drive animations and can create animation controllers
timerSignal(Duration every, {String debugLabel = 'Timer', bool? cancelOnError, bool autoDispose = false}) → TimerSignal
Create a TimerSignal
trackedSignal<T>(T value, {String? debugLabel, bool autoDispose = false}) → TrackedSignal<T>
Create a signal that stores the initial and previous value
untracked<T>(UntrackedCallback<T> fn) → T
In case when you're receiving a callback that can read some signals, but you don't want to subscribe to them, you can use untracked to prevent any subscriptions from happening.
unwatchSignal<T>(BuildContext context, ReadonlySignal<T> signal) → void
Remove all subscribers for a given signal for watchers
valueListenableToSignal<T>(ValueListenable<T> valueListenable, {String? debugLabel, bool autoDispose = false}) → ReadonlySignal<T>
SignalValueNotifier
valueNotifierToSignal<T>(ValueNotifier<T> valueNotifier, {String? debugLabel, bool autoDispose = false}) → Signal<T>
SignalValueNotifier
watchSignal<T>(BuildContext context, ReadonlySignal<T> signal, {String? debugLabel}) → T
Watch a signal value and rebuild the context of the Element if mounted and mark it as dirty

Typedefs

AsyncDataBuilder<E, T> = E Function(T value)
Value builder for AsyncState
AsyncErrorBuilder<E> = Function
Error builder for AsyncState
AsyncStateBuilder<E> = E Function()
Generic builder for AsyncState
BatchCallback<T> = T Function()
A callback that is executed inside a batch.
ComputedCallback<T> = T Function()
A callback that is executed inside a computed.
EffectCallback = dynamic Function()
Function called when signals in the callback change
EffectCleanup = void Function()
Clean up function to stop subscriptions from updating the callback
SignalChange<T> = ({T previousValue, T value})
Signal change that contains a snapshot of the previous value and next value
TimerSignalEvent = ({int iteration, int millis})
Time event to react to
UntrackedCallback<T> = T Function()
A callback that is executed inside a computed.

Exceptions / Errors

EffectCycleDetectionError
Cycle detection usually means you have updated a signal inside an effect and are reading by value.
LazySignalInitializationError
Lazy signal must value value set before it is read
SignalEffectException
Error for when a effect fails to run the callback
SignalsError
Signal usage error
SignalsReadAfterDisposeError
Error to throw if a signal is read after it is disposed
SignalsWriteAfterDisposeError
Error to throw if a signal is written to after it is disposed