Package-level declarations

A function applying a Flow.transform and possibly additional Flow configurations.

A Disposable that can have additional Disposables attached to it, so they are automatically disposed together with this object.

Observer callback used by autoRun and AutoRunner.

Collector of the change events used by autoRun, AutoRunner, coAutoRun and CoAutoRunner.

Watches observables for changes. Often useful to keep things in sync (e.g. ViewModel -> UI). This is the synchronous version. See CoAutoRunner for the suspension function based version.

Base interface for observing a hard-coded AutoRunner instance.

onChange callback used by autoRun and AutoRunner.

Just the minimum interface needed for Resolver. No generic types.

Base class/delegate for ViewModels and other objects that can trigger one-time events/actions and handle errors.

Observer callback used by suspendable coAutoRun and CoAutoRunner.

Watches observables for changes. Often useful to keep things in sync (e.g. ViewModel -> UI). This is the suspension function based version. See AutoRunner for the synchronous version.

onChange callback used by suspendable coAutoRun and CoAutoRunner.

A val for which the value can be set via the coroutineContext.

A val for which the value can be set via the coroutineContext.

Interface for a common set of CoroutineDispatchers.

Interface for launching coroutines with error handling and loading state tracking.

The default CoroutineDispatcherConfig, mapping to Dispatchers.

Marks dependency injection system accessors, so direct access must be explicitly opted in.

An object that can be disposed/deactivated/canceled by calling dispose().

A Disposable that can dispose multiple Disposable and Job instances at once.

A value that must be explicitly disposed when it's not needed anymore.

Events interface with a simple onError event (e.g. for use with EventNotifier).

This is used to send events to an observer. All events are queued for later processing.

This feature is not stable yet and can introduce breaking API changes in minor releases.

A function which can be passed to Flow.transform.

A StateFlowStore that can be used for unit tests or non-Android parts of multiplatform projects.

A Disposable wrapping a Job.

A suspend/coroutine version of Lazy.

A Flow where you can emit/tryEmit values into (backed by a Channel).

A wrapper StateFlowStore that prefixes every key with a namespace.

A Disposable executing the given function on dispose().

A mechanism for ViewModel initialization-time tasks like repository cache refresh. Use via ContextualOnInit.

When the ViewModel is ready this API allows launching coroutines.

Implement this interface to get notified of every ReactiveState added to your object.

Implement this interface on your ReactiveState to get notified it's attached to a parent (screen or ReactiveState).

Handles custom serialization/deserialization. Useful e.g. with JvmSerializerReplacement.

An interface for ViewModels and any other objects that can trigger one-time events/actions and handle errors.

Contains all values which are part of the ViewModel build process.

Base class for ViewModels.

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

Tracks observables for AutoRunner and CoAutoRunner.

Simple default implementation of a CoroutineLauncher which uses a given CoroutineScope.

Base interface for a temporary observable key-value store.

A factory function creating a StateFlowStore.

A reference-counted value that is created on-demand and freed once nobody uses it (whereas by lazy is never freed).

The reference token passed to the WhileUsed builder function.

Wraps a value. Together with nullability can model an Option/Maybe.

Provides access to a ViewModel's OnInit instance.

The currently active CoroutineDispatcherConfig.

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

Returns a new MutableStateFlow that calls setter after doing the actual value update.

Watches observables for changes. Often useful to keep things in sync (e.g. CoroutineLauncher -> UI).

Watches observables for changes. Often useful to keep things in sync (e.g. ViewModel -> UI).

Returns a new MutableStateFlow that calls setter before doing the actual value update.

Creates and attaches a child ReactiveState.

Watches observables for changes. Often useful to keep things in sync (e.g. CoroutineLauncher -> UI).

Watches observables for changes. Often useful to keep things in sync (e.g. ViewModel -> UI).

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

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

Executes each lambda in a Flow using conflatedMap.

This has to be added to the CoroutineScope via CoroutineScope.plus in order for ContextualVal to work.

Runs block with a Resolver as the this argument, so you can evaluate an observer block without subscribing.

Executes each lambda in a Flow using debounce and map.

Atomically decrements this MutableStateFlow by amount (default 1) and returns previous value.

Creates a StateFlow that computes its value based on other StateFlows via an autoRun block.

Creates a StateFlow that computes its value based on other StateFlows via an autoRun block.

Creates a StateFlow that computes its value based on other StateFlows via a suspendable coAutoRun block.

Creates a StateFlow that computes its value based on other StateFlows via a suspendable coAutoRun block.

Constructs a DisposableGroup.

Disposes the Disposable when CoroutineLauncher completes (including cancellation).

Disposes the Disposable when CoroutineContext completes (including cancellation).

Disposes the Disposable when CoroutineScope completes (including cancellation).

Disposes the Disposable when Job completes (including cancellation).

Creates an EventNotifier.

Returns WhileUsed's value and keeps it alive as long as it's still used.

Returns StateFlow.value and tracks the observable (on the MainScope).

A version of getAndUpdate where the current value is passed via this.

For use with by delegation. Returns the StateFlowStore entry for the key that equals the property name.

Consumes and handles EventNotifier's events on the given handler.

Atomically increments this MutableStateFlow by amount (default 1) and returns previous value.

Keeps this incrementedincrement by the latest value in the given flow.

Helper for adding a completion handler to a CoroutineLauncher.

Helper for adding a completion handler to a CoroutineContext.

Helper for adding a completion handler to a CoroutineScope.

Executes each lambda in a Flow using debounce and mapLatest.

A helper for creating a lazily computed ReadOnlyProperty based on a KProperty.

Creates a MutableFlow.

Similar to MutableStateFlow.onSubscription but returns a MutableStateFlow.

Similar to StateFlow.onSubscription but returns a StateFlow.

A lazyProperty that only receives the KProperty.name as its argument.

A version of update where the current value is passed via this.

This is a version of updateAndGet.

Throws an exception if ContextualValRoot was not added to the CoroutineContext/CoroutineScope.

Similar to the stdlib runCatching, but uses throwIfFatal to re-throw fatal exceptions immediately.

Similar to the stdlib runCatching, but uses throwIfFatal to re-throw fatal exceptions immediately.

Runs block with a Resolver as the this argument, so you can evaluate an observer block without subscribing.

Creates a computed SharedFlow without requiring a CoroutineScope (unlike shareIn).

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

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

Throws this exception if it's fatal. Otherwise returns it.

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

Runs OnInit.trigger for this class.

Creates an automatically invalidated property.

Executes the given block, catching any errors and reporting them to the given eventNotifier.

Executes the given block, catching any errors and calling onError, but handling CancellationException.

Returns a new MutableStateFlow that calls setter instead of doing the actual value update.