reactivestate-core/com.ensody.reactivestate/RefreshableStateFlow

RefreshableStateFlow

@ExperimentalReactiveStateApi

interface RefreshableStateFlow<T> : StateFlow<T>

A StateFlow which can retrieve a new value e.g. from a backend via refresh.

Properties

replayCache

abstract val replayCache: List<T>

value

abstract val value: T

Functions

addDelay

fun <T> Flow<T>.addDelay(timeoutMillis: Long): Flow<T>

Adds a timeoutMillis delay to a Flow. If delay is zero or negative this is a no-op.

collect

abstract suspend override fun collect(collector: FlowCollector<T>): Nothing

conflatedMap

inline fun <T, R> Flow<T>.conflatedMap(timeoutMillis: Long = 0, crossinline transform: suspend (value: T) -> R): Flow<R>

Maps a conflated Flow with timeoutMillis delay between the first and last element.

conflatedTransform

inline fun <T, R> Flow<T>.conflatedTransform(timeoutMillis: Long = 0, crossinline transform: suspend FlowCollector<R>.(value: T) -> Unit): Flow<R>

Transforms a conflated Flow with timeoutMillis delay between the first and last element.

conflatedWorker

fun <T, R> Flow<T>.conflatedWorker(timeoutMillis: Long = 0, transform: FlowTransform<T, R>): Flow<R>

Executes each lambda in a Flow using conflatedMap.

debounceWorker

fun <T, R> Flow<T>.debounceWorker(timeoutMillis: Long = 0, transform: FlowTransform<T, R>): Flow<R>

Executes each lambda in a Flow using debounce and map.

latestWorker

fun <T, R> Flow<T>.latestWorker(timeoutMillis: Long = 0, transform: FlowTransform<T, R>): Flow<R>

Executes each lambda in a Flow using debounce and mapLatest.

onStateSubscription

fun <T> StateFlow<T>.onStateSubscription(block: suspend FlowCollector<T>.() -> Unit): StateFlow<T>

Similar to StateFlow.onSubscription but returns a StateFlow.

refresh

abstract suspend fun refresh(force: Boolean = false)

Refreshes the value.

shareOnDemand

fun <T> Flow<T>.shareOnDemand(replay: Int = 0, context: CoroutineContext = EmptyCoroutineContext): SharedFlow<T>

Turns this Flow into a SharedFlow without requiring a CoroutineScope (unlike shareIn).

stateOnDemand

fun <T> Flow<T>.stateOnDemand(initial: T, context: CoroutineContext = EmptyCoroutineContext, synchronous: Boolean = true, emitValueOnStart: Boolean = true): StateFlow<T>

fun <T> Flow<T>.stateOnDemand(context: CoroutineContext = EmptyCoroutineContext, synchronous: Boolean = true, emitValueOnStart: Boolean = true, getter: (previous: Wrapped<T>?) -> T): StateFlow<T>

Turns this Flow into a StateFlow without requiring a CoroutineScope (unlike stateIn).

toMutable

fun <T> StateFlow<T>.toMutable(setter: StateFlow<T>.(T) -> Unit): MutableStateFlow<T>

Converts this StateFlow to a MutableStateFlow that calls setter for doing the actual value update.

withRefresh

@ExperimentalReactiveStateApi

fun <T> StateFlow<T>.withRefresh(block: suspend StateFlow<T>.(force: Boolean) -> Unit): RefreshableStateFlow<T>