Kotlin-first event and result observation for Android and Compose Multiplatform.

The project is split into two public modules:

• event-observer for DataResult, ResponseLiveData, ResponseFlow, and the supporting utilities
• event-observer-compose for ComposableDataResult and the Compose-facing observation DSL

The library centers on DataResult<T> and a small set of wrappers that keep loading, success, error, and list-state handling consistent across Android and Compose layers.

Use event-observer when you want:

• DataResult helpers and status handling
• ResponseLiveData, MutableResponseLiveData, and SwapResponseLiveData
• ResponseFlow, ResponseStateFlow, and ResponseSharedFlow
• chaining, mapping, and merge helpers for reactive state

Use event-observer-compose when you want:

• ComposableDataResult for declarative state rendering
• collectAsComposableState() for Flow<DataResult<T>> and LiveData<DataResult<T>>
• Compose observables such as OnData, OnError, OnShowLoading, OnEmpty, OnNotEmpty, OnSingle, and OnMany
• a Compose-first API on top of event-observer

Pick the module that matches your layer:

dependencies {
    implementation("io.github.matheus-corregiari:event-observer:<version>")
}

dependencies {
    implementation("io.github.matheus-corregiari:event-observer-compose:<version>")
}

event-observer-compose builds on top of event-observer, so use both only when you need Compose rendering on top of the base result model.

event-observer

• base result model and status helpers
• LiveData and Flow wrappers
• transformations, chaining, and merge helpers

event-observer-compose

• Compose observation DSL
• ComposableDataResult
• Compose rendering hooks for loading, data, error, and collection states

Use only event-observer when your UI layer is not Compose. Add event-observer-compose when the final observation point lives inside Jetpack Compose Multiplatform.

The fastest path is to start with DataResult and render it where you need it.

val result = dataResultSuccess("Hello")

result.unwrap {
    data { value -> println(value) }
    error { throwable -> println(throwable.message) }
    loading { isLoading -> println("loading=$isLoading") }
}

For Compose, convert the upstream state into a ComposableDataResult and render the blocks you care about.

myFlow.composable
    .OnShowLoading { CircularProgressIndicator() }
    .OnData { value -> Text(value.toString()) }
    .OnError { error -> Text(error.message ?: "Unknown error") }
    .Unwrap()

Public docs live in docs/:

• Home
• Getting Started
• event-observer
• event-observer-compose
• Core Concepts
• Recipes
• Changelog
• Contributing
• API Reference

The published MkDocs site is built from the same content and mirrors these pages.

• event-observer is Android-facing and integrates with LiveData.
• event-observer-compose builds on top of event-observer, Flow, and Compose state.
• The API is designed to stay predictable in shared KMP-oriented architecture layers.

Read CONTRIBUTING.md before sending changes.

Copyright 2025 Matheus Corregiari

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.