nimble install datastar

import std/[asyncdispatch, asynchttpserver]
import datastar
import datastar/asynchttpserver as DATASTAR

proc handler(req: Request) {.async.} =
  let sse = await req.newSSEGenerator() ; defer: req.closeSSE()
  await sse.patchElements("<div id=\"hello\">Hello World</div>")

proc main() {.async.} =
  var server = newAsyncHttpServer()
  server.listen(Port(8080))
  while true:
    if server.shouldAcceptRequest():
      await server.acceptRequest(handler)
    else:
      await sleepAsync(100)

waitFor main()

# Basic element patch
await sse.patchElements("<div>Content</div>")

# With selector and mode
await sse.patchElements("<div>Content</div>", selector="#target", mode=Append)

# With view transitions
await sse.patchElements("<div>Content</div>", useViewTransition=true)

import std/json

# From JsonNode
await sse.patchSignals(%*{"count": 1, "name": "test"})

# Only if missing
await sse.patchSignals(%*{"count": 0}, onlyIfMissing=true)

# Auto-remove after execution (default)
await sse.executeScript("console.log('hello')")

# Keep script in DOM
await sse.executeScript("window.myFunc = () => {}", autoRemove=false)

# With custom attributes
import std/tables
await sse.executeScript("...", attributes={"type": "module"}.toTable)

await sse.removeElements("#target")
await sse.removeElements(".items", useViewTransition=true)

await sse.removeSignals(@["count", "name"])

# GET requests - extracts 'datastar' query parameter
let signals = readSignals(request.url.query)
echo signals["count"].getInt

# POST/PUT/etc - parse JSON body directly
let signals = readSignalsFromBody(request.body)

# Typed API - returns struct
type MySignals = object
  count: int
  name: string

let signals = readSignals(request.url.query, MySignals)
echo signals.count  # Typed access

# From POST body (typed)
let signals = readSignalsFromBody(request.body, MySignals)

# Custom deserializer (e.g., jsony)
import jsony
let signals = readSignals(request.url.query, proc(s: string): MySignals = s.fromJson(MySignals))

import datastar/asynchttpserver as datastarAsync

proc handler(req: Request) {.async.} =
  let sse = await req.newSSEGenerator()
  defer: req.closeSSE()

  # ...

import datastar/prologue as datastarPrologue

proc handler(ctx: Context) {.async.} =
  let sse = await ctx.newSSEGenerator()
  defer: ctx.closeSSE()
  # ...

nim c -r examples/counter.nim

# Run all tests
nim c -r test/test_golden.nim

# Or using nimble
nimble test