Greetings!

Let's assume we have:

interface HomeScreenState {
val isLoading: Boolean
val title: String
val avatar: String
val items: List
val selectedItem: Any?
}

and a method like

fun update() {
_state.isLoading = true
val data = getSomeData()
_state.title = data.title
_state.avatar = data.avatar
_state.items = data.items
_state.selectedItem = data.items.firstOrNull()
}

or

fun update() {
_state.isLoading = true
val data = getSomeData()
_state.apply {
title = data.title
avatar = data.avatar
items = data.items
selectedItem = data.items.firstOrNull()
}
}

How many times would state.collect {} block be called in a view/widget in both cases?

It would be nice to have a top-level function to create instance of an Immutable model

Like the reddit comment in this.

This seems like it could break data invariants since it pushes updates on every data field update.

Eg if you depend on a data model being in either state A or B, now it can be both or neither since you must account for intermediary steps

Hi Mutekt Teams,
Thanks for your nice tool.
How can use SharedFlow inside Mutekt ? If i suppose i have some variables in this forms:

private val _xx = MutableSharedFlow(false)
val xx = _xx.asSharedFlow()

_xx.emit(true)

Thanks for helping me

Hello,

I recently came across an issue while working with Jetpack Compose, which I discovered after watching a tutorial on YouTube (link to tutorial). The problem arose when I was inspecting the layout using Layout Inspector. I noticed that whenever I modify a state variable within a specific Composable, it causes a global recomposition of all Composables that use state management in my project.

This behavior seems inefficient, especially for larger projects where only a portion of the UI should update in response to state changes. My question is, is there a way to improve this? Specifically, can we limit the recomposition to only the Composables that need updating, rather than triggering a global update across all managed states?

I'm looking for advice or solutions that could help optimize the recomposition process and make it more selective. Any guidance or insights would be greatly appreciated.

Thank you for your time and assistance.

@HiltViewModel
class CarViewModel @Inject constructor() : BaseVM() {
private val stateStore = StateStore(CarState.initialState.mutable())
fun setState(update: MutableCarState.() -> Unit) = stateStore.setState(update)
override val state: StateFlow = stateStore.state

}
@GenerateMutableModel
@immutable
interface CarState : State {
val isLocked: Boolean
val isShowNumber: Boolean
}

CarLockedBtn(Modifier.clickable{
vm.setState {
isLocked = !isLocked
}
})

@OptIn(ExperimentalFoundationApi::class)
@composable
fun TopBar(vm: CarViewModel) {
val state by vm.collectState()
val interaction = remember { MutableInteractionSource() }
val batteryStr = if (state.isShowNumber) "100%" else "693km"
Row{
Text(batteryStr )
BatteryImage()
}
}

Throw error while running KSP if name of declared property is one from the fixed reserved generated properties like _stateFlowImpl, fun asStateFlow()

Invalid code is generated when an interface uses a typealias as a type paramter.

typealias SomeTypeAlias = TypeA<out TypeB>

@GenerateMutableModel
interface UiState {
    val list: List<SomeTypeAlias>
}

Generated code

public fun MutableUiState(
    list: List<SomeTypeAlias<out TypeB>>
)

Expected

public fun MutableUiState(
    list: List<SomeTypeAlias>
)

This library can be easily converted to a multiplatform one since it uses kotlinx-coroutines (with 100% multiplatform support) and KSP that can generate common code. So, it will be possible to use the same code for multiple platforms such as:

• Android
• JVM (ex: Jetbrains Compose applications)
• JS (ex: React or Jetbrains Compose applications)
• iOS (shared view model with Android)

Could you add @stable annotation to data classes?