Live state

package demos

import (
	"time"

	"github.com/go-via/via"
	"github.com/go-via/via/h"
	"github.com/go-via/via/on"
)

// LiveReveal hides a State without leaving it out of the render: Display runs
// on every render, hidden or not, so the unit is live from the GET and the
// reveal has a stream to arrive on.
type LiveReveal struct {
	Open  via.State[bool]
	Since via.State[string]
}

func (r *LiveReveal) OnInit(ctx *via.Ctx) error {
	r.Since.Set("held since " + time.Now().Format("15:04:05"))
	return nil
}

func (r *LiveReveal) Toggle(ctx *via.Ctx) { r.Open.Set(!r.Open.Get()) }

func (r *LiveReveal) View() h.H {
	label := "reveal"
	if r.Open.Get() {
		label = "hide"
	}
	return h.Div(
		h.Button(on.Click(r.Toggle), h.Str(label)),
		h.P(h.Class("metric"), h.Hidden(!r.Open.Get()), r.Since.Display()),
	)
}

package demos

import (
	"fmt"
	"time"

	"github.com/go-via/via"
	"github.com/go-via/via/h"
)

// Pulse is the smallest thing that streams: OnInit asks for a tick, so via
// opens this tab's SSE connection and pushes a re-render of this region — and
// only this region — every second.
type Pulse struct {
	Beats  via.State[int]
	Uptime via.State[string]
}

func (p *Pulse) OnInit(ctx *via.Ctx) error {
	p.Uptime.Set(pulseClock(0))
	ctx.Tick(time.Second, p.beat)
	return nil
}

func (p *Pulse) beat(ctx *via.Ctx) {
	n := p.Beats.Get() + 1
	p.Beats.Set(n)
	p.Uptime.Set(pulseClock(n))
}

func pulseClock(secs int) string { return fmt.Sprintf("%02d:%02d", secs/60, secs%60) }

func (p *Pulse) View() h.H {
	return h.Div(
		h.P(h.Class("metric"), p.Uptime.Display()),
		h.P(h.Class("note"), h.Str("beat "), p.Beats.Display(), h.Str(" since this tab connected")),
	)
}

package demos

import (
	"strconv"
	"sync/atomic"
	"time"

	"github.com/go-via/via"
	"github.com/go-via/via/h"
	"github.com/go-via/via/on"
	"github.com/go-via/via/topic"
)

// feedTopic is a plain package-level value. Nothing about it is via's: any
// goroutine may Publish to it, and a unit's ctx.Listen is what turns a publish
// into a frame on that unit's stream.
var (
	feedTopic = topic.New[FeedPost]()
	feedSeq   atomic.Int64
)

// FeedPost is one broadcast line. Topics carry whatever type you give them.
type FeedPost struct {
	At   time.Time
	Text string
}

// Feed shows every post made while this tab is open — it mirrors no store, so
// a tab that arrives late starts empty. A value every tab must agree on wants
// State.Track instead.
type Feed struct {
	// Limiter, keepRows and trim: see shared_contract.go.
	Lim    Limiter
	Posts  via.List[FeedPost]
	Notice via.State[string]
}

// NewFeed takes the limiter the page owns; a nil one is a wiring mistake, so
// it fails here rather than on the first render.
func NewFeed(lim Limiter) Feed {
	if lim == nil {
		panic("demos: NewFeed: Feed.Lim must not be nil")
	}
	return Feed{Lim: lim}
}

func (f *Feed) OnInit(ctx *via.Ctx) error {
	ctx.Listen(feedTopic, f.recv)
	return nil
}

// recv runs on this unit's own goroutine, serialized with its ticks, so it may
// touch unit state without a lock.
func (f *Feed) recv(ctx *via.Ctx, p FeedPost) {
	f.Posts.Append(p)
	trim(&f.Posts, keepRows)
}

func (f *Feed) Post(ctx *via.Ctx) {
	if !f.Lim.Allow(ctx) {
		f.Notice.Set("slow down — 20 posts a minute")
		return
	}
	f.Notice.Set("")
	feedTopic.Publish(FeedPost{At: time.Now(), Text: "event #" + strconv.FormatInt(feedSeq.Add(1), 10)})
}

func (f *Feed) View() h.H {
	return h.Div(
		h.Div(h.Class("row"),
			h.Button(on.Click(f.Post), h.Str("post an event")),
			h.Span(h.Class("note"), f.Notice.Display()),
		),
		// A scroll container is only keyboard-scrollable while it can hold
		// focus, and nothing inside this one is focusable.
		h.Ul(h.Class("loglist"), h.TabIndex(0), h.Role("log"), h.Aria("label", "Posted events"), f.Posts.Each(func(p FeedPost) h.H {
			return h.Li(h.Str(p.At.Format("15:04:05") + "  " + p.Text))
		})),
	)
}

package demos

import (
	"sync"

	"github.com/go-via/via"
	"github.com/go-via/via/h"
	"github.com/go-via/via/on"
	"github.com/go-via/via/topic"
)

// sharedHits is the store and the topic announces that it moved. sharedMu
// covers each change and its publish together, so publishes leave in the order
// the count moved and the last one a tab sees is the current count.
var (
	sharedMu    sync.Mutex
	sharedHits  int64
	sharedTopic = topic.New[int64]()
)

func sharedAdd(n int64) {
	sharedMu.Lock()
	defer sharedMu.Unlock()
	sharedHits += n
	sharedTopic.Publish(sharedHits)
}

func sharedLoad() int64 {
	sharedMu.Lock()
	defer sharedMu.Unlock()
	return sharedHits
}

func resetShared() {
	sharedMu.Lock()
	defer sharedMu.Unlock()
	sharedHits = 0
	sharedTopic.Publish(0)
}

// Shared follows the counter through the via.StateTrack literal NewShared
// builds; the topic re-seeds it on every publish.
type Shared struct {
	// Limiter: see shared_contract.go.
	Lim    Limiter
	Hits   via.State[int64]
	Notice via.State[string]
}

// NewShared takes the limiter the page owns, and seeds Hits from the store the
// topic announces. A nil limiter is a wiring mistake, so it fails here rather
// than on the first render.
func NewShared(lim Limiter) Shared {
	if lim == nil {
		panic("demos: NewShared: Shared.Lim must not be nil")
	}
	return Shared{Lim: lim, Hits: via.StateTrack(sharedTopic, sharedLoad)}
}

func (s *Shared) Inc(ctx *via.Ctx) {
	if !s.Lim.Allow(ctx) {
		s.Notice.Set("slow down — 20 clicks a minute")
		return
	}
	s.Notice.Set("")
	sharedAdd(1)
}

func (s *Shared) View() h.H {
	return h.Div(
		h.P(h.Class("metric"), s.Hits.Display()),
		h.Div(h.Class("row"),
			h.Button(on.Click(s.Inc), h.Str("+1 for everyone")),
			h.Span(h.Class("note"), s.Notice.Display()),
		),
	)
}

package demos

import (
	"time"

	"github.com/go-via/via"
	"github.com/go-via/via/h"
	"github.com/go-via/via/on"
	"github.com/go-via/via/topic"
)

// pingEvent is addressed: one topic carries every visitor's pings and each
// unit drops the ones that are not its own. A topic per session would be a
// map of topics nobody ever cleans up.
type pingEvent struct {
	To  string
	Msg string
}

var pingTopic = topic.New[pingEvent]()

// Ping is per-user fan-out over a shared topic, keyed by the session id.
type Ping struct {
	// Limiter, keepRows and trim: see shared_contract.go.
	Lim    Limiter
	sid    string
	gone   chan struct{}
	Msgs   via.List[string]
	Notice via.State[string]
}

// NewPing takes the limiter the page owns; a nil one is a wiring mistake, so
// it fails here rather than on the first render.
func NewPing(lim Limiter) Ping {
	if lim == nil {
		panic("demos: NewPing: Ping.Lim must not be nil")
	}
	return Ping{Lim: lim}
}

func (p *Ping) OnInit(ctx *via.Ctx) error {
	p.sid = ctx.Session().ID()
	p.gone = make(chan struct{})
	ctx.Listen(pingTopic, p.recv)
	ctx.OnDispose(func() { close(p.gone) })
	return nil
}

func (p *Ping) recv(ctx *via.Ctx, e pingEvent) {
	if e.To != p.sid {
		return
	}
	p.Msgs.Append(e.Msg)
	trim(&p.Msgs, keepRows)
}

func (p *Ping) Send(ctx *via.Ctx) {
	if !p.Lim.Allow(ctx) {
		p.Notice.Set("slow down — 20 pings a minute")
		return
	}
	// Minting the session here, on a rate-limited action, keeps a crawler's
	// GETs out of the session store.
	p.sid = ctx.Session().Ensure()
	p.Notice.Set("scheduled")
	// A goroutine may not touch unit state; publishing is how it reaches one.
	// gone is closed by OnDispose on the live unit; a request-scoped instance
	// never closes it, and its ping is delivered to nobody.
	to, gone := p.sid, p.gone
	time.AfterFunc(3*time.Second, func() {
		select {
		case <-gone:
			return
		default:
		}
		pingTopic.Publish(pingEvent{To: to, Msg: "ping at " + time.Now().Format("15:04:05")})
	})
}

func (p *Ping) View() h.H {
	return h.Div(
		h.Div(h.Class("row"),
			h.Button(on.Click(p.Send), h.Str("ping me in 3s")),
			h.Span(h.Class("note"), p.Notice.Display()),
		),
		h.Ul(h.Class("loglist"), h.TabIndex(0), h.Role("log"), h.Aria("label", "Pings received"), p.Msgs.Each(func(m string) h.H { return h.Li(h.Str(m)) })),
	)
}

package demos

import (
	"sync"

	"github.com/go-via/via"
	"github.com/go-via/via/h"
	"github.com/go-via/via/topic"
)

// presenceTabs is the head count and the topic tells every tab it moved.
// presenceMu covers each change and its publish together, as in shared.go, so
// the last count a tab sees is the current one.
var (
	presenceMu    sync.Mutex
	presenceTabs  int64
	presenceTopic = topic.New[int64]()
)

func presenceAdd(n int64) {
	presenceMu.Lock()
	defer presenceMu.Unlock()
	presenceTabs += n
	presenceTopic.Publish(presenceTabs)
}

func presenceLoad() int64 {
	presenceMu.Lock()
	defer presenceMu.Unlock()
	return presenceTabs
}

// LivePresence counts the tabs holding a stream open on this page. OnConnect
// and OnDispose run only on a real connection, so a crawler's GET, which
// renders the page but never connects, counts for nothing.
type LivePresence struct {
	Tabs via.State[int64]
}

func NewLivePresence() LivePresence {
	return LivePresence{Tabs: via.StateTrack(presenceTopic, presenceLoad)}
}

func (p *LivePresence) OnInit(ctx *via.Ctx) error {
	ctx.OnConnect(p.join)
	ctx.OnDispose(p.leave)
	return nil
}

func (p *LivePresence) join()  { presenceAdd(1) }
func (p *LivePresence) leave() { presenceAdd(-1) }

func (p *LivePresence) View() h.H {
	return h.Div(
		h.P(h.Class("metric"), p.Tabs.Display()),
		h.P(h.Class("note"), h.Str("tabs connected to this page, yours included")),
	)
}