V2 exp

.github/workflows/coverage.yml

@@ -5,7 +5,7 @@ jobs:
   coverage:
     strategy:
       matrix:
-        go-version: [^1.18]
+        go-version: [^1.22]
         os: [ubuntu-latest]
     runs-on: ${{ matrix.os }}
     env:

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020-2025 Charmbracelet, Inc
+Copyright (c) 2020-2026 Charmbracelet, Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -174,7 +174,7 @@ var DefaultKeyMap = KeyMap{
 
 func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
     switch msg := msg.(type) {
-    case tea.KeyMsg:
+    case tea.KeyPressMsg:
         switch {
         case key.Matches(msg, DefaultKeyMap.Up):
             // The user pressed up

cursor/cursor.go

@@ -1,16 +1,26 @@
-// Package cursor provides cursor functionality for Bubble Tea applications.
+// Package cursor provides a virtual cursor to support the textinput and
+// textarea elements.
 package cursor
 
 import (
 	"context"
+	"sync/atomic"
 	"time"
 
-	tea "github.com/charmbracelet/bubbletea"
-	"github.com/charmbracelet/lipgloss"
+	tea "charm.land/bubbletea/v2"
+	"charm.land/lipgloss/v2"
 )
 
 const defaultBlinkSpeed = time.Millisecond * 530
 
+// Internal ID management. Used during animating to ensure that frame messages
+// are received only by spinner components that sent them.
+var lastID int64
+
+func nextID() int {
+	return int(atomic.AddInt64(&lastID, 1))
+}
+
 // initialBlinkMsg initializes cursor blinking.
 type initialBlinkMsg struct{}
 
@@ -52,36 +62,47 @@ 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.
 	Style lipgloss.Style
-	// TextStyle is the style used for the cursor when it is hidden (when blinking).
-	// I.e. displaying normal text.
+
+	// TextStyle is the style used for the cursor when it is blinking
+	// (hidden), i.e. displaying normal text.
 	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
+
+	// IsBlinked is the state of the cursor blink. When true, the cursor is
+	// hidden.
+	IsBlinked 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
 }
 
 // New creates a new model with default settings.
 func New() Model {
 	return Model{
+		id:         nextID(),
 		BlinkSpeed: defaultBlinkSpeed,
-
-		Blink: true,
-		mode:  CursorBlink,
+		IsBlinked:  true,
+		mode:       CursorBlink,
 
 		blinkCtx: &blinkCtx{
 			ctx: context.Background(),
@@ -99,7 +120,7 @@ func (m Model) Update(msg tea.Msg) (Model, tea.Cmd) {
 			return m, nil
 		}
 
-		cmd := m.BlinkCmd()
+		cmd := m.Blink()
 		return m, cmd
 
 	case tea.FocusMsg:
@@ -125,8 +146,8 @@ func (m Model) Update(msg tea.Msg) (Model, tea.Cmd) {
 
 		var cmd tea.Cmd
 		if m.mode == CursorBlink {
-			m.Blink = !m.Blink
-			cmd = m.BlinkCmd()
+			m.IsBlinked = !m.IsBlinked
+			cmd = m.Blink()
 		}
 		return m, cmd
 
@@ -151,15 +172,15 @@ func (m *Model) SetMode(mode Mode) tea.Cmd {
 		return nil
 	}
 	m.mode = mode
-	m.Blink = m.mode == CursorHide || !m.focus
+	m.IsBlinked = m.mode == CursorHide || !m.focus
 	if mode == CursorBlink {
 		return Blink
 	}
 	return nil
 }
 
-// BlinkCmd is a command used to manage cursor blinking.
-func (m *Model) BlinkCmd() tea.Cmd {
+// Blink is a command used to manage cursor blinking.
+func (m *Model) Blink() tea.Cmd {
 	if m.mode != CursorBlink {
 		return nil
 	}
@@ -172,7 +193,6 @@ func (m *Model) BlinkCmd() tea.Cmd {
 	m.blinkCtx.cancel = cancel
 
 	m.blinkTag++
-
 	blinkMsg := BlinkMsg{id: m.id, tag: m.blinkTag}
 
 	return func() tea.Msg {
@@ -193,18 +213,18 @@ func Blink() tea.Msg {
 // Focus focuses the cursor to allow it to blink if desired.
 func (m *Model) Focus() tea.Cmd {
 	m.focus = true
-	m.Blink = m.mode == CursorHide // show the cursor unless we've explicitly hidden it
+	m.IsBlinked = m.mode == CursorHide // show the cursor unless we've explicitly hidden it
 
 	if m.mode == CursorBlink && m.focus {
-		return m.BlinkCmd()
+		return m.Blink()
 	}
 	return nil
 }
 
 // Blur blurs the cursor.
 func (m *Model) Blur() {
 	m.focus = false
-	m.Blink = true
+	m.IsBlinked = true
 }
 
 // SetChar sets the character under the cursor.
@@ -214,7 +234,7 @@ func (m *Model) SetChar(char string) {
 
 // View displays the cursor.
 func (m Model) View() string {
-	if m.Blink {
+	if m.IsBlinked {
 		return m.TextStyle.Inline(true).Render(m.char)
 	}
 	return m.Style.Inline(true).Reverse(true).Render(m.char)

cursor/cursor_test.go

@@ -8,7 +8,7 @@ import (
 
 // TestBlinkCmdDataRace tests for a race on [Cursor.blinkTag].
 //
-// The original [Model.BlinkCmd] implementation returned a closure over the pointer receiver:
+// The original [Model.Blink] implementation returned a closure over the pointer receiver:
 //
 //	return func() tea.Msg {
 //		defer cancel()
@@ -20,20 +20,20 @@ import (
 //	}
 //
 // A race on “m.blinkTag” will occur if:
-//  1. [Model.BlinkCmd] is called e.g. by calling [Model.Focus] from
-//     ["github.com/charmbracelet/bubbletea".Model.Update];
-//  2. ["github.com/charmbracelet/bubbletea".handleCommands] is kept sufficiently busy that it does not receive and
+//  1. [Model.Blink] is called e.g. by calling [Model.Focus] from
+//     ["charm.land/bubbletea/v2".Model.Update];
+//  2. ["charm.land/bubbletea/v2".handleCommands] is kept sufficiently busy that it does not receive and
 //     execute the [Model.BlinkCmd] e.g. by other long running command or commands;
 //  3. at least [Mode.BlinkSpeed] time elapses;
-//  4. [Model.BlinkCmd] is called again;
-//  5. ["github.com/charmbracelet/bubbletea".handleCommands] gets around to receiving and executing the original
+//  4. [Model.Blink] is called again;
+//  5. ["charm.land/bubbletea/v2".handleCommands] gets around to receiving and executing the original
 //     closure.
 //
 // Even if this did not formally race, the value of the tag fetched would be semantically incorrect (likely being the
 // current value rather than the value at the time the closure was created).
 func TestBlinkCmdDataRace(t *testing.T) {
 	m := New()
-	cmd := m.BlinkCmd()
+	cmd := m.Blink()
 	var wg sync.WaitGroup
 	wg.Add(2)
 	go func() {
@@ -44,7 +44,7 @@ func TestBlinkCmdDataRace(t *testing.T) {
 	go func() {
 		defer wg.Done()
 		time.Sleep(m.BlinkSpeed * 2)
-		m.BlinkCmd()
+		m.Blink()
 	}()
 	wg.Wait()
 }