mirror of
https://github.com/Maks1mS/bubbles.git
synced 2024-12-26 15:28:08 +03:00
564 lines
13 KiB
Go
564 lines
13 KiB
Go
package textarea
|
|
|
|
import (
|
|
"strconv"
|
|
"strings"
|
|
"unicode"
|
|
|
|
"github.com/charmbracelet/bubbles/cursor"
|
|
tea "github.com/charmbracelet/bubbletea"
|
|
rw "github.com/mattn/go-runewidth"
|
|
)
|
|
|
|
// Mode is the possible modes of the textarea for modal editing.
|
|
type Mode string
|
|
|
|
const (
|
|
// ModeNormal is the normal mode for navigating around text.
|
|
ModeNormal Mode = "normal"
|
|
// ModeInsert is the insert mode for inserting text.
|
|
ModeInsert Mode = "insert"
|
|
)
|
|
|
|
// SetMode sets the mode of the textarea.
|
|
func (m *Model) SetMode(mode Mode) tea.Cmd {
|
|
switch mode {
|
|
case ModeInsert:
|
|
m.mode = ModeInsert
|
|
return m.Cursor.SetCursorMode(cursor.CursorBlink)
|
|
case ModeNormal:
|
|
m.mode = ModeNormal
|
|
m.col = clamp(m.col-1, 0, len(m.value[m.row]))
|
|
return m.Cursor.SetCursorMode(cursor.CursorStatic)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Action is the type of action that will be performed when the user completes
|
|
// a key combination.
|
|
type Action int
|
|
|
|
const (
|
|
// ActionMove moves the cursor.
|
|
ActionMove Action = iota
|
|
// ActionSeek seeks the cursor to the desired character.
|
|
// Used in conjunction with f/F/t/T.
|
|
ActionSeek
|
|
// ActionReplace replaces text.
|
|
ActionReplace
|
|
// ActionDelete deletes text.
|
|
ActionDelete
|
|
// ActionYank yanks text.
|
|
ActionYank
|
|
// ActionChange deletes text and enters insert mode.
|
|
ActionChange
|
|
)
|
|
|
|
// Position is a (row, column) pair representing a position of the cursor or
|
|
// any character.
|
|
type Position struct {
|
|
Row int
|
|
Col int
|
|
}
|
|
|
|
// Range is a range of characters in the text area.
|
|
type Range struct {
|
|
Start Position
|
|
End Position
|
|
}
|
|
|
|
// NormalCommand is a helper for keeping track of the various relevant information
|
|
// when performing vim motions in the textarea.
|
|
type NormalCommand struct {
|
|
// Buffer is the buffer of keys that have been press for the current
|
|
// command.
|
|
Buffer string
|
|
// Count is the number of times to replay the action. This is usually
|
|
// optional and defaults to 1.
|
|
Count int
|
|
// Action is the action to be performed.
|
|
Action Action
|
|
// Range is the range of characters to perform the action on.
|
|
Range Range
|
|
}
|
|
|
|
func (m *Model) insertUpdate(msg tea.Msg) tea.Cmd {
|
|
switch msg := msg.(type) {
|
|
case tea.KeyMsg:
|
|
switch msg.String() {
|
|
case "esc":
|
|
return m.SetMode(ModeNormal)
|
|
case "ctrl+k":
|
|
m.col = clamp(m.col, 0, len(m.value[m.row]))
|
|
if m.col >= len(m.value[m.row]) {
|
|
m.mergeLineBelow(m.row)
|
|
break
|
|
}
|
|
m.deleteAfterCursor()
|
|
case "ctrl+u":
|
|
m.col = clamp(m.col, 0, len(m.value[m.row]))
|
|
if m.col <= 0 {
|
|
m.mergeLineAbove(m.row)
|
|
break
|
|
}
|
|
m.deleteBeforeCursor()
|
|
case "backspace", "ctrl+h":
|
|
m.col = clamp(m.col, 0, len(m.value[m.row]))
|
|
if m.col <= 0 {
|
|
m.mergeLineAbove(m.row)
|
|
break
|
|
}
|
|
if len(m.value[m.row]) > 0 {
|
|
m.value[m.row] = append(m.value[m.row][:max(0, m.col-1)], m.value[m.row][m.col:]...)
|
|
if m.col > 0 {
|
|
m.SetCursor(m.col - 1)
|
|
}
|
|
}
|
|
case "delete", "ctrl+d":
|
|
if len(m.value[m.row]) > 0 && m.col < len(m.value[m.row]) {
|
|
m.value[m.row] = append(m.value[m.row][:m.col], m.value[m.row][m.col+1:]...)
|
|
}
|
|
if m.col >= len(m.value[m.row]) {
|
|
m.mergeLineBelow(m.row)
|
|
break
|
|
}
|
|
case "alt+backspace", "ctrl+w":
|
|
if m.col <= 0 {
|
|
m.mergeLineAbove(m.row)
|
|
break
|
|
}
|
|
m.deleteWordLeft()
|
|
case "alt+delete", "alt+d":
|
|
m.col = clamp(m.col, 0, len(m.value[m.row]))
|
|
if m.col >= len(m.value[m.row]) {
|
|
m.mergeLineBelow(m.row)
|
|
break
|
|
}
|
|
m.deleteWordRight()
|
|
case "enter", "ctrl+m":
|
|
if len(m.value) >= maxHeight {
|
|
return nil
|
|
}
|
|
m.col = clamp(m.col, 0, len(m.value[m.row]))
|
|
m.splitLine(m.row, m.col)
|
|
case "end", "ctrl+e":
|
|
m.CursorEnd()
|
|
case "home", "ctrl+a":
|
|
m.CursorStart()
|
|
case "right", "ctrl+f":
|
|
if m.col < len(m.value[m.row]) {
|
|
m.SetCursor(m.col + 1)
|
|
} else {
|
|
if m.row < len(m.value)-1 {
|
|
m.row++
|
|
m.CursorStart()
|
|
}
|
|
}
|
|
case "down", "ctrl+n":
|
|
m.CursorDown()
|
|
case "alt+right", "alt+f":
|
|
m.wordRight()
|
|
case "ctrl+v":
|
|
return Paste
|
|
case "left", "ctrl+b":
|
|
if m.col == 0 && m.row != 0 {
|
|
m.row--
|
|
m.CursorEnd()
|
|
break
|
|
}
|
|
if m.col > 0 {
|
|
m.SetCursor(m.col - 1)
|
|
}
|
|
case "up", "ctrl+p":
|
|
m.CursorUp()
|
|
case "alt+left", "alt+b":
|
|
m.wordLeft()
|
|
default:
|
|
if m.CharLimit > 0 && rw.StringWidth(m.Value()) >= m.CharLimit {
|
|
break
|
|
}
|
|
|
|
m.col = min(m.col, len(m.value[m.row]))
|
|
m.value[m.row] = append(m.value[m.row][:m.col], append(msg.Runes, m.value[m.row][m.col:]...)...)
|
|
m.SetCursor(m.col + len(msg.Runes))
|
|
}
|
|
|
|
case pasteMsg:
|
|
m.handlePaste(string(msg))
|
|
|
|
case pasteErrMsg:
|
|
m.Err = msg
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (m *Model) normalUpdate(msg tea.Msg) tea.Cmd {
|
|
var cmd tea.Cmd
|
|
var execute bool
|
|
|
|
switch msg := msg.(type) {
|
|
case tea.KeyMsg:
|
|
if m.command.Action == ActionReplace {
|
|
for i := m.col; i < m.col+max(m.command.Count, 1); i++ {
|
|
if i >= len(m.value[m.row]) || len(msg.Runes) <= 0 {
|
|
break
|
|
}
|
|
m.value[m.row][i] = msg.Runes[0]
|
|
}
|
|
m.command = &NormalCommand{}
|
|
return nil
|
|
}
|
|
switch msg.String() {
|
|
case "esc":
|
|
m.command = &NormalCommand{}
|
|
return m.SetMode(ModeNormal)
|
|
case "0", "1", "2", "3", "4", "5", "6", "7", "8", "9":
|
|
if m.command.Count == 0 && msg.String() == "0" {
|
|
m.command.Range = Range{
|
|
Start: Position{Row: m.row, Col: m.col},
|
|
End: Position{Row: m.row, Col: 0},
|
|
}
|
|
execute = true
|
|
break
|
|
}
|
|
|
|
v := m.command.Buffer + msg.String()
|
|
count, err := strconv.Atoi(v)
|
|
if err != nil {
|
|
count, _ = strconv.Atoi(msg.String())
|
|
m.command.Buffer = msg.String()
|
|
m.command.Count = count
|
|
} else {
|
|
m.command.Buffer = v
|
|
m.command.Count = count
|
|
}
|
|
case "G":
|
|
var row int
|
|
if m.command.Count > 0 {
|
|
row = m.command.Count - 1
|
|
} else {
|
|
row = len(m.value) - 1
|
|
}
|
|
m.row = clamp(row, 0, len(m.value)-1)
|
|
return nil
|
|
case "g":
|
|
if m.command.Buffer == "g" {
|
|
m.command = &NormalCommand{}
|
|
m.row = clamp(m.command.Count-1, 0, len(m.value)-1)
|
|
} else {
|
|
m.command = &NormalCommand{Buffer: "g"}
|
|
}
|
|
return nil
|
|
case "x":
|
|
m.command.Action = ActionDelete
|
|
m.command.Range = Range{
|
|
Start: Position{Row: m.row, Col: m.col},
|
|
End: Position{Row: m.row, Col: m.col + max(m.command.Count, 1)},
|
|
}
|
|
case "X":
|
|
m.command.Action = ActionDelete
|
|
m.command.Range = Range{
|
|
Start: Position{Row: m.row, Col: m.col},
|
|
End: Position{Row: m.row, Col: m.col - max(m.command.Count, 1)},
|
|
}
|
|
case "c":
|
|
if m.command.Action == ActionChange {
|
|
m.CursorStart()
|
|
m.deleteAfterCursor()
|
|
m.command = &NormalCommand{}
|
|
return m.SetMode(ModeInsert)
|
|
}
|
|
m.command.Action = ActionChange
|
|
case "d":
|
|
if m.command.Action == ActionDelete {
|
|
for i := 0; i < max(m.command.Count, 1); i++ {
|
|
m.value[m.row] = []rune{}
|
|
if m.row < len(m.value)-1 {
|
|
m.mergeLineBelow(m.row)
|
|
} else {
|
|
m.mergeLineAbove(m.row)
|
|
}
|
|
}
|
|
m.command = &NormalCommand{}
|
|
return nil
|
|
}
|
|
m.command.Action = ActionDelete
|
|
case "y":
|
|
m.command.Action = ActionYank
|
|
case "r":
|
|
m.command.Action = ActionReplace
|
|
case "i":
|
|
m.command.Range = Range{
|
|
Start: Position{Row: m.row, Col: m.col},
|
|
End: Position{Row: m.row, Col: m.col},
|
|
}
|
|
cmd = m.SetMode(ModeInsert)
|
|
case "I":
|
|
m.command.Range = Range{
|
|
Start: Position{Row: m.row, Col: m.col},
|
|
End: Position{Row: m.row, Col: 0},
|
|
}
|
|
cmd = m.SetMode(ModeInsert)
|
|
case "a":
|
|
m.command.Range = Range{
|
|
Start: Position{Row: m.row, Col: m.col},
|
|
End: Position{Row: m.row, Col: m.col + 1},
|
|
}
|
|
cmd = m.SetMode(ModeInsert)
|
|
case "A":
|
|
m.command.Range = Range{
|
|
Start: Position{Row: m.row, Col: m.col},
|
|
End: Position{Row: m.row, Col: len(m.value[m.row]) + 1},
|
|
}
|
|
cmd = m.SetMode(ModeInsert)
|
|
case "^":
|
|
m.command.Range = Range{
|
|
Start: Position{m.row, m.col},
|
|
End: Position{m.row, 0},
|
|
}
|
|
case "$":
|
|
m.command.Range = Range{
|
|
Start: Position{m.row, m.col},
|
|
End: Position{m.row, len(m.value[m.row])},
|
|
}
|
|
case "e", "E":
|
|
end := m.findWordEndRight(max(m.command.Count, 1), msg.String() == "E")
|
|
if m.command.Action == ActionDelete {
|
|
end.Col = min(end.Col+1, len(m.value[end.Row]))
|
|
}
|
|
m.command.Range = Range{
|
|
Start: Position{m.row, m.col},
|
|
End: end,
|
|
}
|
|
case "w", "W":
|
|
m.command.Range = Range{
|
|
Start: Position{m.row, m.col},
|
|
End: m.findWordStartRight(max(m.command.Count, 1), msg.String() == "W"),
|
|
}
|
|
case "b", "B":
|
|
m.command.Range = Range{
|
|
Start: Position{m.row, m.col},
|
|
End: m.findWordLeft(max(m.command.Count, 1), msg.String() == "B"),
|
|
}
|
|
case "h", "l":
|
|
direction := 1
|
|
if msg.String() == "h" {
|
|
direction = -1
|
|
}
|
|
m.lastCharOffset = 0
|
|
m.command.Range = Range{
|
|
Start: Position{m.row, m.col},
|
|
End: Position{m.row, clamp(m.col+(direction*max(m.command.Count, 1)), 0, len(m.value[m.row]))},
|
|
}
|
|
case "j", "k":
|
|
direction := 1
|
|
if msg.String() == "k" {
|
|
direction = -1
|
|
}
|
|
row := clamp(m.row+(direction*max(m.command.Count, 1)), 0, len(m.value)-1)
|
|
li := m.LineInfo()
|
|
charOffset := max(m.lastCharOffset, li.CharOffset)
|
|
m.lastCharOffset = charOffset
|
|
|
|
rowContent := m.value[row]
|
|
charWidth := rw.StringWidth(string(rowContent))
|
|
|
|
col := 0
|
|
offset := 0
|
|
|
|
for offset < charOffset {
|
|
if col > len(m.value[row]) || offset >= charWidth-1 {
|
|
break
|
|
}
|
|
offset += rw.RuneWidth(m.value[row][col])
|
|
col++
|
|
}
|
|
|
|
m.command.Range = Range{
|
|
Start: Position{m.row, m.col},
|
|
End: Position{row, col},
|
|
}
|
|
case "C":
|
|
m.deleteAfterCursor()
|
|
m.command = &NormalCommand{}
|
|
return m.SetMode(ModeInsert)
|
|
case "D":
|
|
m.deleteAfterCursor()
|
|
m.command = &NormalCommand{}
|
|
return nil
|
|
case "J":
|
|
m.CursorEnd()
|
|
m.mergeLineBelow(m.row)
|
|
return nil
|
|
case "p":
|
|
cmd = Paste
|
|
}
|
|
|
|
if !strings.ContainsAny(msg.String(), "jk") {
|
|
m.lastCharOffset = 0
|
|
}
|
|
|
|
if strings.ContainsAny(msg.String(), "iIaAeEwWbBhjklp$^xX") || execute {
|
|
switch m.command.Action {
|
|
case ActionDelete:
|
|
m.deleteRange(m.command.Range)
|
|
case ActionChange:
|
|
m.deleteRange(m.command.Range)
|
|
cmd = m.SetMode(ModeInsert)
|
|
case ActionMove:
|
|
m.row = clamp(m.command.Range.End.Row, 0, len(m.value)-1)
|
|
m.col = clamp(m.command.Range.End.Col, 0, len(m.value[m.row]))
|
|
}
|
|
m.command = &NormalCommand{}
|
|
}
|
|
|
|
case pasteMsg:
|
|
m.handlePaste(string(msg))
|
|
}
|
|
|
|
return cmd
|
|
}
|
|
|
|
// findWordLeft locates the start of the word on the left of the current word.
|
|
// It takes whether or not to break words on spaces or any non-alpha-numeric
|
|
// character as an argument.
|
|
func (m *Model) findWordLeft(count int, ignorePunctuation bool) Position {
|
|
wordBreak := isSoftWordBreak
|
|
if ignorePunctuation {
|
|
wordBreak = isWordBreak
|
|
}
|
|
|
|
row, col := m.row, m.col
|
|
|
|
for count > 0 {
|
|
if col <= 0 && row > 0 {
|
|
row--
|
|
col = len(m.value[row]) - 1
|
|
}
|
|
|
|
// Skip all spaces (and punctuation) to the left of the cursor.
|
|
for col > 0 && wordBreak(m.value[row][col-1]) {
|
|
col--
|
|
}
|
|
|
|
// Then skip all non-spaces to the left of the cursor.
|
|
for col > 0 && !wordBreak(m.value[row][col-1]) {
|
|
col--
|
|
}
|
|
|
|
count--
|
|
|
|
if row <= 0 && col <= 0 {
|
|
break
|
|
}
|
|
}
|
|
|
|
return Position{Row: row, Col: col}
|
|
}
|
|
|
|
// findWordStartRight locates the start of the next word. It takes whether or not to
|
|
// break words on spaces or any non-alpha-numeric character as an argument.
|
|
func (m *Model) findWordStartRight(count int, ignorePunctuation bool) Position {
|
|
wordBreak := isSoftWordBreak
|
|
if ignorePunctuation {
|
|
wordBreak = isWordBreak
|
|
}
|
|
|
|
row, col := m.row, m.col
|
|
|
|
for count > 0 {
|
|
if col >= len(m.value[row])-1 && row < len(m.value)-1 {
|
|
row++
|
|
col = 0
|
|
}
|
|
|
|
// Skip until the start of a word is found.
|
|
for col < len(m.value[row]) && !wordBreak(m.value[row][col]) {
|
|
col++
|
|
}
|
|
// Skip all spaces to the right of the cursor.
|
|
for col < len(m.value[row])-1 && wordBreak(m.value[row][col]) {
|
|
col++
|
|
}
|
|
count--
|
|
|
|
if row >= len(m.value)-1 && col >= len(m.value[row])-1 {
|
|
break
|
|
}
|
|
}
|
|
|
|
return Position{Row: row, Col: col}
|
|
}
|
|
|
|
// findWordEndRight locates the start of the next word. It takes whether or not to
|
|
// break words on spaces or any non-alpha-numeric character as an argument.
|
|
func (m *Model) findWordEndRight(count int, ignorePunctuation bool) Position {
|
|
wordBreak := isSoftWordBreak
|
|
if ignorePunctuation {
|
|
wordBreak = isWordBreak
|
|
}
|
|
|
|
row, col := m.row, m.col
|
|
|
|
for count > 0 {
|
|
if col > len(m.value[row]) && row < len(m.value)-1 {
|
|
row++
|
|
col = 0
|
|
}
|
|
|
|
// Skip all spaces to the right of the cursor.
|
|
for col < len(m.value[row])-1 && wordBreak(m.value[row][col+1]) {
|
|
col++
|
|
}
|
|
|
|
// Then skip all non-spaces to the right of the cursor.
|
|
for col < len(m.value[row])-1 && !wordBreak(m.value[row][col+1]) {
|
|
col++
|
|
}
|
|
|
|
count--
|
|
|
|
if row <= 0 && col <= 0 {
|
|
break
|
|
}
|
|
}
|
|
|
|
return Position{Row: row, Col: col}
|
|
}
|
|
|
|
func isWordBreak(char rune) bool {
|
|
return unicode.IsSpace(char)
|
|
}
|
|
|
|
func isSoftWordBreak(char rune) bool {
|
|
return unicode.IsSpace(char) || unicode.IsPunct(char)
|
|
}
|
|
|
|
func (m *Model) deleteRange(r Range) {
|
|
if r.Start.Row == r.End.Row && r.Start.Col == r.End.Col {
|
|
return
|
|
}
|
|
|
|
minCol, maxCol := min(r.Start.Col, r.End.Col), max(r.Start.Col, r.End.Col)
|
|
|
|
minCol = clamp(minCol, 0, len(m.value[r.Start.Row]))
|
|
maxCol = clamp(maxCol, 0, len(m.value[r.Start.Row]))
|
|
|
|
if r.Start.Row == r.End.Row {
|
|
m.value[r.Start.Row] = append(m.value[r.Start.Row][:minCol], m.value[r.Start.Row][maxCol:]...)
|
|
m.SetCursor(minCol)
|
|
return
|
|
}
|
|
|
|
minRow, maxRow := min(r.Start.Row, r.End.Row), max(r.Start.Row, r.End.Row)
|
|
|
|
for i := max(minRow, 0); i <= min(maxRow, len(m.value)-1); i++ {
|
|
m.value[i] = []rune{}
|
|
}
|
|
|
|
m.value = append(m.value[:minRow], m.value[maxRow:]...)
|
|
|
|
m.row = clamp(0, minRow, len(m.value))
|
|
}
|