Additional VHS files, implemented table ui, adjusted TUI file structure

assets/vhs/configure/configure-pat.tape

@@ -1,5 +1,5 @@
 # Where should we write the GIF?
-Output assets/img/configure/configure-pat.gif
+Output assets/img/vhs/configure/configure-pat.gif
 
 # Set up a 1200x600 terminal with 46px font.
 Set FontSize 16

assets/vhs/linuxMake.tape

@@ -1,5 +1,5 @@
 # Where should we write the GIF?
-Output assets/img/MacOSAndLinux.gif
+Output assets/img/vhs/MacOSAndLinux.gif
 
 # Set up a 1200x600 terminal with 46px font.
 Set FontSize 16

assets/vhs/sail.tape

@@ -1,5 +1,5 @@
 # Where should we write the GIF?
-Output assets/img/Sail.gif
+Output assets/img/vhs/Sail.gif
 
 # Set up a 1200x600 terminal with 46px font.
 Set FontSize 16

assets/vhs/transform/transform-create.tape

@@ -1,5 +1,5 @@
 # Where should we write the GIF?
-Output assets/img/transform/transform-create.gif
+Output assets/img/vhs/transform/transform-create.gif
 
 # Set up a 1200x600 terminal with 46px font.
 Set FontSize 16

assets/vhs/transform/transform-download.tape

@@ -1,5 +1,5 @@
 # Where should we write the GIF?
-Output assets/img/transform/transform-download.gif
+Output assets/img/vhs/transform/transform-download.gif
 
 # Set up a 1200x600 terminal with 46px font.
 Set FontSize 16

assets/vhs/transform/transform-list.tape

@@ -1,5 +1,5 @@
 # Where should we write the GIF?
-Output assets/img/transform/transform-list.gif
+Output assets/img/vhs/transform/transform-list.gif
 
 # Set up a 1200x600 terminal with 46px font.
 Set FontSize 16

assets/vhs/va/va-collect.tape

@@ -1,5 +1,5 @@
 # Where should we write the GIF?
-Output assets/img/va/va-collect.gif
+Output assets/img/vhs/va/va-collect.gif
 
 # Set up a 1200x600 terminal with 46px font.
 Set FontSize 16

assets/vhs/va/va-parse.tape

@@ -1,5 +1,5 @@
 # Where should we write the GIF?
-Output assets/img/va/va-parse.gif
+Output assets/img/vhs/va/va-parse.gif
 
 # Set up a 1200x600 terminal with 46px font.
 Set FontSize 16

assets/vhs/va/va-troubleshoot.tape

@@ -1,5 +1,5 @@
 # Where should we write the GIF?
-Output assets/img/va/va-troubleshoot.gif
+Output assets/img/vhs/va/va-troubleshoot.gif
 
 # Set up a 1200x600 terminal with 46px font.
 Set FontSize 16

assets/vhs/va/va-update.tape

@@ -1,5 +1,5 @@
 # Where should we write the GIF?
-Output assets/img/va/va-update.gif
+Output assets/img/vhs/va/va-update.gif
 
 # Set up a 1200x600 terminal with 46px font.
 Set FontSize 16

assets/vhs/windowsBuild.tape

@@ -1,5 +1,5 @@
 # Where should we write the GIF?
-Output img/Windows.gif
+Output assets/img/vhs/Windows.gif
 
 # Set up a 1200x600 terminal with 46px font.
 Set FontSize 16

cmd/root/configure.go

@@ -14,7 +14,7 @@ import (
 	tea "github.com/charmbracelet/bubbletea"
 	"github.com/sailpoint-oss/sailpoint-cli/internal/auth"
 	"github.com/sailpoint-oss/sailpoint-cli/internal/client"
-	"github.com/sailpoint-oss/sailpoint-cli/internal/tui"
+	tuilist "github.com/sailpoint-oss/sailpoint-cli/internal/tui/list"
 	"github.com/sailpoint-oss/sailpoint-cli/internal/types"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
@@ -32,21 +32,21 @@ const (
 
 func PromptAuth() (string, error) {
 	items := []list.Item{
-		tui.Item("PAT"),
-		tui.Item("OAuth"),
+		tuilist.Item("PAT"),
+		tuilist.Item("OAuth"),
 	}
 
 	const defaultWidth = 20
 
-	l := list.New(items, tui.ItemDelegate{}, defaultWidth, tui.ListHeight)
+	l := list.New(items, tuilist.ItemDelegate{}, defaultWidth, tuilist.ListHeight)
 	l.Title = "What authentication method do you want to use?"
 	l.SetShowStatusBar(false)
 	l.SetFilteringEnabled(false)
-	l.Styles.Title = tui.TitleStyle
-	l.Styles.PaginationStyle = tui.PaginationStyle
-	l.Styles.HelpStyle = tui.HelpStyle
+	l.Styles.Title = tuilist.TitleStyle
+	l.Styles.PaginationStyle = tuilist.PaginationStyle
+	l.Styles.HelpStyle = tuilist.HelpStyle
 
-	m := tui.Model{List: l}
+	m := tuilist.Model{List: l}
 	_, err := tea.NewProgram(m).Run()
 	if err != nil {
 		return "", err

cmd/transform/delete.go

@@ -2,12 +2,18 @@
 package transform
 
 import (
+	"errors"
 	"fmt"
 	"io"
 	"net/http"
+	"os"
 
+	"github.com/charmbracelet/bubbles/table"
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
 	"github.com/fatih/color"
 	"github.com/sailpoint-oss/sailpoint-cli/internal/client"
+	tuitable "github.com/sailpoint-oss/sailpoint-cli/internal/tui/table"
 	"github.com/sailpoint-oss/sailpoint-cli/internal/util"
 	"github.com/spf13/cobra"
 )
@@ -19,14 +25,71 @@ func newDeleteCmd(client client.Client) *cobra.Command {
 		Long:    "Delete a transform",
 		Example: "sail transform d 03d5187b-ab96-402c-b5a1-40b74285d77a",
 		Aliases: []string{"d"},
-		Args:    cobra.ExactArgs(1),
+		Args:    cobra.MaximumNArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
-			id := args[0]
-			if id == "" {
-				return fmt.Errorf("transform ID cannot be empty")
-			}
 
 			endpoint := cmd.Flags().Lookup("transforms-endpoint").Value.String()
+
+			id := ""
+
+			if len(args) > 0 {
+				id = args[0]
+			}
+
+			if id == "" {
+
+				transforms, err := getTransforms(client, endpoint, cmd)
+				if err != nil {
+					return err
+				}
+
+				columns := []table.Column{
+					{Title: "Name", Width: 25},
+					{Title: "ID", Width: 40},
+					{Title: "Type", Width: 25},
+				}
+
+				var rows []table.Row
+
+				for i := 0; i < len(transforms); i++ {
+					rows = append(rows, transforms[i].TransformToRows())
+				}
+
+				t := table.New(
+					table.WithColumns(columns),
+					table.WithRows(rows),
+					table.WithFocused(true),
+					table.WithHeight(7),
+				)
+
+				s := table.DefaultStyles()
+				s.Header = s.Header.
+					BorderStyle(lipgloss.NormalBorder()).
+					BorderForeground(lipgloss.Color("240")).
+					BorderBottom(true).
+					Bold(false)
+				s.Selected = s.Selected.
+					Foreground(lipgloss.Color("229")).
+					Background(lipgloss.Color("57")).
+					Bold(false)
+				t.SetStyles(s)
+
+				m := tuitable.Model{Table: t}
+				if _, err := tea.NewProgram(m).Run(); err != nil {
+					fmt.Println("Error running program:", err)
+					os.Exit(1)
+				}
+
+				tempRow := m.Retrieve()
+
+				if len(tempRow) > 0 {
+					id = m.Retrieve()[1]
+				} else {
+					return errors.New("no transform selected")
+				}
+
+			}
+
 			resp, err := client.Delete(cmd.Context(), util.ResourceUrl(endpoint, id), nil)
 			if err != nil {
 				return err

cmd/transform/list.go

@@ -13,10 +13,10 @@ import (
 	"github.com/spf13/cobra"
 )
 
-func listTransforms(client client.Client, endpoint string, cmd *cobra.Command) error {
+func getTransforms(client client.Client, endpoint string, cmd *cobra.Command) ([]transmodel.Transform, error) {
 	resp, err := client.Get(cmd.Context(), endpoint)
 	if err != nil {
-		return err
+		return nil, err
 	}
 	defer func(Body io.ReadCloser) {
 		_ = Body.Close()
@@ -24,16 +24,26 @@ func listTransforms(client client.Client, endpoint string, cmd *cobra.Command) e
 
 	if resp.StatusCode != http.StatusOK {
 		body, _ := io.ReadAll(resp.Body)
-		return fmt.Errorf("non-200 response: %s\nbody: %s", resp.Status, body)
+		return nil, fmt.Errorf("non-200 response: %s\nbody: %s", resp.Status, body)
 	}
 
 	raw, err := io.ReadAll(resp.Body)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	var transforms []transmodel.Transform
 	err = json.Unmarshal(raw, &transforms)
+	if err != nil {
+		return nil, err
+	}
+
+	return transforms, nil
+}
+
+func listTransforms(client client.Client, endpoint string, cmd *cobra.Command) error {
+
+	transforms, err := getTransforms(client, endpoint, cmd)
 	if err != nil {
 		return err
 	}

cmd/transform/model/models.go

@@ -11,6 +11,10 @@ func (t Transform) TransformToColumns() []string {
 	return []string{t.ID, t.Name}
 }
 
+func (t Transform) TransformToRows() []string {
+	return []string{t.Name, t.ID, t.Type}
+}
+
 var TransformColumns = []string{"ID", "Name"}
 
 type AttributesOfAccount struct {

internal/tui/list/main.go

@@ -1,4 +1,4 @@
-package tui
+package tuilist
 
 import (
 	"fmt"

internal/tui/table/main.go

@@ -0,0 +1,49 @@
+package tuitable
+
+import (
+	"github.com/charmbracelet/bubbles/table"
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
+)
+
+var baseStyle = lipgloss.NewStyle().
+	BorderStyle(lipgloss.NormalBorder()).
+	BorderForeground(lipgloss.Color("240"))
+
+var choice table.Row
+
+type Model struct {
+	Table table.Model
+}
+
+func (m Model) Init() tea.Cmd { return nil }
+
+func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	var cmd tea.Cmd
+	switch msg := msg.(type) {
+	case tea.KeyMsg:
+		switch msg.String() {
+		case "esc":
+			if m.Table.Focused() {
+				m.Table.Blur()
+			} else {
+				m.Table.Focus()
+			}
+		case "q", "ctrl+c":
+			return m, tea.Quit
+		case "enter":
+			choice = m.Table.SelectedRow()
+			return m, tea.Quit
+		}
+	}
+	m.Table, cmd = m.Table.Update(msg)
+	return m, cmd
+}
+
+func (m Model) View() string {
+	return baseStyle.Render(m.Table.View()) + "\n"
+}
+
+func (m Model) Retrieve() table.Row {
+	return choice
+}

vendor/github.com/charmbracelet/bubbles/table/table.go

@@ -0,0 +1,393 @@
+package table
+
+import (
+	"strings"
+
+	"github.com/charmbracelet/bubbles/key"
+	"github.com/charmbracelet/bubbles/viewport"
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/mattn/go-runewidth"
+)
+
+// Model defines a state for the table widget.
+type Model struct {
+	KeyMap KeyMap
+
+	cols   []Column
+	rows   []Row
+	cursor int
+	focus  bool
+	styles Styles
+
+	viewport viewport.Model
+}
+
+// Row represents one line in the table.
+type Row []string
+
+// Column defines the table structure.
+type Column struct {
+	Title string
+	Width int
+}
+
+// KeyMap defines keybindings. It satisfies to the help.KeyMap interface, which
+// is used to render the menu menu.
+type KeyMap struct {
+	LineUp       key.Binding
+	LineDown     key.Binding
+	PageUp       key.Binding
+	PageDown     key.Binding
+	HalfPageUp   key.Binding
+	HalfPageDown key.Binding
+	GotoTop      key.Binding
+	GotoBottom   key.Binding
+}
+
+// DefaultKeyMap returns a default set of keybindings.
+func DefaultKeyMap() KeyMap {
+	const spacebar = " "
+	return KeyMap{
+		LineUp: key.NewBinding(
+			key.WithKeys("up", "k"),
+			key.WithHelp("↑/k", "up"),
+		),
+		LineDown: key.NewBinding(
+			key.WithKeys("down", "j"),
+			key.WithHelp("↓/j", "down"),
+		),
+		PageUp: key.NewBinding(
+			key.WithKeys("b", "pgup"),
+			key.WithHelp("b/pgup", "page up"),
+		),
+		PageDown: key.NewBinding(
+			key.WithKeys("f", "pgdown", spacebar),
+			key.WithHelp("f/pgdn", "page down"),
+		),
+		HalfPageUp: key.NewBinding(
+			key.WithKeys("u", "ctrl+u"),
+			key.WithHelp("u", "½ page up"),
+		),
+		HalfPageDown: key.NewBinding(
+			key.WithKeys("d", "ctrl+d"),
+			key.WithHelp("d", "½ page down"),
+		),
+		GotoTop: key.NewBinding(
+			key.WithKeys("home", "g"),
+			key.WithHelp("g/home", "go to start"),
+		),
+		GotoBottom: key.NewBinding(
+			key.WithKeys("end", "G"),
+			key.WithHelp("G/end", "go to end"),
+		),
+	}
+}
+
+// Styles contains style definitions for this list component. By default, these
+// values are generated by DefaultStyles.
+type Styles struct {
+	Header   lipgloss.Style
+	Cell     lipgloss.Style
+	Selected lipgloss.Style
+}
+
+// DefaultStyles returns a set of default style definitions for this table.
+func DefaultStyles() Styles {
+	return Styles{
+		Selected: lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("212")),
+		Header:   lipgloss.NewStyle().Bold(true).Padding(0, 1),
+		Cell:     lipgloss.NewStyle().Padding(0, 1),
+	}
+}
+
+// SetStyles sets the table styles.
+func (m *Model) SetStyles(s Styles) {
+	m.styles = s
+	m.UpdateViewport()
+}
+
+// Option is used to set options in New. For example:
+//
+//    table := New(WithColumns([]Column{{Title: "ID", Width: 10}}))
+//
+type Option func(*Model)
+
+// New creates a new model for the table widget.
+func New(opts ...Option) Model {
+	m := Model{
+		cursor:   0,
+		viewport: viewport.New(0, 20),
+
+		KeyMap: DefaultKeyMap(),
+		styles: DefaultStyles(),
+	}
+
+	for _, opt := range opts {
+		opt(&m)
+	}
+
+	m.UpdateViewport()
+
+	return m
+}
+
+// WithColumns sets the table columns (headers).
+func WithColumns(cols []Column) Option {
+	return func(m *Model) {
+		m.cols = cols
+	}
+}
+
+// WithRows sets the table rows (data).
+func WithRows(rows []Row) Option {
+	return func(m *Model) {
+		m.rows = rows
+	}
+}
+
+// WithHeight sets the height of the table.
+func WithHeight(h int) Option {
+	return func(m *Model) {
+		m.viewport.Height = h
+	}
+}
+
+// WithWidth sets the width of the table.
+func WithWidth(w int) Option {
+	return func(m *Model) {
+		m.viewport.Width = w
+	}
+}
+
+// WithFocused sets the focus state of the table.
+func WithFocused(f bool) Option {
+	return func(m *Model) {
+		m.focus = f
+	}
+}
+
+// WithStyles sets the table styles.
+func WithStyles(s Styles) Option {
+	return func(m *Model) {
+		m.styles = s
+	}
+}
+
+// WithKeyMap sets the key map.
+func WithKeyMap(km KeyMap) Option {
+	return func(m *Model) {
+		m.KeyMap = km
+	}
+}
+
+// Update is the Bubble Tea update loop.
+func (m Model) Update(msg tea.Msg) (Model, tea.Cmd) {
+	if !m.focus {
+		return m, nil
+	}
+
+	var cmds []tea.Cmd
+
+	switch msg := msg.(type) {
+	case tea.KeyMsg:
+		switch {
+		case key.Matches(msg, m.KeyMap.LineUp):
+			m.MoveUp(1)
+		case key.Matches(msg, m.KeyMap.LineDown):
+			m.MoveDown(1)
+		case key.Matches(msg, m.KeyMap.PageUp):
+			m.MoveUp(m.viewport.Height)
+		case key.Matches(msg, m.KeyMap.PageDown):
+			m.MoveDown(m.viewport.Height)
+		case key.Matches(msg, m.KeyMap.HalfPageUp):
+			m.MoveUp(m.viewport.Height / 2)
+		case key.Matches(msg, m.KeyMap.HalfPageDown):
+			m.MoveDown(m.viewport.Height / 2)
+		case key.Matches(msg, m.KeyMap.LineDown):
+			m.MoveDown(1)
+		case key.Matches(msg, m.KeyMap.GotoTop):
+			m.GotoTop()
+		case key.Matches(msg, m.KeyMap.GotoBottom):
+			m.GotoBottom()
+		}
+	}
+
+	return m, tea.Batch(cmds...)
+}
+
+// Focused returns the focus state of the table.
+func (m Model) Focused() bool {
+	return m.focus
+}
+
+// Focus focusses the table, allowing the user to move around the rows and
+// interact.
+func (m *Model) Focus() {
+	m.focus = true
+	m.UpdateViewport()
+}
+
+// Blur blurs the table, preventing selection or movement.
+func (m *Model) Blur() {
+	m.focus = false
+	m.UpdateViewport()
+}
+
+// View renders the component.
+func (m Model) View() string {
+	return m.headersView() + "\n" + m.viewport.View()
+}
+
+// UpdateViewport updates the list content based on the previously defined
+// columns and rows.
+func (m *Model) UpdateViewport() {
+	renderedRows := make([]string, 0, len(m.rows))
+	for i := range m.rows {
+		renderedRows = append(renderedRows, m.renderRow(i))
+	}
+
+	m.viewport.SetContent(
+		lipgloss.JoinVertical(lipgloss.Left, renderedRows...),
+	)
+}
+
+// SelectedRow returns the selected row.
+// You can cast it to your own implementation.
+func (m Model) SelectedRow() Row {
+	return m.rows[m.cursor]
+}
+
+// SetRows set a new rows state.
+func (m *Model) SetRows(r []Row) {
+	m.rows = r
+	m.UpdateViewport()
+}
+
+// SetWidth sets the width of the viewport of the table.
+func (m *Model) SetWidth(w int) {
+	m.viewport.Width = w
+	m.UpdateViewport()
+}
+
+// SetHeight sets the height of the viewport of the table.
+func (m *Model) SetHeight(h int) {
+	m.viewport.Height = h
+	m.UpdateViewport()
+}
+
+// Height returns the viewport height of the table.
+func (m Model) Height() int {
+	return m.viewport.Height
+}
+
+// Width returns the viewport width of the table.
+func (m Model) Width() int {
+	return m.viewport.Width
+}
+
+// Cursor returns the index of the selected row.
+func (m Model) Cursor() int {
+	return m.cursor
+}
+
+// SetCursor sets the cursor position in the table.
+func (m *Model) SetCursor(n int) {
+	m.cursor = clamp(n, 0, len(m.rows)-1)
+	m.UpdateViewport()
+}
+
+// MoveUp moves the selection up by any number of row.
+// It can not go above the first row.
+func (m *Model) MoveUp(n int) {
+	m.cursor = clamp(m.cursor-n, 0, len(m.rows)-1)
+	m.UpdateViewport()
+
+	if m.cursor < m.viewport.YOffset {
+		m.viewport.SetYOffset(m.cursor)
+	}
+}
+
+// MoveDown moves the selection down by any number of row.
+// It can not go below the last row.
+func (m *Model) MoveDown(n int) {
+	m.cursor = clamp(m.cursor+n, 0, len(m.rows)-1)
+	m.UpdateViewport()
+
+	if m.cursor > (m.viewport.YOffset + (m.viewport.Height - 1)) {
+		m.viewport.SetYOffset(m.cursor - (m.viewport.Height - 1))
+	}
+}
+
+// GotoTop moves the selection to the first row.
+func (m *Model) GotoTop() {
+	m.MoveUp(m.cursor)
+}
+
+// GotoBottom moves the selection to the last row.
+func (m *Model) GotoBottom() {
+	m.MoveDown(len(m.rows))
+}
+
+// FromValues create the table rows from a simple string. It uses `\n` by
+// default for getting all the rows and the given separator for the fields on
+// each row.
+func (m *Model) FromValues(value, separator string) {
+	rows := []Row{}
+	for _, line := range strings.Split(value, "\n") {
+		r := Row{}
+		for _, field := range strings.Split(line, separator) {
+			r = append(r, field)
+		}
+		rows = append(rows, r)
+	}
+
+	m.SetRows(rows)
+}
+
+func (m Model) headersView() string {
+	var s = make([]string, 0, len(m.cols))
+	for _, col := range m.cols {
+		style := lipgloss.NewStyle().Width(col.Width).MaxWidth(col.Width).Inline(true)
+		renderedCell := style.Render(runewidth.Truncate(col.Title, col.Width, "…"))
+		s = append(s, m.styles.Header.Render(renderedCell))
+	}
+	return lipgloss.JoinHorizontal(lipgloss.Left, s...)
+}
+
+func (m *Model) renderRow(rowID int) string {
+	var s = make([]string, 0, len(m.cols))
+	for i, value := range m.rows[rowID] {
+		style := lipgloss.NewStyle().Width(m.cols[i].Width).MaxWidth(m.cols[i].Width).Inline(true)
+		renderedCell := m.styles.Cell.Render(style.Render(runewidth.Truncate(value, m.cols[i].Width, "…")))
+		s = append(s, renderedCell)
+	}
+
+	row := lipgloss.JoinHorizontal(lipgloss.Left, s...)
+
+	if rowID == m.cursor {
+		return m.styles.Selected.Render(row)
+	}
+
+	return row
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+
+	return b
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+
+	return b
+}
+
+func clamp(v, low, high int) int {
+	return min(max(v, low), high)
+}

vendor/github.com/charmbracelet/bubbles/viewport/keymap.go

@@ -0,0 +1,48 @@
+package viewport
+
+import "github.com/charmbracelet/bubbles/key"
+
+const spacebar = " "
+
+// KeyMap defines the keybindings for the viewport. Note that you don't
+// necessary need to use keybindings at all; the viewport can be controlled
+// programmatically with methods like Model.LineDown(1). See the GoDocs for
+// details.
+type KeyMap struct {
+	PageDown     key.Binding
+	PageUp       key.Binding
+	HalfPageUp   key.Binding
+	HalfPageDown key.Binding
+	Down         key.Binding
+	Up           key.Binding
+}
+
+// DefaultKeyMap returns a set of pager-like default keybindings.
+func DefaultKeyMap() KeyMap {
+	return KeyMap{
+		PageDown: key.NewBinding(
+			key.WithKeys("pgdown", spacebar, "f"),
+			key.WithHelp("f/pgdn", "page down"),
+		),
+		PageUp: key.NewBinding(
+			key.WithKeys("pgup", "b"),
+			key.WithHelp("b/pgup", "page up"),
+		),
+		HalfPageUp: key.NewBinding(
+			key.WithKeys("u", "ctrl+u"),
+			key.WithHelp("u", "½ page up"),
+		),
+		HalfPageDown: key.NewBinding(
+			key.WithKeys("d", "ctrl+d"),
+			key.WithHelp("d", "½ page down"),
+		),
+		Up: key.NewBinding(
+			key.WithKeys("up", "k"),
+			key.WithHelp("↑/k", "up"),
+		),
+		Down: key.NewBinding(
+			key.WithKeys("down", "j"),
+			key.WithHelp("↓/j", "down"),
+		),
+	}
+}

vendor/github.com/charmbracelet/bubbles/viewport/viewport.go

@@ -0,0 +1,391 @@
+package viewport
+
+import (
+	"math"
+	"strings"
+
+	"github.com/charmbracelet/bubbles/key"
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
+)
+
+// New returns a new model with the given width and height as well as default
+// key mappings.
+func New(width, height int) (m Model) {
+	m.Width = width
+	m.Height = height
+	m.setInitialValues()
+	return m
+}
+
+// Model is the Bubble Tea model for this viewport element.
+type Model struct {
+	Width  int
+	Height int
+	KeyMap KeyMap
+
+	// Whether or not to respond to the mouse. The mouse must be enabled in
+	// Bubble Tea for this to work. For details, see the Bubble Tea docs.
+	MouseWheelEnabled bool
+
+	// The number of lines the mouse wheel will scroll. By default, this is 3.
+	MouseWheelDelta int
+
+	// YOffset is the vertical scroll position.
+	YOffset int
+
+	// YPosition is the position of the viewport in relation to the terminal
+	// window. It's used in high performance rendering only.
+	YPosition int
+
+	// Style applies a lipgloss style to the viewport. Realistically, it's most
+	// useful for setting borders, margins and padding.
+	Style lipgloss.Style
+
+	// HighPerformanceRendering bypasses the normal Bubble Tea renderer to
+	// provide higher performance rendering. Most of the time the normal Bubble
+	// Tea rendering methods will suffice, but if you're passing content with
+	// a lot of ANSI escape codes you may see improved rendering in certain
+	// terminals with this enabled.
+	//
+	// This should only be used in program occupying the entire terminal,
+	// which is usually via the alternate screen buffer.
+	HighPerformanceRendering bool
+
+	initialized bool
+	lines       []string
+}
+
+func (m *Model) setInitialValues() {
+	m.KeyMap = DefaultKeyMap()
+	m.MouseWheelEnabled = true
+	m.MouseWheelDelta = 3
+	m.initialized = true
+}
+
+// Init exists to satisfy the tea.Model interface for composability purposes.
+func (m Model) Init() tea.Cmd {
+	return nil
+}
+
+// AtTop returns whether or not the viewport is in the very top position.
+func (m Model) AtTop() bool {
+	return m.YOffset <= 0
+}
+
+// AtBottom returns whether or not the viewport is at or past the very bottom
+// position.
+func (m Model) AtBottom() bool {
+	return m.YOffset >= m.maxYOffset()
+}
+
+// PastBottom returns whether or not the viewport is scrolled beyond the last
+// line. This can happen when adjusting the viewport height.
+func (m Model) PastBottom() bool {
+	return m.YOffset > m.maxYOffset()
+}
+
+// ScrollPercent returns the amount scrolled as a float between 0 and 1.
+func (m Model) ScrollPercent() float64 {
+	if m.Height >= len(m.lines) {
+		return 1.0
+	}
+	y := float64(m.YOffset)
+	h := float64(m.Height)
+	t := float64(len(m.lines) - 1)
+	v := y / (t - h)
+	return math.Max(0.0, math.Min(1.0, v))
+}
+
+// SetContent set the pager's text content. For high performance rendering the
+// Sync command should also be called.
+func (m *Model) SetContent(s string) {
+	s = strings.ReplaceAll(s, "\r\n", "\n") // normalize line endings
+	m.lines = strings.Split(s, "\n")
+
+	if m.YOffset > len(m.lines)-1 {
+		m.GotoBottom()
+	}
+}
+
+// maxYOffset returns the maximum possible value of the y-offset based on the
+// viewport's content and set height.
+func (m Model) maxYOffset() int {
+	return max(0, len(m.lines)-m.Height)
+}
+
+// visibleLines returns the lines that should currently be visible in the
+// viewport.
+func (m Model) visibleLines() (lines []string) {
+	if len(m.lines) > 0 {
+		top := max(0, m.YOffset)
+		bottom := clamp(m.YOffset+m.Height, top, len(m.lines))
+		lines = m.lines[top:bottom]
+	}
+	return lines
+}
+
+// scrollArea returns the scrollable boundaries for high performance rendering.
+func (m Model) scrollArea() (top, bottom int) {
+	top = max(0, m.YPosition)
+	bottom = max(top, top+m.Height)
+	if top > 0 && bottom > top {
+		bottom--
+	}
+	return top, bottom
+}
+
+// SetYOffset sets the Y offset.
+func (m *Model) SetYOffset(n int) {
+	m.YOffset = clamp(n, 0, m.maxYOffset())
+}
+
+// ViewDown moves the view down by the number of lines in the viewport.
+// Basically, "page down".
+func (m *Model) ViewDown() []string {
+	if m.AtBottom() {
+		return nil
+	}
+
+	m.SetYOffset(m.YOffset + m.Height)
+	return m.visibleLines()
+}
+
+// ViewUp moves the view up by one height of the viewport. Basically, "page up".
+func (m *Model) ViewUp() []string {
+	if m.AtTop() {
+		return nil
+	}
+
+	m.SetYOffset(m.YOffset - m.Height)
+	return m.visibleLines()
+}
+
+// HalfViewDown moves the view down by half the height of the viewport.
+func (m *Model) HalfViewDown() (lines []string) {
+	if m.AtBottom() {
+		return nil
+	}
+
+	m.SetYOffset(m.YOffset + m.Height/2)
+	return m.visibleLines()
+}
+
+// HalfViewUp moves the view up by half the height of the viewport.
+func (m *Model) HalfViewUp() (lines []string) {
+	if m.AtTop() {
+		return nil
+	}
+
+	m.SetYOffset(m.YOffset - m.Height/2)
+	return m.visibleLines()
+}
+
+// LineDown moves the view down by the given number of lines.
+func (m *Model) LineDown(n int) (lines []string) {
+	if m.AtBottom() || n == 0 {
+		return nil
+	}
+
+	// Make sure the number of lines by which we're going to scroll isn't
+	// greater than the number of lines we actually have left before we reach
+	// the bottom.
+	m.SetYOffset(m.YOffset + n)
+	return m.visibleLines()
+}
+
+// LineUp moves the view down by the given number of lines. Returns the new
+// lines to show.
+func (m *Model) LineUp(n int) (lines []string) {
+	if m.AtTop() || n == 0 {
+		return nil
+	}
+
+	// Make sure the number of lines by which we're going to scroll isn't
+	// greater than the number of lines we are from the top.
+	m.SetYOffset(m.YOffset - n)
+	return m.visibleLines()
+}
+
+// GotoTop sets the viewport to the top position.
+func (m *Model) GotoTop() (lines []string) {
+	if m.AtTop() {
+		return nil
+	}
+
+	m.SetYOffset(0)
+	return m.visibleLines()
+}
+
+// GotoBottom sets the viewport to the bottom position.
+func (m *Model) GotoBottom() (lines []string) {
+	m.SetYOffset(m.maxYOffset())
+	return m.visibleLines()
+}
+
+// Sync tells the renderer where the viewport will be located and requests
+// a render of the current state of the viewport. It should be called for the
+// first render and after a window resize.
+//
+// For high performance rendering only.
+func Sync(m Model) tea.Cmd {
+	if len(m.lines) == 0 {
+		return nil
+	}
+	top, bottom := m.scrollArea()
+	return tea.SyncScrollArea(m.visibleLines(), top, bottom)
+}
+
+// ViewDown is a high performance command that moves the viewport up by a given
+// number of lines. Use Model.ViewDown to get the lines that should be rendered.
+// For example:
+//
+//     lines := model.ViewDown(1)
+//     cmd := ViewDown(m, lines)
+//
+func ViewDown(m Model, lines []string) tea.Cmd {
+	if len(lines) == 0 {
+		return nil
+	}
+	top, bottom := m.scrollArea()
+	return tea.ScrollDown(lines, top, bottom)
+}
+
+// ViewUp is a high performance command the moves the viewport down by a given
+// number of lines height. Use Model.ViewUp to get the lines that should be
+// rendered.
+func ViewUp(m Model, lines []string) tea.Cmd {
+	if len(lines) == 0 {
+		return nil
+	}
+	top, bottom := m.scrollArea()
+	return tea.ScrollUp(lines, top, bottom)
+}
+
+// Update handles standard message-based viewport updates.
+func (m Model) Update(msg tea.Msg) (Model, tea.Cmd) {
+	var cmd tea.Cmd
+	m, cmd = m.updateAsModel(msg)
+	return m, cmd
+}
+
+// Author's note: this method has been broken out to make it easier to
+// potentially transition Update to satisfy tea.Model.
+func (m Model) updateAsModel(msg tea.Msg) (Model, tea.Cmd) {
+	if !m.initialized {
+		m.setInitialValues()
+	}
+
+	var cmd tea.Cmd
+
+	switch msg := msg.(type) {
+	case tea.KeyMsg:
+		switch {
+		case key.Matches(msg, m.KeyMap.PageDown):
+			lines := m.ViewDown()
+			if m.HighPerformanceRendering {
+				cmd = ViewDown(m, lines)
+			}
+
+		case key.Matches(msg, m.KeyMap.PageUp):
+			lines := m.ViewUp()
+			if m.HighPerformanceRendering {
+				cmd = ViewUp(m, lines)
+			}
+
+		case key.Matches(msg, m.KeyMap.HalfPageDown):
+			lines := m.HalfViewDown()
+			if m.HighPerformanceRendering {
+				cmd = ViewDown(m, lines)
+			}
+
+		case key.Matches(msg, m.KeyMap.HalfPageUp):
+			lines := m.HalfViewUp()
+			if m.HighPerformanceRendering {
+				cmd = ViewUp(m, lines)
+			}
+
+		case key.Matches(msg, m.KeyMap.Down):
+			lines := m.LineDown(1)
+			if m.HighPerformanceRendering {
+				cmd = ViewDown(m, lines)
+			}
+
+		case key.Matches(msg, m.KeyMap.Up):
+			lines := m.LineUp(1)
+			if m.HighPerformanceRendering {
+				cmd = ViewUp(m, lines)
+			}
+		}
+
+	case tea.MouseMsg:
+		if !m.MouseWheelEnabled {
+			break
+		}
+		switch msg.Type {
+		case tea.MouseWheelUp:
+			lines := m.LineUp(m.MouseWheelDelta)
+			if m.HighPerformanceRendering {
+				cmd = ViewUp(m, lines)
+			}
+
+		case tea.MouseWheelDown:
+			lines := m.LineDown(m.MouseWheelDelta)
+			if m.HighPerformanceRendering {
+				cmd = ViewDown(m, lines)
+			}
+		}
+	}
+
+	return m, cmd
+}
+
+// View renders the viewport into a string.
+func (m Model) View() string {
+	if m.HighPerformanceRendering {
+		// Just send newlines since we're going to be rendering the actual
+		// content separately. We still need to send something that equals the
+		// height of this view so that the Bubble Tea standard renderer can
+		// position anything below this view properly.
+		return strings.Repeat("\n", max(0, m.Height-1))
+	}
+
+	w, h := m.Width, m.Height
+	if sw := m.Style.GetWidth(); sw != 0 {
+		w = min(w, sw)
+	}
+	if sh := m.Style.GetHeight(); sh != 0 {
+		h = min(h, sh)
+	}
+	contentWidth := w - m.Style.GetHorizontalFrameSize()
+	contentHeight := h - m.Style.GetVerticalFrameSize()
+	contents := lipgloss.NewStyle().
+		Height(contentHeight).    // pad to height.
+		MaxHeight(contentHeight). // truncate height if taller.
+		MaxWidth(contentWidth).   // truncate width.
+		Render(strings.Join(m.visibleLines(), "\n"))
+	return m.Style.Copy().
+		UnsetWidth().UnsetHeight(). // Style size already applied in contents.
+		Render(contents)
+}
+
+func clamp(v, low, high int) int {
+	if high < low {
+		low, high = high, low
+	}
+	return min(high, max(low, v))
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}

vendor/modules.txt

@@ -19,7 +19,9 @@ github.com/charmbracelet/bubbles/key
 github.com/charmbracelet/bubbles/list
 github.com/charmbracelet/bubbles/paginator
 github.com/charmbracelet/bubbles/spinner
+github.com/charmbracelet/bubbles/table
 github.com/charmbracelet/bubbles/textinput
+github.com/charmbracelet/bubbles/viewport
 # github.com/charmbracelet/bubbletea v0.23.1
 ## explicit; go 1.16
 github.com/charmbracelet/bubbletea