From 87a4e45a58fa5bdad06c03c831aff90b6fe8ab25 Mon Sep 17 00:00:00 2001
From: Carlos Alexandro Becker <caarlos0@users.noreply.github.com>
Date: Fri, 17 Jan 2025 17:32:41 -0300
Subject: [PATCH 01/22] docs: additional bubbles (#583)

* docs: additional bubbles

Signed-off-by: Carlos Alexandro Becker <caarlos0@users.noreply.github.com>

* Update README.md

Co-authored-by: bashbunni <15822994+bashbunni@users.noreply.github.com>

* Update README.md

Co-authored-by: Christian Rocha <christian@rocha.is>

* Update README.md

Co-authored-by: Christian Rocha <christian@rocha.is>

---------

Signed-off-by: Carlos Alexandro Becker <caarlos0@users.noreply.github.com>
Co-authored-by: bashbunni <15822994+bashbunni@users.noreply.github.com>
Co-authored-by: Christian Rocha <christian@rocha.is>
---
 README.md | 96 ++++++++++++++++---------------------------------------
 1 file changed, 28 insertions(+), 68 deletions(-)

diff --git a/README.md b/README.md
index 66abbd78..3a07a37b 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,4 @@
-Bubbles
-=======
+# Bubbles
 
 <p>
   <img src="https://stuff.charm.sh/bubbles/bubbles-github.png" width="233" alt="The Bubbles Logo">
@@ -18,7 +17,6 @@ applications. These components are used in production in [Glow][glow],
 [charm]: https://github.com/charmbracelet/charm
 [otherstuff]: https://github.com/charmbracelet/bubbletea/#bubble-tea-in-the-wild
 
-
 ## Spinner
 
 <img src="https://stuff.charm.sh/bubbles-examples/spinner.gif" width="400" alt="Spinner Example">
@@ -26,9 +24,8 @@ applications. These components are used in production in [Glow][glow],
 A spinner, useful for indicating that some kind an operation is happening.
 There are a couple default ones, but you can also pass your own ”frames.”
 
-* [Example code, basic spinner](https://github.com/charmbracelet/bubbletea/tree/master/examples/spinner/main.go)
-* [Example code, various spinners](https://github.com/charmbracelet/bubbletea/tree/master/examples/spinners/main.go)
-
+- [Example code, basic spinner](https://github.com/charmbracelet/bubbletea/tree/master/examples/spinner/main.go)
+- [Example code, various spinners](https://github.com/charmbracelet/bubbletea/tree/master/examples/spinners/main.go)
 
 ## Text Input
 
@@ -38,8 +35,8 @@ A text input field, akin to an `<input type="text">` in HTML. Supports unicode,
 pasting, in-place scrolling when the value exceeds the width of the element and
 the common, and many customization options.
 
-* [Example code, one field](https://github.com/charmbracelet/bubbletea/tree/master/examples/textinput/main.go)
-* [Example code, many fields](https://github.com/charmbracelet/bubbletea/tree/master/examples/textinputs/main.go)
+- [Example code, one field](https://github.com/charmbracelet/bubbletea/tree/master/examples/textinput/main.go)
+- [Example code, many fields](https://github.com/charmbracelet/bubbletea/tree/master/examples/textinputs/main.go)
 
 ## Text Area
 
@@ -47,11 +44,11 @@ the common, and many customization options.
 
 A text area field, akin to an `<textarea />` in HTML. Allows for input that
 spans multiple lines. Supports unicode, pasting, vertical scrolling when the
-value exceeds the width and height of the element,  and many customization
+value exceeds the width and height of the element, and many customization
 options.
 
-* [Example code, chat input](https://github.com/charmbracelet/bubbletea/tree/master/examples/chat/main.go)
-* [Example code, story time input](https://github.com/charmbracelet/bubbletea/tree/master/examples/textarea/main.go)
+- [Example code, chat input](https://github.com/charmbracelet/bubbletea/tree/master/examples/chat/main.go)
+- [Example code, story time input](https://github.com/charmbracelet/bubbletea/tree/master/examples/textarea/main.go)
 
 ## Table
 
@@ -60,7 +57,7 @@ options.
 A component for displaying and navigating tabular data (columns and rows).
 Supports vertical scrolling and many customization options.
 
-* [Example code, countries and populations](https://github.com/charmbracelet/bubbletea/tree/master/examples/table/main.go)
+- [Example code, countries and populations](https://github.com/charmbracelet/bubbletea/tree/master/examples/table/main.go)
 
 ## Progress
 
@@ -71,12 +68,11 @@ A simple, customizable progress meter, with optional animation via
 runes can be set to whatever you'd like. The percentage readout is customizable
 and can also be omitted entirely.
 
-* [Animated example](https://github.com/charmbracelet/bubbletea/blob/master/examples/progress-animated/main.go)
-* [Static example](https://github.com/charmbracelet/bubbletea/blob/master/examples/progress-static/main.go)
+- [Animated example](https://github.com/charmbracelet/bubbletea/blob/master/examples/progress-animated/main.go)
+- [Static example](https://github.com/charmbracelet/bubbletea/blob/master/examples/progress-static/main.go)
 
 [harmonica]: https://github.com/charmbracelet/harmonica
 
-
 ## Paginator
 
 <img src="https://stuff.charm.sh/bubbles-examples/pagination.gif" width="200" alt="Paginator Example">
@@ -86,8 +82,7 @@ Supports "dot-style" pagination (similar to what you might see on iOS) and
 numeric page numbering, but you could also just use this component for the
 logic and visualize pagination however you like.
 
-* [Example code](https://github.com/charmbracelet/bubbletea/blob/master/examples/paginator/main.go)
-
+- [Example code](https://github.com/charmbracelet/bubbletea/blob/master/examples/paginator/main.go)
 
 ## Viewport
 
@@ -97,14 +92,13 @@ A viewport for vertically scrolling content. Optionally includes standard
 pager keybindings and mouse wheel support. A high performance mode is available
 for applications which make use of the alternate screen buffer.
 
-* [Example code](https://github.com/charmbracelet/bubbletea/tree/master/examples/pager/main.go)
+- [Example code](https://github.com/charmbracelet/bubbletea/tree/master/examples/pager/main.go)
 
 This component is well complemented with [Reflow][reflow] for ANSI-aware
 indenting and text wrapping.
 
 [reflow]: https://github.com/muesli/reflow
 
-
 ## List
 
 <img src="https://stuff.charm.sh/bubbles-examples/list.gif" width="600" alt="List Example">
@@ -114,9 +108,9 @@ Features pagination, fuzzy filtering, auto-generated help, an activity spinner,
 and status messages, all of which can be enabled and disabled as needed.
 Extrapolated from [Glow][glow].
 
-* [Example code, default list](https://github.com/charmbracelet/bubbletea/tree/master/examples/list-default/main.go)
-* [Example code, simple list](https://github.com/charmbracelet/bubbletea/tree/master/examples/list-simple/main.go)
-* [Example code, all features](https://github.com/charmbracelet/bubbletea/tree/master/examples/list-fancy/main.go)
+- [Example code, default list](https://github.com/charmbracelet/bubbletea/tree/master/examples/list-default/main.go)
+- [Example code, simple list](https://github.com/charmbracelet/bubbletea/tree/master/examples/list-simple/main.go)
+- [Example code, all features](https://github.com/charmbracelet/bubbletea/tree/master/examples/list-fancy/main.go)
 
 ## File Picker
 
@@ -126,7 +120,7 @@ A customizable component for picking a file from the file system. Navigate
 through directories and select files, optionally limit to certain file
 extensions.
 
-* [Example code](https://github.com/charmbracelet/bubbletea/tree/master/examples/file-picker/main.go)
+- [Example code](https://github.com/charmbracelet/bubbletea/tree/master/examples/file-picker/main.go)
 
 ## Timer
 
@@ -135,8 +129,7 @@ can be customized as you like.
 
 <img src="https://stuff.charm.sh/bubbles-examples/timer.gif" width="400" alt="Timer example">
 
-* [Example code](https://github.com/charmbracelet/bubbletea/blob/master/examples/timer/main.go)
-
+- [Example code](https://github.com/charmbracelet/bubbletea/blob/master/examples/timer/main.go)
 
 ## Stopwatch
 
@@ -145,8 +138,7 @@ can be customized as you like.
 A simple, flexible component for counting up. The update frequency and output
 can be customized as you see fit.
 
-* [Example code](https://github.com/charmbracelet/bubbletea/blob/master/examples/stopwatch/main.go)
-
+- [Example code](https://github.com/charmbracelet/bubbletea/blob/master/examples/stopwatch/main.go)
 
 ## Help
 
@@ -157,8 +149,7 @@ from your keybindings. It features single and multi-line modes, which the user
 can optionally toggle between. It will truncate gracefully if the terminal is
 too wide for the content.
 
-* [Example code](https://github.com/charmbracelet/bubbletea/blob/master/examples/help/main.go)
-
+- [Example code](https://github.com/charmbracelet/bubbletea/blob/master/examples/help/main.go)
 
 ## Key
 
@@ -197,42 +188,11 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 }
 ```
 
+## There’s more where that came from
 
-## Additional Bubbles
-
-<!-- in alphabetical order by author -->
-
-* [76creates/stickers](https://github.com/76creates/stickers): Responsive
-  flexbox and table components.
-* [calyptia/go-bubble-table](https://github.com/calyptia/go-bubble-table): An
-  interactive, customizable, scrollable table component.
-* [erikgeiser/promptkit](https://github.com/erikgeiser/promptkit): A collection
-  of common prompts for cases like selection, text input, and confirmation.
-  Each prompt comes with sensible defaults, remappable keybindings, any many
-  customization options.
-* [evertras/bubble-table](https://github.com/Evertras/bubble-table): Interactive,
-  customizable, paginated tables.
-* [knipferrc/teacup](https://github.com/knipferrc/teacup): Various handy
-  bubbles and utilities for building Bubble Tea applications.
-* [mritd/bubbles](https://github.com/mritd/bubbles): Some general-purpose
-  bubbles. Inputs with validation, menu selection, a modified progressbar, and
-  so on.
-* [kevm/bubbleo](https://github.com/KevM/bubbleo): A set of bubbles with a
-  focus on navigation: navigation stacks, breakcrumbs, menus and so on.
-* [treilik/bubbleboxer](https://github.com/treilik/bubbleboxer): Layout
-  multiple bubbles side-by-side in a layout-tree.
-* [treilik/bubblelister](https://github.com/treilik/bubblelister): An alternate
-  list that is scrollable without pagination and has the ability to contain
-  other bubbles as list items.
-
-If you’ve built a Bubble you think should be listed here, please create a Pull
-Request. Please note that for a project to be included, it must meet the
-following requirements:
-- The README has a demo GIF.
-- The README clearly states the purpose of the bubble along with an example on how to use it. 
-- The bubble must *always* be in a working state on its `main` branch.
-
-Thank you!
+There are also
+[community-owned bubbles.](https://github.com/charm-community/additional-bubbles)
+Check out the project’s README for instructions on how to get your Bubble added to the list!
 
 ## Contributing
 
@@ -244,15 +204,15 @@ See [contributing][contribute].
 
 We’d love to hear your thoughts on this project. Feel free to drop us a note!
 
-* [Twitter](https://twitter.com/charmcli)
-* [The Fediverse](https://mastodon.social/@charmcli)
-* [Discord](https://charm.sh/chat)
+- [Twitter](https://twitter.com/charmcli)
+- [The Fediverse](https://mastodon.social/@charmcli)
+- [Discord](https://charm.sh/chat)
 
 ## License
 
 [MIT](https://github.com/charmbracelet/bubbletea/raw/master/LICENSE)
 
-***
+---
 
 Part of [Charm](https://charm.sh).
 

From e3ce11a65f9191b02d7606bd222e3b0705737167 Mon Sep 17 00:00:00 2001
From: bashbunni <15822994+bashbunni@users.noreply.github.com>
Date: Fri, 17 Jan 2025 12:48:08 -0800
Subject: [PATCH 02/22] docs: update charm & friends blurb (#703)

* docs: update charm & friends blurb

* docs: simplify messaging, link to instructions
---
 README.md | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 3a07a37b..dac05bdf 100644
--- a/README.md
+++ b/README.md
@@ -190,9 +190,11 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 
 ## There’s more where that came from
 
-There are also
-[community-owned bubbles.](https://github.com/charm-community/additional-bubbles)
-Check out the project’s README for instructions on how to get your Bubble added to the list!
+To check out community-maintained Bubbles see [Charm &
+Friends](https://github.com/charm-and-friends/additional-bubbles). Made a cool Bubble
+that you want to share?
+[PRs](https://github.com/charm-and-friends/additional-bubbles?tab=readme-ov-file#what-is-a-complete-project)
+are welcome!
 
 ## Contributing
 

From 7ab08fb438e4fa1f7968a00a345399de30d1684c Mon Sep 17 00:00:00 2001
From: Carlos Alexandro Becker <caarlos0@users.noreply.github.com>
Date: Tue, 21 Jan 2025 19:31:03 -0300
Subject: [PATCH 03/22] fix(viewport): scroll to last line when borders (#706)

If the viewport has borders, they are not currently taken into account
when calculating the viewport max y offset, which might cause the last
line to not be visible.

This is easily reproducible in `gum pager`.

Signed-off-by: Carlos Alexandro Becker <caarlos0@users.noreply.github.com>
---
 viewport/viewport.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/viewport/viewport.go b/viewport/viewport.go
index 1835b8d0..11c6da7c 100644
--- a/viewport/viewport.go
+++ b/viewport/viewport.go
@@ -140,7 +140,7 @@ func (m *Model) SetContent(s string) {
 // 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)
+	return max(0, len(m.lines)-m.Height+m.Style.GetVerticalFrameSize())
 }
 
 // visibleLines returns the lines that should currently be visible in the

From 1bdd4c6fb3653943cb6941304c2c74354c4af519 Mon Sep 17 00:00:00 2001
From: Bisons Evicted <170766675+bevicted@users.noreply.github.com>
Date: Wed, 22 Jan 2025 13:10:20 +0100
Subject: [PATCH 04/22] fix: stopwatch.Start() (#707)

Signed-off-by: Bence Vidosits <bence.vidosits1@ibm.com>
Co-authored-by: Bence Vidosits <bence.vidosits1@ibm.com>
---
 stopwatch/stopwatch.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stopwatch/stopwatch.go b/stopwatch/stopwatch.go
index e5d5f633..891a4c52 100644
--- a/stopwatch/stopwatch.go
+++ b/stopwatch/stopwatch.go
@@ -75,7 +75,7 @@ func (m Model) Init() tea.Cmd {
 
 // Start starts the stopwatch.
 func (m Model) Start() tea.Cmd {
-	return tea.Batch(func() tea.Msg {
+	return tea.Sequence(func() tea.Msg {
 		return StartStopMsg{ID: m.id, running: true}
 	}, tick(m.id, m.tag, m.Interval))
 }

From 518ff7d0d0163844c72821d23a59963627fdbd37 Mon Sep 17 00:00:00 2001
From: Ayman Bagabas <ayman.bagabas@gmail.com>
Date: Thu, 23 Jan 2025 16:37:07 -0500
Subject: [PATCH 05/22] feat(textarea): add Cursor method (#712)

* feat(textarea): add CursorPosition method

This returns the current cursor position accounting any soft-wrapped
lines and multi-rune characters.

* chore(textarea): redefine how real cursor properties are accessed (#714)

---------

Co-authored-by: Christian Rocha <christian@rocha.is>
---
 go.mod               |  2 +-
 go.sum               |  8 ++++++++
 textarea/textarea.go | 49 ++++++++++++++++++++++++++++----------------
 3 files changed, 40 insertions(+), 19 deletions(-)

diff --git a/go.mod b/go.mod
index 4c084779..5bb6b706 100644
--- a/go.mod
+++ b/go.mod
@@ -5,7 +5,7 @@ go 1.18
 require (
 	github.com/MakeNowJust/heredoc v1.0.0
 	github.com/atotto/clipboard v0.1.4
-	github.com/charmbracelet/bubbletea/v2 v2.0.0-alpha.2.0.20250114201644-43a5b4dd0af0
+	github.com/charmbracelet/bubbletea/v2 v2.0.0-alpha.2.0.20250123211610-443afa6fa0c1
 	github.com/charmbracelet/harmonica v0.2.0
 	github.com/charmbracelet/lipgloss/v2 v2.0.0-alpha.2.0.20250114171829-b67eb015d607
 	github.com/charmbracelet/x/ansi v0.7.0
diff --git a/go.sum b/go.sum
index 23461870..7a9bc21a 100644
--- a/go.sum
+++ b/go.sum
@@ -6,6 +6,14 @@ github.com/aymanbagabas/go-udiff v0.2.0 h1:TK0fH4MteXUDspT88n8CKzvK0X9O2xu9yQjWp
 github.com/aymanbagabas/go-udiff v0.2.0/go.mod h1:RE4Ex0qsGkTAJoQdQQCA0uG+nAzJO/pI/QwceO5fgrA=
 github.com/charmbracelet/bubbletea/v2 v2.0.0-alpha.2.0.20250114201644-43a5b4dd0af0 h1:BWjXQRSwBjoCpLeNu8zT93n+NHhZZhkQQLveXMmnkYc=
 github.com/charmbracelet/bubbletea/v2 v2.0.0-alpha.2.0.20250114201644-43a5b4dd0af0/go.mod h1:hT2875Ank3ylgW13kqu6cjDc9XIk9sE5JsOFYdl09b8=
+github.com/charmbracelet/bubbletea/v2 v2.0.0-alpha.2.0.20250123204203-55f6f9f70bf6 h1:L2+Kl71AsucUpl32AqmbjVv/4Ha7dwlSFwqrU4sAeTE=
+github.com/charmbracelet/bubbletea/v2 v2.0.0-alpha.2.0.20250123204203-55f6f9f70bf6/go.mod h1:hT2875Ank3ylgW13kqu6cjDc9XIk9sE5JsOFYdl09b8=
+github.com/charmbracelet/bubbletea/v2 v2.0.0-alpha.2.0.20250123210727-80fa20da7d7b h1:QqN3KApDbHJl+B1lVSir6GyRbxH7EA6U1SCDoxz8xYU=
+github.com/charmbracelet/bubbletea/v2 v2.0.0-alpha.2.0.20250123210727-80fa20da7d7b/go.mod h1:hT2875Ank3ylgW13kqu6cjDc9XIk9sE5JsOFYdl09b8=
+github.com/charmbracelet/bubbletea/v2 v2.0.0-alpha.2.0.20250123210853-99e3bbf892cd h1:1WsMNlPUaDXgJprIvWg+ZsXmc4GiL4KsBEFNZ3ymKeA=
+github.com/charmbracelet/bubbletea/v2 v2.0.0-alpha.2.0.20250123210853-99e3bbf892cd/go.mod h1:hT2875Ank3ylgW13kqu6cjDc9XIk9sE5JsOFYdl09b8=
+github.com/charmbracelet/bubbletea/v2 v2.0.0-alpha.2.0.20250123211610-443afa6fa0c1 h1:tktnM4YimEWSYd58iZlPDB3Xz25/r94VYZZsHK5zWL0=
+github.com/charmbracelet/bubbletea/v2 v2.0.0-alpha.2.0.20250123211610-443afa6fa0c1/go.mod h1:hT2875Ank3ylgW13kqu6cjDc9XIk9sE5JsOFYdl09b8=
 github.com/charmbracelet/colorprofile v0.1.9 h1:5JnfvX+I9D6rRNu8xK3pgIqknaBVTXHU9pGu1jkZxLw=
 github.com/charmbracelet/colorprofile v0.1.9/go.mod h1:+jpmObxZl1Dab3H3IMVIPSZTsKcFpjJUv97G0dLqM60=
 github.com/charmbracelet/harmonica v0.2.0 h1:8NxJWRWg/bzKqqEaaeFNipOu77YR5t8aSwG4pgaUBiQ=
diff --git a/textarea/textarea.go b/textarea/textarea.go
index 0bd77009..d35c6ca7 100644
--- a/textarea/textarea.go
+++ b/textarea/textarea.go
@@ -231,8 +231,8 @@ type Model struct {
 	// when switching focus states.
 	activeStyle *StyleState
 
-	// Cursor is the text area cursor.
-	Cursor cursor.Model
+	// VirtualCursor is the text area cursor.
+	VirtualCursor cursor.Model
 
 	// CharLimit is the maximum number of characters this input element will
 	// accept. If 0 or less, there's no limit.
@@ -305,7 +305,7 @@ func New() Model {
 		cache:                memoization.NewMemoCache[line, [][]rune](maxLines),
 		EndOfBufferCharacter: ' ',
 		ShowLineNumbers:      true,
-		Cursor:               cur,
+		VirtualCursor:        cur,
 		KeyMap:               DefaultKeyMap(),
 
 		value: make([][]rune, minHeight, maxLines),
@@ -600,7 +600,7 @@ func (m Model) Focused() bool {
 func (m *Model) Focus() tea.Cmd {
 	m.focus = true
 	m.activeStyle = &m.Styles.Focused
-	return m.Cursor.Focus()
+	return m.VirtualCursor.Focus()
 }
 
 // Blur removes the focus state on the model. When the model is blurred it can
@@ -608,7 +608,7 @@ func (m *Model) Focus() tea.Cmd {
 func (m *Model) Blur() {
 	m.focus = false
 	m.activeStyle = &m.Styles.Blurred
-	m.Cursor.Blur()
+	m.VirtualCursor.Blur()
 }
 
 // Reset sets the input to its default state with no input.
@@ -976,7 +976,7 @@ func (m *Model) SetHeight(h int) {
 // Update is the Bubble Tea update loop.
 func (m Model) Update(msg tea.Msg) (Model, tea.Cmd) {
 	if !m.focus {
-		m.Cursor.Blur()
+		m.VirtualCursor.Blur()
 		return m, nil
 	}
 
@@ -1098,10 +1098,10 @@ func (m Model) Update(msg tea.Msg) (Model, tea.Cmd) {
 	cmds = append(cmds, cmd)
 
 	newRow, newCol := m.cursorLineNumber(), m.col
-	m.Cursor, cmd = m.Cursor.Update(msg)
-	if (newRow != oldRow || newCol != oldCol) && m.Cursor.Mode() == cursor.CursorBlink {
-		m.Cursor.Blink = false
-		cmd = m.Cursor.BlinkCmd()
+	m.VirtualCursor, cmd = m.VirtualCursor.Update(msg)
+	if (newRow != oldRow || newCol != oldCol) && m.VirtualCursor.Mode() == cursor.CursorBlink {
+		m.VirtualCursor.Blink = false
+		cmd = m.VirtualCursor.BlinkCmd()
 	}
 	cmds = append(cmds, cmd)
 
@@ -1115,7 +1115,7 @@ func (m Model) View() string {
 	if m.Value() == "" && m.row == 0 && m.col == 0 && m.Placeholder != "" {
 		return m.placeholderView()
 	}
-	m.Cursor.TextStyle = m.activeStyle.computedCursorLine()
+	m.VirtualCursor.TextStyle = m.activeStyle.computedCursorLine()
 
 	var (
 		s                strings.Builder
@@ -1184,11 +1184,11 @@ func (m Model) View() string {
 			if m.row == l && lineInfo.RowOffset == wl {
 				s.WriteString(style.Render(string(wrappedLine[:lineInfo.ColumnOffset])))
 				if m.col >= len(line) && lineInfo.CharOffset >= m.width {
-					m.Cursor.SetChar(" ")
-					s.WriteString(m.Cursor.View())
+					m.VirtualCursor.SetChar(" ")
+					s.WriteString(m.VirtualCursor.View())
 				} else {
-					m.Cursor.SetChar(string(wrappedLine[lineInfo.ColumnOffset]))
-					s.WriteString(style.Render(m.Cursor.View()))
+					m.VirtualCursor.SetChar(string(wrappedLine[lineInfo.ColumnOffset]))
+					s.WriteString(style.Render(m.VirtualCursor.View()))
 					s.WriteString(style.Render(string(wrappedLine[lineInfo.ColumnOffset+1:])))
 				}
 			} else {
@@ -1291,9 +1291,9 @@ func (m Model) placeholderView() string {
 		// first line
 		case i == 0:
 			// first character of first line as cursor with character
-			m.Cursor.TextStyle = m.activeStyle.computedPlaceholder()
-			m.Cursor.SetChar(string(plines[0][0]))
-			s.WriteString(lineStyle.Render(m.Cursor.View()))
+			m.VirtualCursor.TextStyle = m.activeStyle.computedPlaceholder()
+			m.VirtualCursor.SetChar(string(plines[0][0]))
+			s.WriteString(lineStyle.Render(m.VirtualCursor.View()))
 
 			// the rest of the first line
 			s.WriteString(lineStyle.Render(style.Render(plines[0][1:] + strings.Repeat(" ", max(0, m.width-uniseg.StringWidth(plines[0]))))))
@@ -1322,6 +1322,19 @@ func Blink() tea.Msg {
 	return cursor.Blink()
 }
 
+// Cursor returns the current cursor position accounting any
+// soft-wrapped lines.
+func (m Model) Cursor() *tea.Cursor {
+	lineInfo := m.LineInfo()
+	x, y := lineInfo.CharOffset, m.cursorLineNumber()-m.viewport.YOffset
+
+	// TODO: sort out where these properties live.
+	c := tea.NewCursor(x, y)
+	c.Blink = true
+	c.Color = m.VirtualCursor.Style.GetForeground()
+	return c
+}
+
 func (m Model) memoizedWrap(runes []rune, width int) [][]rune {
 	input := line{runes: runes, width: width}
 	if v, ok := m.cache.Get(input); ok {

From a0d9fe396dcff9806999a60b9fdcd63cf15ac6b9 Mon Sep 17 00:00:00 2001
From: Ayman Bagabas <ayman.bagabas@gmail.com>
Date: Wed, 29 Jan 2025 15:59:11 -0500
Subject: [PATCH 06/22] refactor: progress: return Model instead of tea.Model
 (#719)

This conforms to the new generic bubbletea API.
See https://github.com/charmbracelet/bubbletea/pull/1298
---
 progress/progress.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/progress/progress.go b/progress/progress.go
index b596c30c..512aaa8d 100644
--- a/progress/progress.go
+++ b/progress/progress.go
@@ -182,7 +182,7 @@ func New(opts ...Option) Model {
 }
 
 // Init exists to satisfy the tea.Model interface.
-func (m Model) Init() (tea.Model, tea.Cmd) {
+func (m Model) Init() (Model, tea.Cmd) {
 	return m, nil
 }
 
@@ -190,7 +190,7 @@ func (m Model) Init() (tea.Model, tea.Cmd) {
 // SetPercent to create the command you'll need to trigger the animation.
 //
 // If you're rendering with ViewAs you won't need this.
-func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+func (m Model) Update(msg tea.Msg) (Model, tea.Cmd) {
 	switch msg := msg.(type) {
 	case FrameMsg:
 		if msg.id != m.id || msg.tag != m.tag {

From 9d5d140b3cfd8a9456f45f8c6d0a577eef873553 Mon Sep 17 00:00:00 2001
From: Christian Rocha <christian@rocha.is>
Date: Tue, 28 Jan 2025 10:21:58 -0500
Subject: [PATCH 07/22] chore(textarea,cursor): flesh out real cursor API

---
 cursor/cursor.go       | 45 +++++++++++++++++++-----
 textarea/textarea.go   | 78 ++++++++++++++++++++++++++++--------------
 textinput/textinput.go |  4 +--
 3 files changed, 92 insertions(+), 35 deletions(-)

diff --git a/cursor/cursor.go b/cursor/cursor.go
index c49781ed..2ee2ef51 100644
--- a/cursor/cursor.go
+++ b/cursor/cursor.go
@@ -1,3 +1,8 @@
+// Package cursor provides a virtual cursor to support the textinput and
+// textarea elements.
+//
+// Both the textinput and textarea elements also use this package to style an
+// optional real cursor.
 package cursor
 
 import (
@@ -51,25 +56,49 @@ func (c Mode) String() string {
 
 // Model is the Bubble Tea model for this cursor element.
 type Model struct {
-	BlinkSpeed time.Duration
-	// Style for styling the cursor block.
+	// Style styles the cursor block.
+	//
+	// For real cursors, the foreground color set here will be used as the
+	// cursor color.
 	Style lipgloss.Style
-	// TextStyle is the style used for the cursor when it is hidden (when blinking).
-	// I.e. displaying normal text.
-	TextStyle lipgloss.Style
+
+	// Shape is the cursor shape. The following shapes are available:
+	//
+	// - tea.CursorBlock
+	// - tea.CursorUnderline
+	// - tea.CursorBar
+	//
+	// This is only used for real cursors.
+	Shape tea.CursorShape
+
+	// BlinkedStyle is the style used for the cursor when it is blinking
+	// (hidden), i.e. displaying normal text. This has no effect on real
+	// cursors.
+	BlinkedStyle lipgloss.Style
+
+	// BlinkSpeed is the speed at which the cursor blinks. This has no effect
+	// on real cursors as well as no effect if the [CursorMode] is not set to
+	// [CursorBlink].
+	BlinkSpeed time.Duration
+
+	// Blink is the cursor blink state.
+	Blink bool
 
 	// char is the character under the cursor
 	char string
+
 	// The ID of this Model as it relates to other cursors
 	id int
+
 	// focus indicates whether the containing input is focused
 	focus bool
-	// Cursor Blink state.
-	Blink bool
+
 	// Used to manage cursor blink
 	blinkCtx *blinkCtx
+
 	// The ID of the blink message we're expecting to receive.
 	blinkTag int
+
 	// mode determines the behavior of the cursor
 	mode Mode
 }
@@ -212,7 +241,7 @@ func (m *Model) SetChar(char string) {
 // View displays the cursor.
 func (m Model) View() string {
 	if m.Blink {
-		return m.TextStyle.Inline(true).Render(m.char)
+		return m.BlinkedStyle.Inline(true).Render(m.char)
 	}
 	return m.Style.Inline(true).Reverse(true).Render(m.char)
 }
diff --git a/textarea/textarea.go b/textarea/textarea.go
index d35c6ca7..9de266c1 100644
--- a/textarea/textarea.go
+++ b/textarea/textarea.go
@@ -102,19 +102,25 @@ func DefaultKeyMap() KeyMap {
 type LineInfo struct {
 	// Width is the number of columns in the line.
 	Width int
+
 	// CharWidth is the number of characters in the line to account for
 	// double-width runes.
 	CharWidth int
+
 	// Height is the number of rows in the line.
 	Height int
+
 	// StartColumn is the index of the first column of the line.
 	StartColumn int
+
 	// ColumnOffset is the number of columns that the cursor is offset from the
 	// start of the line.
 	ColumnOffset int
+
 	// RowOffset is the number of rows that the cursor is offset from the start
 	// of the line.
 	RowOffset int
+
 	// CharOffset is the number of characters that the cursor is offset
 	// from the start of the line. This will generally be equivalent to
 	// ColumnOffset, but will be different there are double-width runes before
@@ -231,8 +237,27 @@ type Model struct {
 	// when switching focus states.
 	activeStyle *StyleState
 
-	// VirtualCursor is the text area cursor.
-	VirtualCursor cursor.Model
+	// Cursor manages the virtual cursor and contains styling settings for
+	// both a real and virtual cursor.
+	Cursor cursor.Model
+
+	// UseRealCursor determines whether or not to use the real cursor. By
+	// default, a virtual cursor is used.
+	//
+	// When [UseRealCursor] is enabled, the virual cursor is hidden and you
+	// must use [Model.RealCursor] to produce a real cursor for a [tea.Frame].
+	//
+	// Note that you will almost certainly also need to adjust the offset
+	// postion of the textarea to properly set the cursor position.
+	//
+	// Example:
+	//
+	//  // In your top-level View function:
+	//  f := tea.NewFrame(m.textarea.View())
+	//  f.Cursor = m.textarea.RealCursor()
+	//  f.Cursor.Position.X += offsetX
+	//  f.Cursor.Position.Y += offsetY
+	UseRealCursor bool
 
 	// CharLimit is the maximum number of characters this input element will
 	// accept. If 0 or less, there's no limit.
@@ -305,7 +330,7 @@ func New() Model {
 		cache:                memoization.NewMemoCache[line, [][]rune](maxLines),
 		EndOfBufferCharacter: ' ',
 		ShowLineNumbers:      true,
-		VirtualCursor:        cur,
+		Cursor:               cur,
 		KeyMap:               DefaultKeyMap(),
 
 		value: make([][]rune, minHeight, maxLines),
@@ -600,7 +625,7 @@ func (m Model) Focused() bool {
 func (m *Model) Focus() tea.Cmd {
 	m.focus = true
 	m.activeStyle = &m.Styles.Focused
-	return m.VirtualCursor.Focus()
+	return m.Cursor.Focus()
 }
 
 // Blur removes the focus state on the model. When the model is blurred it can
@@ -608,7 +633,7 @@ func (m *Model) Focus() tea.Cmd {
 func (m *Model) Blur() {
 	m.focus = false
 	m.activeStyle = &m.Styles.Blurred
-	m.VirtualCursor.Blur()
+	m.Cursor.Blur()
 }
 
 // Reset sets the input to its default state with no input.
@@ -976,7 +1001,7 @@ func (m *Model) SetHeight(h int) {
 // Update is the Bubble Tea update loop.
 func (m Model) Update(msg tea.Msg) (Model, tea.Cmd) {
 	if !m.focus {
-		m.VirtualCursor.Blur()
+		m.Cursor.Blur()
 		return m, nil
 	}
 
@@ -1098,10 +1123,10 @@ func (m Model) Update(msg tea.Msg) (Model, tea.Cmd) {
 	cmds = append(cmds, cmd)
 
 	newRow, newCol := m.cursorLineNumber(), m.col
-	m.VirtualCursor, cmd = m.VirtualCursor.Update(msg)
-	if (newRow != oldRow || newCol != oldCol) && m.VirtualCursor.Mode() == cursor.CursorBlink {
-		m.VirtualCursor.Blink = false
-		cmd = m.VirtualCursor.BlinkCmd()
+	m.Cursor, cmd = m.Cursor.Update(msg)
+	if (newRow != oldRow || newCol != oldCol) && m.Cursor.Mode() == cursor.CursorBlink {
+		m.Cursor.Blink = false
+		cmd = m.Cursor.BlinkCmd()
 	}
 	cmds = append(cmds, cmd)
 
@@ -1115,7 +1140,7 @@ func (m Model) View() string {
 	if m.Value() == "" && m.row == 0 && m.col == 0 && m.Placeholder != "" {
 		return m.placeholderView()
 	}
-	m.VirtualCursor.TextStyle = m.activeStyle.computedCursorLine()
+	m.Cursor.BlinkedStyle = m.activeStyle.computedCursorLine()
 
 	var (
 		s                strings.Builder
@@ -1184,11 +1209,11 @@ func (m Model) View() string {
 			if m.row == l && lineInfo.RowOffset == wl {
 				s.WriteString(style.Render(string(wrappedLine[:lineInfo.ColumnOffset])))
 				if m.col >= len(line) && lineInfo.CharOffset >= m.width {
-					m.VirtualCursor.SetChar(" ")
-					s.WriteString(m.VirtualCursor.View())
+					m.Cursor.SetChar(" ")
+					s.WriteString(m.Cursor.View())
 				} else {
-					m.VirtualCursor.SetChar(string(wrappedLine[lineInfo.ColumnOffset]))
-					s.WriteString(style.Render(m.VirtualCursor.View()))
+					m.Cursor.SetChar(string(wrappedLine[lineInfo.ColumnOffset]))
+					s.WriteString(style.Render(m.Cursor.View()))
 					s.WriteString(style.Render(string(wrappedLine[lineInfo.ColumnOffset+1:])))
 				}
 			} else {
@@ -1291,9 +1316,9 @@ func (m Model) placeholderView() string {
 		// first line
 		case i == 0:
 			// first character of first line as cursor with character
-			m.VirtualCursor.TextStyle = m.activeStyle.computedPlaceholder()
-			m.VirtualCursor.SetChar(string(plines[0][0]))
-			s.WriteString(lineStyle.Render(m.VirtualCursor.View()))
+			m.Cursor.BlinkedStyle = m.activeStyle.computedPlaceholder()
+			m.Cursor.SetChar(string(plines[0][0]))
+			s.WriteString(lineStyle.Render(m.Cursor.View()))
 
 			// the rest of the first line
 			s.WriteString(lineStyle.Render(style.Render(plines[0][1:] + strings.Repeat(" ", max(0, m.width-uniseg.StringWidth(plines[0]))))))
@@ -1317,21 +1342,24 @@ func (m Model) placeholderView() string {
 	return m.activeStyle.Base.Render(m.viewport.View())
 }
 
-// Blink returns the blink command for the cursor.
+// Blink returns the blink command for the virtual cursor.
 func Blink() tea.Msg {
 	return cursor.Blink()
 }
 
-// Cursor returns the current cursor position accounting any
-// soft-wrapped lines.
-func (m Model) Cursor() *tea.Cursor {
+// RealCursor returns a [tea.Cursor] for rendering a real cursor in a Bubble
+// Tea program.
+func (m Model) RealCursor() *tea.Cursor {
+	if m.Cursor.Mode() == cursor.CursorHide {
+		return nil
+	}
+
 	lineInfo := m.LineInfo()
 	x, y := lineInfo.CharOffset, m.cursorLineNumber()-m.viewport.YOffset
 
-	// TODO: sort out where these properties live.
 	c := tea.NewCursor(x, y)
-	c.Blink = true
-	c.Color = m.VirtualCursor.Style.GetForeground()
+	c.Blink = m.Cursor.Mode() == cursor.CursorBlink
+	c.Color = m.Cursor.Style.GetForeground()
 	return c
 }
 
diff --git a/textinput/textinput.go b/textinput/textinput.go
index 92c468ac..b98d00b1 100644
--- a/textinput/textinput.go
+++ b/textinput/textinput.go
@@ -671,7 +671,7 @@ func (m Model) View() string {
 		if m.canAcceptSuggestion() {
 			suggestion := m.matchedSuggestions[m.currentSuggestionIndex]
 			if len(value) < len(suggestion) {
-				m.Cursor.TextStyle = m.CompletionStyle
+				m.Cursor.BlinkedStyle = m.CompletionStyle
 				m.Cursor.SetChar(m.echoTransform(string(suggestion[pos])))
 				v += m.Cursor.View()
 				v += m.completionView(1)
@@ -709,7 +709,7 @@ func (m Model) placeholderView() string {
 	p := make([]rune, m.Width()+1)
 	copy(p, []rune(m.Placeholder))
 
-	m.Cursor.TextStyle = m.PlaceholderStyle
+	m.Cursor.BlinkedStyle = m.PlaceholderStyle
 	m.Cursor.SetChar(string(p[:1]))
 	v += m.Cursor.View()
 

From 7cdd5f37fe85d9380e41d416a710113eda5c84ff Mon Sep 17 00:00:00 2001
From: Christian Rocha <christian@rocha.is>
Date: Tue, 28 Jan 2025 11:45:25 -0500
Subject: [PATCH 08/22] chore(textarea,cursor): use textarea to manage virtual
 cursor styling

---
 cursor/cursor.go     |  21 +-----
 textarea/textarea.go | 164 +++++++++++++++++++++++++++++++------------
 2 files changed, 120 insertions(+), 65 deletions(-)

diff --git a/cursor/cursor.go b/cursor/cursor.go
index 2ee2ef51..33d29465 100644
--- a/cursor/cursor.go
+++ b/cursor/cursor.go
@@ -1,8 +1,5 @@
 // Package cursor provides a virtual cursor to support the textinput and
 // textarea elements.
-//
-// Both the textinput and textarea elements also use this package to style an
-// optional real cursor.
 package cursor
 
 import (
@@ -57,28 +54,14 @@ func (c Mode) String() string {
 // Model is the Bubble Tea model for this cursor element.
 type Model struct {
 	// Style styles the cursor block.
-	//
-	// For real cursors, the foreground color set here will be used as the
-	// cursor color.
 	Style lipgloss.Style
 
-	// Shape is the cursor shape. The following shapes are available:
-	//
-	// - tea.CursorBlock
-	// - tea.CursorUnderline
-	// - tea.CursorBar
-	//
-	// This is only used for real cursors.
-	Shape tea.CursorShape
-
 	// BlinkedStyle is the style used for the cursor when it is blinking
-	// (hidden), i.e. displaying normal text. This has no effect on real
-	// cursors.
+	// (hidden), i.e. displaying normal text.
 	BlinkedStyle lipgloss.Style
 
 	// BlinkSpeed is the speed at which the cursor blinks. This has no effect
-	// on real cursors as well as no effect if the [CursorMode] is not set to
-	// [CursorBlink].
+	// unless [CursorMode] is not set to [CursorBlink].
 	BlinkSpeed time.Duration
 
 	// Blink is the cursor blink state.
diff --git a/textarea/textarea.go b/textarea/textarea.go
index 9de266c1..57c4a8c5 100644
--- a/textarea/textarea.go
+++ b/textarea/textarea.go
@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"strconv"
 	"strings"
+	"time"
 	"unicode"
 
 	"github.com/atotto/clipboard"
@@ -128,6 +129,39 @@ type LineInfo struct {
 	CharOffset int
 }
 
+// CursorStyle is the style for real and virtual cursors.
+type CursorStyle struct {
+	// Style styles the cursor block.
+	//
+	// For real cursors, the foreground color set here will be used as the
+	// cursor color.
+	Style lipgloss.Style
+
+	// BlinkedStyle is the style used for the cursor when it is blinking
+	// (hidden), i.e. displaying normal text. This is only used for virtual
+	// cursors.
+	BlinkedStyle lipgloss.Style
+
+	// Shape is the cursor shape. The following shapes are available:
+	//
+	// - tea.CursorBlock
+	// - tea.CursorUnderline
+	// - tea.CursorBar
+	//
+	// This is only used for real cursors.
+	Shape tea.CursorShape
+
+	// CursorBlink determines whether or not the cursor should blink.
+	Blink bool
+
+	// BlinkSpeed is the speed at which the virtualcursor blinks. This has no
+	// effect on real cursors as well as no effect if the cursor is set not
+	// to [CursorBlink].
+	//
+	// By default, the blink speed is set to about 500ms.
+	BlinkSpeed time.Duration
+}
+
 // Styles are the styles for the textarea, separated into focused and blurred
 // states. The appropriate styles will be chosen based on the focus state of
 // the textarea.
@@ -152,6 +186,7 @@ type StyleState struct {
 	Placeholder      lipgloss.Style
 	Prompt           lipgloss.Style
 	Text             lipgloss.Style
+	Cursor           CursorStyle
 }
 
 func (s StyleState) computedCursorLine() lipgloss.Style {
@@ -229,7 +264,7 @@ type Model struct {
 
 	// Styling. FocusedStyle and BlurredStyle are used to style the textarea in
 	// focused and blurred states.
-	Styles Styles
+	styles Styles
 
 	// activeStyle is the current styling to use.
 	// It is used to abstract the differences in focus state when styling the
@@ -237,27 +272,12 @@ type Model struct {
 	// when switching focus states.
 	activeStyle *StyleState
 
-	// Cursor manages the virtual cursor and contains styling settings for
-	// both a real and virtual cursor.
-	Cursor cursor.Model
+	// virtualCursor manages the virtual cursor.
+	virtualCursor cursor.Model
 
-	// UseRealCursor determines whether or not to use the real cursor. By
-	// default, a virtual cursor is used.
-	//
-	// When [UseRealCursor] is enabled, the virual cursor is hidden and you
-	// must use [Model.RealCursor] to produce a real cursor for a [tea.Frame].
-	//
-	// Note that you will almost certainly also need to adjust the offset
-	// postion of the textarea to properly set the cursor position.
-	//
-	// Example:
-	//
-	//  // In your top-level View function:
-	//  f := tea.NewFrame(m.textarea.View())
-	//  f.Cursor = m.textarea.RealCursor()
-	//  f.Cursor.Position.X += offsetX
-	//  f.Cursor.Position.Y += offsetY
-	UseRealCursor bool
+	// VirtualCursor determines whether or not to use the virtual cursor. If
+	// set to false, use [Model.Cursor] to return a real cursor for rendering.
+	VirtualCursor bool
 
 	// CharLimit is the maximum number of characters this input element will
 	// accept. If 0 or less, there's no limit.
@@ -325,12 +345,13 @@ func New() Model {
 		MaxHeight:            defaultMaxHeight,
 		MaxWidth:             defaultMaxWidth,
 		Prompt:               lipgloss.ThickBorder().Left + " ",
-		Styles:               styles,
+		styles:               styles,
 		activeStyle:          &styles.Blurred,
 		cache:                memoization.NewMemoCache[line, [][]rune](maxLines),
 		EndOfBufferCharacter: ' ',
 		ShowLineNumbers:      true,
-		Cursor:               cur,
+		VirtualCursor:        true,
+		virtualCursor:        cur,
 		KeyMap:               DefaultKeyMap(),
 
 		value: make([][]rune, minHeight, maxLines),
@@ -362,6 +383,9 @@ func DefaultStyles(isDark bool) Styles {
 		Placeholder:      lipgloss.NewStyle().Foreground(lipgloss.Color("240")),
 		Prompt:           lipgloss.NewStyle().Foreground(lipgloss.Color("7")),
 		Text:             lipgloss.NewStyle(),
+		Cursor: CursorStyle{
+			Style: lipgloss.NewStyle().Foreground(lipgloss.Color("7")),
+		},
 	}
 	s.Blurred = StyleState{
 		Base:             lipgloss.NewStyle(),
@@ -386,6 +410,40 @@ func DefaultDarkStyles() Styles {
 	return DefaultStyles(true)
 }
 
+// SetStyles sets the styles for the textarea.
+func (m *Model) SetStyles(s Styles) {
+	m.styles = s
+	if m.focus {
+		m.activeStyle = &m.styles.Focused
+	} else {
+		m.activeStyle = &m.styles.Blurred
+	}
+
+	m.virtualCursor.Style = s.Focused.Cursor.Style
+	m.virtualCursor.BlinkedStyle = s.Focused.Cursor.BlinkedStyle
+
+	// By default, the blink speed of the cursor is set to a deafault
+	// internally.
+	if s.Focused.Cursor.BlinkSpeed > 0 {
+		m.virtualCursor.BlinkSpeed = m.activeStyle.Cursor.BlinkSpeed
+	}
+
+	if !m.VirtualCursor {
+		m.virtualCursor.SetMode(cursor.CursorHide)
+		return
+	}
+	if s.Focused.Cursor.Blink {
+		m.virtualCursor.SetMode(cursor.CursorBlink)
+		return
+	}
+	m.virtualCursor.SetMode(cursor.CursorStatic)
+}
+
+// Styles returns the styles for the textarea.
+func (m Model) Styles() Styles {
+	return m.styles
+}
+
 // SetValue sets the value of the text input.
 func (m *Model) SetValue(s string) {
 	m.Reset()
@@ -624,16 +682,16 @@ func (m Model) Focused() bool {
 // receive keyboard input and the cursor will be hidden.
 func (m *Model) Focus() tea.Cmd {
 	m.focus = true
-	m.activeStyle = &m.Styles.Focused
-	return m.Cursor.Focus()
+	m.activeStyle = &m.styles.Focused
+	return m.virtualCursor.Focus()
 }
 
 // Blur removes the focus state on the model. When the model is blurred it can
 // not receive keyboard input and the cursor will be hidden.
 func (m *Model) Blur() {
 	m.focus = false
-	m.activeStyle = &m.Styles.Blurred
-	m.Cursor.Blur()
+	m.activeStyle = &m.styles.Blurred
+	m.virtualCursor.Blur()
 }
 
 // Reset sets the input to its default state with no input.
@@ -1001,7 +1059,7 @@ func (m *Model) SetHeight(h int) {
 // Update is the Bubble Tea update loop.
 func (m Model) Update(msg tea.Msg) (Model, tea.Cmd) {
 	if !m.focus {
-		m.Cursor.Blur()
+		m.virtualCursor.Blur()
 		return m, nil
 	}
 
@@ -1123,10 +1181,10 @@ func (m Model) Update(msg tea.Msg) (Model, tea.Cmd) {
 	cmds = append(cmds, cmd)
 
 	newRow, newCol := m.cursorLineNumber(), m.col
-	m.Cursor, cmd = m.Cursor.Update(msg)
-	if (newRow != oldRow || newCol != oldCol) && m.Cursor.Mode() == cursor.CursorBlink {
-		m.Cursor.Blink = false
-		cmd = m.Cursor.BlinkCmd()
+	m.virtualCursor, cmd = m.virtualCursor.Update(msg)
+	if (newRow != oldRow || newCol != oldCol) && m.virtualCursor.Mode() == cursor.CursorBlink {
+		m.virtualCursor.Blink = false
+		cmd = m.virtualCursor.BlinkCmd()
 	}
 	cmds = append(cmds, cmd)
 
@@ -1140,7 +1198,7 @@ func (m Model) View() string {
 	if m.Value() == "" && m.row == 0 && m.col == 0 && m.Placeholder != "" {
 		return m.placeholderView()
 	}
-	m.Cursor.BlinkedStyle = m.activeStyle.computedCursorLine()
+	m.virtualCursor.BlinkedStyle = m.activeStyle.computedCursorLine()
 
 	var (
 		s                strings.Builder
@@ -1209,11 +1267,11 @@ func (m Model) View() string {
 			if m.row == l && lineInfo.RowOffset == wl {
 				s.WriteString(style.Render(string(wrappedLine[:lineInfo.ColumnOffset])))
 				if m.col >= len(line) && lineInfo.CharOffset >= m.width {
-					m.Cursor.SetChar(" ")
-					s.WriteString(m.Cursor.View())
+					m.virtualCursor.SetChar(" ")
+					s.WriteString(m.virtualCursor.View())
 				} else {
-					m.Cursor.SetChar(string(wrappedLine[lineInfo.ColumnOffset]))
-					s.WriteString(style.Render(m.Cursor.View()))
+					m.virtualCursor.SetChar(string(wrappedLine[lineInfo.ColumnOffset]))
+					s.WriteString(style.Render(m.virtualCursor.View()))
 					s.WriteString(style.Render(string(wrappedLine[lineInfo.ColumnOffset+1:])))
 				}
 			} else {
@@ -1316,9 +1374,9 @@ func (m Model) placeholderView() string {
 		// first line
 		case i == 0:
 			// first character of first line as cursor with character
-			m.Cursor.BlinkedStyle = m.activeStyle.computedPlaceholder()
-			m.Cursor.SetChar(string(plines[0][0]))
-			s.WriteString(lineStyle.Render(m.Cursor.View()))
+			m.virtualCursor.BlinkedStyle = m.activeStyle.computedPlaceholder()
+			m.virtualCursor.SetChar(string(plines[0][0]))
+			s.WriteString(lineStyle.Render(m.virtualCursor.View()))
 
 			// the rest of the first line
 			s.WriteString(lineStyle.Render(style.Render(plines[0][1:] + strings.Repeat(" ", max(0, m.width-uniseg.StringWidth(plines[0]))))))
@@ -1347,10 +1405,24 @@ func Blink() tea.Msg {
 	return cursor.Blink()
 }
 
-// RealCursor returns a [tea.Cursor] for rendering a real cursor in a Bubble
-// Tea program.
-func (m Model) RealCursor() *tea.Cursor {
-	if m.Cursor.Mode() == cursor.CursorHide {
+// Cursor returns a [tea.Cursor] for rendering a real cursor in a Bubble Tea
+// program.
+//
+// Example:
+//
+//	// In your top-level View function:
+//	f := tea.NewFrame(m.textarea.View())
+//	f.Cursor = m.textarea.RealCursor()
+//	f.Cursor.Position.X += offsetX
+//	f.Cursor.Position.Y += offsetY
+//
+// Note that you will almost certainly also need to adjust the offset
+// position of the textarea to properly set the cursor position.
+//
+// If you're using a real cursor, you should also set [Model.VirtualCursor] to
+// false.
+func (m Model) Cursor() *tea.Cursor {
+	if m.VirtualCursor || !m.Focused() {
 		return nil
 	}
 
@@ -1358,8 +1430,8 @@ func (m Model) RealCursor() *tea.Cursor {
 	x, y := lineInfo.CharOffset, m.cursorLineNumber()-m.viewport.YOffset
 
 	c := tea.NewCursor(x, y)
-	c.Blink = m.Cursor.Mode() == cursor.CursorBlink
-	c.Color = m.Cursor.Style.GetForeground()
+	c.Blink = m.styles.Focused.Cursor.Blink
+	c.Color = m.styles.Focused.Cursor.Style.GetForeground()
 	return c
 }
 

From 0b3c0a26533e8002b4107c471a65d7b628795811 Mon Sep 17 00:00:00 2001
From: Christian Rocha <christian@rocha.is>
Date: Tue, 28 Jan 2025 12:58:29 -0500
Subject: [PATCH 09/22] fix(textarea): doc comment

Co-authored-by: Ayman Bagabas <ayman.bagabas@gmail.com>
---
 textarea/textarea.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/textarea/textarea.go b/textarea/textarea.go
index 57c4a8c5..3e5fc9b3 100644
--- a/textarea/textarea.go
+++ b/textarea/textarea.go
@@ -1412,7 +1412,7 @@ func Blink() tea.Msg {
 //
 //	// In your top-level View function:
 //	f := tea.NewFrame(m.textarea.View())
-//	f.Cursor = m.textarea.RealCursor()
+//	f.Cursor = m.textarea.Cursor()
 //	f.Cursor.Position.X += offsetX
 //	f.Cursor.Position.Y += offsetY
 //

From 58b94b31e8c034cea844c3171175cb56db283794 Mon Sep 17 00:00:00 2001
From: Christian Rocha <christian@rocha.is>
Date: Tue, 28 Jan 2025 12:58:40 -0500
Subject: [PATCH 10/22] fix(textarea): doc comment typo

Co-authored-by: Ayman Bagabas <ayman.bagabas@gmail.com>
---
 textarea/textarea.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/textarea/textarea.go b/textarea/textarea.go
index 3e5fc9b3..94d6909a 100644
--- a/textarea/textarea.go
+++ b/textarea/textarea.go
@@ -422,7 +422,7 @@ func (m *Model) SetStyles(s Styles) {
 	m.virtualCursor.Style = s.Focused.Cursor.Style
 	m.virtualCursor.BlinkedStyle = s.Focused.Cursor.BlinkedStyle
 
-	// By default, the blink speed of the cursor is set to a deafault
+	// By default, the blink speed of the cursor is set to a default
 	// internally.
 	if s.Focused.Cursor.BlinkSpeed > 0 {
 		m.virtualCursor.BlinkSpeed = m.activeStyle.Cursor.BlinkSpeed

From 0e5ff3c5c3900d7df1a349a3b7c0d56106055d2c Mon Sep 17 00:00:00 2001
From: Christian Rocha <christian@rocha.is>
Date: Tue, 28 Jan 2025 16:20:09 -0500
Subject: [PATCH 11/22] chore(textarea): rename Model.SetCursor to
 Model.SetCursorColumn

Set.CursorColumn sets the cursor column position. This change was made
for clarity.
---
 textarea/textarea.go | 48 ++++++++++++++++++++++----------------------
 1 file changed, 24 insertions(+), 24 deletions(-)

diff --git a/textarea/textarea.go b/textarea/textarea.go
index 94d6909a..5dd02d99 100644
--- a/textarea/textarea.go
+++ b/textarea/textarea.go
@@ -546,7 +546,7 @@ func (m *Model) insertRunesFromUserInput(runes []rune) {
 	// Finally add the tail at the end of the last line inserted.
 	m.value[m.row] = append(m.value[m.row], tail...)
 
-	m.SetCursor(m.col)
+	m.SetCursorColumn(m.col)
 }
 
 // Value returns the value of the text input.
@@ -654,9 +654,9 @@ func (m *Model) CursorUp() {
 	}
 }
 
-// SetCursor moves the cursor to the given position. If the position is
+// SetCursorColumn moves the cursor to the given position. If the position is
 // out of bounds the cursor will be moved to the start or end accordingly.
-func (m *Model) SetCursor(col int) {
+func (m *Model) SetCursorColumn(col int) {
 	m.col = clamp(col, 0, len(m.value[m.row]))
 	// Any time that we move the cursor horizontally we need to reset the last
 	// offset so that the horizontal position when navigating is adjusted.
@@ -665,12 +665,12 @@ func (m *Model) SetCursor(col int) {
 
 // CursorStart moves the cursor to the start of the input field.
 func (m *Model) CursorStart() {
-	m.SetCursor(0)
+	m.SetCursorColumn(0)
 }
 
 // CursorEnd moves the cursor to the end of the input field.
 func (m *Model) CursorEnd() {
-	m.SetCursor(len(m.value[m.row]))
+	m.SetCursorColumn(len(m.value[m.row]))
 }
 
 // Focused returns the focus state on the model.
@@ -700,7 +700,7 @@ func (m *Model) Reset() {
 	m.col = 0
 	m.row = 0
 	m.viewport.GotoTop()
-	m.SetCursor(0)
+	m.SetCursorColumn(0)
 }
 
 // san initializes or retrieves the rune sanitizer.
@@ -717,7 +717,7 @@ func (m *Model) san() runeutil.Sanitizer {
 // not the cursor blink should be reset.
 func (m *Model) deleteBeforeCursor() {
 	m.value[m.row] = m.value[m.row][m.col:]
-	m.SetCursor(0)
+	m.SetCursorColumn(0)
 }
 
 // deleteAfterCursor deletes all text after the cursor. Returns whether or not
@@ -725,7 +725,7 @@ func (m *Model) deleteBeforeCursor() {
 // the cursor so as not to reveal word breaks in the masked input.
 func (m *Model) deleteAfterCursor() {
 	m.value[m.row] = m.value[m.row][:m.col]
-	m.SetCursor(len(m.value[m.row]))
+	m.SetCursorColumn(len(m.value[m.row]))
 }
 
 // transposeLeft exchanges the runes at the cursor and immediately
@@ -737,11 +737,11 @@ func (m *Model) transposeLeft() {
 		return
 	}
 	if m.col >= len(m.value[m.row]) {
-		m.SetCursor(m.col - 1)
+		m.SetCursorColumn(m.col - 1)
 	}
 	m.value[m.row][m.col-1], m.value[m.row][m.col] = m.value[m.row][m.col], m.value[m.row][m.col-1]
 	if m.col < len(m.value[m.row]) {
-		m.SetCursor(m.col + 1)
+		m.SetCursorColumn(m.col + 1)
 	}
 }
 
@@ -757,22 +757,22 @@ func (m *Model) deleteWordLeft() {
 	// call into the corresponding if clause does not apply here.
 	oldCol := m.col //nolint:ifshort
 
-	m.SetCursor(m.col - 1)
+	m.SetCursorColumn(m.col - 1)
 	for unicode.IsSpace(m.value[m.row][m.col]) {
 		if m.col <= 0 {
 			break
 		}
 		// ignore series of whitespace before cursor
-		m.SetCursor(m.col - 1)
+		m.SetCursorColumn(m.col - 1)
 	}
 
 	for m.col > 0 {
 		if !unicode.IsSpace(m.value[m.row][m.col]) {
-			m.SetCursor(m.col - 1)
+			m.SetCursorColumn(m.col - 1)
 		} else {
 			if m.col > 0 {
 				// keep the previous space
-				m.SetCursor(m.col + 1)
+				m.SetCursorColumn(m.col + 1)
 			}
 			break
 		}
@@ -795,12 +795,12 @@ func (m *Model) deleteWordRight() {
 
 	for m.col < len(m.value[m.row]) && unicode.IsSpace(m.value[m.row][m.col]) {
 		// ignore series of whitespace after cursor
-		m.SetCursor(m.col + 1)
+		m.SetCursorColumn(m.col + 1)
 	}
 
 	for m.col < len(m.value[m.row]) {
 		if !unicode.IsSpace(m.value[m.row][m.col]) {
-			m.SetCursor(m.col + 1)
+			m.SetCursorColumn(m.col + 1)
 		} else {
 			break
 		}
@@ -812,13 +812,13 @@ func (m *Model) deleteWordRight() {
 		m.value[m.row] = append(m.value[m.row][:oldCol], m.value[m.row][m.col:]...)
 	}
 
-	m.SetCursor(oldCol)
+	m.SetCursorColumn(oldCol)
 }
 
 // characterRight moves the cursor one character to the right.
 func (m *Model) characterRight() {
 	if m.col < len(m.value[m.row]) {
-		m.SetCursor(m.col + 1)
+		m.SetCursorColumn(m.col + 1)
 	} else {
 		if m.row < len(m.value)-1 {
 			m.row++
@@ -839,7 +839,7 @@ func (m *Model) characterLeft(insideLine bool) {
 		}
 	}
 	if m.col > 0 {
-		m.SetCursor(m.col - 1)
+		m.SetCursorColumn(m.col - 1)
 	}
 }
 
@@ -858,7 +858,7 @@ func (m *Model) wordLeft() {
 		if unicode.IsSpace(m.value[m.row][m.col-1]) {
 			break
 		}
-		m.SetCursor(m.col - 1)
+		m.SetCursorColumn(m.col - 1)
 	}
 }
 
@@ -885,7 +885,7 @@ func (m *Model) doWordRight(fn func(charIdx int, pos int)) {
 			break
 		}
 		fn(charIdx, m.col)
-		m.SetCursor(m.col + 1)
+		m.SetCursorColumn(m.col + 1)
 		charIdx++
 	}
 }
@@ -975,13 +975,13 @@ func (m Model) Width() int {
 // moveToBegin moves the cursor to the beginning of the input.
 func (m *Model) moveToBegin() {
 	m.row = 0
-	m.SetCursor(0)
+	m.SetCursorColumn(0)
 }
 
 // moveToEnd moves the cursor to the end of the input.
 func (m *Model) moveToEnd() {
 	m.row = len(m.value) - 1
-	m.SetCursor(len(m.value[m.row]))
+	m.SetCursorColumn(len(m.value[m.row]))
 }
 
 // SetWidth sets the width of the textarea to fit exactly within the given width.
@@ -1104,7 +1104,7 @@ func (m Model) Update(msg tea.Msg) (Model, tea.Cmd) {
 			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)
+					m.SetCursorColumn(m.col - 1)
 				}
 			}
 		case key.Matches(msg, m.KeyMap.DeleteCharacterForward):

From eb985a2f8173d769f614bfede3962d70d7a2d2d6 Mon Sep 17 00:00:00 2001
From: Christian Rocha <christian@rocha.is>
Date: Tue, 28 Jan 2025 16:21:20 -0500
Subject: [PATCH 12/22] chore(textarea): improve cursor styling API

---
 textarea/textarea.go | 61 ++++++++++++++++++++------------------------
 1 file changed, 27 insertions(+), 34 deletions(-)

diff --git a/textarea/textarea.go b/textarea/textarea.go
index 5dd02d99..ea1a0342 100644
--- a/textarea/textarea.go
+++ b/textarea/textarea.go
@@ -154,9 +154,9 @@ type CursorStyle struct {
 	// CursorBlink determines whether or not the cursor should blink.
 	Blink bool
 
-	// BlinkSpeed is the speed at which the virtualcursor blinks. This has no
-	// effect on real cursors as well as no effect if the cursor is set not
-	// to [CursorBlink].
+	// BlinkSpeed is the speed at which the virtual cursor blinks. This has no
+	// effect on real cursors as well as no effect if the cursor is set not to
+	// [CursorBlink].
 	//
 	// By default, the blink speed is set to about 500ms.
 	BlinkSpeed time.Duration
@@ -168,6 +168,7 @@ type CursorStyle struct {
 type Styles struct {
 	Focused StyleState
 	Blurred StyleState
+	Cursor  CursorStyle
 }
 
 // StyleState that will be applied to the text area.
@@ -186,7 +187,6 @@ type StyleState struct {
 	Placeholder      lipgloss.Style
 	Prompt           lipgloss.Style
 	Text             lipgloss.Style
-	Cursor           CursorStyle
 }
 
 func (s StyleState) computedCursorLine() lipgloss.Style {
@@ -264,7 +264,7 @@ type Model struct {
 
 	// Styling. FocusedStyle and BlurredStyle are used to style the textarea in
 	// focused and blurred states.
-	styles Styles
+	Styles Styles
 
 	// activeStyle is the current styling to use.
 	// It is used to abstract the differences in focus state when styling the
@@ -345,7 +345,7 @@ func New() Model {
 		MaxHeight:            defaultMaxHeight,
 		MaxWidth:             defaultMaxWidth,
 		Prompt:               lipgloss.ThickBorder().Left + " ",
-		styles:               styles,
+		Styles:               styles,
 		activeStyle:          &styles.Blurred,
 		cache:                memoization.NewMemoCache[line, [][]rune](maxLines),
 		EndOfBufferCharacter: ' ',
@@ -383,9 +383,6 @@ func DefaultStyles(isDark bool) Styles {
 		Placeholder:      lipgloss.NewStyle().Foreground(lipgloss.Color("240")),
 		Prompt:           lipgloss.NewStyle().Foreground(lipgloss.Color("7")),
 		Text:             lipgloss.NewStyle(),
-		Cursor: CursorStyle{
-			Style: lipgloss.NewStyle().Foreground(lipgloss.Color("7")),
-		},
 	}
 	s.Blurred = StyleState{
 		Base:             lipgloss.NewStyle(),
@@ -397,6 +394,10 @@ func DefaultStyles(isDark bool) Styles {
 		Prompt:           lipgloss.NewStyle().Foreground(lipgloss.Color("7")),
 		Text:             lipgloss.NewStyle().Foreground(lightDark(lipgloss.Color("245"), lipgloss.Color("7"))),
 	}
+	s.Cursor = CursorStyle{
+		Style: lipgloss.NewStyle().Foreground(lipgloss.Color("7")),
+		Blink: true,
+	}
 	return s
 }
 
@@ -410,40 +411,34 @@ func DefaultDarkStyles() Styles {
 	return DefaultStyles(true)
 }
 
-// SetStyles sets the styles for the textarea.
-func (m *Model) SetStyles(s Styles) {
-	m.styles = s
-	if m.focus {
-		m.activeStyle = &m.styles.Focused
-	} else {
-		m.activeStyle = &m.styles.Blurred
+// updateVirtualCursorStyle sets styling on the virtual cursor based on the
+// textarea's style settings.
+func (m *Model) updateVirtualCursorStyle() {
+	if !m.VirtualCursor {
+		m.virtualCursor.SetMode(cursor.CursorHide)
+		return
 	}
 
-	m.virtualCursor.Style = s.Focused.Cursor.Style
-	m.virtualCursor.BlinkedStyle = s.Focused.Cursor.BlinkedStyle
+	m.virtualCursor.Style = m.Styles.Cursor.Style
+	m.virtualCursor.BlinkedStyle = m.Styles.Cursor.BlinkedStyle
 
 	// By default, the blink speed of the cursor is set to a default
 	// internally.
-	if s.Focused.Cursor.BlinkSpeed > 0 {
-		m.virtualCursor.BlinkSpeed = m.activeStyle.Cursor.BlinkSpeed
+	if m.Styles.Cursor.BlinkSpeed > 0 {
+		m.virtualCursor.BlinkSpeed = m.Styles.Cursor.BlinkSpeed
 	}
 
 	if !m.VirtualCursor {
 		m.virtualCursor.SetMode(cursor.CursorHide)
 		return
 	}
-	if s.Focused.Cursor.Blink {
+	if m.Styles.Cursor.Blink {
 		m.virtualCursor.SetMode(cursor.CursorBlink)
 		return
 	}
 	m.virtualCursor.SetMode(cursor.CursorStatic)
 }
 
-// Styles returns the styles for the textarea.
-func (m Model) Styles() Styles {
-	return m.styles
-}
-
 // SetValue sets the value of the text input.
 func (m *Model) SetValue(s string) {
 	m.Reset()
@@ -682,7 +677,7 @@ func (m Model) Focused() bool {
 // receive keyboard input and the cursor will be hidden.
 func (m *Model) Focus() tea.Cmd {
 	m.focus = true
-	m.activeStyle = &m.styles.Focused
+	m.activeStyle = &m.Styles.Focused
 	return m.virtualCursor.Focus()
 }
 
@@ -690,7 +685,7 @@ func (m *Model) Focus() tea.Cmd {
 // not receive keyboard input and the cursor will be hidden.
 func (m *Model) Blur() {
 	m.focus = false
-	m.activeStyle = &m.styles.Blurred
+	m.activeStyle = &m.Styles.Blurred
 	m.virtualCursor.Blur()
 }
 
@@ -1195,6 +1190,7 @@ func (m Model) Update(msg tea.Msg) (Model, tea.Cmd) {
 
 // View renders the text area in its current state.
 func (m Model) View() string {
+	m.updateVirtualCursorStyle()
 	if m.Value() == "" && m.row == 0 && m.col == 0 && m.Placeholder != "" {
 		return m.placeholderView()
 	}
@@ -1422,16 +1418,13 @@ func Blink() tea.Msg {
 // If you're using a real cursor, you should also set [Model.VirtualCursor] to
 // false.
 func (m Model) Cursor() *tea.Cursor {
-	if m.VirtualCursor || !m.Focused() {
-		return nil
-	}
-
 	lineInfo := m.LineInfo()
 	x, y := lineInfo.CharOffset, m.cursorLineNumber()-m.viewport.YOffset
 
 	c := tea.NewCursor(x, y)
-	c.Blink = m.styles.Focused.Cursor.Blink
-	c.Color = m.styles.Focused.Cursor.Style.GetForeground()
+	c.Blink = m.Styles.Cursor.Blink
+	c.Color = m.Styles.Cursor.Style.GetForeground()
+	c.Shape = m.Styles.Cursor.Shape
 	return c
 }
 

From 1fd9c2666a335d96e6146bbcb6c72ac793a8eede Mon Sep 17 00:00:00 2001
From: Christian Rocha <christian@rocha.is>
Date: Tue, 28 Jan 2025 22:06:47 -0500
Subject: [PATCH 13/22] chore(textarea,cursor): simplify cursor API

---
 cursor/cursor.go       |  8 ++++----
 textarea/textarea.go   | 20 ++++++++------------
 textinput/textinput.go |  4 ++--
 3 files changed, 14 insertions(+), 18 deletions(-)

diff --git a/cursor/cursor.go b/cursor/cursor.go
index 33d29465..824b4503 100644
--- a/cursor/cursor.go
+++ b/cursor/cursor.go
@@ -56,15 +56,15 @@ type Model struct {
 	// Style styles the cursor block.
 	Style lipgloss.Style
 
-	// BlinkedStyle is the style used for the cursor when it is blinking
+	// TextStyle is the style used for the cursor when it is blinking
 	// (hidden), i.e. displaying normal text.
-	BlinkedStyle lipgloss.Style
+	TextStyle lipgloss.Style
 
 	// BlinkSpeed is the speed at which the cursor blinks. This has no effect
 	// unless [CursorMode] is not set to [CursorBlink].
 	BlinkSpeed time.Duration
 
-	// Blink is the cursor blink state.
+	// Blink is the state of the cursor blink. When true, the cursor is hidden.
 	Blink bool
 
 	// char is the character under the cursor
@@ -224,7 +224,7 @@ func (m *Model) SetChar(char string) {
 // View displays the cursor.
 func (m Model) View() string {
 	if m.Blink {
-		return m.BlinkedStyle.Inline(true).Render(m.char)
+		return m.TextStyle.Inline(true).Render(m.char)
 	}
 	return m.Style.Inline(true).Reverse(true).Render(m.char)
 }
diff --git a/textarea/textarea.go b/textarea/textarea.go
index ea1a0342..f57faaf7 100644
--- a/textarea/textarea.go
+++ b/textarea/textarea.go
@@ -3,6 +3,7 @@ package textarea
 import (
 	"crypto/sha256"
 	"fmt"
+	"image/color"
 	"strconv"
 	"strings"
 	"time"
@@ -135,12 +136,7 @@ type CursorStyle struct {
 	//
 	// For real cursors, the foreground color set here will be used as the
 	// cursor color.
-	Style lipgloss.Style
-
-	// BlinkedStyle is the style used for the cursor when it is blinking
-	// (hidden), i.e. displaying normal text. This is only used for virtual
-	// cursors.
-	BlinkedStyle lipgloss.Style
+	Color color.Color
 
 	// Shape is the cursor shape. The following shapes are available:
 	//
@@ -395,7 +391,8 @@ func DefaultStyles(isDark bool) Styles {
 		Text:             lipgloss.NewStyle().Foreground(lightDark(lipgloss.Color("245"), lipgloss.Color("7"))),
 	}
 	s.Cursor = CursorStyle{
-		Style: lipgloss.NewStyle().Foreground(lipgloss.Color("7")),
+		Color: lipgloss.Color("7"),
+		Shape: tea.CursorBlock,
 		Blink: true,
 	}
 	return s
@@ -419,8 +416,7 @@ func (m *Model) updateVirtualCursorStyle() {
 		return
 	}
 
-	m.virtualCursor.Style = m.Styles.Cursor.Style
-	m.virtualCursor.BlinkedStyle = m.Styles.Cursor.BlinkedStyle
+	m.virtualCursor.Style = lipgloss.NewStyle().Foreground(m.Styles.Cursor.Color)
 
 	// By default, the blink speed of the cursor is set to a default
 	// internally.
@@ -1194,7 +1190,7 @@ func (m Model) View() string {
 	if m.Value() == "" && m.row == 0 && m.col == 0 && m.Placeholder != "" {
 		return m.placeholderView()
 	}
-	m.virtualCursor.BlinkedStyle = m.activeStyle.computedCursorLine()
+	m.virtualCursor.TextStyle = m.activeStyle.computedCursorLine()
 
 	var (
 		s                strings.Builder
@@ -1370,7 +1366,7 @@ func (m Model) placeholderView() string {
 		// first line
 		case i == 0:
 			// first character of first line as cursor with character
-			m.virtualCursor.BlinkedStyle = m.activeStyle.computedPlaceholder()
+			m.virtualCursor.TextStyle = m.activeStyle.computedPlaceholder()
 			m.virtualCursor.SetChar(string(plines[0][0]))
 			s.WriteString(lineStyle.Render(m.virtualCursor.View()))
 
@@ -1423,7 +1419,7 @@ func (m Model) Cursor() *tea.Cursor {
 
 	c := tea.NewCursor(x, y)
 	c.Blink = m.Styles.Cursor.Blink
-	c.Color = m.Styles.Cursor.Style.GetForeground()
+	c.Color = m.Styles.Cursor.Color
 	c.Shape = m.Styles.Cursor.Shape
 	return c
 }
diff --git a/textinput/textinput.go b/textinput/textinput.go
index b98d00b1..92c468ac 100644
--- a/textinput/textinput.go
+++ b/textinput/textinput.go
@@ -671,7 +671,7 @@ func (m Model) View() string {
 		if m.canAcceptSuggestion() {
 			suggestion := m.matchedSuggestions[m.currentSuggestionIndex]
 			if len(value) < len(suggestion) {
-				m.Cursor.BlinkedStyle = m.CompletionStyle
+				m.Cursor.TextStyle = m.CompletionStyle
 				m.Cursor.SetChar(m.echoTransform(string(suggestion[pos])))
 				v += m.Cursor.View()
 				v += m.completionView(1)
@@ -709,7 +709,7 @@ func (m Model) placeholderView() string {
 	p := make([]rune, m.Width()+1)
 	copy(p, []rune(m.Placeholder))
 
-	m.Cursor.BlinkedStyle = m.PlaceholderStyle
+	m.Cursor.TextStyle = m.PlaceholderStyle
 	m.Cursor.SetChar(string(p[:1]))
 	v += m.Cursor.View()
 

From ad8e4bf48011a258a027ef9c7e58781fba6b285b Mon Sep 17 00:00:00 2001
From: Christian Rocha <christian@rocha.is>
Date: Tue, 28 Jan 2025 22:12:24 -0500
Subject: [PATCH 14/22] chore(textarea): improve comments, note ares that need
 attention

---
 textarea/textarea.go | 24 +++++++++++++-----------
 1 file changed, 13 insertions(+), 11 deletions(-)

diff --git a/textarea/textarea.go b/textarea/textarea.go
index f57faaf7..226c45ad 100644
--- a/textarea/textarea.go
+++ b/textarea/textarea.go
@@ -241,7 +241,7 @@ type Model struct {
 	// When changing the value of Prompt after the model has been
 	// initialized, ensure that SetWidth() gets called afterwards.
 	//
-	// See also SetPromptFunc().
+	// See also [SetPromptFunc] for a dynamic prompt.
 	Prompt string
 
 	// Placeholder is the text displayed when the user
@@ -983,9 +983,11 @@ func (m *Model) moveToEnd() {
 // It is important that the width of the textarea be exactly the given width
 // and no more.
 func (m *Model) SetWidth(w int) {
-	// Update prompt width only if there is no prompt function as SetPromptFunc
-	// updates the prompt width when it is called.
+	// Update prompt width only if there is no prompt function as
+	// [SetPromptFunc] updates the prompt width when it is called.
 	if m.promptFunc == nil {
+		// XXX: This should account for a styled prompt and use lipglosss.Width
+		// instead of uniseg.StringWidth.
 		m.promptWidth = uniseg.StringWidth(m.Prompt)
 	}
 
@@ -997,6 +999,7 @@ func (m *Model) SetWidth(w int) {
 
 	// Add line number width to reserved inner width.
 	if m.ShowLineNumbers {
+		// XXX: this should almost certainly not be hardcoded.
 		const lnWidth = 4 // Up to 3 digits for line number plus 1 margin.
 		reservedInner += lnWidth
 	}
@@ -1019,14 +1022,13 @@ func (m *Model) SetWidth(w int) {
 	m.width = inputWidth - reservedOuter - reservedInner
 }
 
-// SetPromptFunc supersedes the Prompt field and sets a dynamic prompt
-// instead.
-// If the function returns a prompt that is shorter than the
-// specified promptWidth, it will be padded to the left.
-// If it returns a prompt that is longer, display artifacts
-// may occur; the caller is responsible for computing an adequate
-// promptWidth.
-func (m *Model) SetPromptFunc(promptWidth int, fn func(lineIdx int) string) {
+// SetPromptFunc supersedes the Prompt field and sets a dynamic prompt instead.
+//
+// If the function returns a prompt that is shorter than the specified
+// promptWidth, it will be padded to the left. If it returns a prompt that is
+// longer, display artifacts may occur; the caller is responsible for computing
+// an adequate promptWidth.
+func (m *Model) SetPromptFunc(promptWidth int, fn func(lineIndex int) string) {
 	m.promptFunc = fn
 	m.promptWidth = promptWidth
 }

From 24016e6ce4ed255c0c4b5249b97bf25936cea294 Mon Sep 17 00:00:00 2001
From: Christian Rocha <christian@rocha.is>
Date: Thu, 30 Jan 2025 12:15:27 -0500
Subject: [PATCH 15/22] chore(textarea): consolidate line number rendering into
 a method

---
 textarea/textarea.go | 80 +++++++++++++++++++++++++++-----------------
 1 file changed, 50 insertions(+), 30 deletions(-)

diff --git a/textarea/textarea.go b/textarea/textarea.go
index 226c45ad..2e5b0c4d 100644
--- a/textarea/textarea.go
+++ b/textarea/textarea.go
@@ -176,13 +176,13 @@ type Styles struct {
 // https://github.com/charmbracelet/lipgloss
 type StyleState struct {
 	Base             lipgloss.Style
-	CursorLine       lipgloss.Style
+	Text             lipgloss.Style
+	LineNumber       lipgloss.Style
 	CursorLineNumber lipgloss.Style
+	CursorLine       lipgloss.Style
 	EndOfBuffer      lipgloss.Style
-	LineNumber       lipgloss.Style
 	Placeholder      lipgloss.Style
 	Prompt           lipgloss.Style
-	Text             lipgloss.Style
 }
 
 func (s StyleState) computedCursorLine() lipgloss.Style {
@@ -1220,22 +1220,12 @@ func (m Model) View() string {
 
 			var ln string
 			if m.ShowLineNumbers { //nolint:nestif
-				if wl == 0 {
-					if m.row == l {
-						ln = style.Render(m.activeStyle.computedCursorLineNumber().Render(m.formatLineNumber(l + 1)))
-						s.WriteString(ln)
-					} else {
-						ln = style.Render(m.activeStyle.computedLineNumber().Render(m.formatLineNumber(l + 1)))
-						s.WriteString(ln)
-					}
-				} else {
-					if m.row == l {
-						ln = style.Render(m.activeStyle.computedCursorLineNumber().Render(m.formatLineNumber(" ")))
-						s.WriteString(ln)
-					} else {
-						ln = style.Render(m.activeStyle.computedLineNumber().Render(m.formatLineNumber(" ")))
-						s.WriteString(ln)
-					}
+				if wl == 0 { // normal line
+					isCursorLine := m.row == l
+					s.WriteString(m.lineNumberView(l+1, isCursorLine))
+				} else { // soft wrapped line
+					isCursorLine := m.row == l
+					s.WriteString(m.lineNumberView(-1, isCursorLine))
 				}
 			}
 
@@ -1297,13 +1287,42 @@ func (m Model) View() string {
 	return m.activeStyle.Base.Render(m.viewport.View())
 }
 
-// formatLineNumber formats the line number for display dynamically based on
-// the maximum number of lines.
-func (m Model) formatLineNumber(x any) string {
-	// XXX: ultimately we should use a max buffer height, which has yet to be
-	// implemented.
+// promptView returns the prompt for a single line (as prompts are applited to
+// each line).
+func (m Model) promptView() string {
+	return ""
+}
+
+// lineNumberView returns the line number.
+//
+// If the argument is less than 0, a space styled as a line number is returned
+// instead. Such cases are used for soft-wrapped lines.
+//
+// The second argument indicates whether this line number is for a 'cursorline'
+// line number.
+func (m Model) lineNumberView(n int, isCursorLine bool) (str string) {
+	if !m.ShowLineNumbers {
+		return ""
+	}
+
+	if n < 0 {
+		str = " "
+	} else {
+		str = strconv.Itoa(n)
+	}
+
+	textStyle := m.activeStyle.computedText()
+	lineNumberStyle := m.activeStyle.computedLineNumber()
+	if isCursorLine {
+		textStyle = m.activeStyle.computedCursorLine()
+		lineNumberStyle = m.activeStyle.computedCursorLineNumber()
+	}
+
+	// Format line number dynamically based on the maximum number of lines.
 	digits := len(strconv.Itoa(m.MaxHeight))
-	return fmt.Sprintf(" %*v ", digits, x)
+	str = fmt.Sprintf(" %*v ", digits, str)
+
+	return textStyle.Render(lineNumberStyle.Render(str))
 }
 
 func (m Model) getPromptString(displayLine int) (prompt string) {
@@ -1335,11 +1354,12 @@ func (m Model) placeholderView() string {
 	plines := strings.Split(strings.TrimSpace(pwrap), "\n")
 
 	for i := 0; i < m.height; i++ {
+		isLineNumber := len(plines) > i
+
+		// XXX: This will go.
 		lineStyle := m.activeStyle.computedPlaceholder()
-		lineNumberStyle := m.activeStyle.computedLineNumber()
 		if len(plines) > i {
 			lineStyle = m.activeStyle.computedCursorLine()
-			lineNumberStyle = m.activeStyle.computedCursorLineNumber()
 		}
 
 		// render prompt
@@ -1352,14 +1372,14 @@ func (m Model) placeholderView() string {
 		// - indent other placeholder lines
 		// this is consistent with vim with line numbers enabled
 		if m.ShowLineNumbers {
-			var ln string
+			var ln int
 
 			switch {
 			case i == 0:
-				ln = strconv.Itoa(i + 1)
+				ln = i + 1
 				fallthrough
 			case len(plines) > i:
-				s.WriteString(lineStyle.Render(lineNumberStyle.Render(m.formatLineNumber(ln))))
+				s.WriteString(m.lineNumberView(ln, isLineNumber))
 			default:
 			}
 		}

From de97754f09d6d29e81a4f0fb90c3c332edafd83a Mon Sep 17 00:00:00 2001
From: Christian Rocha <christian@rocha.is>
Date: Thu, 30 Jan 2025 12:26:51 -0500
Subject: [PATCH 16/22] fix(textarea): infer if we should use focused or
 blurred styles

---
 textarea/textarea.go | 69 +++++++++++++++++++++++---------------------
 1 file changed, 36 insertions(+), 33 deletions(-)

diff --git a/textarea/textarea.go b/textarea/textarea.go
index 2e5b0c4d..d29c671a 100644
--- a/textarea/textarea.go
+++ b/textarea/textarea.go
@@ -262,12 +262,6 @@ type Model struct {
 	// focused and blurred states.
 	Styles Styles
 
-	// activeStyle is the current styling to use.
-	// It is used to abstract the differences in focus state when styling the
-	// model, since we can simply assign the set of activeStyle to this variable
-	// when switching focus states.
-	activeStyle *StyleState
-
 	// virtualCursor manages the virtual cursor.
 	virtualCursor cursor.Model
 
@@ -342,7 +336,6 @@ func New() Model {
 		MaxWidth:             defaultMaxWidth,
 		Prompt:               lipgloss.ThickBorder().Left + " ",
 		Styles:               styles,
-		activeStyle:          &styles.Blurred,
 		cache:                memoization.NewMemoCache[line, [][]rune](maxLines),
 		EndOfBufferCharacter: ' ',
 		ShowLineNumbers:      true,
@@ -669,11 +662,19 @@ func (m Model) Focused() bool {
 	return m.focus
 }
 
+// activeStyle returns the appropriate set of styles to use depending on
+// whether the textarea is focused or blurred.
+func (m Model) activeStyle() *StyleState {
+	if m.focus {
+		return &m.Styles.Focused
+	}
+	return &m.Styles.Blurred
+}
+
 // Focus sets the focus state on the model. When the model is in focus it can
 // receive keyboard input and the cursor will be hidden.
 func (m *Model) Focus() tea.Cmd {
 	m.focus = true
-	m.activeStyle = &m.Styles.Focused
 	return m.virtualCursor.Focus()
 }
 
@@ -681,7 +682,6 @@ func (m *Model) Focus() tea.Cmd {
 // not receive keyboard input and the cursor will be hidden.
 func (m *Model) Blur() {
 	m.focus = false
-	m.activeStyle = &m.Styles.Blurred
 	m.virtualCursor.Blur()
 }
 
@@ -992,7 +992,7 @@ func (m *Model) SetWidth(w int) {
 	}
 
 	// Add base style borders and padding to reserved outer width.
-	reservedOuter := m.activeStyle.Base.GetHorizontalFrameSize()
+	reservedOuter := m.activeStyle().Base.GetHorizontalFrameSize()
 
 	// Add prompt width to reserved inner width.
 	reservedInner := m.promptWidth
@@ -1192,7 +1192,7 @@ func (m Model) View() string {
 	if m.Value() == "" && m.row == 0 && m.col == 0 && m.Placeholder != "" {
 		return m.placeholderView()
 	}
-	m.virtualCursor.TextStyle = m.activeStyle.computedCursorLine()
+	m.virtualCursor.TextStyle = m.activeStyle().computedCursorLine()
 
 	var (
 		s                strings.Builder
@@ -1200,6 +1200,7 @@ func (m Model) View() string {
 		newLines         int
 		widestLineNumber int
 		lineInfo         = m.LineInfo()
+		styles           = m.activeStyle()
 	)
 
 	displayLine := 0
@@ -1207,14 +1208,14 @@ func (m Model) View() string {
 		wrappedLines := m.memoizedWrap(line, m.width)
 
 		if m.row == l {
-			style = m.activeStyle.computedCursorLine()
+			style = styles.computedCursorLine()
 		} else {
-			style = m.activeStyle.computedText()
+			style = styles.computedText()
 		}
 
 		for wl, wrappedLine := range wrappedLines {
 			prompt := m.getPromptString(displayLine)
-			prompt = m.activeStyle.computedPrompt().Render(prompt)
+			prompt = styles.computedPrompt().Render(prompt)
 			s.WriteString(style.Render(prompt))
 			displayLine++
 
@@ -1271,7 +1272,7 @@ func (m Model) View() string {
 	// To do this we can simply pad out a few extra new lines in the view.
 	for i := 0; i < m.height; i++ {
 		prompt := m.getPromptString(displayLine)
-		prompt = m.activeStyle.computedPrompt().Render(prompt)
+		prompt = styles.computedPrompt().Render(prompt)
 		s.WriteString(prompt)
 		displayLine++
 
@@ -1279,12 +1280,12 @@ func (m Model) View() string {
 		leftGutter := string(m.EndOfBufferCharacter)
 		rightGapWidth := m.Width() - lipgloss.Width(leftGutter) + widestLineNumber
 		rightGap := strings.Repeat(" ", max(0, rightGapWidth))
-		s.WriteString(m.activeStyle.computedEndOfBuffer().Render(leftGutter + rightGap))
+		s.WriteString(styles.computedEndOfBuffer().Render(leftGutter + rightGap))
 		s.WriteRune('\n')
 	}
 
 	m.viewport.SetContent(s.String())
-	return m.activeStyle.Base.Render(m.viewport.View())
+	return styles.Base.Render(m.viewport.View())
 }
 
 // promptView returns the prompt for a single line (as prompts are applited to
@@ -1305,17 +1306,18 @@ func (m Model) lineNumberView(n int, isCursorLine bool) (str string) {
 		return ""
 	}
 
-	if n < 0 {
+	if n <= 0 {
 		str = " "
 	} else {
 		str = strconv.Itoa(n)
 	}
 
-	textStyle := m.activeStyle.computedText()
-	lineNumberStyle := m.activeStyle.computedLineNumber()
+	// XXX: is textStyle really necessary here?
+	textStyle := m.activeStyle().computedText()
+	lineNumberStyle := m.activeStyle().computedLineNumber()
 	if isCursorLine {
-		textStyle = m.activeStyle.computedCursorLine()
-		lineNumberStyle = m.activeStyle.computedCursorLineNumber()
+		textStyle = m.activeStyle().computedCursorLine()
+		lineNumberStyle = m.activeStyle().computedCursorLineNumber()
 	}
 
 	// Format line number dynamically based on the maximum number of lines.
@@ -1341,9 +1343,10 @@ func (m Model) getPromptString(displayLine int) (prompt string) {
 // placeholderView returns the prompt and placeholder view, if any.
 func (m Model) placeholderView() string {
 	var (
-		s     strings.Builder
-		p     = m.Placeholder
-		style = m.activeStyle.computedPlaceholder()
+		s      strings.Builder
+		p      = m.Placeholder
+		styles = m.activeStyle()
+		// placeholderStyle = m.activeStyle().computedPlaceholder()
 	)
 
 	// word wrap lines
@@ -1357,14 +1360,14 @@ func (m Model) placeholderView() string {
 		isLineNumber := len(plines) > i
 
 		// XXX: This will go.
-		lineStyle := m.activeStyle.computedPlaceholder()
+		lineStyle := m.activeStyle().computedPlaceholder()
 		if len(plines) > i {
-			lineStyle = m.activeStyle.computedCursorLine()
+			lineStyle = m.activeStyle().computedCursorLine()
 		}
 
 		// render prompt
 		prompt := m.getPromptString(i)
-		prompt = m.activeStyle.computedPrompt().Render(prompt)
+		prompt = styles.computedPrompt().Render(prompt)
 		s.WriteString(lineStyle.Render(prompt))
 
 		// when show line numbers enabled:
@@ -1388,21 +1391,21 @@ func (m Model) placeholderView() string {
 		// first line
 		case i == 0:
 			// first character of first line as cursor with character
-			m.virtualCursor.TextStyle = m.activeStyle.computedPlaceholder()
+			m.virtualCursor.TextStyle = styles.computedPlaceholder()
 			m.virtualCursor.SetChar(string(plines[0][0]))
 			s.WriteString(lineStyle.Render(m.virtualCursor.View()))
 
 			// the rest of the first line
-			s.WriteString(lineStyle.Render(style.Render(plines[0][1:] + strings.Repeat(" ", max(0, m.width-uniseg.StringWidth(plines[0]))))))
+			s.WriteString(lineStyle.Render(plines[0][1:] + strings.Repeat(" ", max(0, m.width-uniseg.StringWidth(plines[0])))))
 		// remaining lines
 		case len(plines) > i:
 			// current line placeholder text
 			if len(plines) > i {
-				s.WriteString(lineStyle.Render(style.Render(plines[i] + strings.Repeat(" ", max(0, m.width-uniseg.StringWidth(plines[i]))))))
+				s.WriteString(lineStyle.Render(plines[i] + strings.Repeat(" ", max(0, m.width-uniseg.StringWidth(plines[i])))))
 			}
 		default:
 			// end of line buffer character
-			eob := m.activeStyle.computedEndOfBuffer().Render(string(m.EndOfBufferCharacter))
+			eob := styles.computedEndOfBuffer().Render(string(m.EndOfBufferCharacter))
 			s.WriteString(eob)
 		}
 
@@ -1411,7 +1414,7 @@ func (m Model) placeholderView() string {
 	}
 
 	m.viewport.SetContent(s.String())
-	return m.activeStyle.Base.Render(m.viewport.View())
+	return styles.Base.Render(m.viewport.View())
 }
 
 // Blink returns the blink command for the virtual cursor.

From 63fb8c67e788b7f60216aef015d2408578f2e25f Mon Sep 17 00:00:00 2001
From: Christian Rocha <christian@rocha.is>
Date: Thu, 30 Jan 2025 13:50:25 -0500
Subject: [PATCH 17/22] fix(textarea): don't hardcode line number gutter width

---
 textarea/textarea.go | 34 +++++++++++++++++++++++++++++++---
 1 file changed, 31 insertions(+), 3 deletions(-)

diff --git a/textarea/textarea.go b/textarea/textarea.go
index d29c671a..6f6a8716 100644
--- a/textarea/textarea.go
+++ b/textarea/textarea.go
@@ -988,6 +988,9 @@ func (m *Model) SetWidth(w int) {
 	if m.promptFunc == nil {
 		// XXX: This should account for a styled prompt and use lipglosss.Width
 		// instead of uniseg.StringWidth.
+		//
+		// XXX: Do we even need this or can we calculate the prompt width
+		// at render time?
 		m.promptWidth = uniseg.StringWidth(m.Prompt)
 	}
 
@@ -999,9 +1002,13 @@ func (m *Model) SetWidth(w int) {
 
 	// Add line number width to reserved inner width.
 	if m.ShowLineNumbers {
-		// XXX: this should almost certainly not be hardcoded.
-		const lnWidth = 4 // Up to 3 digits for line number plus 1 margin.
-		reservedInner += lnWidth
+		// XXX: this was originally documented as needing "1 cell" but was,
+		// in practice, hardcoded to effectively 2 cells. We can, and should,
+		// reduce this to one gap and update the tests accordingly.
+		const gap = 2
+
+		// Number of digits plus 1 cell for the margin.
+		reservedInner += numDigits(m.MaxHeight) + gap
 	}
 
 	// Input width must be at least one more than the reserved inner and outer
@@ -1610,6 +1617,20 @@ func repeatSpaces(n int) []rune {
 	return []rune(strings.Repeat(string(' '), n))
 }
 
+// numDigits returns the number of digits in an integer.
+func numDigits(n int) int {
+	if n == 0 {
+		return 1
+	}
+	count := 0
+	num := abs(n)
+	for num > 0 {
+		count++
+		num /= 10
+	}
+	return count
+}
+
 func clamp(v, low, high int) int {
 	if high < low {
 		low, high = high, low
@@ -1630,3 +1651,10 @@ func max(a, b int) int {
 	}
 	return b
 }
+
+func abs(n int) int {
+	if n < 0 {
+		return -n
+	}
+	return n
+}

From a6b8a4559cadffcf8733946efbfe71835995aa84 Mon Sep 17 00:00:00 2001
From: Christian Rocha <christian@rocha.is>
Date: Thu, 30 Jan 2025 17:09:22 -0500
Subject: [PATCH 18/22] chore(textarea): consolidate prompt rendering in a
 method

---
 textarea/textarea.go | 40 +++++++++++++++++-----------------------
 1 file changed, 17 insertions(+), 23 deletions(-)

diff --git a/textarea/textarea.go b/textarea/textarea.go
index 6f6a8716..29a1fc5c 100644
--- a/textarea/textarea.go
+++ b/textarea/textarea.go
@@ -1221,7 +1221,7 @@ func (m Model) View() string {
 		}
 
 		for wl, wrappedLine := range wrappedLines {
-			prompt := m.getPromptString(displayLine)
+			prompt := m.promptView(displayLine)
 			prompt = styles.computedPrompt().Render(prompt)
 			s.WriteString(style.Render(prompt))
 			displayLine++
@@ -1278,9 +1278,7 @@ func (m Model) View() string {
 	// Always show at least `m.Height` lines at all times.
 	// To do this we can simply pad out a few extra new lines in the view.
 	for i := 0; i < m.height; i++ {
-		prompt := m.getPromptString(displayLine)
-		prompt = styles.computedPrompt().Render(prompt)
-		s.WriteString(prompt)
+		s.WriteString(m.promptView(displayLine))
 		displayLine++
 
 		// Write end of buffer content
@@ -1295,13 +1293,22 @@ func (m Model) View() string {
 	return styles.Base.Render(m.viewport.View())
 }
 
-// promptView returns the prompt for a single line (as prompts are applited to
-// each line).
-func (m Model) promptView() string {
-	return ""
+// promptView renders a single line of the prompt.
+func (m Model) promptView(displayLine int) (prompt string) {
+	prompt = m.Prompt
+	if m.promptFunc == nil {
+		return prompt
+	}
+	prompt = m.promptFunc(displayLine)
+	width := lipgloss.Width(prompt)
+	if width < m.promptWidth {
+		prompt = fmt.Sprintf("%*s%s", m.promptWidth-width, "", prompt)
+	}
+
+	return m.activeStyle().computedPrompt().Render(prompt)
 }
 
-// lineNumberView returns the line number.
+// lineNumberView renders the line number.
 //
 // If the argument is less than 0, a space styled as a line number is returned
 // instead. Such cases are used for soft-wrapped lines.
@@ -1334,19 +1341,6 @@ func (m Model) lineNumberView(n int, isCursorLine bool) (str string) {
 	return textStyle.Render(lineNumberStyle.Render(str))
 }
 
-func (m Model) getPromptString(displayLine int) (prompt string) {
-	prompt = m.Prompt
-	if m.promptFunc == nil {
-		return prompt
-	}
-	prompt = m.promptFunc(displayLine)
-	pl := uniseg.StringWidth(prompt)
-	if pl < m.promptWidth {
-		prompt = fmt.Sprintf("%*s%s", m.promptWidth-pl, "", prompt)
-	}
-	return prompt
-}
-
 // placeholderView returns the prompt and placeholder view, if any.
 func (m Model) placeholderView() string {
 	var (
@@ -1373,7 +1367,7 @@ func (m Model) placeholderView() string {
 		}
 
 		// render prompt
-		prompt := m.getPromptString(i)
+		prompt := m.promptView(i)
 		prompt = styles.computedPrompt().Render(prompt)
 		s.WriteString(lineStyle.Render(prompt))
 

From 78262b85c33b65c33ab4c5cd482f8f14bfaaceb4 Mon Sep 17 00:00:00 2001
From: Christian Rocha <christian@rocha.is>
Date: Thu, 30 Jan 2025 17:47:17 -0500
Subject: [PATCH 19/22] chore(textarea): make placeholder rendering more
 readable

---
 textarea/textarea.go | 20 +++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

diff --git a/textarea/textarea.go b/textarea/textarea.go
index 29a1fc5c..afb597af 100644
--- a/textarea/textarea.go
+++ b/textarea/textarea.go
@@ -1341,18 +1341,16 @@ func (m Model) lineNumberView(n int, isCursorLine bool) (str string) {
 	return textStyle.Render(lineNumberStyle.Render(str))
 }
 
-// placeholderView returns the prompt and placeholder view, if any.
+// placeholderView returns the prompt and placeholder, if any.
 func (m Model) placeholderView() string {
 	var (
 		s      strings.Builder
 		p      = m.Placeholder
 		styles = m.activeStyle()
-		// placeholderStyle = m.activeStyle().computedPlaceholder()
 	)
-
 	// word wrap lines
 	pwordwrap := ansi.Wordwrap(p, m.width, "")
-	// wrap lines (handles lines that could not be word wrapped)
+	// hard wrap lines (handles lines that could not be word wrapped)
 	pwrap := ansi.Hardwrap(pwordwrap, m.width, true)
 	// split string by new lines
 	plines := strings.Split(strings.TrimSpace(pwrap), "\n")
@@ -1360,10 +1358,9 @@ func (m Model) placeholderView() string {
 	for i := 0; i < m.height; i++ {
 		isLineNumber := len(plines) > i
 
-		// XXX: This will go.
-		lineStyle := m.activeStyle().computedPlaceholder()
+		lineStyle := styles.computedPlaceholder()
 		if len(plines) > i {
-			lineStyle = m.activeStyle().computedCursorLine()
+			lineStyle = styles.computedCursorLine()
 		}
 
 		// render prompt
@@ -1397,12 +1394,17 @@ func (m Model) placeholderView() string {
 			s.WriteString(lineStyle.Render(m.virtualCursor.View()))
 
 			// the rest of the first line
-			s.WriteString(lineStyle.Render(plines[0][1:] + strings.Repeat(" ", max(0, m.width-uniseg.StringWidth(plines[0])))))
+			placeholderTail := plines[0][1:]
+			gap := strings.Repeat(" ", max(0, m.width-uniseg.StringWidth(plines[0])))
+			renderedPlaceholder := styles.computedPlaceholder().Render(placeholderTail + gap)
+			s.WriteString(lineStyle.Render(renderedPlaceholder))
 		// remaining lines
 		case len(plines) > i:
 			// current line placeholder text
 			if len(plines) > i {
-				s.WriteString(lineStyle.Render(plines[i] + strings.Repeat(" ", max(0, m.width-uniseg.StringWidth(plines[i])))))
+				placeholderLine := plines[i]
+				gap := strings.Repeat(" ", max(0, m.width-uniseg.StringWidth(plines[i])))
+				s.WriteString(lineStyle.Render(placeholderLine + gap))
 			}
 		default:
 			// end of line buffer character

From 28249668559c0adbd0ffbb5c7787a2a5639a0d35 Mon Sep 17 00:00:00 2001
From: Christian Rocha <christian@rocha.is>
Date: Thu, 30 Jan 2025 18:00:35 -0500
Subject: [PATCH 20/22] feat(textarea): auto-calculate inner X/Y cursor offset

---
 textarea/textarea.go | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/textarea/textarea.go b/textarea/textarea.go
index afb597af..8e0d4132 100644
--- a/textarea/textarea.go
+++ b/textarea/textarea.go
@@ -1443,7 +1443,9 @@ func Blink() tea.Msg {
 // false.
 func (m Model) Cursor() *tea.Cursor {
 	lineInfo := m.LineInfo()
-	x, y := lineInfo.CharOffset, m.cursorLineNumber()-m.viewport.YOffset
+	w := lipgloss.Width
+	x := lineInfo.CharOffset + w(m.promptView(0)) + w(m.lineNumberView(0, false))
+	y := m.cursorLineNumber() - m.viewport.YOffset
 
 	c := tea.NewCursor(x, y)
 	c.Blink = m.Styles.Cursor.Blink

From 841c9ce98c89ca23b76427a30f2b7af74b65537a Mon Sep 17 00:00:00 2001
From: Christian Rocha <christian@rocha.is>
Date: Thu, 30 Jan 2025 18:08:12 -0500
Subject: [PATCH 21/22] chore(textarea): comments and cleanup

---
 textarea/textarea.go | 15 ++++++---------
 1 file changed, 6 insertions(+), 9 deletions(-)

diff --git a/textarea/textarea.go b/textarea/textarea.go
index 8e0d4132..7adb9024 100644
--- a/textarea/textarea.go
+++ b/textarea/textarea.go
@@ -986,9 +986,6 @@ func (m *Model) SetWidth(w int) {
 	// Update prompt width only if there is no prompt function as
 	// [SetPromptFunc] updates the prompt width when it is called.
 	if m.promptFunc == nil {
-		// XXX: This should account for a styled prompt and use lipglosss.Width
-		// instead of uniseg.StringWidth.
-		//
 		// XXX: Do we even need this or can we calculate the prompt width
 		// at render time?
 		m.promptWidth = uniseg.StringWidth(m.Prompt)
@@ -1003,7 +1000,7 @@ func (m *Model) SetWidth(w int) {
 	// Add line number width to reserved inner width.
 	if m.ShowLineNumbers {
 		// XXX: this was originally documented as needing "1 cell" but was,
-		// in practice, hardcoded to effectively 2 cells. We can, and should,
+		// in practice, effectively hardcoded to 2 cells. We can, and should,
 		// reduce this to one gap and update the tests accordingly.
 		const gap = 2
 
@@ -1238,7 +1235,7 @@ func (m Model) View() string {
 			}
 
 			// Note the widest line number for padding purposes later.
-			lnw := lipgloss.Width(ln)
+			lnw := uniseg.StringWidth(ln)
 			if lnw > widestLineNumber {
 				widestLineNumber = lnw
 			}
@@ -1283,7 +1280,7 @@ func (m Model) View() string {
 
 		// Write end of buffer content
 		leftGutter := string(m.EndOfBufferCharacter)
-		rightGapWidth := m.Width() - lipgloss.Width(leftGutter) + widestLineNumber
+		rightGapWidth := m.Width() - uniseg.StringWidth(leftGutter) + widestLineNumber
 		rightGap := strings.Repeat(" ", max(0, rightGapWidth))
 		s.WriteString(styles.computedEndOfBuffer().Render(leftGutter + rightGap))
 		s.WriteRune('\n')
@@ -1444,10 +1441,10 @@ func Blink() tea.Msg {
 func (m Model) Cursor() *tea.Cursor {
 	lineInfo := m.LineInfo()
 	w := lipgloss.Width
-	x := lineInfo.CharOffset + w(m.promptView(0)) + w(m.lineNumberView(0, false))
-	y := m.cursorLineNumber() - m.viewport.YOffset
+	xOffset := lineInfo.CharOffset + w(m.promptView(0)) + w(m.lineNumberView(0, false))
+	yOffset := m.cursorLineNumber() - m.viewport.YOffset
 
-	c := tea.NewCursor(x, y)
+	c := tea.NewCursor(xOffset, yOffset)
 	c.Blink = m.Styles.Cursor.Blink
 	c.Color = m.Styles.Cursor.Color
 	c.Shape = m.Styles.Cursor.Shape

From b2e3cc53717008a81e43bc8a617f585743e2f724 Mon Sep 17 00:00:00 2001
From: Christian Rocha <christian@rocha.is>
Date: Fri, 31 Jan 2025 15:18:23 -0500
Subject: [PATCH 22/22] chore(textarea): account for margins and padding in
 cursor offsets

---
 textarea/textarea.go | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/textarea/textarea.go b/textarea/textarea.go
index 7adb9024..39e5fed4 100644
--- a/textarea/textarea.go
+++ b/textarea/textarea.go
@@ -1441,8 +1441,20 @@ func Blink() tea.Msg {
 func (m Model) Cursor() *tea.Cursor {
 	lineInfo := m.LineInfo()
 	w := lipgloss.Width
-	xOffset := lineInfo.CharOffset + w(m.promptView(0)) + w(m.lineNumberView(0, false))
-	yOffset := m.cursorLineNumber() - m.viewport.YOffset
+	baseStyle := m.activeStyle().Base
+
+	xOffset := lineInfo.CharOffset +
+		w(m.promptView(0)) +
+		w(m.lineNumberView(0, false)) +
+		baseStyle.GetMarginLeft() +
+		baseStyle.GetPaddingLeft() +
+		baseStyle.GetBorderLeftSize()
+
+	yOffset := m.cursorLineNumber() +
+		m.viewport.YOffset +
+		baseStyle.GetMarginTop() +
+		baseStyle.GetPaddingTop() +
+		baseStyle.GetBorderTopSize()
 
 	c := tea.NewCursor(xOffset, yOffset)
 	c.Blink = m.Styles.Cursor.Blink