feat: properly call nested sequenceMsg and batchMsg

examples/sequence/main.go

@@ -5,6 +5,7 @@ package main
 import (
 	"fmt"
 	"os"
+	"time"
 
 	tea "github.com/charmbracelet/bubbletea"
 )
@@ -14,15 +15,39 @@ type model struct{}
 func (m model) Init() tea.Cmd {
 	return tea.Sequence(
 		tea.Batch(
-			tea.Println("A"),
-			tea.Println("B"),
-			tea.Println("C"),
+			tea.Sequence(
+				SleepPrintln("1-1-1", 1000),
+				SleepPrintln("1-1-2", 1000),
+			),
+			tea.Batch(
+				SleepPrintln("1-2-1", 1500),
+				SleepPrintln("1-2-2", 1250),
+			),
+		),
+		tea.Println("2"),
+		tea.Sequence(
+			tea.Batch(
+				SleepPrintln("3-1-1", 500),
+				SleepPrintln("3-1-2", 1000),
+			),
+			tea.Sequence(
+				SleepPrintln("3-2-1", 750),
+				SleepPrintln("3-2-2", 500),
+			),
 		),
-		tea.Println("Z"),
 		tea.Quit,
 	)
 }
 
+// print string after stopping for a certain period of time
+func SleepPrintln(s string, milisecond int) tea.Cmd {
+	printCmd := tea.Println(s)
+	return func() tea.Msg {
+		time.Sleep(time.Duration(milisecond) * time.Millisecond)
+		return printCmd()
+	}
+}
+
 func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	switch msg.(type) {
 	case tea.KeyMsg:

tea.go

@@ -355,38 +355,12 @@ func (p *Program) eventLoop(model Model, cmds chan Cmd) (Model, error) {
 				p.exec(msg.cmd, msg.fn)
 
 			case BatchMsg:
-				for _, cmd := range msg {
-					cmds <- cmd
-				}
+				go p.execBatchMsg(msg)
 				continue
 
 			case sequenceMsg:
-				go func() {
-					// Execute commands one at a time, in order.
-					for _, cmd := range msg {
-						if cmd == nil {
-							continue
-						}
-
-						msg := cmd()
-						if batchMsg, ok := msg.(BatchMsg); ok {
-							g, _ := errgroup.WithContext(p.ctx)
-							for _, cmd := range batchMsg {
-								cmd := cmd
-								g.Go(func() error {
-									p.Send(cmd())
-									return nil
-								})
-							}
-
-							//nolint:errcheck
-							g.Wait() // wait for all commands from batch msg to finish
-							continue
-						}
-
-						p.Send(msg)
-					}
-				}()
+				go p.execSequenceMsg(msg)
+				continue
 			}
 
 			// Process internal messages for the renderer.
@@ -402,6 +376,50 @@ func (p *Program) eventLoop(model Model, cmds chan Cmd) (Model, error) {
 	}
 }
 
+func (p *Program) execSequenceMsg(msg sequenceMsg) {
+	// Execute commands one at a time, in order.
+	for _, cmd := range msg {
+		if cmd == nil {
+			continue
+		}
+		msg := cmd()
+		switch msg := msg.(type) {
+		case BatchMsg:
+			p.execBatchMsg(msg)
+		case sequenceMsg:
+			p.execSequenceMsg(msg)
+		default:
+			p.Send(msg)
+		}
+	}
+}
+
+func (p *Program) execBatchMsg(msg BatchMsg) {
+	// Execute commands one at a time.
+	g, _ := errgroup.WithContext(p.ctx)
+	for _, cmd := range msg {
+		cmd := cmd
+		if cmd == nil {
+			continue
+		}
+		g.Go(func() error {
+			msg := cmd()
+			switch msg := msg.(type) {
+			case BatchMsg:
+				p.execBatchMsg(msg)
+			case sequenceMsg:
+				p.execSequenceMsg(msg)
+			default:
+				p.Send(msg)
+			}
+			return nil
+		})
+	}
+
+	//nolint:errcheck
+	g.Wait() // wait for all commands from batch msg to finish
+}
+
 // Run initializes the program and runs its event loops, blocking until it gets
 // terminated by either [Program.Quit], [Program.Kill], or its signal handler.
 // Returns the final model.