prime8dev

update.go (7449B)

---

 package tui
 
 import (
 	"time"
 
 	"git.prime8.dev/moncheeta/prime8dev/internal/utils"
 
 	"github.com/charmbracelet/bubbles/key"
 	"github.com/charmbracelet/bubbles/viewport"
 	tea "github.com/charmbracelet/bubbletea"
 )
 
 func tickCmd() tea.Cmd {
 	return tea.Tick(time.Second, func(t time.Time) tea.Msg {
 		return tickMsg(t)
 	})
 }
 
 func (m portfolioModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	next, cmd := m.update(msg)
 	pm, ok := next.(portfolioModel)
 	if !ok {
 		return next, cmd
 	}
 	if title := pm.windowTitle(); title != pm.windowTitleSet {
 		pm.windowTitleSet = title
 		cmd = tea.Batch(cmd, tea.SetWindowTitle(title))
 	}
 	return pm, cmd
 }
 
 func (m portfolioModel) windowTitle() string {
 	path := "~"
 	switch m.activeTab {
 	case tabExperience:
 		path += "/experience"
 	case tabProjects:
 		path += "/projects"
 		if p := m.selectedProject(); p != nil {
 			path += "/" + p.ID
 		}
 	}
 	return utils.WindowTitle(path)
 }
 
 func (m portfolioModel) update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	switch msg := msg.(type) {
 	case tea.WindowSizeMsg:
 		m.width = msg.Width
 		m.height = msg.Height
 		m.syncViewport()
 		return m, m.refreshDataCmd()
 	case cursorBlinkMsg:
 		// The viewport holds a rendered copy of the page, so the prompt line
 		// has to be re-rendered for the blink to show. SetContent keeps the
 		// scroll offset.
 		if m.activeTab == tabAbout && !m.bootActive {
 			m.viewport.SetContent(m.detailContent())
 		}
 		return m, cursorBlinkCmd()
 	case tickMsg:
 		m.now = time.Time(msg)
 		return m, tea.Batch(tickCmd(), m.refreshDataCmd())
 	case bootTickMsg:
 		if !m.bootActive {
 			return m, nil
 		}
 		m.syncBootFrame(time.Time(msg))
 		if !m.bootActive {
 			return m, m.startAboutLogoReveal()
 		}
 		return m, bootTickCmd()
 	case wakaFooterInitMsg:
 		return m, m.maybeLoadWakaFooterCmd()
 	case projectReadmeMsg:
 		m.projectReadmeLoads[msg.projectID] = false
 		if msg.err != nil {
 			m.projectReadmeErrors[msg.projectID] = msg.err.Error()
 		} else {
 			if m.projectReadmes[msg.projectID] != msg.readme {
 				delete(m.projectReadmeRender, msg.projectID) // re-render on the next sync
 			}
 			m.projectReadmes[msg.projectID] = msg.readme
 			delete(m.projectReadmeErrors, msg.projectID)
 		}
 		if m.activeTab == tabProjects {
 			if selected := m.selectedProject(); selected != nil && selected.ID == msg.projectID {
 				m.syncViewport()
 			}
 		}
 		return m, nil
 	case aboutASCIIRenderedMsg:
 		m.applyAboutASCIIRendered(msg)
 		cmd := m.startAboutLogoReveal()
 		if m.activeTab == tabAbout {
 			m.syncViewport()
 		}
 		return m, cmd
 	case aboutLogoRowMsg:
 		cmd := m.stepAboutLogoReveal(msg)
 		if m.activeTab == tabAbout {
 			m.syncViewport()
 		}
 		return m, cmd
 	case wakaFooterMsg:
 		m.wakaLoading = false
 		m.wakaLoaded = true
 		if msg.ok {
 			m.wakaHours = msg.hours
 		} else {
 			m.wakaHours = ""
 		}
 		if m.activeTab == tabAbout {
 			m.syncViewport()
 		}
 		return m, nil
 	case tea.KeyMsg:
 		return m, m.handleKeyMsg(msg)
 	}
 
 	return m, nil
 }
 
 func (m *portfolioModel) refreshDataCmd() tea.Cmd {
 	return tea.Batch(
 		m.maybeLoadProjectReadmeCmd(),
 		m.maybePrefetchProjectReadmesCmd(),
 		m.maybeLoadWakaFooterCmd(),
 		m.maybeRenderAboutASCIICmd(),
 	)
 }
 
 func (m *portfolioModel) handleKeyMsg(msg tea.KeyMsg) tea.Cmd {
 	if m.bootActive {
 		if key.Matches(msg, m.keys.Quit) {
 			return tea.Quit
 		}
 		return nil
 	}
 
 	if m.help.ShowAll {
 		switch {
 		case key.Matches(msg, m.keys.Quit):
 			return tea.Quit
 		case key.Matches(msg, m.keys.Help), key.Matches(msg, m.keys.Back):
 			m.help.ShowAll = false
 			return nil
 		default:
 			return nil
 		}
 	}
 
 	if m.activeTab == tabAbout {
 		if cmd, ok := m.handleShellKey(msg); ok {
 			return cmd
 		}
 	}
 
 	if m.activeTab == tabProjects {
 		// With the readme focused, plain arrows pan sideways instead of
 		// switching tabs; left at the left edge falls through and backs out.
 		readme := m.projectReadmeScroll
 		switch {
 		case key.Matches(msg, m.keys.Left),
 			readme && msg.Type == tea.KeyLeft && m.detailXOffset > 0:
 			m.scrollDetailX(-detailHorizontalStep)
 			return nil
 		case key.Matches(msg, m.keys.Right),
 			readme && msg.Type == tea.KeyRight:
 			m.scrollDetailX(detailHorizontalStep)
 			return nil
 		}
 	}
 
 	if m.consumeProjectReadmeBack(msg) {
 		return nil
 	}
 
 	if tab, ok := tabIndexFromKey(msg.String()); ok {
 		return m.activateTab(tab)
 	}
 
 	switch {
 	case key.Matches(msg, m.keys.Quit):
 		return tea.Quit
 	case key.Matches(msg, m.keys.Help):
 		m.help.ShowAll = !m.help.ShowAll
 		return nil
 	case key.Matches(msg, m.keys.TabNext):
 		return m.activateTab(wrapIndex(m.activeTab+1, len(tabLabels)))
 	case key.Matches(msg, m.keys.TabPrev):
 		return m.activateTab(wrapIndex(m.activeTab-1, len(tabLabels)))
 	case key.Matches(msg, m.keys.Open):
 		return m.handleOpenKey()
 	case key.Matches(msg, m.keys.Back):
 		return m.handleBackKey()
 	case key.Matches(msg, m.keys.Up):
 		return tea.Batch(m.moveSelection(-1), m.refreshDataCmd())
 	case key.Matches(msg, m.keys.Down):
 		return tea.Batch(m.moveSelection(1), m.refreshDataCmd())
 	case key.Matches(msg, m.keys.PageUp):
 		if m.canPageScroll() {
 			m.viewport.HalfViewUp()
 		}
 		return nil
 	case key.Matches(msg, m.keys.PageDown):
 		if m.canPageScroll() {
 			m.viewport.HalfViewDown()
 		}
 		return nil
 	default:
 		return nil
 	}
 }
 
 func (m *portfolioModel) activateTab(tab int) tea.Cmd {
 	if tab < 0 || tab >= len(tabLabels) {
 		return nil
 	}
 
 	m.activeTab = tab
 	m.projectReadmeScroll = false
 	// coming back to a tab shows the cursor solid, like a fresh keystroke
 	m.shell.lastKey = time.Now()
 	m.resetViewport()
 
 	return tea.Batch(m.refreshDataCmd(), m.startAboutLogoReveal())
 }
 
 func (m *portfolioModel) consumeProjectReadmeBack(msg tea.KeyMsg) bool {
 	if m.activeTab != tabProjects || !m.projectReadmeScroll {
 		return false
 	}
 
 	if msg.String() != "left" && !key.Matches(msg, m.keys.Back) {
 		return false
 	}
 
 	m.projectReadmeScroll = false
 	m.resetViewport()
 	return true
 }
 
 func (m *portfolioModel) handleOpenKey() tea.Cmd {
 	switch m.activeTab {
 	case tabProjects:
 		if len(m.projects) == 0 {
 			return nil
 		}
 		m.projectReadmeScroll = !m.projectReadmeScroll
 		return nil
 	default:
 		return nil
 	}
 }
 
 func (m *portfolioModel) handleBackKey() tea.Cmd {
 	if m.activeTab == tabProjects && m.projectReadmeScroll {
 		m.projectReadmeScroll = false
 		m.resetViewport()
 		return nil
 	}
 
 	return tea.Quit
 }
 
 func (m portfolioModel) canPageScroll() bool {
 	return m.activeTab != tabProjects || m.projectReadmeScroll
 }
 
 func tabIndexFromKey(keyString string) (int, bool) {
 	if len(keyString) != 1 {
 		return 0, false
 	}
 
 	if keyString[0] < '1' || keyString[0] > '9' {
 		return 0, false
 	}
 
 	idx := int(keyString[0] - '1')
 	if idx < 0 || idx >= len(tabLabels) {
 		return 0, false
 	}
 
 	return idx, true
 }
 
 func (m *portfolioModel) moveSelection(delta int) tea.Cmd {
 	if m.activeTab == tabAbout || (m.activeTab == tabProjects && m.projectReadmeScroll) {
 		scrollViewport(&m.viewport, delta)
 		return nil
 	}
 
 	switch m.activeTab {
 	case tabProjects:
 		if len(m.projects) == 0 {
 			scrollViewport(&m.viewport, delta)
 			return nil
 		}
 		m.projectIndex = wrapIndex(m.projectIndex+delta, len(m.projects))
 		m.syncViewport()
 	case tabExperience:
 		if len(m.experience) == 0 {
 			scrollViewport(&m.viewport, delta)
 			return nil
 		}
 		m.experienceIndex = wrapIndex(m.experienceIndex+delta, len(m.experience))
 		m.syncViewport()
 	}
 
 	return nil
 }
 
 func scrollViewport(vp *viewport.Model, delta int) {
 	if delta > 0 {
 		_ = vp.LineDown(delta)
 		return
 	}
 	_ = vp.LineUp(-delta)
 }