Implements TEA architecture using coroutines for scalable, testable applications. Offers simplicity, extensibility, and debugging with IntelliJ plugin support. Components reside in single files.
Surfaced from shared tags and platforms — no rankings paid for.
Tea Bag is a simple implementation of TEA
architecture written in Kotlin. This library is based on Kotlin's coroutines, extensively uses
extension-based approach and supports many targets including jvm, js, wasmJs, ios, macos, tvos,
watchos, linux and mingw.
This library is designed to be a lightweight, simple, and multiplatform-first implementation of the TEA architecture. It provides a minimal set of abstractions to build TEA app
Nothing special: we just need to code our initializer, resolver (tracker function),
updater (computeNewState function), and UI (renderSnapshot function). After that, we should pass
them to an appropriate Component builder overload.
The sample above will print the following:
Display: Initial(currentState=0, commands=[])
Track: "Regular(currentState=1, commands=[1], previousState=0, message=1)"
Track: "Initial(currentState=0, commands=[])"
Track: "Regular(currentState=3, commands=[2], previousState=1, message=2)"
Track: "Regular(currentState=0, commands=[-3], previousState=3, message=-3)"
Display: Regular(currentState=1, commands=[1], previousState=0, message=1)
Display: Regular(currentState=3, commands=[2], previousState=1, message=2)
Display: Regular(currentState=0, commands=[-3], previousState=3, message=-3)
Real-world examples include Android and iOS app samples that use the same application component and share common entities, application, and navigation logic. IntelliJ plugin is built on top of the library as well.
For more info, visit the Wiki page.
Add the dependency:
implementation("io.github.xlopec:tea-core:[version]")
implementation("io.github.xlopec:tea-compose:[version]")
implementation("io.github.xlopec:tea-async:[version]")
implementation("io.github.xlopec:tea-async-compose:[version]")
implementation("io.github.xlopec:tea-navigation:[version]")
Make sure that you have mavenCentral() in the list of repositories.
Plugin is available on JetBrains marketplace
To build the plugin from sources, use the ./gradlew tea-time-travel-plugin:buildPlugin command.
The installable plugin will be located in the tea-time-travel-plugin/build/distributions directory.
To run IntelliJ IDEA with the installed plugin, use the ./gradlew tea-time-travel-plugin:runIde
command.
To build the Android app sample, run ./gradlew :samples:app:assembleDefaultDebug or ./gradlew :samples:app:assembleRemoteDebug.
The last command assembles a debuggable version of the application that connects to the currently running instance of
the debugger (will try connecting to http://localhost:8080).
kotlinx.serialization.json.Contributions are more than welcome. If something cannot be done, is not convenient, or does not work - create an issue or PR.
(ExperimentalTeaApi::class)
package io.github.xlopec.counter
import io.github.xlopec.tea.core.*
import kotlinx.coroutines.runBlocking
/**Async initializer, provides initial state*/
suspend fun initializer(): Initial<Int, Int> = Initial(0)
/**Some tracker*/
fun track(
event: Snapshot<Int, Int, Int>,
ctx: ResolveCtx<Int>,
) {
ctx sideEffect { println("Track: \"$event\"") }
}
/**App logic, for now it just adds delta to count and returns this as result*/
fun add(
delta: Int,
counter: Int,
): Update<Int, Int> = (counter + delta) command delta
/**Some UI, e.g. console*/
suspend fun display(
snapshot: Snapshot<*, *, *>,
) {
println("Display: $snapshot")
}
fun main() = runBlocking {
// Somewhere at the application level
val component = Component(
initializer = ::initializer,
resolver = ::track,
updater = ::add,
scope = this,
)
// UI = component([message1, message2, ..., message N])
component(+1, +2, -3).collect(::display)
}
jvm, js, wasmJs, ios, macos, tvos, watchos, linux
and mingw targetsLoadable, Paginatable) for modelling the
lifecycle of asynchronous operations (network fetches, form submissions, paginated lists, …)Loadable and Paginatable
values. Exposes slot-based dispatchers (Loadable, Paginatable) and their LazyListScope
variants (loadableItems, paginatableItems) that route each state of the container to its
own composable slot