// Package tea provides a framework for building rich terminal user interfaces

// based on the paradigms of The Elm Architecture. It's well-suited for simple

// and complex terminal applications, either inline, full-window, or a mix of

// both. It's been battle-tested in several large projects and is

// production-ready.

//

// A tutorial is available at https://github.com/charmbracelet/bubbletea/tree/master/tutorials

//

// Example programs can be found at https://github.com/charmbracelet/bubbletea/tree/master/examples

package tea

import (

"context"

"errors"

"fmt"

"io"

"os"

"os/signal"

"runtime/debug"

"sync"

"sync/atomic"

"syscall"

"github.com/containerd/console"

isatty "github.com/mattn/go-isatty"

"github.com/muesli/cancelreader"

"github.com/muesli/termenv"

"golang.org/x/sync/errgroup"

)

// ErrProgramKilled is returned by [Program.Run] when the program got killed.

var ErrProgramKilled = errors.New("program was killed")

// Msg contain data from the result of a IO operation. Msgs trigger the update

// function and, henceforth, the UI.

type Msg interface{}

// Model contains the program's state as well as its core functions.

type Model interface {

}

// Cmd is an IO operation that returns a message when it's complete. If it's

// nil it's considered a no-op. Use it for things like HTTP requests, timers,

// saving and loading from disk, and so on.

//

// Note that there's almost never a reason to use a command to send a message

// to another part of your program. That can almost always be done in the

// update function.

type Cmd func() Msg

type inputType int

const (

defaultInput inputType = iota

ttyInput

customInput

)

// String implements the stringer interface for [inputType]. It is inteded to

// be used in testing.

func (i inputType) String() string {

}

// Options to customize the program during its initialization. These are

// generally set with ProgramOptions.

//

// The options here are treated as bits.

type startupOptions int16

func (s startupOptions) has(option startupOptions) bool {

return s&option != 0

}

const (

withAltScreen startupOptions = 1 << iota

withMouseCellMotion

withMouseAllMotion

withANSICompressor

withoutSignalHandler

// Catching panics is incredibly useful for restoring the terminal to a

// usable state after a panic occurs. When this is set, Bubble Tea will

// recover from panics, print the stack trace, and disable raw mode. This

// feature is on by default.

withoutCatchPanics

withoutBracketedPaste

)

// handlers manages series of channels returned by various processes. It allows

// us to wait for those processes to terminate before exiting the program.

type handlers []chan struct{}

// Adds a channel to the list of handlers. We wait for all handlers to terminate

// gracefully on shutdown.

func (h *handlers) add(ch chan struct{}) {

*h = append(*h, ch)

}

// shutdown waits for all handlers to terminate.

func (h handlers) shutdown() {

}

// Program is a terminal user interface.

type Program struct {

}

// Quit is a special command that tells the Bubble Tea program to exit.

func Quit() Msg {

return QuitMsg{}

}

// QuitMsg signals that the program should quit. You can send a QuitMsg with

// Quit.

type QuitMsg struct{}

// NewProgram creates a new Program.

func NewProgram(model Model, opts ...ProgramOption) *Program {

}

func (p *Program) handleSignals() chan struct{} {

}

// handleResize handles terminal resize events.

func (p *Program) handleResize() chan struct{} {

}

// handleCommands runs commands in a goroutine and sends the result to the

// program's message channel.

func (p *Program) handleCommands(cmds chan Cmd) chan struct{} {

}

func (p *Program) disableMouse() {

}

// eventLoop is the central message loop. It receives and handles the default

// Bubble Tea messages, update the model and triggers redraws.

func (p *Program) eventLoop(model Model, cmds chan Cmd) (Model, error) {

}

// 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.

func (p *Program) Run() (Model, error) {

}

// StartReturningModel 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.

//

// Deprecated: please use [Program.Run] instead.

func (p *Program) StartReturningModel() (Model, error) {

return p.Run()

}

// Start initializes the program and runs its event loops, blocking until it

// gets terminated by either [Program.Quit], [Program.Kill], or its signal

// handler.

//

// Deprecated: please use [Program.Run] instead.

func (p *Program) Start() error {

_, err := p.Run()

return err

}

// Send sends a message to the main update function, effectively allowing

// messages to be injected from outside the program for interoperability

// purposes.

//

// If the program hasn't started yet this will be a blocking operation.

// If the program has already been terminated this will be a no-op, so it's safe

// to send messages after the program has exited.

func (p *Program) Send(msg Msg) {

}

// Quit is a convenience function for quitting Bubble Tea programs. Use it

// when you need to shut down a Bubble Tea program from the outside.

//

// If you wish to quit from within a Bubble Tea program use the Quit command.

//

// If the program is not running this will be a no-op, so it's safe to call

// if the program is unstarted or has already exited.

func (p *Program) Quit() {

p.Send(Quit())

}

// Kill stops the program immediately and restores the former terminal state.

// The final render that you would normally see when quitting will be skipped.

// [program.Run] returns a [ErrProgramKilled] error.

func (p *Program) Kill() {

p.cancel()

}

// Wait waits/blocks until the underlying Program finished shutting down.

func (p *Program) Wait() {

<-p.finished

}

// shutdown performs operations to free up resources and restore the terminal

// to its original state.

func (p *Program) shutdown(kill bool) {

}

// ReleaseTerminal restores the original terminal state and cancels the input

// reader. You can return control to the Program with RestoreTerminal.

func (p *Program) ReleaseTerminal() error {

}

// RestoreTerminal reinitializes the Program's input reader, restores the

// terminal to the former state when the program was running, and repaints.

// Use it to reinitialize a Program after running ReleaseTerminal.

func (p *Program) RestoreTerminal() error {

}

// Println prints above the Program. This output is unmanaged by the program

// and will persist across renders by the Program.

//

// If the altscreen is active no output will be printed.

func (p *Program) Println(args ...interface{}) {

}

// Printf prints above the Program. It takes a format template followed by

// values similar to fmt.Printf. This output is unmanaged by the program and

// will persist across renders by the Program.

//

// Unlike fmt.Printf (but similar to log.Printf) the message will be print on

// its own line.

//

// If the altscreen is active no output will be printed.

func (p *Program) Printf(template string, args ...interface{}) {

}