The frontend framework for correctness.

import { Effect, Match as M, Schema as S } from 'effect'
import { Command } from 'foldkit'
import { m } from 'foldkit/message'
import { evo } from 'foldkit/struct'

// MODEL

const Model = S.Struct({
  count: S.Number,
  isResetting: S.Boolean,
  resetDuration: S.Number,
})
type Model = typeof Model.Type

// MESSAGE

const ClickedIncrement = m('ClickedIncrement')
const ChangedResetDuration = m('ChangedResetDuration', {
  seconds: S.Number,
})
const ClickedResetAfterDelay = m('ClickedResetAfterDelay')
const CompletedDelayReset = m('CompletedDelayReset')

const Message = S.Union([
  ClickedIncrement,
  ChangedResetDuration,
  ClickedResetAfterDelay,
  CompletedDelayReset,
])
type Message = typeof Message.Type

// COMMAND

const DelayReset = Command.define('DelayReset', {
  args: { seconds: S.Number },
  messages: [CompletedDelayReset],
  execute: ({ seconds }) =>
    Effect.as(Effect.sleep(`${seconds} seconds`), CompletedDelayReset()),
})

// UPDATE

type UpdateReturn = readonly [
  Model,
  ReadonlyArray<Command.Command<Message>>,
]
const withUpdateReturn = M.withReturnType<UpdateReturn>()

const update = (model: Model, message: Message): UpdateReturn =>
  M.value(message).pipe(
    withUpdateReturn,
    M.tagsExhaustive({
      ClickedIncrement: () => [
        evo(model, { count: count => count + 1 }),
        [],
      ],
      ChangedResetDuration: ({ seconds }) => [
        evo(model, { resetDuration: () => seconds }),
        [],
      ],
      ClickedResetAfterDelay: () => [
        evo(model, { isResetting: () => true }),
        [DelayReset({ seconds: model.resetDuration })],
      ],
      CompletedDelayReset: () => [
        evo(model, { count: () => 0, isResetting: () => false }),
        [],
      ],
    }),
  )