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

"fmt"

"io"

"os"

"os/signal"

"runtime/debug"

"sync"

"syscall"

"time"

"github.com/containerd/console"

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

"github.com/muesli/cancelreader"

te "github.com/muesli/termenv"

"golang.org/x/term"

)

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

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

// generally set with ProgramOptions.

//

// The options here are treated as bits.

type startupOptions byte

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

return s&option != 0

}

const (

withAltScreen startupOptions = 1 << iota

withMouseCellMotion

withMouseAllMotion

withInputTTY

withCustomInput

withANSICompressor

)

// Program is a terminal user interface.

type Program struct {

}

// Batch performs a bunch of commands concurrently with no ordering guarantees

// about the results. Use a Batch to return several commands.

//

// Example:

//

// func (m model) Init() Cmd {

// return tea.Batch(someCommand, someOtherCommand)

// }

//

func Batch(cmds ...Cmd) Cmd {

}

// batchMsg is the internal message used to perform a bunch of commands. You

// can send a batchMsg with Batch.

type batchMsg []Cmd

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

func Quit() Msg {

return quitMsg{}

}

// quitMsg in an internal message signals that the program should quit. You can

// send a quitMsg with Quit.

type quitMsg struct{}

// EnterAltScreen is a special command that tells the Bubble Tea program to

// enter the alternate screen buffer.

//

// Because commands run asynchronously, this command should not be used in your

// model's Init function. To initialize your program with the altscreen enabled

// use the WithAltScreen ProgramOption instead.

func EnterAltScreen() Msg {

return enterAltScreenMsg{}

}

// enterAltScreenMsg in an internal message signals that the program should

// enter alternate screen buffer. You can send a enterAltScreenMsg with

// EnterAltScreen.

type enterAltScreenMsg struct{}

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

// the alternate screen buffer. This command should be used to exit the

// alternate screen buffer while the program is running.

//

// Note that the alternate screen buffer will be automatically exited when the

// program quits.

func ExitAltScreen() Msg {

return exitAltScreenMsg{}

}

// exitAltScreenMsg in an internal message signals that the program should exit

// alternate screen buffer. You can send a exitAltScreenMsg with ExitAltScreen.

type exitAltScreenMsg struct{}

// EnableMouseCellMotion is a special command that enables mouse click,

// release, and wheel events. Mouse movement events are also captured if

// a mouse button is pressed (i.e., drag events).

//

// Because commands run asynchronously, this command should not be used in your

// model's Init function. Use the WithMouseCellMotion ProgramOption instead.

func EnableMouseCellMotion() Msg {

return enableMouseCellMotionMsg{}

}

// enableMouseCellMotionMsg is a special command that signals to start

// listening for "cell motion" type mouse events (ESC[?1002l). To send an

// enableMouseCellMotionMsg, use the EnableMouseCellMotion command.

type enableMouseCellMotionMsg struct{}

// EnableMouseAllMotion is a special command that enables mouse click, release,

// wheel, and motion events, which are delivered regardless of whether a mouse

// button is pressed, effectively enabling support for hover interactions.

//

// Many modern terminals support this, but not all. If in doubt, use

// EnableMouseCellMotion instead.

//

// Because commands run asynchronously, this command should not be used in your

// model's Init function. Use the WithMouseAllMotion ProgramOption instead.

func EnableMouseAllMotion() Msg {

return enableMouseAllMotionMsg{}

}

// enableMouseAllMotionMsg is a special command that signals to start listening

// for "all motion" type mouse events (ESC[?1003l). To send an

// enableMouseAllMotionMsg, use the EnableMouseAllMotion command.

type enableMouseAllMotionMsg struct{}

// DisableMouse is a special command that stops listening for mouse events.

func DisableMouse() Msg {

return disableMouseMsg{}

}

// disableMouseMsg is an internal message that that signals to stop listening

// for mouse events. To send a disableMouseMsg, use the DisableMouse command.

type disableMouseMsg struct{}

// WindowSizeMsg is used to report the terminal size. It's sent to Update once

// initially and then on every terminal resize. Note that Windows does not

// have support for reporting when resizes occur as it does not support the

// SIGWINCH signal.

type WindowSizeMsg struct {

Width int

Height int

}

// HideCursor is a special command for manually instructing Bubble Tea to hide

// the cursor. In some rare cases, certain operations will cause the terminal

// to show the cursor, which is normally hidden for the duration of a Bubble

// Tea program's lifetime. You will most likely not need to use this command.

func HideCursor() Msg {

return hideCursorMsg{}

}

// hideCursorMsg is an internal command used to hide the cursor. You can send

// this message with HideCursor.

type hideCursorMsg struct{}

// NewProgram creates a new Program.

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

}

// StartReturningModel initializes the program. Returns the final model.

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

}

// Start initializes the program. Ignores the final model.

func (p *Program) Start() error {

_, err := p.StartReturningModel()

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 is not running this this will be a no-op, so it's safe to

// send messages if the program is unstarted, or has exited.

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

p.msgs <- 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.

func (p *Program) Kill() {

p.killc <- true

p.shutdown(true)

}

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

// to its original state.

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

}

// EnterAltScreen enters the alternate screen buffer, which consumes the entire

// terminal window. ExitAltScreen will return the terminal to its former state.

//

// Deprecated: Use the WithAltScreen ProgramOption instead.

func (p *Program) EnterAltScreen() {

}

// ExitAltScreen exits the alternate screen buffer.

//

// Deprecated: The altscreen will exited automatically when the program exits.

func (p *Program) ExitAltScreen() {

}

// EnableMouseCellMotion enables mouse click, release, wheel and motion events

// if a mouse button is pressed (i.e., drag events).

//

// Deprecated: Use the WithMouseCellMotion ProgramOption instead.

func (p *Program) EnableMouseCellMotion() {

}

// DisableMouseCellMotion disables Mouse Cell Motion tracking. This will be

// called automatically when exiting a Bubble Tea program.

//

// Deprecated: The mouse will automatically be disabled when the program exits.

func (p *Program) DisableMouseCellMotion() {

}

// EnableMouseAllMotion enables mouse click, release, wheel and motion events,

// regardless of whether a mouse button is pressed. Many modern terminals

// support this, but not all.

//

// Deprecated: Use the WithMouseAllMotion ProgramOption instead.

func (p *Program) EnableMouseAllMotion() {

}

// DisableMouseAllMotion disables All Motion mouse tracking. This will be

// called automatically when exiting a Bubble Tea program.

//

// Deprecated: The mouse will automatically be disabled when the program exits.

func (p *Program) DisableMouseAllMotion() {

}

// 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{}) {

}