retrace_frontend - v0.1.0

retrace_frontend/capture

Optional capture coordination. Observe only application-approved transitions. Map the returned effects/messages into your application. They are not events to record. Stop the owned client when the application unmounts.

Types

Info

</> 
pub type Info {
  Info(
    session: wire.Session,
    captured: Int,
    saved: Int,
    delivery: client.Status,
    failure: option.Option(String),
  )
}

Constructors

Message

opaque </> 
pub opaque type Message

State

opaque </> 
pub opaque type State

Values

info

</> 
pub fn info(state: State) -> Info

observe

</> 
pub fn observe(
  state: State,
  before: model,
  message: message,
  encode_model: fn(model) -> String,
  encode_message: fn(message) -> wire.Event,
) -> #(State, effect.Effect(Message))

Observe after accepting a transition, passing its state BEFORE reduction. This helper never runs application effects. Record their resulting messages through this same hook. A failure stops capture; your update still proceeds.

retry

</> 
pub fn retry(state: State) -> effect.Effect(Message)

session

</> 
pub fn session(
  user_ref: String,
  build: String,
  contract: String,
  platform: String,
) -> wire.Session

Start a new identity; every application instance needs a distinct session.

start

</> 
pub fn start(
  session: wire.Session,
  config: client.Config,
  storage: client.Storage,
  transport: client.Transport,
) -> Result(#(State, effect.Effect(Message)), retrace.Error(Nil))

start_with_clock

</> 
pub fn start_with_clock(
  session: wire.Session,
  config: client.Config,
  storage: client.Storage,
  transport: client.Transport,
  clock: fn() -> Int,
) -> Result(#(State, effect.Effect(Message)), retrace.Error(Nil))

The clock returns elapsed milliseconds since this session began.

stop

</> 
pub fn stop(state: State) -> effect.Effect(Message)

Run before discarding the application state. Persisted batches remain queued.

update

</> 
pub fn update(state: State, message: Message) -> State
✨ Search Document