gotextlog

view.go (19430B)

---

 package tui
 
 import (
 	"fmt"
 	"strings"
 	"time"
 
 	"git.ryansepassi.com/git/gotextlog.git/internal/config"
 	"git.ryansepassi.com/git/gotextlog.git/internal/domain"
 	"git.ryansepassi.com/git/gotextlog.git/internal/textlog"
 	"github.com/charmbracelet/lipgloss"
 )
 
 type palette struct{ ink, muted, soft, accent, danger, success, quote lipgloss.Color }
 
 func colors(theme config.Theme, noColor bool) palette {
 	if noColor {
 		return palette{}
 	}
 	if theme == config.ThemeAuto {
 		// The terminal owns automatic colors. COLORFGBG is often stale inside
 		// tmux and can otherwise select dark text on a dark background.
 		return palette{"", "8", "8", "2", "1", "2", "8"}
 	}
 	if theme == config.ThemeLight {
 		return palette{"#20231f", "#747c72", "#d9dbd4", "#55734a", "#7a3f39", "#466342", "#e9e9e3"}
 	}
 	return palette{"#f4f7f2", "#a9b3a9", "#536053", "#a9d99c", "#ffb4ab", "#b8e0ae", "#293229"}
 }
 func (m Model) View() string {
 	if len(m.stack) == 0 {
 		return ""
 	}
 	p := colors(m.config.Theme, m.config.NoColor)
 	s := m.current()
 	header := m.header(s, p)
 	body := m.screenView(s, p)
 	if m.status != "" {
 		style := lipgloss.NewStyle().Foreground(p.success)
 		if m.statusError {
 			style = style.Foreground(p.danger)
 		}
 		body = style.Render(" "+m.status) + "\n" + body
 	}
 	footer := lipgloss.NewStyle().Foreground(p.muted).BorderTop(true).BorderForeground(p.soft).Width(max(1, m.width)).Render(m.footer(s))
 	available := max(1, m.height-lipgloss.Height(header)-lipgloss.Height(footer))
 	body = lipgloss.NewStyle().Height(available).MaxHeight(available).Width(max(1, m.width)).Render(body)
 	return header + "\n" + body + "\n" + footer
 }
 func (m *Model) header(s *screen, p palette) string {
 	active := m.title(s)
 	tabs := []string{"1 hot", "2 latest", "3 live"}
 	if m.config.Token != "" {
 		tabs = []string{"1 for you", "2 to me", "3 hot", "4 latest", "5 live"}
 		if m.width < 80 {
 			tabs = []string{"1 you", "2 me", "3 hot", "4 latest", "5 live"}
 		}
 	}
 	if m.width < 80 && s.kind != screenFeed && s.kind != screenLive {
 		tabs = nil
 	}
 	activeTab := strings.ReplaceAll(active, "-", " ")
 	activeNumber := ""
 	if s.kind == screenFeed || s.kind == screenLive {
 		if m.config.Token != "" {
 			activeNumber = map[string]string{"for-you": "1", "to-me": "2", "hot": "3", "latest": "4", "live": "5"}[active]
 		} else {
 			activeNumber = map[string]string{"hot": "1", "latest": "2", "live": "3"}[active]
 		}
 	}
 	for i, tab := range tabs {
 		style := lipgloss.NewStyle().Foreground(p.muted)
 		if strings.Contains(tab, activeTab) || activeNumber != "" && strings.HasPrefix(tab, activeNumber+" ") {
 			style = style.Bold(true).Foreground(p.accent)
 		}
 		tabs[i] = style.Render(tab)
 	}
 	who := "guest"
 	if m.me != nil {
 		who = "0 @" + m.me.Handle
 	}
 	brand := lipgloss.NewStyle().Bold(true).Foreground(p.accent).Render("textlog")
 	left := brand + "  " + strings.Join(tabs, "  ")
 	if s.kind != screenFeed && s.kind != screenLive {
 		left += lipgloss.NewStyle().Foreground(p.soft).Render("  │  ") + lipgloss.NewStyle().Foreground(p.ink).Render(active)
 	}
 	space := max(1, m.width-lipgloss.Width(left)-lipgloss.Width(who)-2)
 	return lipgloss.NewStyle().Width(max(1, m.width)).Render(" " + left + strings.Repeat(" ", space) + lipgloss.NewStyle().Foreground(p.muted).Render(who))
 }
 func (m *Model) title(s *screen) string {
 	switch s.kind {
 	case screenFeed:
 		return string(s.feed)
 	case screenPost:
 		return fmt.Sprintf("note #%d", s.id)
 	case screenProfile:
 		return "@" + s.handle
 	case screenTag:
 		return "#" + s.tag
 	case screenSearch:
 		return "search"
 	case screenLive:
 		return "live"
 	case screenCompose:
 		return "compose"
 	case screenLogin:
 		return "login"
 	case screenAccount:
 		return "account"
 	case screenSettings:
 		return "settings"
 	default:
 		return "help"
 	}
 }
 func editingView(s *screen) bool {
 	return (s.kind == screenSearch && s.query == "") || s.kind == screenCompose || s.kind == screenLogin || (s.kind == screenAccount && s.phase == "bio") || (s.kind == screenSettings && s.phase == "url")
 }
 
 func (m *Model) footer(s *screen) string {
 	if s.kind == screenCompose || (s.kind == screenAccount && s.phase == "bio") {
 		return " Enter newline  ·  Ctrl+S preview/submit  ·  Esc cancel"
 	}
 	if s.kind == screenLogin {
 		return " Enter continue  ·  Tab email/SSH key  ·  Esc back"
 	}
 	if editingView(s) {
 		return " Enter continue  ·  Esc cancel"
 	}
 	if s.kind == screenPost {
 		if m.width < 90 {
 			return " j/k move · Space fold · Enter focus · r reply · u user · q back"
 		}
 		return " j/k move  ·  Space fold/unfold  ·  Enter focus  ·  r reply  ·  u profile  ·  ! actions  ·  q back"
 	}
 	if s.kind == screenHelp {
 		return " q back"
 	}
 	return " j/k move · Enter open · / search · w write · ? help · q back"
 }
 func (m *Model) screenView(s *screen, p palette) string {
 	if s.loading {
 		return lipgloss.NewStyle().Foreground(p.muted).Padding(1).Render("loading···")
 	}
 	if s.err != "" {
 		return lipgloss.NewStyle().Foreground(p.danger).Padding(1).Render(s.err)
 	}
 	switch s.kind {
 	case screenFeed:
 		return m.postsView(s, p)
 	case screenSearch:
 		if s.query == "" {
 			return editor("search public notes", s.input, false, false, m.width, p)
 		}
 		return lipgloss.NewStyle().Foreground(p.muted).Render(" results for “"+s.query+"”") + "\n" + m.postsView(s, p)
 	case screenPost:
 		return m.postsView(s, p)
 	case screenProfile:
 		return m.profileView(s, p)
 	case screenTag:
 		return m.tagView(s, p)
 	case screenLive:
 		return lipgloss.NewStyle().Foreground(p.success).Render(" ● "+s.streamState+" · Space pause/resume") + "\n" + m.postsView(s, p)
 	case screenCompose:
 		return m.composeView(s, p)
 	case screenLogin:
 		switch s.phase {
 		case "key":
 			if len(s.keys) == 0 {
 				return lipgloss.NewStyle().Foreground(p.muted).Padding(1).Render("No Ed25519 SSH public keys found in ~/.ssh")
 			}
 			lines := []string{"Select an Ed25519 SSH key:"}
 			for i, key := range s.keys {
 				marker := "  "
 				if i == s.selected {
 					marker = "› "
 				}
 				lines = append(lines, marker+key.Path+"  "+key.Fingerprint)
 			}
 			return lipgloss.NewStyle().Padding(1).Render(strings.Join(lines, "\n"))
 		case "handle":
 			key := s.keys[s.selected]
 			return lipgloss.NewStyle().Foreground(p.muted).Padding(0, 1).Render(key.Path+"  "+key.Fingerprint) + "\n" +
 				editor("handle (required for first use)", s.input, false, false, m.width, p)
 		default:
 			label := "email address"
 			if s.phase == "code" {
 				label = "code sent to " + s.query
 			}
 			return editor(label, s.input, s.phase == "code", false, m.width, p)
 		}
 	case screenAccount:
 		return m.accountView(s, p)
 	case screenSettings:
 		return m.settingsView(s, p)
 	case screenHelp:
 		return m.helpView(p)
 	}
 	return ""
 }
 
 func (m *Model) postsView(s *screen, p palette) string {
 	if len(s.posts) == 0 {
 		return lipgloss.NewStyle().Foreground(p.muted).Padding(0, 1).Render("No notes here.")
 	}
 	rendered := make([]string, len(s.posts))
 	for i := range s.posts {
 		depth := 0
 		if i < len(s.depths) {
 			depth = s.depths[i]
 		}
 		focused := -1
 		if i == s.selected {
 			focused = s.target
 		}
 		context := ""
 		if i < len(s.entries) {
 			context = s.entries[i].Context
 		}
 		if s.kind == screenPost && threadHasChildren(s.thread, s.posts[i].ID) {
 			context = "▾ expanded"
 			if s.folded[s.posts[i].ID] {
 				context = "▸ folded"
 			}
 		}
 		bodyLines := 3
 		if s.kind == screenPost && i == s.selected {
 			bodyLines = 8
 		}
 		note := renderNote(s.posts[i], i == s.selected, focused, context, max(20, m.width-depth*2), bodyLines, p)
 		if depth > 0 {
 			note = indentNote(note, depth)
 		}
 		if s.kind == screenFeed && s.feed == string(config.FeedLatest) && s.posts[i].Parent != nil {
 			parent := renderNote(*s.posts[i].Parent, false, -1, "parent", m.width, 3, p)
 			note = parent + "\n" + indentNote(note, 1)
 		}
 		if i < len(s.more) && s.more[i] > 0 {
 			label := fmt.Sprintf("more · %d replies", s.more[i])
 			if s.folded[s.posts[i].ID] {
 				label = fmt.Sprintf("%d replies folded", s.more[i])
 			}
 			note += "\n" + lipgloss.NewStyle().Foreground(p.muted).Render(strings.Repeat("  ", depth+1)+label)
 		}
 		rendered[i] = note
 	}
 
 	available := max(1, m.height-4)
 	switch s.kind {
 	case screenSearch, screenLive, screenTag:
 		available--
 	case screenProfile:
 		available -= 1 + strings.Count(s.profile.Bio, "\n")
 		if s.profile.Bio != "" {
 			available--
 		}
 	}
 	available = max(1, available)
 	if s.kind == screenFeed || s.kind == screenSearch {
 		available--
 	}
 	selected := clamp(s.selected, len(rendered))
 	start := selected
 	used := lipgloss.Height(rendered[selected])
 	for start > 0 {
 		height := lipgloss.Height(rendered[start-1])
 		if used+height > available/2 {
 			break
 		}
 		start--
 		used += height
 	}
 	end := start
 	used = 0
 	for end < len(rendered) {
 		height := lipgloss.Height(rendered[end])
 		if end > start && used+height > available {
 			break
 		}
 		used += height
 		end++
 	}
 	for start > 0 {
 		height := lipgloss.Height(rendered[start-1])
 		if used+height > available {
 			break
 		}
 		start--
 		used += height
 	}
 	parts := append([]string(nil), rendered[start:end]...)
 	if s.kind == screenFeed || s.kind == screenSearch {
 		page := fmt.Sprintf("page %d", s.page+1)
 		if s.page > 0 {
 			page = "p previous  ·  " + page
 		}
 		if s.nextCursor != "" {
 			page += "  ·  n next"
 		}
 		parts = append(parts, lipgloss.NewStyle().Foreground(p.muted).PaddingLeft(2).Render(page))
 	}
 	return strings.Join(parts, "\n")
 }
 
 func indentNote(note string, depth int) string {
 	lines := strings.Split(note, "\n")
 	prefix := strings.Repeat("│ ", depth)
 	for i := range lines {
 		lines[i] = prefix + lines[i]
 	}
 	return strings.Join(lines, "\n")
 }
 
 func renderNote(post textlog.Post, selected bool, focused int, context string, width, maxBodyLines int, p palette) string {
 	if post.Body == "↑ top" && post.Author.Handle == "" && post.CreatedAt.IsZero() {
 		style := lipgloss.NewStyle().Foreground(p.accent).Width(max(10, width-2))
 		if selected {
 			style = style.BorderStyle(lipgloss.ThickBorder()).BorderLeft(true).BorderForeground(p.accent).PaddingLeft(1)
 		} else {
 			style = style.PaddingLeft(2)
 		}
 		return style.Render(post.Body)
 	}
 	replies := fmt.Sprintf("%d replies", post.ReplyCount)
 	if post.ReplyCount == 1 {
 		replies = "1 reply"
 	}
 	authorStyle := lipgloss.NewStyle().Foreground(p.accent).Bold(selected).Reverse(focused == 0)
 	threadStyle := lipgloss.NewStyle().Foreground(p.muted).Reverse(focused == 1)
 	replyStyle := lipgloss.NewStyle().Foreground(p.accent).Reverse(focused == 2)
 	meta := authorStyle.Render("@"+post.Author.Handle) + "  " + threadStyle.Render(relative(post.CreatedAt)+" · "+replies)
 	if context != "" {
 		meta += lipgloss.NewStyle().Foreground(p.muted).Render(" · " + context)
 	}
 	meta += "  " + replyStyle.Render("reply")
 	content := meta
 	if post.Body != "" {
 		bodyWidth := max(8, width-4)
 		body := lipgloss.NewStyle().Width(bodyWidth).MaxHeight(maxBodyLines).Render(renderRich(post.Body, post.Tags, focused-3, p))
 		content += "\n" + body
 	}
 	style := lipgloss.NewStyle().Width(max(10, width-2))
 	if selected {
 		style = style.BorderStyle(lipgloss.ThickBorder()).BorderLeft(true).BorderForeground(p.accent).PaddingLeft(1)
 	} else {
 		style = style.PaddingLeft(2)
 	}
 	return style.Render(content)
 }
 func relative(value time.Time) string {
 	if value.IsZero() {
 		return "now"
 	}
 	seconds := int(time.Since(value).Seconds())
 	if seconds < 0 {
 		seconds = 0
 	}
 	if seconds < 60 {
 		return fmt.Sprintf("%ds", seconds)
 	}
 	if seconds < 3600 {
 		return fmt.Sprintf("%dm", seconds/60)
 	}
 	if seconds < 86400 {
 		return fmt.Sprintf("%dh", seconds/3600)
 	}
 	if seconds < 86400*30 {
 		return fmt.Sprintf("%dd", seconds/86400)
 	}
 	return value.Format("2006-01-02")
 }
 func renderRich(body string, tags []string, focused int, p palette) string {
 	body = domain.TerminalSafeText(body)
 	if domain.IsASCIIArt(body, tags) {
 		return body
 	}
 	var b strings.Builder
 	interactive := -1
 	for _, token := range domain.TokenizeRichText(body) {
 		style := lipgloss.NewStyle().Foreground(p.ink)
 		switch token.Kind {
 		case domain.TokenLink:
 			interactive++
 			style = style.Foreground(p.accent).Underline(true).Reverse(focused == interactive)
 		case domain.TokenReference:
 			interactive++
 			style = style.Foreground(p.accent).Bold(true).Reverse(focused == interactive)
 		case domain.TokenCode:
 			style = style.Foreground(p.muted)
 		}
 		b.WriteString(style.Render(token.Text))
 	}
 	return b.String()
 }
 func editor(label, value string, secret, multiline bool, width int, p palette) string {
 	shown := value
 	if secret {
 		shown = strings.Repeat("•", domain.CodePointLength(value))
 	}
 	field := shown + lipgloss.NewStyle().Reverse(true).Render(" ")
 	style := lipgloss.NewStyle().BorderStyle(lipgloss.ThickBorder()).BorderLeft(true).BorderBottom(true).BorderForeground(p.accent).
 		PaddingLeft(1).Width(max(20, width-4))
 	if multiline {
 		style = style.Height(4)
 	}
 	return lipgloss.NewStyle().Padding(0, 1).Render(
 		lipgloss.NewStyle().Bold(true).Foreground(p.accent).Render(label) + "\n" + style.Render(field),
 	)
 }
 
 func (m *Model) composeView(s *screen, p palette) string {
 	label := "What's on your mind?"
 	if s.parent != nil {
 		label = "reply to @" + s.parent.Author.Handle
 	}
 	if s.edit != nil {
 		label = "edit note"
 	}
 	if !s.preview {
 		return editor(label, s.input, false, true, m.width, p) + fmt.Sprintf("\n %d/280", domain.CodePointLength(s.input))
 	}
 	preview := textlog.Post{Body: s.input, CreatedAt: time.Now(), Author: textlog.UserReference{Handle: m.me.Handle}}
 	items := []string{"publish", "keep editing", "cancel"}
 	for i := range items {
 		prefix := "  "
 		if i == s.menuSelected {
 			prefix = "› "
 			items[i] = lipgloss.NewStyle().Foreground(p.accent).Render(prefix + items[i])
 		} else {
 			items[i] = prefix + items[i]
 		}
 	}
 	return lipgloss.NewStyle().Padding(1).Bold(true).Render(label) + "\n" + renderNote(preview, true, -1, "", m.width, 8, p) + "\n" + lipgloss.NewStyle().Bold(true).Render("Publish this note?") + "\n" + strings.Join(items, "\n")
 }
 func (m *Model) profileView(s *screen, p palette) string {
 	if s.profile == nil {
 		return "Profile not found"
 	}
 	profile := s.profile
 	tabs := []string{fmt.Sprintf("%d notes", profile.PostCount), fmt.Sprintf("%d replies", profile.RepliesCount), fmt.Sprintf("%d users", profile.FollowingUserCount), fmt.Sprintf("%d tags", profile.FollowingTagCount), fmt.Sprintf("%d followers", profile.FollowerCount)}
 	if m.me != nil && strings.EqualFold(m.me.Handle, s.handle) {
 		tabs = append(tabs, fmt.Sprintf("%d blocked", profile.BlockedUserCount))
 	}
 	for i := range tabs {
 		if i == s.activeTab {
 			tabs[i] = lipgloss.NewStyle().Bold(true).Foreground(p.accent).Render(tabs[i])
 		} else {
 			tabs[i] = lipgloss.NewStyle().Foreground(p.muted).Render(tabs[i])
 		}
 	}
 	headerText := strings.Join(tabs, "  ")
 	if profile.Bio != "" {
 		headerText = renderRich(profile.Bio, nil, -1, p) + "\n" + headerText
 	}
 	header := lipgloss.NewStyle().Padding(0, 1).Render(headerText)
 	if s.activeTab < 2 {
 		return header + "\n" + m.postsView(s, p)
 	}
 	height := max(1, m.height-3-lipgloss.Height(header))
 	if s.activeTab == 3 {
 		return header + "\n" + referenceTags(s.tags, s.selected, height, p)
 	}
 	return header + "\n" + referenceUsers(s.users, s.selected, height, p)
 }
 func (m *Model) tagView(s *screen, p palette) string {
 	if len(s.tags) == 0 {
 		return "Tag not found"
 	}
 	details := &s.tags[0]
 	tabs := []string{fmt.Sprintf("%d notes", details.PostCount), fmt.Sprintf("%d followers", details.FollowerCount)}
 	tabs[s.activeTab] = lipgloss.NewStyle().Bold(true).Foreground(p.accent).Render(tabs[s.activeTab])
 	header := lipgloss.NewStyle().Padding(0, 1).Render(strings.Join(tabs, "  "))
 	if s.activeTab == 0 {
 		return header + "\n" + m.postsView(s, p)
 	}
 	return header + "\n" + referenceUsers(s.users, s.selected, max(1, m.height-3-lipgloss.Height(header)), p)
 }
 func referenceUsers(items []textlog.UserReference, selected, height int, p palette) string {
 	if len(items) == 0 {
 		return lipgloss.NewStyle().Foreground(p.muted).Render(" No users here.")
 	}
 	start, end := referenceWindow(selected, len(items), height)
 	lines := make([]string, 0, end-start)
 	for i := start; i < end; i++ {
 		prefix := "  "
 		if i == selected {
 			prefix = "› "
 			lines = append(lines, lipgloss.NewStyle().Foreground(p.accent).Render(prefix+"@"+items[i].Handle))
 		} else {
 			lines = append(lines, prefix+"@"+items[i].Handle)
 		}
 	}
 	return strings.Join(lines, "\n")
 }
 
 func referenceTags(items []textlog.TagReference, selected, height int, p palette) string {
 	if len(items) == 0 {
 		return lipgloss.NewStyle().Foreground(p.muted).Render(" No tags here.")
 	}
 	start, end := referenceWindow(selected, len(items), height)
 	lines := make([]string, 0, end-start)
 	for i := start; i < end; i++ {
 		prefix := "  "
 		if i == selected {
 			prefix = "› "
 		}
 		lines = append(lines, prefix+"#"+items[i].Tag)
 	}
 	return strings.Join(lines, "\n")
 }
 
 func referenceWindow(selected, length, height int) (int, int) {
 	height = max(1, height)
 	start := max(0, clamp(selected, length)-height/2)
 	end := min(length, start+height)
 	if end-start < height {
 		start = max(0, end-height)
 	}
 	return start, end
 }
 
 func (m *Model) accountView(s *screen, p palette) string {
 	if s.phase == "bio" {
 		return editor("edit bio", s.input, false, true, m.width, p)
 	}
 	if m.me == nil {
 		return "You are not signed in."
 	}
 	return lipgloss.NewStyle().Padding(1).Render(lipgloss.NewStyle().Bold(true).Foreground(p.accent).Render("@"+m.me.Handle) + "\n" + m.me.Email + "\n" + m.me.Bio + "\n" + lipgloss.NewStyle().Foreground(p.muted).Render(map[bool]string{true: "email verified", false: "email not verified"}[m.me.EmailVerified]) + "\n\n" + lipgloss.NewStyle().Foreground(p.accent).Render("e edit bio · u profile · , settings · s sign out"))
 }
 func (m *Model) settingsView(s *screen, p palette) string {
 	if s.phase == "url" {
 		return editor("Textlog instance URL", s.input, false, false, m.width, p)
 	}
 	items := []string{"theme: " + string(m.config.Theme), "change instance URL", "open web app", "back"}
 	for i := range items {
 		prefix := "  "
 		if i == s.menuSelected {
 			prefix = "› "
 			items[i] = lipgloss.NewStyle().Foreground(p.accent).Render(prefix + items[i])
 		} else {
 			items[i] = prefix + items[i]
 		}
 	}
 	return lipgloss.NewStyle().Padding(1).Render(lipgloss.NewStyle().Bold(true).Render("settings · "+m.config.BaseURL) + "\n" + strings.Join(items, "\n"))
 }
 func (m *Model) helpView(p palette) string {
 	feeds := "1–3 feeds"
 	if m.config.Token != "" {
 		feeds = "1–5 feeds"
 	}
 	label := func(value string) string {
 		return lipgloss.NewStyle().Width(9).Foreground(p.muted).Render(value)
 	}
 	lines := []string{
 		lipgloss.NewStyle().Bold(true).Foreground(p.accent).Render("a quieter place for your thoughts"),
 		"",
 		label("global") + feeds + " · / search · w write · a account · 0 profile",
 		label("move") + "↑↓ j/k · Enter/l open · h/q back · g/G first/last",
 		label("pages") + "p/n previous/next · R refresh",
 		label("notes") + "Tab target · r reply · u author · t tag · o browser",
 		label("actions") + "f/F follow · b/B block · e edit · d delete · ! report",
 		label("tabs") + "Tab or ←/→ on profiles and tags",
 		"",
 		lipgloss.NewStyle().Foreground(p.muted).Render("Activity feeds require sign-in · API " + m.config.BaseURL + "/api"),
 	}
 	return lipgloss.NewStyle().Padding(0, 1).Render(strings.Join(lines, "\n"))
 }