Adapts the Redux pattern with coroutine integration, offering testable and extensible store functionality, middleware support, coroutine handling, and various integrations to streamline development and reduce boilerplate.
ReduKt is a Redux pattern adaptation in Kotlin, integrated with coroutines, testable and multiplatform. Implemented store provides easy & powerful way of extending its functionality - dispatch closure. It is used to deliver customizable extensions that help you reduce the boilerplate according to your needs!
If you want to see basic examples, go to overview section. More in-depth guides and examples are available for each library in their corresponding README files. They are easily accessible from libraries section.
API reference is available here.
If you want to use more than redukt-core it's a good idea to add redukt-bom:
val commonMain by getting {
dependencies {
implementation(platform("com.daftmobile.redukt:redukt-bom:1.0"))
implementation()
implementation()
implementation()
implementation()
implementation()
implementation()
}
}
commonTest getting {
dependencies {
implementation(kotlin())
implementation()
implementation()
}
}
iosMain getting {
dependencies {
implementation()
}
}
Every Redux app starts with creating a store. In ReduKt here is how it's done:
data class AppState(val posts: List<Post> = emptyList())
fun appReducer(state: AppState, action: Action) = AppState(posts = postsReducer(state.posts, action))
// More flexible store creation with DSL!
val store = buildStore {
AppState() reducedBy ::appReducer
middlewares {
if (IS_DEBUG) +debugMiddleware
+postsMiddleware
}
closure {
+GlobalKoinDI
}
}
State changes are delivered by the StateFlow:
// Collecting whole state...
store.state.collect { /* ... */ }
// ...or just a part of it!
store.select { it.posts }.collect { /* ... */ }
Customizable selectors that enables performance improvements:
val totalProductsPriceSelector = Selector(
stateEquality = { old, new -> old.products == new.products },
selector = { it.products.sumBy(Product::price) }
)
store.select(totalProductsPriceSelector).collect {
// Total prices is recalculated only if products have changed and when value is really needed!
}
Declaring middlewares comes with predefined utils:
// Standard middleware declaration. In comparison to Redux JS it has only 1 nested lambda.
// All the operations are available from lambda receiver and do not require declaring them as parameters!
val debugMiddleware: Middleware<AppState> = {
{ action ->
println(action)
next(action)
}
}
// You can declare it shorter with `middleware` util
val debugMiddleware = middleware<AppState> { action ->
println(action)
next(action)
}
// ...or even shorter with `translucentMiddleware`
val debugMiddleware = translucentMiddleware<AppState> { action -> println(action) }
Launching and controlling coroutines is integrated with the store:
fun fetchPostsMiddleware(client: HttpClient) = consumingMiddleware<AppState, PostAction.FetchAll> {
launchForeground {
runCatching { client.get("/posts") }
.onSuccess { dispatch(PostAction.FetchSuccess(it)) }
.onFailure { dispatch(PostAction.FetchFailure(it)) }
}
}
// ...
val job = store.dispatchJob(PostAction.FetchAll)
// ...
job.cancel()
Http client instance might be injected thanks to ReduKt Koin:
val fetchPostsMiddleware = consumingMiddleware<AppState, PostAction.FetchAll> {
val httpClient by koin.inject<HttpClient>()
launchForeground {
// ...
}
}
You might reduce amount of required middlewares with ReduKt Thunk:
object FetchAllPosts : BaseCoThunk<AppState>({
val client by koin.inject<HttpClient>()
runCatching { client.get("/posts") }
.onSuccess { dispatch(PostAction.FetchSuccess(it)) }
.onFailure { dispatch(PostAction.FetchFailure(it)) }
})
// ...
val job = store.dispatchJob(FetchAllPosts)
// ...
job.cancel()
To reduce even more code with asynchronous data sources, you can use ReduKt Data!
This library is highly dependent on Kotlin Coroutines and therefore supports the same range of targets.
Targets list is available here.
Surfaced from shared tags and platforms — no rankings paid for.