counterStateMachine for blog

counterStateMachine.kt

fun CoroutineScope.counterStateMachine(
    initialState: CounterState,
    mutableStateFlow: MutableStateFlow<CounterState>,
    mutableMessages: MutableSharedFlow<CounterMessage>,
) =
    actor<CounterMessage> {
        var state: CounterState = initialState
        channel.consumeEach { message ->
            when (message) {
                is IncrementCounter -> {
                    state = state.copy(count = state.count + 1)
                    mutableStateFlow.emit(state)
                    mutableMessages.emit(message)
                }
                is DecrementCounter -> {
                    state = state.copy(count = state.count - 1)
                    mutableStateFlow.emit(state)
                    mutableMessages.emit(message)
                }
                is GetCounterState -> message.deferred.complete(state)
            }
        }
    }
    
    
class CounterStateStore(initialState: CounterState, val scope: CoroutineScope) {

    private val mutableStateFlow = MutableStateFlow<CounterState>(initialState)
    private val mutableMessages = MutableSharedFlow<CounterMessage>()
    private val stateMachine =
        scope.counterStateMachine(initialState, mutableStateFlow, mutableMessages)

    val stateFlow: Flow<CounterState> = mutableStateFlow
    val messagesFlow: Flow<CounterMessage> = mutableMessages

    fun dispatch(message: CounterMessage) {
        stateMachine.trySend(message)
    }

    suspend fun getState(): CounterState {
        val completableDeferred = CompletableDeferred<CounterState>()
        dispatch(GetCounterState(completableDeferred))
        return completableDeferred.await()
    }

}