AsyncState<T> class sealed

AsyncState is class commonly used with Future/Stream signals to represent the states the signal can be in.

AsyncSignal

AsyncState is the default state if you want to create a AsyncSignal directly:

final s = asyncSignal(AsyncState.data(1));
s.value = AsyncState.loading(); // or AsyncLoading();
s.value = AsyncState.error('Error', null); // or AsyncError();

AsyncState

AsyncState is a sealed union made up of AsyncLoading, AsyncData and AsyncError.

.future

Sometimes you need to await a signal value in a async function until a value is completed and in this case use the .future getter.

final s = asyncSignal<int>(AsyncState.loading());
s.value = AsyncState.data(1);
await s.future; // Waits until data or error is set

.isCompleted

Returns true if the future has completed with an error or value:

final s = asyncSignal<int>(AsyncState.loading());
s.value = AsyncState.data(1);
print(s.isCompleted); // true

.hasValue

Returns true if the state has a value - AsyncData.

final s = asyncSignal<int>(AsyncState.loading());
print(s.hasValue); // false
s.value = AsyncState.data(1);
print(s.hasValue); // true

.hasError

Returns true if the state has a error - AsyncError.

final s = asyncSignal<int>(AsyncState.loading());
print(s.hasError); // false
s.value = AsyncState.error('error');
print(s.hasError); // true

.isRefreshing

Returns true if the state is refreshing - AsyncDataRefreshing or AsyncErrorRefreshing.

final s = asyncSignal<int>(AsyncState.loading());
print(s.isRefreshing); // false
s.value = AsyncState.errorRefreshing('error');
print(s.isRefreshing); // true
s.value = AsyncState.dataRefreshing(1);
print(s.isRefreshing); // true

.isReloading

Returns true if the state is refreshing - AsyncDataReloading or AsyncErrorReloading.

final s = asyncSignal<int>(AsyncState.loading());
print(s.isReloading); // false
s.value = AsyncState.dataReloading(1);
print(s.isReloading); // true
s.value = AsyncState.errorReloading('error');
print(s.isReloading); // true

.requireValue

Force unwrap the value of the state and throw an error if it has an error or is null - AsyncData.

final s = asyncSignal<int>(AsyncState.data(1));
print(s.requireValue); // 1

.value

Return the current value if exists - AsyncData.

final s = asyncSignal<int>(AsyncState.data(1));
print(s.value); // 1 or null

.error

Return the current error if exists - AsyncError.

final s = asyncSignal<int>(AsyncState.error('error'));
print(s.error); // 'error' or null

.stackTrace

Return the current stack trace if exists - AsyncError.

final s = asyncSignal<int>(AsyncState.error('error', StackTrace(...)));
print(s.stackTrace); // StackTrace(...) or null

.map

If you want to handle the states of the signal map will enforce all branching.

final signal = asyncSignal<int>(AsyncState.data(1));
signal.value.map(
 data: (value) => 'Value: $value',
 error: (error, stackTrace) => 'Error: $error',
 loading: () => 'Loading...',
);

.maybeMap

If you want to handle some of the states of the signal maybeMap will provide a default and optional overrides.

final signal = asyncSignal<int>(AsyncState.data(1));
signal.value.maybeMap(
 data: (value) => 'Value: $value',
 orElse: () => 'Loading...',
);

Pattern Matching

Instead of map and maybeMap it is also possible to use dart switch expressions to handle the branching.

final signal = asyncSignal<int>(AsyncState.data(1));
final value = switch (signal.value) {
    AsyncData<int> data => 'value: ${data.value}',
    AsyncError<int> error => 'error: ${error.error}',
    AsyncLoading<int>() => 'loading',
};

@link https://dartsignals.dev/async/state

Constructors

AsyncState.data(T data)

Create a state with a value

factory

AsyncState.dataRefreshing(T data)

Create a state with a value that is refreshing

factory

AsyncState.dataReloading(T data)

Create a state with a value that is reloading

factory

AsyncState.error(Object error, [StackTrace? stackTrace])

Create a state with an error

factory

AsyncState.errorRefreshing(Object error, [StackTrace? stackTrace])

Create a state with an error that is refreshing

factory

AsyncState.errorReloading(Object error, [StackTrace? stackTrace])

Create a state with an error that is reloading

factory

AsyncState.loading()

Create a loading state

factory

Properties

error → Object?

Returns the error of the state.

no setter

hasError → bool

Returns true if the state has an error

no setter

hashCode → int

The hash code for this object.

no setter, override

hasValue → bool

Returns true if the state has a value

no setter

isLoading → bool

Check if the state is a loading state

no setter

isRefreshing → bool

Returns true if the state is refreshing with a loading flag, has a value or error and is not the loading state

no setter

isReloading → bool

Returns true if the state is reloading with having a value or error, and is the loading state

no setter

requireValue → T

Force unwrap the value of the state.

no setter

runtimeType → Type

A representation of the runtime type of the object.

no setter, inherited

stackTrace → StackTrace?

Returns the stack trace of the state.

no setter

value → T?

Returns the value of the state.

no setter

Methods

map<E>({required AsyncDataBuilder<E, T> data, required AsyncErrorBuilder<E> error, required AsyncStateBuilder<E> loading, AsyncStateBuilder<E>? reloading, AsyncStateBuilder<E>? refreshing}) → E

Map the state to a value.

maybeMap<E>({AsyncDataBuilder<E, T>? data, AsyncErrorBuilder<E>? error, AsyncStateBuilder<E>? loading, AsyncStateBuilder<E>? reloading, AsyncStateBuilder<E>? refreshing, required AsyncStateBuilder<E> orElse}) → E

Map the state to a value with optional or else.

noSuchMethod(Invocation invocation) → dynamic

Invoked when a nonexistent method or property is accessed.

inherited

toString() → String

A string representation of this object.

inherited

Operators

operator ==(covariant AsyncState<T> other) → bool

The equality operator.

override