Compositions

package demos

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

// Region is one region: its own State, its own action, its own container. Two
// of them on a page never collide — via keys a child by its position among its
// parent's Child calls, and that key is the container id, the signal prefix
// and the action address alike.
type Region struct {
	Label string
	N     via.State[int]
}

func (r *Region) Bump(ctx *via.Ctx) { r.N.Set(r.N.Get() + 1) }

func (r *Region) View() h.H {
	return h.Div(h.Class("row"),
		h.Strong(h.Str(r.Label)),
		h.Output(r.N.Display()),
		h.Button(on.Click(r.Bump), h.Str("+")),
	)
}

// Compose holds two of them as plain struct fields. It is itself plain: a live
// unit may not contain another live unit, but a plain one may nest as deep as
// it likes.
type Compose struct{ Left, Right Region }

// OnInit seeds what a parent would normally put in the child's literal;
// Compose is a zero-value field of its page, so there is no literal to seed
// from.
func (c *Compose) OnInit(ctx *via.Ctx) error {
	c.Left.Label, c.Right.Label = "left", "right"
	return nil
}

func (c *Compose) View() h.H {
	return h.Div(h.Class("pair"), via.Child(c.Left), via.Child(c.Right))
}

package demos

import (
	"sync"
	"time"

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

// dismissals is which visitors closed a banner, keyed by session id. It stands
// in for any store that changes while a page is open.
type dismissals struct {
	mu sync.Mutex
	by map[string]bool
}

// maxDismissals bounds the map: a visitor forgotten by it sees the banner again.
const maxDismissals = 10000

func (d *dismissals) get(sid string) bool {
	d.mu.Lock()
	defer d.mu.Unlock()
	return d.by[sid]
}

func (d *dismissals) set(sid string, v bool) {
	d.mu.Lock()
	defer d.mu.Unlock()
	if d.by == nil || len(d.by) >= maxDismissals {
		d.by = map[string]bool{}
	}
	if v {
		d.by[sid] = true
	} else {
		delete(d.by, sid)
	}
}

// Banner hides itself once dismissed, so it is safe to embed unconditionally.
type Banner struct {
	Seen   *dismissals
	hidden bool
}

func (b *Banner) OnInit(ctx *via.Ctx) error {
	b.hidden = b.Seen.get(ctx.Session().ID())
	return nil
}

func (b *Banner) Dismiss(ctx *via.Ctx) {
	b.Seen.set(ctx.Session().Ensure(), true)
	b.hidden = true
}

func (b *Banner) View() h.H { return via.When(!b.hidden, b.body) }

func (b *Banner) body() h.H {
	return h.P(h.Class("panel", "row"),
		h.Span(h.Str("A banner above the clock.")),
		h.Button(on.Click(b.Dismiss), h.Str("dismiss")),
	)
}

// Stamp is plain: each click is a fresh request, addressed by Stamp's key.
type Stamp struct{ At via.Signal[string] }

func (s *Stamp) Read(ctx *via.Ctx) { s.At.Set(time.Now().Format("15:04:05")) }

func (s *Stamp) View() h.H {
	return h.Div(h.Class("row"),
		h.Button(on.Click(s.Read), h.Str("read the clock")),
		h.Output(s.At.Display()),
	)
}

// ShiftBroken wraps the Child in a When. Dismissing drops Banner from the
// server's tree, so Stamp's key moves from 1 to 0, but the page still holds
// Stamp's button with key 1 in its URL.
type ShiftBroken struct {
	Banner Banner
	Stamp  Stamp
	hidden bool
}

func (p *ShiftBroken) OnInit(ctx *via.Ctx) error {
	p.hidden = p.Banner.Seen.get(ctx.Session().ID())
	return nil
}

func (p *ShiftBroken) View() h.H {
	return h.Div(
		h.P(h.Class("note"), h.Str("When around the Child")),
		via.When(!p.hidden, p.banner),
		via.Child(p.Stamp),
		h.Button(on.Click(p.Restore), h.Str("bring the banner back")),
	)
}

func (p *ShiftBroken) banner() h.H { return via.Child(p.Banner) }

func (p *ShiftBroken) Restore(ctx *via.Ctx) {
	p.Banner.Seen.set(ctx.Session().ID(), false)
	p.hidden = false
}

// ShiftFixed always calls Child; Banner decides inside its own View whether
// to draw anything. Every key stays put.
type ShiftFixed struct {
	Banner Banner
	Stamp  Stamp
}

func (p *ShiftFixed) View() h.H {
	return h.Div(
		h.P(h.Class("note"), h.Str("When inside the child")),
		via.Child(p.Banner),
		via.Child(p.Stamp),
		h.Button(on.Click(p.Restore), h.Str("bring the banner back")),
	)
}

func (p *ShiftFixed) Restore(ctx *via.Ctx) { p.Banner.Seen.set(ctx.Session().ID(), false) }

// ShiftPair holds both variants under one parent, so one Wire pane follows
// the two halves' traffic. Each half gets its own store, so dismissing one
// banner leaves the other alone.
type ShiftPair struct {
	Broken ShiftBroken
	Fixed  ShiftFixed
}

func NewShiftPair() ShiftPair {
	return ShiftPair{
		Broken: ShiftBroken{Banner: Banner{Seen: new(dismissals)}},
		Fixed:  ShiftFixed{Banner: Banner{Seen: new(dismissals)}},
	}
}

func (p *ShiftPair) View() h.H {
	return h.Div(h.Class("pair"), via.Child(p.Broken), via.Child(p.Fixed))
}

package demos

import (
	"fmt"
	"slices"
	"strings"
	"sync"
	"sync/atomic"
	"time"

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

// hookLogs outlives every instance: the GET's, the stream's, and the one a
// closed stream disposed of each write here, and none of them lives long enough
// to see the others' lines.
var hookLogs = &sessionLog{}

type sessionLog struct {
	mu sync.Mutex
	by map[string][]string
}

const (
	stampFormat     = "15:04:05.000"
	hookLogRows     = 14
	hookLogSessions = 2000
)

func (s *sessionLog) add(sid string, lines ...string) []string {
	s.mu.Lock()
	defer s.mu.Unlock()
	if s.by == nil || len(s.by) >= hookLogSessions {
		s.by = map[string][]string{}
	}
	// Instances append out of order (a request that ran before the session
	// existed hands its lines over later), and every line starts with its time.
	log := append(s.by[sid], lines...)
	slices.SortStableFunc(log, func(a, b string) int { return strings.Compare(a[:len(stampFormat)], b[:len(stampFormat)]) })
	if len(log) > hookLogRows {
		log = log[len(log)-hookLogRows:]
	}
	s.by[sid] = log
	return slices.Clone(log)
}

var hookInstances atomic.Int64

// HookLog writes one line per hook, tagged with the instance it ran on. Until
// the visitor has a session there is nowhere to keep lines across instances, so
// each instance shows only its own; the first action mints one.
type HookLog struct {
	Log via.List[string]
	n   int64
	sid string
}

func (l *HookLog) OnInit(ctx *via.Ctx) error {
	l.n = hookInstances.Add(1)
	l.sid = ctx.Session().ID()
	l.note("OnInit", ctx.Request().Method+" "+ctx.Request().URL.Path)
	ctx.OnConnect(l.connected)
	ctx.OnDispose(l.disposed)
	return nil
}

func (l *HookLog) connected() { l.note("OnConnect", "stream open") }
func (l *HookLog) disposed()  { l.note("OnDispose", "stream closed") }

func (l *HookLog) Act(ctx *via.Ctx) {
	if l.sid == "" {
		l.sid = ctx.Session().Ensure()
		hookLogs.add(l.sid, l.Log.Get()...)
	}
	l.note("action", "Act")
}

func (l *HookLog) OnReload(ctx *via.Ctx) error {
	l.note("OnReload", "after Act")
	return nil
}

func (l *HookLog) note(hook, detail string) {
	line := fmt.Sprintf("%s  #%d  %-9s  %s", time.Now().Format(stampFormat), l.n, hook, detail)
	if l.sid == "" {
		l.Log.Append(line)
		trim(&l.Log, hookLogRows)
		return
	}
	l.Log.Set(hookLogs.add(l.sid, line))
}

func (l *HookLog) View() h.H {
	return h.Div(
		h.Button(on.Click(l.Act), h.Str("run an action")),
		h.Ul(h.Class("loglist"), h.TabIndex(0), h.Role("log"), h.Aria("label", "Hook calls"),
			l.Log.Each(func(s string) h.H { return h.Li(h.Str(s)) })),
	)
}

package demos

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

var relayChoices = []string{"Go", "Rust", "Zig"}

// Relay hands both children one topic.
type Relay struct {
	Picker  Picker
	Summary Summary
}

// Picker publishes without knowing who listens.
type Picker struct {
	Picks *topic.Topic[string]
	Sent  via.State[int]
}

// Summary listens, and its re-render is pushed after each value.
type Summary struct {
	Picks *topic.Topic[string]
	Last  via.State[string]
	Count via.State[int]
}

// A new topic per render: each tab's
// stream gets its own.
func (r *Relay) OnInit(
	ctx *via.Ctx,
) error {
	t := topic.New[string]()
	r.Picker.Picks = t
	r.Summary.Picks = t
	return nil
}

func (p *Picker) Pick(
	ctx *via.Ctx, choice string,
) {
	p.Sent.Set(p.Sent.Get() + 1)
	p.Picks.Publish(choice)
}

func (s *Summary) OnInit(
	ctx *via.Ctx,
) error {
	ctx.Listen(s.Picks, s.picked)
	return nil
}

func (s *Summary) picked(ctx *via.Ctx, choice string) {
	s.Last.Set(choice)
	s.Count.Set(s.Count.Get() + 1)
}

func (r *Relay) View() h.H {
	return h.Div(h.Class("pair"), via.Child(r.Picker), via.Child(r.Summary))
}

func (p *Picker) View() h.H {
	return h.Div(
		h.Div(h.Class("row"), via.Each(relayChoices, p.button)),
		h.P(h.Class("note"), h.Str("sent: "), p.Sent.Display()),
	)
}

func (p *Picker) button(choice string) h.H {
	return h.Button(on.Click(on.WithArg(p.Pick, choice)), h.Str(choice))
}

func (s *Summary) View() h.H {
	return h.Div(
		h.P(h.Str("last pick: "), h.Strong(s.Last.Display())),
		h.P(h.Class("note"), h.Str("received: "), s.Count.Display()),
	)
}