eSliderandCursor
0ed2d9b0f5
Add Users list/detail with ACL toggles and library people update/status APIs. Fix project table layout and ANSI-safe cell rendering, and decode array responses from people/status so saves no longer fail on JSON unmarshal. Co-authored-by: Cursor <cursoragent@cursor.com>
1050 lines
24 KiB
Go
1050 lines
24 KiB
Go
package ui
|
|
|
|
import (
|
|
"context"
|
|
"strings"
|
|
|
|
"github.com/charmbracelet/bubbles/viewport"
|
|
tea "github.com/charmbracelet/bubbletea"
|
|
"github.com/charmbracelet/lipgloss"
|
|
onlyoffice "github.com/eslider/go-onlyoffice"
|
|
"github.com/eslider/go-onlyoffice/cmd/office/fetch"
|
|
"github.com/eslider/go-onlyoffice/cmd/office/model"
|
|
)
|
|
|
|
type listLoadedMsg struct {
|
|
items []model.Item
|
|
spec model.ListSpec
|
|
err error
|
|
}
|
|
|
|
type listMoreLoadedMsg struct {
|
|
items []model.Item
|
|
err error
|
|
}
|
|
|
|
type detailLoadedMsg struct {
|
|
item model.Item
|
|
document bool
|
|
fields model.FormFields
|
|
markdown string
|
|
err error
|
|
}
|
|
|
|
type detailSavedMsg struct {
|
|
item model.Item
|
|
fields model.FormFields
|
|
err error
|
|
}
|
|
|
|
type actionDoneMsg struct {
|
|
message string
|
|
err error
|
|
}
|
|
|
|
type navProjectsMsg struct {
|
|
projects []model.Item
|
|
err error
|
|
}
|
|
|
|
// Model is the root Bubble Tea model for the office TUI.
|
|
type Model struct {
|
|
client *onlyoffice.Client
|
|
loader *fetch.Loader
|
|
nav *model.NavTree
|
|
listSpec model.ListSpec
|
|
hasList bool
|
|
items []model.Item
|
|
selection *model.Selection
|
|
listHasMore bool
|
|
listLoadingMore bool
|
|
focus model.FocusPane
|
|
width int
|
|
height int
|
|
status string
|
|
err string
|
|
loading bool
|
|
menuVP viewport.Model
|
|
listTable DataTable
|
|
listToolbar ListToolbar
|
|
detail DetailPane
|
|
showMenu bool
|
|
showList bool
|
|
showDetail bool
|
|
customPaneLayout bool
|
|
paneSizes PaneWidths
|
|
resize paneResizeState
|
|
}
|
|
|
|
// NewModel constructs the TUI with an authenticated client.
|
|
func NewModel(client *onlyoffice.Client) Model {
|
|
h, w := 24, 80
|
|
m := Model{
|
|
client: client,
|
|
loader: &fetch.Loader{Client: client},
|
|
nav: model.DefaultNavTree(),
|
|
selection: model.NewSelection(),
|
|
focus: model.FocusMenu,
|
|
status: "Tab: pane · / filter · Space select row · 💾🗑 when selected · v: detail · q quit",
|
|
height: h,
|
|
width: w,
|
|
}
|
|
m.menuVP = viewport.New(m.paneInnerWidth(22), m.paneHeight())
|
|
m.listTable = newDataTable()
|
|
m.listToolbar = newListToolbar()
|
|
m.detail = newDetailPane()
|
|
m.showMenu, m.showList, m.showDetail = true, true, true
|
|
m.menuVP.MouseWheelEnabled = true
|
|
return m
|
|
}
|
|
|
|
func (m Model) Init() tea.Cmd {
|
|
return tea.Batch(m.loadNavProjectsCmd(), m.detail.BlinkCmd(), filterSearchBlinkCmd())
|
|
}
|
|
|
|
func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
|
|
switch msg := msg.(type) {
|
|
case tea.WindowSizeMsg:
|
|
m.width = msg.Width
|
|
m.height = msg.Height
|
|
if m.customPaneLayout {
|
|
m.paneSizes = FitPaneWidths(m.width, m.paneVis(), m.paneSizes)
|
|
}
|
|
m.layoutViewports()
|
|
m.syncAllContent()
|
|
return m, nil
|
|
|
|
case tea.KeyMsg:
|
|
key := msg.String()
|
|
if key == "esc" && m.focus == model.FocusList && m.listToolbar.Zone() != listZoneTable {
|
|
m.listToolbar.FocusTable()
|
|
m.syncPaneFocus()
|
|
return m, nil
|
|
}
|
|
if key == "esc" && m.focus == model.FocusList && m.listToolbar.Query() != "" {
|
|
m.listToolbar.ClearFilter()
|
|
m.nav.ClearFilter()
|
|
m.syncMenuContent()
|
|
m.syncListTable()
|
|
return m, nil
|
|
}
|
|
if m.focus == model.FocusList && m.listToolbar.Zone() == listZoneFilter {
|
|
switch key {
|
|
case "tab", "shift+tab", "backtab":
|
|
// allow pane switching
|
|
default:
|
|
cmd := m.listToolbar.Update(msg, m.listToolbarMeta())
|
|
m.applyFilter()
|
|
return m, cmd
|
|
}
|
|
}
|
|
if m.focus == model.FocusList && m.listToolbar.Zone() == listZoneActions {
|
|
meta := m.listToolbarMeta()
|
|
switch key {
|
|
case "enter":
|
|
if act, ok := m.listToolbar.SelectedAction(meta); ok && m.listToolbar.IsActionEnabled(act, meta) {
|
|
return m, m.runListToolbarAction(act)
|
|
}
|
|
return m, nil
|
|
case "tab", "shift+tab", "backtab":
|
|
// allow pane switching
|
|
default:
|
|
cmd := m.listToolbar.Update(msg, meta)
|
|
return m, cmd
|
|
}
|
|
}
|
|
if key == "?" {
|
|
m.status = helpText()
|
|
return m, nil
|
|
}
|
|
if m.scrollFocusedPane(key) {
|
|
return m, nil
|
|
}
|
|
if m.focus == model.FocusPreview {
|
|
if cmd, handled := m.handleDetailKey(key, msg); handled {
|
|
return m, cmd
|
|
}
|
|
}
|
|
action := KeyAction(key, m.focus)
|
|
if action == ActionNone && (key == "up" || key == "k") {
|
|
action = ResolveMoveUp(m.focus)
|
|
}
|
|
switch action {
|
|
case ActionQuit:
|
|
return m, tea.Quit
|
|
case ActionNextPane:
|
|
prev := m.focus
|
|
m.focus = NextVisibleFocus(m.focus, m.paneVis())
|
|
if m.focus == model.FocusPreview && prev != model.FocusPreview {
|
|
m.detail.FocusFirstStop()
|
|
}
|
|
if m.focus == model.FocusList && prev != model.FocusList {
|
|
m.listToolbar.FocusTable()
|
|
}
|
|
m.syncPaneFocus()
|
|
return m, nil
|
|
case ActionPrevPane:
|
|
prev := m.focus
|
|
m.focus = PrevVisibleFocus(m.focus, m.paneVis())
|
|
if m.focus == model.FocusPreview && prev != model.FocusPreview {
|
|
m.detail.FocusFirstStop()
|
|
}
|
|
if m.focus == model.FocusList && prev != model.FocusList {
|
|
m.listToolbar.FocusTable()
|
|
}
|
|
m.syncPaneFocus()
|
|
return m, nil
|
|
case ActionMoveUp:
|
|
if m.focus == model.FocusPreview {
|
|
return m.handleDetailMove(-1)
|
|
}
|
|
if m.focus == model.FocusList && m.listToolbar.Zone() != listZoneTable {
|
|
return m, nil
|
|
}
|
|
m.moveUp()
|
|
m.syncFocusedPane()
|
|
if m.focus == model.FocusList {
|
|
return m, m.onListRowChanged()
|
|
}
|
|
return m, nil
|
|
case ActionMoveDown:
|
|
if m.focus == model.FocusPreview {
|
|
return m.handleDetailMove(1)
|
|
}
|
|
if m.focus == model.FocusList && m.listToolbar.Zone() != listZoneTable {
|
|
return m, nil
|
|
}
|
|
m.moveDown()
|
|
m.syncFocusedPane()
|
|
if m.focus == model.FocusList {
|
|
return m, m.onListRowChanged()
|
|
}
|
|
return m, nil
|
|
case ActionMoveLeft:
|
|
if m.focus == model.FocusPreview && m.detail.Zone() == detailZoneActions {
|
|
m.detail.MoveTabStop(-1)
|
|
return m, nil
|
|
}
|
|
if m.focus == model.FocusMenu {
|
|
return m.handleMenuHorizontal(-1)
|
|
}
|
|
if m.focus == model.FocusList && m.hasList && m.listToolbar.Zone() == listZoneTable {
|
|
m.listTable.MoveCol(-1)
|
|
}
|
|
return m, nil
|
|
case ActionMoveRight:
|
|
if m.focus == model.FocusPreview && m.detail.Zone() == detailZoneActions {
|
|
m.detail.MoveTabStop(1)
|
|
return m, nil
|
|
}
|
|
if m.focus == model.FocusMenu {
|
|
return m.handleMenuHorizontal(1)
|
|
}
|
|
if m.focus == model.FocusList && m.hasList && m.listToolbar.Zone() == listZoneTable {
|
|
m.listTable.MoveCol(1)
|
|
}
|
|
return m, nil
|
|
case ActionSort:
|
|
if m.focus == model.FocusList && m.hasList && m.listToolbar.Zone() == listZoneTable {
|
|
m.listTable.ToggleSort()
|
|
}
|
|
return m, nil
|
|
case ActionToggleSelect:
|
|
if m.hasList {
|
|
if it, ok := m.listTableItem(); ok {
|
|
for i := range m.items {
|
|
if m.items[i].ID == it.ID {
|
|
m.selection.Toggle(&m.items, i)
|
|
break
|
|
}
|
|
}
|
|
m.syncListTable()
|
|
}
|
|
}
|
|
return m, nil
|
|
case ActionFocusDetail:
|
|
if m.hasList && m.showDetail {
|
|
m.focus = model.FocusPreview
|
|
m.syncPaneFocus()
|
|
m.detail.FocusFirstStop()
|
|
return m, m.onListRowChanged()
|
|
}
|
|
return m, nil
|
|
case ActionToggleMenuPane:
|
|
m.togglePane(1)
|
|
return m, nil
|
|
case ActionToggleListPane:
|
|
m.togglePane(2)
|
|
return m, nil
|
|
case ActionToggleDetailPane:
|
|
m.togglePane(3)
|
|
return m, nil
|
|
case ActionFilter:
|
|
if m.hasList {
|
|
m.focus = model.FocusList
|
|
m.listToolbar.FocusFilter()
|
|
m.syncPaneFocus()
|
|
}
|
|
return m, nil
|
|
case ActionRefresh:
|
|
if m.hasList {
|
|
m.loading = true
|
|
return m, m.loadListCmd(m.listSpec)
|
|
}
|
|
return m, nil
|
|
}
|
|
if m.focus == model.FocusMenu {
|
|
switch key {
|
|
case " ":
|
|
m.nav.ToggleExpand(m.nav.Cursor())
|
|
m.syncMenuContent()
|
|
return m, nil
|
|
case "enter":
|
|
if spec, ok := m.nav.Activate(); ok {
|
|
return m.withList(*spec)
|
|
}
|
|
m.syncMenuContent()
|
|
return m, nil
|
|
}
|
|
}
|
|
|
|
case listLoadedMsg:
|
|
m.loading = false
|
|
m.listLoadingMore = false
|
|
if msg.err != nil {
|
|
m.err = msg.err.Error()
|
|
m.items = nil
|
|
m.hasList = false
|
|
m.listHasMore = false
|
|
m.listTable.Clear()
|
|
m.detail.Clear()
|
|
} else {
|
|
m.err = ""
|
|
m.items = msg.items
|
|
m.listSpec = msg.spec
|
|
m.hasList = true
|
|
m.listHasMore = model.SubjectIsMail(msg.spec.Subject) && len(msg.items) >= fetch.MailListPageSize
|
|
m.listTable.SetData(m.listSpec, m.items)
|
|
m.applyFilter()
|
|
}
|
|
return m, tea.Batch(m.onListRowChanged(), m.maybeLoadMoreList())
|
|
|
|
case listMoreLoadedMsg:
|
|
m.listLoadingMore = false
|
|
m.listTable.SetLoadingMore(false)
|
|
if msg.err != nil {
|
|
m.err = msg.err.Error()
|
|
return m, nil
|
|
}
|
|
if len(msg.items) == 0 {
|
|
m.listHasMore = false
|
|
return m, nil
|
|
}
|
|
added := m.listTable.AppendItems(msg.items)
|
|
if added > 0 {
|
|
m.items = m.listTable.Items()
|
|
}
|
|
m.listHasMore = len(msg.items) >= fetch.MailListPageSize
|
|
m.err = ""
|
|
return m, nil
|
|
|
|
case detailLoadedMsg:
|
|
m.loading = false
|
|
if msg.err != nil {
|
|
m.err = msg.err.Error()
|
|
m.detail.Clear()
|
|
} else {
|
|
pw := m.paneLayout()
|
|
w := pw.Detail - 4
|
|
if w < 20 {
|
|
w = 20
|
|
}
|
|
if msg.document {
|
|
m.detail.LoadDocument(msg.item, msg.markdown, w)
|
|
} else {
|
|
m.detail.LoadForm(msg.item, msg.fields)
|
|
}
|
|
m.detail.SetFocused(m.focus == model.FocusPreview)
|
|
m.err = ""
|
|
}
|
|
return m, nil
|
|
|
|
case detailSavedMsg:
|
|
m.loading = false
|
|
if msg.err != nil {
|
|
m.err = msg.err.Error()
|
|
} else {
|
|
m.updateItemAfterSave(msg.item, msg.fields)
|
|
m.detail.LoadForm(msg.item, msg.fields)
|
|
m.detail.form.MarkClean()
|
|
m.detail.SetFocused(m.focus == model.FocusPreview)
|
|
if msg.fields.HasTaskStatus && msg.fields.TaskStatus == model.TaskLifecycleClosed {
|
|
m.status = "Closed"
|
|
} else {
|
|
m.status = "Saved"
|
|
}
|
|
m.err = ""
|
|
}
|
|
return m, nil
|
|
|
|
case actionDoneMsg:
|
|
m.loading = false
|
|
if msg.err != nil {
|
|
m.err = msg.err.Error()
|
|
} else {
|
|
m.status = msg.message
|
|
m.err = ""
|
|
m.selection.Clear()
|
|
if m.hasList {
|
|
m.loading = true
|
|
return m, m.loadListCmd(m.listSpec)
|
|
}
|
|
}
|
|
return m, nil
|
|
|
|
case navProjectsMsg:
|
|
if msg.err == nil {
|
|
m.nav.InjectProjectNodes(msg.projects)
|
|
m.syncMenuContent()
|
|
}
|
|
return m, nil
|
|
|
|
case tea.MouseMsg:
|
|
if m.handlePaneResizeMouse(msg) {
|
|
return m, nil
|
|
}
|
|
if cmd, handled := m.routeDetailDocumentMouse(msg); handled {
|
|
return m, cmd
|
|
}
|
|
var cmd tea.Cmd
|
|
switch m.focus {
|
|
case model.FocusMenu:
|
|
m.menuVP, cmd = m.menuVP.Update(msg)
|
|
case model.FocusList:
|
|
if m.listToolbar.Zone() == listZoneTable {
|
|
cmd = m.listTable.Update(msg)
|
|
}
|
|
case model.FocusPreview:
|
|
cmd = m.detail.Update(msg)
|
|
}
|
|
return m, cmd
|
|
}
|
|
|
|
var cmd tea.Cmd
|
|
switch m.focus {
|
|
case model.FocusMenu:
|
|
m.menuVP, cmd = m.menuVP.Update(msg)
|
|
case model.FocusList:
|
|
cmd = m.listTable.Update(msg)
|
|
case model.FocusPreview:
|
|
cmd = m.detail.Update(msg)
|
|
}
|
|
return m, cmd
|
|
}
|
|
|
|
func (m *Model) handleDetailKey(key string, msg tea.KeyMsg) (tea.Cmd, bool) {
|
|
switch key {
|
|
case "tab", "shift+tab", "backtab":
|
|
reverse := key != "tab"
|
|
if reverse {
|
|
if m.detail.TabBackward() {
|
|
m.focus = PrevVisibleFocus(m.focus, m.paneVis())
|
|
}
|
|
} else if m.detail.TabForward() {
|
|
m.focus = NextVisibleFocus(m.focus, m.paneVis())
|
|
}
|
|
m.syncPaneFocus()
|
|
return nil, true
|
|
case "ctrl+s":
|
|
m.loading = true
|
|
return m.saveDetailCmd(), true
|
|
case "enter":
|
|
if m.detail.Zone() == detailZoneActions {
|
|
act, ok := m.detail.SelectedAction()
|
|
if !ok {
|
|
return nil, true
|
|
}
|
|
m.loading = true
|
|
if act.ID == model.ActionSave {
|
|
return m.saveDetailCmd(), true
|
|
}
|
|
if act.ID == model.ActionClose && m.detail.Item().Kind == model.KindTask {
|
|
return m.closeTaskCmd(), true
|
|
}
|
|
return m.executeActionCmd(act.ID, m.detail.Item()), true
|
|
}
|
|
}
|
|
if m.detail.Zone() == detailZoneContent {
|
|
return m.detail.Update(msg), true
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
func (m *Model) routeDetailDocumentMouse(msg tea.MouseMsg) (tea.Cmd, bool) {
|
|
if !m.showDetail {
|
|
return nil, false
|
|
}
|
|
if !m.detail.IsDocumentContent() && !m.detail.isReadOnlyFormContent() {
|
|
return nil, false
|
|
}
|
|
if msg.Y > m.paneHeight()+1 {
|
|
return nil, false
|
|
}
|
|
x0, x1 := DetailPaneXRange(m.paneLayout())
|
|
if x0 >= x1 || msg.X < x0 || msg.X >= x1 {
|
|
return nil, false
|
|
}
|
|
cmd := m.detail.ScrollDocumentMouse(msg)
|
|
if msg.Button == tea.MouseButtonWheelUp || msg.Button == tea.MouseButtonWheelDown {
|
|
return cmd, true
|
|
}
|
|
return cmd, false
|
|
}
|
|
|
|
func (m Model) handleDetailMove(delta int) (Model, tea.Cmd) {
|
|
if m.detail.Zone() == detailZoneContent && (m.detail.IsDocumentContent() || m.detail.isReadOnlyFormContent()) {
|
|
key := "down"
|
|
if delta < 0 {
|
|
key = "up"
|
|
}
|
|
m.detail.ScrollDocument(key)
|
|
return m, nil
|
|
}
|
|
m.detail.MoveTabStop(delta)
|
|
return m, nil
|
|
}
|
|
|
|
func (m Model) View() string {
|
|
if m.width == 0 {
|
|
return "Loading…\n"
|
|
}
|
|
pw := m.paneLayout()
|
|
h := m.paneHeight() + 2
|
|
var parts []string
|
|
if pw.Visibility.Menu {
|
|
menuStyle := paneStyle(m.focus == model.FocusMenu).Width(paneLipglossWidth(pw.Menu)).Height(h)
|
|
menuBody := ApplyVerticalScrollbar(
|
|
m.menuVP.View(),
|
|
m.menuVP.Width,
|
|
m.menuVP.Height,
|
|
m.menuVP.TotalLineCount(),
|
|
m.menuVP.YOffset,
|
|
)
|
|
parts = append(parts, menuStyle.Render(menuBody))
|
|
}
|
|
if pw.Visibility.List {
|
|
listStyle := paneStyle(m.focus == model.FocusList).Width(paneLipglossWidth(pw.List)).Height(h)
|
|
meta := m.listToolbarMeta()
|
|
body := lipgloss.JoinVertical(lipgloss.Left,
|
|
m.listToolbar.View(meta),
|
|
m.listTable.View(),
|
|
)
|
|
parts = append(parts, listStyle.Render(body))
|
|
}
|
|
if pw.Visibility.Detail {
|
|
prevStyle := paneStyle(m.focus == model.FocusPreview).Width(paneLipglossWidth(pw.Detail)).Height(h)
|
|
parts = append(parts, prevStyle.Render(m.detail.View()))
|
|
}
|
|
|
|
status := m.status
|
|
if m.loading {
|
|
status = "Loading…"
|
|
}
|
|
if m.err != "" {
|
|
status = "Error: " + m.err
|
|
}
|
|
bar := lipgloss.NewStyle().Foreground(lipgloss.Color("241")).Render(status)
|
|
|
|
return lipgloss.JoinHorizontal(lipgloss.Top, parts...) + "\n" + bar
|
|
}
|
|
|
|
func (m Model) paneVis() PaneVisibility {
|
|
return PaneVisibility{Menu: m.showMenu, List: m.showList, Detail: m.showDetail}
|
|
}
|
|
|
|
func (m Model) paneLayout() PaneWidths {
|
|
vis := m.paneVis()
|
|
if m.customPaneLayout {
|
|
return FitPaneWidths(m.width, vis, m.paneSizes)
|
|
}
|
|
return LayoutWidths(m.width, vis)
|
|
}
|
|
|
|
func (m *Model) syncPaneFocus() {
|
|
onList := m.focus == model.FocusList && m.showList
|
|
m.listTable.SetFocused(onList && m.listToolbar.Zone() == listZoneTable)
|
|
if onList {
|
|
m.listToolbar.syncInputFocus()
|
|
} else {
|
|
m.listToolbar.filter.SetFocused(false)
|
|
}
|
|
m.detail.SetFocused(m.focus == model.FocusPreview && m.showDetail)
|
|
}
|
|
|
|
func (m Model) listToolbarMeta() ListToolbarMeta {
|
|
meta := ListToolbarMeta{
|
|
Subject: m.listTable.SubjectLabel(),
|
|
Count: m.listTable.ItemCount(),
|
|
SortLabel: m.listTable.SortHint(),
|
|
LoadingMore: m.listTable.LoadingMore(),
|
|
SaveEnabled: m.canSaveFromList(),
|
|
DeleteEnabled: m.canDeleteFromList(),
|
|
}
|
|
return meta
|
|
}
|
|
|
|
func (m Model) selectedItems() []model.Item {
|
|
var out []model.Item
|
|
for _, it := range m.items {
|
|
if it.Selected {
|
|
out = append(out, it)
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
func (m Model) canSaveFromList() bool {
|
|
selected := m.selectedItems()
|
|
if len(selected) != 1 {
|
|
return false
|
|
}
|
|
for _, act := range model.ActionsFor(selected[0].Kind) {
|
|
if act.ID == model.ActionSave && m.detail.LoadedID() == selected[0].ID {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m Model) canDeleteFromList() bool {
|
|
selected := m.selectedItems()
|
|
if len(selected) == 0 {
|
|
return false
|
|
}
|
|
for _, it := range selected {
|
|
if !actionAvailable(model.ActionsFor(it.Kind), model.ActionDelete) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func actionAvailable(actions []model.ItemAction, id model.ActionID) bool {
|
|
for _, a := range actions {
|
|
if a.ID == id {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *Model) runListToolbarAction(action model.ActionID) tea.Cmd {
|
|
meta := m.listToolbarMeta()
|
|
if !m.listToolbar.IsActionEnabled(action, meta) {
|
|
return nil
|
|
}
|
|
switch action {
|
|
case model.ActionSave:
|
|
m.loading = true
|
|
return m.saveDetailCmd()
|
|
case model.ActionDelete:
|
|
m.loading = true
|
|
return m.deleteSelectedCmd()
|
|
default:
|
|
return nil
|
|
}
|
|
}
|
|
|
|
func (m *Model) deleteSelectedCmd() tea.Cmd {
|
|
selected := m.selectedItems()
|
|
if len(selected) == 0 {
|
|
return nil
|
|
}
|
|
if len(selected) == 1 {
|
|
return m.executeActionCmd(model.ActionDelete, selected[0])
|
|
}
|
|
cmds := make([]tea.Cmd, len(selected))
|
|
for i, it := range selected {
|
|
cmds[i] = m.executeActionCmd(model.ActionDelete, it)
|
|
}
|
|
return tea.Batch(cmds...)
|
|
}
|
|
|
|
func (m *Model) togglePane(which int) {
|
|
switch which {
|
|
case 1:
|
|
m.showMenu = !m.showMenu
|
|
case 2:
|
|
m.showList = !m.showList
|
|
case 3:
|
|
m.showDetail = !m.showDetail
|
|
}
|
|
if !m.showMenu && !m.showList && !m.showDetail {
|
|
switch which {
|
|
case 1:
|
|
m.showMenu = true
|
|
case 2:
|
|
m.showList = true
|
|
case 3:
|
|
m.showDetail = true
|
|
}
|
|
}
|
|
if !paneVisible(m.focus, m.paneVis()) {
|
|
m.focus = firstVisibleFocus(m.paneVis())
|
|
}
|
|
if m.customPaneLayout {
|
|
m.paneSizes = FitPaneWidths(m.width, m.paneVis(), m.paneSizes)
|
|
}
|
|
m.layoutViewports()
|
|
m.syncAllContent()
|
|
m.syncPaneFocus()
|
|
}
|
|
|
|
func (m Model) withList(spec model.ListSpec) (Model, tea.Cmd) {
|
|
m.listSpec = spec
|
|
m.selection.Clear()
|
|
m.hasList = false
|
|
m.listHasMore = false
|
|
m.listLoadingMore = false
|
|
m.focus = model.FocusList
|
|
m.listTable.SetFocused(true)
|
|
m.detail.Clear()
|
|
m.loading = true
|
|
return m, m.loadListCmd(spec)
|
|
}
|
|
|
|
func (m *Model) layoutViewports() {
|
|
pw := m.paneLayout()
|
|
h := m.paneHeight()
|
|
if pw.Visibility.Menu {
|
|
m.menuVP.Width = m.paneInnerWidth(pw.Menu)
|
|
m.menuVP.Height = h
|
|
}
|
|
if pw.Visibility.List {
|
|
w := m.paneInnerWidth(pw.List)
|
|
m.listToolbar.SetWidth(w)
|
|
m.listTable.SetSize(w, h-listToolbarHeight)
|
|
}
|
|
if pw.Visibility.Detail {
|
|
m.detail.SetSize(m.paneInnerWidth(pw.Detail), h)
|
|
}
|
|
}
|
|
|
|
func (m *Model) syncAllContent() {
|
|
m.syncMenuContent()
|
|
m.syncListTable()
|
|
}
|
|
|
|
func (m *Model) syncListTable() {
|
|
if !m.hasList {
|
|
m.listTable.Clear()
|
|
return
|
|
}
|
|
items := m.items
|
|
if q := m.listToolbar.Query(); q != "" {
|
|
items = model.FilterItems(m.items, q)
|
|
}
|
|
m.listTable.UpdateItems(items)
|
|
}
|
|
|
|
func (m *Model) applyFilter() {
|
|
q := m.listToolbar.Query()
|
|
m.nav.SetFilter(q)
|
|
m.syncMenuContent()
|
|
m.syncListTable()
|
|
}
|
|
|
|
func (m Model) listTableItem() (model.Item, bool) {
|
|
idx := m.listTable.ItemIndex()
|
|
if idx < 0 {
|
|
return model.Item{}, false
|
|
}
|
|
items := m.items
|
|
if q := m.listToolbar.Query(); q != "" {
|
|
items = model.FilterItems(m.items, q)
|
|
}
|
|
if idx >= len(items) {
|
|
return model.Item{}, false
|
|
}
|
|
return items[idx], true
|
|
}
|
|
|
|
func (m *Model) syncMenuContent() {
|
|
var b strings.Builder
|
|
title := "Navigation"
|
|
if m.listToolbar.Query() != "" {
|
|
title += " (filtered)"
|
|
}
|
|
b.WriteString(title + "\n\n")
|
|
menuW := m.menuVP.Width
|
|
if menuW < 10 {
|
|
menuW = 20
|
|
}
|
|
selectedStyle := lipgloss.NewStyle().
|
|
Background(lipgloss.Color("62")).
|
|
Foreground(lipgloss.Color("255"))
|
|
for i := 0; i < m.nav.VisibleCount(); i++ {
|
|
n, _ := m.nav.NodeAtVisible(i)
|
|
depth := m.nav.DepthAtVisible(i)
|
|
prefix := strings.Repeat(" ", depth)
|
|
line := prefix + n.Label
|
|
if m.nav.IsExpandable(i) {
|
|
if m.nav.IsExpanded(i) {
|
|
line = prefix + "▾ " + n.Label
|
|
} else {
|
|
line = prefix + "▸ " + n.Label
|
|
}
|
|
} else if n.List != nil {
|
|
line = prefix + "• " + n.Label
|
|
}
|
|
if i == m.nav.Cursor() && m.focus == model.FocusMenu {
|
|
line = selectedStyle.Width(menuW).Render(truncateRunes(line, menuW))
|
|
}
|
|
b.WriteString(line + "\n")
|
|
}
|
|
m.menuVP.SetContent(b.String())
|
|
syncVPToLine(&m.menuVP, m.nav.Cursor()+2)
|
|
}
|
|
|
|
func truncateRunes(s string, max int) string {
|
|
if max <= 0 {
|
|
return s
|
|
}
|
|
r := []rune(s)
|
|
if len(r) <= max {
|
|
return s
|
|
}
|
|
if max <= 1 {
|
|
return string(r[:max])
|
|
}
|
|
return string(r[:max-1]) + "…"
|
|
}
|
|
|
|
func (m Model) handleMenuHorizontal(delta int) (Model, tea.Cmd) {
|
|
cur := m.nav.Cursor()
|
|
switch delta {
|
|
case 1:
|
|
if spec, ok := m.nav.CurrentListSpec(); ok {
|
|
return m.withList(*spec)
|
|
}
|
|
m.nav.Activate()
|
|
case -1:
|
|
if m.nav.IsExpandable(cur) && m.nav.IsExpanded(cur) {
|
|
m.nav.ToggleExpand(cur)
|
|
}
|
|
}
|
|
m.syncMenuContent()
|
|
return m, nil
|
|
}
|
|
|
|
func (m *Model) syncFocusedPane() {
|
|
switch m.focus {
|
|
case model.FocusMenu:
|
|
m.syncMenuContent()
|
|
case model.FocusList:
|
|
m.syncListTable()
|
|
}
|
|
}
|
|
|
|
func (m *Model) moveUp() {
|
|
switch m.focus {
|
|
case model.FocusMenu:
|
|
m.nav.MoveUp()
|
|
case model.FocusList:
|
|
if m.hasList {
|
|
m.listTable.MoveRow(-1)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (m *Model) moveDown() {
|
|
switch m.focus {
|
|
case model.FocusMenu:
|
|
m.nav.MoveDown()
|
|
case model.FocusList:
|
|
if m.hasList {
|
|
m.listTable.MoveRow(1)
|
|
}
|
|
}
|
|
}
|
|
|
|
func syncVPToLine(vp *viewport.Model, line int) {
|
|
if line < 0 {
|
|
line = 0
|
|
}
|
|
max := vp.TotalLineCount()
|
|
if max == 0 {
|
|
vp.YOffset = 0
|
|
return
|
|
}
|
|
if line >= max {
|
|
line = max - 1
|
|
}
|
|
if line < vp.YOffset {
|
|
vp.YOffset = line
|
|
} else if line >= vp.YOffset+vp.Height {
|
|
vp.YOffset = line - vp.Height + 1
|
|
}
|
|
if vp.YOffset < 0 {
|
|
vp.YOffset = 0
|
|
}
|
|
maxOff := max - vp.Height
|
|
if maxOff < 0 {
|
|
maxOff = 0
|
|
}
|
|
if vp.YOffset > maxOff {
|
|
vp.YOffset = maxOff
|
|
}
|
|
}
|
|
|
|
func (m *Model) loadListCmd(spec model.ListSpec) tea.Cmd {
|
|
return func() tea.Msg {
|
|
ctx := context.Background()
|
|
items, err := m.loader.List(ctx, spec)
|
|
return listLoadedMsg{items: items, spec: spec, err: err}
|
|
}
|
|
}
|
|
|
|
func (m *Model) executeActionCmd(action model.ActionID, item model.Item) tea.Cmd {
|
|
return func() tea.Msg {
|
|
ctx := context.Background()
|
|
msg, err := m.loader.Execute(ctx, action, item, "")
|
|
return actionDoneMsg{message: msg, err: err}
|
|
}
|
|
}
|
|
|
|
func (m *Model) loadNavProjectsCmd() tea.Cmd {
|
|
return func() tea.Msg {
|
|
ctx := context.Background()
|
|
projects, err := m.loader.LoadProjectsForNav(ctx)
|
|
return navProjectsMsg{projects: projects, err: err}
|
|
}
|
|
}
|
|
|
|
func (m *Model) onListRowChanged() tea.Cmd {
|
|
if !m.hasList {
|
|
m.detail.Clear()
|
|
return m.maybeLoadMoreList()
|
|
}
|
|
it, ok := m.listTableItem()
|
|
if !ok {
|
|
m.detail.Clear()
|
|
return m.maybeLoadMoreList()
|
|
}
|
|
var cmds []tea.Cmd
|
|
cmds = append(cmds, m.maybeLoadMoreList())
|
|
if m.detail.LoadedID() != it.ID {
|
|
m.loading = true
|
|
cmds = append(cmds, m.loadDetailCmd(it))
|
|
}
|
|
return tea.Batch(cmds...)
|
|
}
|
|
|
|
const mailListLoadThreshold = 3
|
|
|
|
func (m *Model) maybeLoadMoreList() tea.Cmd {
|
|
if !m.hasList || m.listLoadingMore || !m.listHasMore {
|
|
return nil
|
|
}
|
|
if !model.SubjectIsMail(m.listSpec.Subject) {
|
|
return nil
|
|
}
|
|
if !m.listTable.NearEnd(mailListLoadThreshold) {
|
|
return nil
|
|
}
|
|
m.listLoadingMore = true
|
|
m.listTable.SetLoadingMore(true)
|
|
return m.loadListMoreCmd()
|
|
}
|
|
|
|
func (m *Model) loadListMoreCmd() tea.Cmd {
|
|
start := len(m.items)
|
|
spec := m.listSpec
|
|
return func() tea.Msg {
|
|
ctx := context.Background()
|
|
items, err := m.loader.ListMailMore(ctx, spec, start)
|
|
return listMoreLoadedMsg{items: items, err: err}
|
|
}
|
|
}
|
|
|
|
func (m *Model) loadDetailCmd(item model.Item) tea.Cmd {
|
|
return func() tea.Msg {
|
|
ctx := context.Background()
|
|
if model.IsDocumentKind(item.Kind) {
|
|
md, err := m.loader.PreviewMarkdown(ctx, item)
|
|
return detailLoadedMsg{item: item, document: true, markdown: md, err: err}
|
|
}
|
|
fields, err := m.loader.DetailForm(ctx, item)
|
|
return detailLoadedMsg{item: item, fields: fields, err: err}
|
|
}
|
|
}
|
|
|
|
func (m *Model) closeTaskCmd() tea.Cmd {
|
|
item := m.detail.Item()
|
|
fields := m.detail.form.FormFields()
|
|
fields.TaskStatus = model.TaskLifecycleClosed
|
|
return func() tea.Msg {
|
|
ctx := context.Background()
|
|
err := m.loader.CloseTask(ctx, item.ID, fields)
|
|
return detailSavedMsg{item: item, fields: fields, err: err}
|
|
}
|
|
}
|
|
|
|
func (m *Model) saveDetailCmd() tea.Cmd {
|
|
item := m.detail.Item()
|
|
fields := m.detail.form.FormFields()
|
|
return func() tea.Msg {
|
|
ctx := context.Background()
|
|
err := m.loader.SaveItem(ctx, item, fields)
|
|
return detailSavedMsg{item: item, fields: fields, err: err}
|
|
}
|
|
}
|
|
|
|
func (m *Model) updateItemAfterSave(item model.Item, fields model.FormFields) {
|
|
for i := range m.items {
|
|
if m.items[i].ID != item.ID {
|
|
continue
|
|
}
|
|
m.items[i].Title = fields.Primary
|
|
if m.items[i].Raw == nil {
|
|
m.items[i].Raw = map[string]any{}
|
|
}
|
|
m.items[i].Raw["title"] = fields.Primary
|
|
m.items[i].Raw["description"] = fields.Secondary
|
|
if fields.HasStatus {
|
|
m.items[i].Raw["status"] = statusInt(fields.Status)
|
|
}
|
|
if fields.HasTaskStatus {
|
|
m.items[i].Raw["status"] = int(fields.TaskStatus)
|
|
}
|
|
if fields.ResponsibleID != "" {
|
|
m.items[i].Raw["responsibleIds"] = []any{fields.ResponsibleID}
|
|
}
|
|
m.syncListTable()
|
|
return
|
|
}
|
|
}
|
|
|
|
func statusInt(s model.ProjectLifecycle) int {
|
|
switch s {
|
|
case model.ProjectLifecycleClosed:
|
|
return 2
|
|
case model.ProjectLifecyclePaused:
|
|
return 1
|
|
default:
|
|
return 0
|
|
}
|
|
}
|
|
|
|
func paneStyle(focused bool) lipgloss.Style {
|
|
s := lipgloss.NewStyle().Padding(0, 1)
|
|
if focused {
|
|
return s.Border(lipgloss.RoundedBorder()).BorderForeground(lipgloss.Color("62"))
|
|
}
|
|
return s.Border(lipgloss.NormalBorder()).BorderForeground(lipgloss.Color("238"))
|
|
}
|
|
|
|
func helpText() string {
|
|
return "Alt+1/2/3: panes · / filter · Space select · 💾🗑 when selected · v: detail · Ctrl+S: save · q: quit"
|
|
}
|