@@ -13,6 +13,9 @@ import (
1313 "github.com/charmbracelet/crush/internal/tui/styles"
1414 "github.com/charmbracelet/crush/internal/tui/util"
1515 "github.com/charmbracelet/lipgloss/v2"
16+ uv "github.com/charmbracelet/ultraviolet"
17+ "github.com/charmbracelet/x/ansi"
18+ "github.com/rivo/uniseg"
1619)
1720
1821type Item interface {
@@ -46,6 +49,14 @@ type List[T Item] interface {
4649 DeleteItem(string) tea.Cmd
4750 PrependItem(T) tea.Cmd
4851 AppendItem(T) tea.Cmd
52+ StartSelection(col, line int)
53+ EndSelection(col, line int)
54+ SelectionStop()
55+ SelectionClear()
56+ SelectWord(col, line int)
57+ SelectParagraph(col, line int)
58+ GetSelectedText(paddingLeft int) string
59+ HasSelection() bool
4960}
5061
5162type direction int
@@ -94,7 +105,13 @@ type list[T Item] struct {
94105 renderMu sync.Mutex
95106 rendered string
96107
97− movingByItem bool
108+ movingByItem bool
109+ selectionStartCol int
110+ selectionStartLine int
111+ selectionEndCol int
112+ selectionEndLine int
113+
114+ selectionActive bool
98115}
99116
100117type ListOption func(*confOptions)
@@ -172,9 +189,13 @@ func New[T Item](items []T, opts ...ListOption) List[T] {
172189 keyMap: DefaultKeyMap(),
173190 focused: true,
174191 },
175− items: csync.NewSliceFrom(items),
176− indexMap: csync.NewMap[string, int](),
177− renderedItems: csync.NewMap[string, renderedItem](),
192+ items: csync.NewSliceFrom(items),
193+ indexMap: csync.NewMap[string, int](),
194+ renderedItems: csync.NewMap[string, renderedItem](),
195+ selectionStartCol: -1,
196+ selectionStartLine: -1,
197+ selectionEndLine: -1,
198+ selectionEndCol: -1,
178199 }
179200 for _, opt := range opts {
180201 opt(list.confOptions)
@@ -266,6 +287,157 @@ func (l *list[T]) handleMouseWheel(msg tea.MouseWheelMsg) (tea.Model, tea.Cmd) {
266287 return l, cmd
267288}
268289
290+// selectionView renders the highlighted selection in the view and returns it
291+// as a string. If textOnly is true, it won't render any styles.
292+func (l *list[T]) selectionView(view string, textOnly bool) string {
293+ t := styles.CurrentTheme()
294+ area := uv.Rect(0, 0, l.width, l.height)
295+ scr := uv.NewScreenBuffer(area.Dx(), area.Dy())
296+ uv.NewStyledString(view).Draw(scr, area)
297+
298+ selArea := uv.Rectangle{
299+ Min: uv.Pos(l.selectionStartCol, l.selectionStartLine),
300+ Max: uv.Pos(l.selectionEndCol, l.selectionEndLine),
301+ }
302+ selArea = selArea.Canon()
303+
304+ specialChars := make(map[string]bool, len(styles.SelectionIgnoreIcons))
305+ for _, icon := range styles.SelectionIgnoreIcons {
306+ specialChars[icon] = true
307+ }
308+
309+ isNonWhitespace := func(r rune) bool {
310+ return r != ' ' && r != '\t' && r != 0 && r != '\n' && r != '\r'
311+ }
312+
313+ type selectionBounds struct {
314+ startX, endX int
315+ inSelection bool
316+ }
317+ lineSelections := make([]selectionBounds, scr.Height())
318+
319+ for y := range scr.Height() {
320+ bounds := selectionBounds{startX: -1, endX: -1, inSelection: false}
321+
322+ if y >= selArea.Min.Y && y <= selArea.Max.Y {
323+ bounds.inSelection = true
324+ if selArea.Min.Y == selArea.Max.Y {
325+ // Single line selection
326+ bounds.startX = selArea.Min.X
327+ bounds.endX = selArea.Max.X
328+ } else if y == selArea.Min.Y {
329+ // First line of multi-line selection
330+ bounds.startX = selArea.Min.X
331+ bounds.endX = scr.Width()
332+ } else if y == selArea.Max.Y {
333+ // Last line of multi-line selection
334+ bounds.startX = 0
335+ bounds.endX = selArea.Max.X
336+ } else {
337+ // Middle lines
338+ bounds.startX = 0
339+ bounds.endX = scr.Width()
340+ }
341+ }
342+ lineSelections[y] = bounds
343+ }
344+
345+ type lineBounds struct {
346+ start, end int
347+ }
348+ lineTextBounds := make([]lineBounds, scr.Height())
349+
350+ // First pass: find text bounds for lines that have selections
351+ for y := range scr.Height() {
352+ bounds := lineBounds{start: -1, end: -1}
353+
354+ // Only process lines that might have selections
355+ if lineSelections[y].inSelection {
356+ for x := range scr.Width() {
357+ cell := scr.CellAt(x, y)
358+ if cell == nil {
359+ continue
360+ }
361+
362+ cellStr := cell.String()
363+ if len(cellStr) == 0 {
364+ continue
365+ }
366+
367+ char := rune(cellStr[0])
368+ isSpecial := specialChars[cellStr]
369+
370+ if (isNonWhitespace(char) && !isSpecial) || cell.Style.Bg != nil {
371+ if bounds.start == -1 {
372+ bounds.start = x
373+ }
374+ bounds.end = x + 1 // Position after last character
375+ }
376+ }
377+ }
378+ lineTextBounds[y] = bounds
379+ }
380+
381+ var selectedText strings.Builder
382+
383+ // Second pass: apply selection highlighting
384+ for y := range scr.Height() {
385+ selBounds := lineSelections[y]
386+ if !selBounds.inSelection {
387+ continue
388+ }
389+
390+ textBounds := lineTextBounds[y]
391+ if textBounds.start < 0 {
392+ if textOnly {
393+ // We don't want to get rid of all empty lines in text-only mode
394+ selectedText.WriteByte('\n')
395+ }
396+
397+ continue // No text on this line
398+ }
399+
400+ // Only scan within the intersection of text bounds and selection bounds
401+ scanStart := max(textBounds.start, selBounds.startX)
402+ scanEnd := min(textBounds.end, selBounds.endX)
403+
404+ for x := scanStart; x < scanEnd; x++ {
405+ cell := scr.CellAt(x, y)
406+ if cell == nil {
407+ continue
408+ }
409+
410+ cellStr := cell.String()
411+ if len(cellStr) > 0 && !specialChars[cellStr] {
412+ if textOnly {
413+ // Collect selected text without styles
414+ selectedText.WriteString(cell.String())
415+ continue
416+ }
417+
418+ // Text selection styling, which is a Lip Gloss style. We must
419+ // extract the values to use in a UV style, below.
420+ ts := t.TextSelection
421+
422+ cell = cell.Clone()
423+ cell.Style = cell.Style.Background(ts.GetBackground()).Foreground(ts.GetForeground())
424+ scr.SetCell(x, y, cell)
425+ }
426+ }
427+
428+ if textOnly {
429+ // Make sure we add a newline after each line of selected text
430+ selectedText.WriteByte('\n')
431+ }
432+ }
433+
434+ if textOnly {
435+ return strings.TrimSpace(selectedText.String())
436+ }
437+
438+ return scr.Render()
439+}
440+
269441// View implements List.
270442func (l *list[T]) View() string {
271443 if l.height <= 0 || l.width <= 0 {
@@ -282,10 +454,16 @@ func (l *list[T]) View() string {
282454 if l.resize {
283455 return strings.Join(lines, "\n")
284456 }
285− return t.S().Base.
457+ view = t.S().Base.
286458 Height(l.height).
287459 Width(l.width).
288460 Render(strings.Join(lines, "\n"))
461+
462+ if !l.hasSelection() {
463+ return view
464+ }
465+
466+ return l.selectionView(view, false)
289467}
290468
291469func (l *list[T]) viewPosition() (int, int) {
@@ -817,21 +995,67 @@ func (l *list[T]) decrementOffset(n int) {
817995
818996// MoveDown implements List.
819997func (l *list[T]) MoveDown(n int) tea.Cmd {
998+ oldOffset := l.offset
820999 if l.direction == DirectionForward {
8211000 l.incrementOffset(n)
8221001 } else {
8231002 l.decrementOffset(n)
8241003 }
1004+
1005+ if oldOffset == l.offset {
1006+ // no change in offset, so no need to change selection
1007+ return nil
1008+ }
1009+ // if we are not actively selecting move the whole selection down
1010+ if l.hasSelection() && !l.selectionActive {
1011+ if l.selectionStartLine < l.selectionEndLine {
1012+ l.selectionStartLine -= n
1013+ l.selectionEndLine -= n
1014+ } else {
1015+ l.selectionStartLine -= n
1016+ l.selectionEndLine -= n
1017+ }
1018+ }
1019+ if l.selectionActive {
1020+ if l.selectionStartLine < l.selectionEndLine {
1021+ l.selectionStartLine -= n
1022+ } else {
1023+ l.selectionEndLine -= n
1024+ }
1025+ }
8251026 return l.changeSelectionWhenScrolling()
8261027}
8271028
8281029// MoveUp implements List.
8291030func (l *list[T]) MoveUp(n int) tea.Cmd {
1031+ oldOffset := l.offset
8301032 if l.direction == DirectionForward {
8311033 l.decrementOffset(n)
8321034 } else {
8331035 l.incrementOffset(n)
8341036 }
1037+
1038+ if oldOffset == l.offset {
1039+ // no change in offset, so no need to change selection
1040+ return nil
1041+ }
1042+
1043+ if l.hasSelection() && !l.selectionActive {
1044+ if l.selectionStartLine > l.selectionEndLine {
1045+ l.selectionStartLine += n
1046+ l.selectionEndLine += n
1047+ } else {
1048+ l.selectionStartLine += n
1049+ l.selectionEndLine += n
1050+ }
1051+ }
1052+ if l.selectionActive {
1053+ if l.selectionStartLine > l.selectionEndLine {
1054+ l.selectionStartLine += n
1055+ } else {
1056+ l.selectionEndLine += n
1057+ }
1058+ }
8351059 return l.changeSelectionWhenScrolling()
8361060}
8371061
@@ -1029,3 +1253,172 @@ func (l *list[T]) UpdateItem(id string, item T) tea.Cmd {
10291253 }
10301254 return tea.Sequence(cmds...)
10311255}
1256+
1257+func (l *list[T]) hasSelection() bool {
1258+ return l.selectionEndCol != l.selectionStartCol || l.selectionEndLine != l.selectionStartLine
1259+}
1260+
1261+// StartSelection implements List.
1262+func (l *list[T]) StartSelection(col, line int) {
1263+ l.selectionStartCol = col
1264+ l.selectionStartLine = line
1265+ l.selectionEndCol = col
1266+ l.selectionEndLine = line
1267+ l.selectionActive = true
1268+}
1269+
1270+// EndSelection implements List.
1271+func (l *list[T]) EndSelection(col, line int) {
1272+ if !l.selectionActive {
1273+ return
1274+ }
1275+ l.selectionEndCol = col
1276+ l.selectionEndLine = line
1277+}
1278+
1279+func (l *list[T]) SelectionStop() {
1280+ l.selectionActive = false
1281+}
1282+
1283+func (l *list[T]) SelectionClear() {
1284+ l.selectionStartCol = -1
1285+ l.selectionStartLine = -1
1286+ l.selectionEndCol = -1
1287+ l.selectionEndLine = -1
1288+ l.selectionActive = false
1289+}
1290+
1291+func (l *list[T]) findWordBoundaries(col, line int) (startCol, endCol int) {
1292+ lines := strings.Split(l.rendered, "\n")
1293+ for i, l := range lines {
1294+ lines[i] = ansi.Strip(l)
1295+ }
1296+
1297+ if l.direction == DirectionBackward && len(lines) > l.height {
1298+ line = ((len(lines) - 1) - l.height) + line + 1
1299+ }
1300+
1301+ if l.offset > 0 {
1302+ if l.direction == DirectionBackward {
1303+ line -= l.offset
1304+ } else {
1305+ line += l.offset
1306+ }
1307+ }
1308+
1309+ currentLine := lines[line]
1310+ gr := uniseg.NewGraphemes(currentLine)
1311+ startCol = -1
1312+ upTo := col
1313+ for gr.Next() {
1314+ if gr.IsWordBoundary() && upTo > 0 {
1315+ startCol = col - upTo + 1
1316+ } else if gr.IsWordBoundary() && upTo < 0 {
1317+ endCol = col - upTo + 1
1318+ break
1319+ }
1320+ if upTo == 0 && gr.Str() == " " {
1321+ return 0, 0
1322+ }
1323+ upTo -= 1
1324+ }
1325+ if startCol == -1 {
1326+ return 0, 0
1327+ }
1328+ return
1329+}
1330+
1331+func (l *list[T]) findParagraphBoundaries(line int) (startLine, endLine int, found bool) {
1332+ lines := strings.Split(l.rendered, "\n")
1333+ for i, l := range lines {
1334+ lines[i] = ansi.Strip(l)
1335+ for _, icon := range styles.SelectionIgnoreIcons {
1336+ lines[i] = strings.ReplaceAll(lines[i], icon, " ")
1337+ }
1338+ }
1339+ if l.direction == DirectionBackward && len(lines) > l.height {
1340+ line = (len(lines) - 1) - l.height + line + 1
1341+ }
1342+
1343+ if strings.TrimSpace(lines[line]) == "" {
1344+ return 0, 0, false
1345+ }
1346+
1347+ if l.offset > 0 {
1348+ if l.direction == DirectionBackward {
1349+ line -= l.offset
1350+ } else {
1351+ line += l.offset
1352+ }
1353+ }
1354+
1355+ // Ensure line is within bounds
1356+ if line < 0 || line >= len(lines) {
1357+ return 0, 0, false
1358+ }
1359+
1360+ // Find start of paragraph (search backwards for empty line or start of text)
1361+ startLine = line
1362+ for startLine > 0 && strings.TrimSpace(lines[startLine-1]) != "" {
1363+ startLine--
1364+ }
1365+
1366+ // Find end of paragraph (search forwards for empty line or end of text)
1367+ endLine = line
1368+ for endLine < len(lines)-1 && strings.TrimSpace(lines[endLine+1]) != "" {
1369+ endLine++
1370+ }
1371+
1372+ // revert the line numbers if we are in backward direction
1373+ if l.direction == DirectionBackward && len(lines) > l.height {
1374+ startLine = startLine - (len(lines) - 1) + l.height - 1
1375+ endLine = endLine - (len(lines) - 1) + l.height - 1
1376+ }
1377+ if l.offset > 0 {
1378+ if l.direction == DirectionBackward {
1379+ startLine += l.offset
1380+ endLine += l.offset
1381+ } else {
1382+ startLine -= l.offset
1383+ endLine -= l.offset
1384+ }
1385+ }
1386+ return startLine, endLine, true
1387+}
1388+
1389+// SelectWord selects the word at the given position.
1390+func (l *list[T]) SelectWord(col, line int) {
1391+ startCol, endCol := l.findWordBoundaries(col, line)
1392+ l.selectionStartCol = startCol
1393+ l.selectionStartLine = line
1394+ l.selectionEndCol = endCol
1395+ l.selectionEndLine = line
1396+ l.selectionActive = false // Not actively selecting, just selected
1397+}
1398+
1399+// SelectParagraph selects the paragraph at the given position.
1400+func (l *list[T]) SelectParagraph(col, line int) {
1401+ startLine, endLine, found := l.findParagraphBoundaries(line)
1402+ if !found {
1403+ return
1404+ }
1405+ l.selectionStartCol = 0
1406+ l.selectionStartLine = startLine
1407+ l.selectionEndCol = l.width - 1
1408+ l.selectionEndLine = endLine
1409+ l.selectionActive = false // Not actively selecting, just selected
1410+}
1411+
1412+// HasSelection returns whether there is an active selection.
1413+func (l *list[T]) HasSelection() bool {
1414+ return l.hasSelection()
1415+}
1416+
1417+// GetSelectedText returns the currently selected text.
1418+func (l *list[T]) GetSelectedText(paddingLeft int) string {
1419+ if !l.hasSelection() {
1420+ return ""
1421+ }
1422+
1423+ return l.selectionView(l.View(), true)
1424+}